Class: String

Inherits:
Object show all
Defined in:
lib/source/ruby.rb

Overview

A String object holds and manipulates an arbitrary sequence of bytes, typically representing characters. String objects may be created using String::new or as literals. Typically, methods with names ending in “!” modify their receiver, while those without a “!” return a new String.

Instance Method Summary collapse

Constructor Details

#initialize(string = `''`) ⇒ String

call-seq:

String.new(str = '') -> string

Returns a new string object containing a copy of str.



5267
5268
5269
 
# File 'lib/source/ruby.rb', line 5267

def initialize(string = `''`)
  `this._value=string._value||string`
end

Instance Method Details

#%(arg) ⇒ Object

call-seq:

str % arg -> string

Format – uses str as a format specification, and returns the result of applying it to arg. If the format specification contains more than one substitution, then arg must be an Array containing the values to be substituted. See Kernel::sprintf for details of the format string.

"%05d" % 123                        #=> "00123"
"%s: %08x" % ['ID', self.__id__]    #=> "ID: 200e14d6"



5283
5284
5285
5286
 
# File 'lib/source/ruby.rb', line 5283

def %(arg)
  `arg.m$class()==c$Array?arg.unshift(this):arg=[this,arg]`
  `m$sprintf.apply(null,arg)`
end

#*(n) ⇒ Object

call-seq:

str * num -> string

Copy – returns a new string containing num copies of str.

'abc ' * 3    #=> "abc abc abc "



5295
5296
5297
5298
 
# File 'lib/source/ruby.rb', line 5295

def *(n)
  `for(var i=0,str=this._value,result='';i<n;++i){result+=str;}`
  return `$q(result)`
end

#+(str) ⇒ Object

call-seq:

str + other -> string

Concatenation – returns a new string containing other concatenated to str.

'abc' + 'def'   #=> 'abcdef'



5308
5309
5310
 
# File 'lib/source/ruby.rb', line 5308

def +(str)
  `$q(this._value + str._value)`
end

#<<(obj) ⇒ Object

call-seq:

str << num      -> str
str << obj      -> str
str.concat(num) -> str
str.concat(obj) -> str

Append – concatenates the given object to str. If the object is an integer between 0 and 255, it is converted to a character before concatenation.

s = 'abc'

s << 'def'         #=> "abcdef"
s << 103 << 104    #=> "abcdefgh"



5327
5328
5329
5330
 
# File 'lib/source/ruby.rb', line 5327

def <<(obj)
  `this._value+=(typeof(obj)=='number'?String.fromCharCode(obj):obj._value)`
  return self
end

#<=>(str) ⇒ Object

call-seq:

str <=> other -> -1, 0, 1

Comparison – returns -1 if other is less than, 0 if other is equal to, and 1 if other is greater than str. If the strings are of different lengths, and the strings are equal when compared up to the shortest length, then the longer string is considered greater than the shorter one.

<=> is the basis for the methods <, <=, >, >=, and between?, included from module Comparable. The method String#== does not use Comparable#==.

'abcdef' <=> 'abcde'     #=> 1
'abcdef' <=> 'abcdef'    #=> 0
'abcdef' <=> 'abcdefg'   #=> -1
'abcdef' <=> 'ABCDEF'    #=> 1



5351
5352
5353
5354
5355
5356
5357
5358
 
# File 'lib/source/ruby.rb', line 5351

def <=>(str)
  `if(str.m$class()!=c$String){return nil;}`
  `var tv=this._value,sv=str._value`
  `if(tv>sv){return 1;}`
  `if(tv==sv){return 0;}`
  `if(tv<sv){return -1;}`
  return nil
end

#==(str) ⇒ Object

call-seq:

str == other -> true or false

Equality – if other is not a String, returns false. Otherwise, returns true if str <=> obj returns zero.



5366
5367
5368
5369
 
# File 'lib/source/ruby.rb', line 5366

def ==(str)
  `if(str.m$class()!=c$String){return false;}`
  return `this.m$_ltgt(str)==0`
end

#=~(str) ⇒ Object

FIX: Incomplete



5372
5373
 
# File 'lib/source/ruby.rb', line 5372

def =~(str)
end

#[] ⇒ Object

call-seq:

str[num]               -> integer or nil
str[num, num]          -> string or nil
str[range]             -> string or nil
str[regexp]            -> string or nil
str[regexp, num]       -> string or nil
str[other]             -> string or nil
str.slice(num)         -> integer or nil
str.slice(num, num)    -> string or nil
str.slice(range)       -> string or nil
str.slice(regexp)      -> string or nil
str.slice(regexp, num) -> string or nil
str.slice(other)       -> string or nil

FIX: Incomplete



5390
5391
 
# File 'lib/source/ruby.rb', line 5390

def []
end

#[]= ⇒ Object

call-seq:

str[num] = num            -> num
str[num] = string         -> string
str[num, num] = string    -> string
str[range] = string       -> string
str[regexp] = string      -> string
str[regexp, num] = string -> string
str[other] = string       -> string

FIX: Incomplete



5403
5404
 
# File 'lib/source/ruby.rb', line 5403

def []=
end

#capitalize ⇒ Object

call-seq:

str.capitalize -> string

Returns a copy of str with the first character converted to uppercase and the remainder to lowercase.

'abcdef'.capitalize   #=> "Abcdef"
'ABCDEF'.capitalize   #=> "Abcdef"
'123ABC'.capitalize   #=> "123abc"



5416
5417
5418
5419
 
# File 'lib/source/ruby.rb', line 5416

def capitalize
  `var v=this._value`
  `$q(v.slice(0,1).toUpperCase()+v.slice(1,v.length).toLowerCase())`
end

#capitalize! ⇒ Object

call-seq:

str.capitalize! -> str or nil

Returns str with the first character converted to uppercase and the remainder to lowercase, or nil if no changes were made.

s = 'abcdef'

s.capitalize!   #=> "Abcdef"
s.capitalize!   #=> nil
s               #=> "Abcdef"



5433
5434
5435
5436
5437
 
# File 'lib/source/ruby.rb', line 5433

def capitalize!
  `var v=this._value`
  `this._value=v.slice(0,1).toUpperCase()+v.slice(1,v.length).toLowerCase()`
  return `v==this._value?nil:this`
end

#casecmp(str) ⇒ Object

call-seq:

str.casecmp(other) -> -1, 0, 1

Case-insensitive version of String#<=>.

'abcdef'.casecmp('abcde')     #=> 1
'aBcDeF'.casecmp('abcdef')    #=> 0
'abcdef'.casecmp('abcdefg')   #=> -1
'abcdef'.casecmp('ABCDEF')    #=> 0



5449
5450
5451
5452
5453
5454
5455
5456
 
# File 'lib/source/ruby.rb', line 5449

def casecmp(str)
  `if(str.m$class()!=c$String){return nil;}`
  `var tv=this._value.toLowerCase(),sv=str._value.toLowerCase()`
  `if(tv>sv){return 1;}`
  `if(tv==sv){return 0;}`
  `if(tv<sv){return -1;}`
  return nil
end

#center ⇒ Object

FIX: Incomplete



5459
5460
 
# File 'lib/source/ruby.rb', line 5459

def center
end

#chomp ⇒ Object

FIX: Incomplete



5463
5464
 
# File 'lib/source/ruby.rb', line 5463

def chomp
end

#chomp! ⇒ Object

FIX: Incomplete



5467
5468
 
# File 'lib/source/ruby.rb', line 5467

def chomp!
end

#chop ⇒ Object

FIX: Incomplete



5471
5472
 
# File 'lib/source/ruby.rb', line 5471

def chop
end

#chop! ⇒ Object

FIX: Incomplete



5475
5476
 
# File 'lib/source/ruby.rb', line 5475

def chop!
end

#concat(obj) ⇒ Object

call-seq:

str << num      -> str
str << obj      -> str
str.concat(num) -> str
str.concat(obj) -> str

Append – concatenates the given object to str. If the object is an integer between 0 and 255, it is converted to a character before concatenation.

a = 'abc'

a.concat('def')              #=> "abcdef"
a.concat(103).concat(104)    #=> "abcdefgh"



5493
5494
5495
5496
 
# File 'lib/source/ruby.rb', line 5493

def concat(obj)
  `this._value+=(typeof(obj)=='number'?String.fromCharCode(obj):obj._value)`
  return self
end

#count ⇒ Object

FIX: Incomplete



5499
5500
 
# File 'lib/source/ruby.rb', line 5499

def count
end

#crypt ⇒ Object

FIX: Incomplete



5503
5504
 
# File 'lib/source/ruby.rb', line 5503

def crypt
end

#delete ⇒ Object

FIX: Incomplete



5507
5508
 
# File 'lib/source/ruby.rb', line 5507

def delete
end

#delete! ⇒ Object

FIX: Incomplete



5511
5512
 
# File 'lib/source/ruby.rb', line 5511

def delete!
end

#downcase ⇒ Object

call-seq:

str.downcase -> string

Returns a copy of str with all uppercase letters replaced with their lowercase counterparts.

'aBCDEf'.downcase   #=> "abcdef"



5522
5523
5524
 
# File 'lib/source/ruby.rb', line 5522

def downcase
  `$q(this._value.toLowerCase())`
end

#downcase! ⇒ Object

call-seq:

str.downcase! -> str or nil

Returns str with all uppercase letters replaced with their lowercase counterparts, or nil if no changes were made.

s = 'aBCDEf'

s.downcase!   #=> "abcdef"
s.downcase!   #=> nil
s             #=> "abcdef"



5538
5539
5540
5541
5542
 
# File 'lib/source/ruby.rb', line 5538

def downcase!
  `var v=this._value`
  `this._value=v.toLowerCase()`
  return `v==this._value?nil:this`
end

#each ⇒ Object

FIX: Incomplete



5545
5546
 
# File 'lib/source/ruby.rb', line 5545

def each
end

#each_byte ⇒ Object

FIX: Incomplete



5549
5550
 
# File 'lib/source/ruby.rb', line 5549

def each_byte
end

#each_line ⇒ Object

FIX: Incomplete



5553
5554
 
# File 'lib/source/ruby.rb', line 5553

def each_line
end

#empty? ⇒ Boolean

call-seq:

str.empty? -> true or false

Returns true if str has a length of zero.

'abcdef'.empty?   #=> false
''.empty?         #=> true

Returns:

  • (Boolean) 


5564
5565
5566
 
# File 'lib/source/ruby.rb', line 5564

def empty?
  `this._value==''`
end

#eql?(str) ⇒ Boolean

call-seq:

str.eql?(other) -> true or false

Two strings are equal if they have the same length and content.

Returns:

  • (Boolean) 


5573
5574
5575
5576
 
# File 'lib/source/ruby.rb', line 5573

def eql?(str)
  `if(str.m$class()!=c$String){return false;}`
  `this._value==str._value`
end

#gsub ⇒ Object

FIX: Incomplete



5579
5580
 
# File 'lib/source/ruby.rb', line 5579

def gsub
end

#gsub! ⇒ Object

FIX: Incomplete



5583
5584
 
# File 'lib/source/ruby.rb', line 5583

def gsub!
end

#hash ⇒ Object

:nodoc:



5586
5587
5588
 
# File 'lib/source/ruby.rb', line 5586

def hash # :nodoc:
  `'q_'+this._value`
end

#hex ⇒ Object

call-seq:

str.hex -> num

Treats leading characters from str as a string of hexadecimal digits (with an optional sign and an optional 0x) and returns the corresponding number. Zero is returned on error.

'0x0a'.hex      #=> 10
'-1234'.hex     #=> -4660
'0'.hex         #=> 0
'abcdef'.hex    #=> 0



5602
5603
5604
5605
 
# File 'lib/source/ruby.rb', line 5602

def hex
  `var result=parseInt(this._value,16)`
  return `result.toString()=='NaN'?0:result`
end

#include?(obj) ⇒ Boolean

call-seq:

str.include?(other) -> true or false
str.include?(num)   -> true or false

Returns true if str contains the given string or character.

'abcdef'.include?('bc')   #=> true
'abcdef'.include?('xy')   #=> false
'abcdef'.include?(?c)     #=> true

Returns:

  • (Boolean) 


5617
5618
5619
 
# File 'lib/source/ruby.rb', line 5617

def include?(obj)
  `new(RegExp)(typeof(obj)=='number'?String.fromCharCode(obj):obj._value.replace(/([-.*+?^${}()|[\\]\\/\\\\])/g, '\\\\$1')).test(this._value)`
end

#index ⇒ Object

FIX: Incomplete



5622
5623
 
# File 'lib/source/ruby.rb', line 5622

def index
end

#insert ⇒ Object

FIX: Incomplete



5626
5627
 
# File 'lib/source/ruby.rb', line 5626

def insert
end

#inspect ⇒ Object

FIX: Incomplete



5630
5631
5632
 
# File 'lib/source/ruby.rb', line 5630

def inspect
  `$q('"'+this._value.replace(/\\\\/g,'\\\\\\\\').replace(/"/g,'\\\\"')+'"')`
end

#intern ⇒ Object

call-seq:

str.intern -> symbol
str.to_sym -> symbol

Returns the Symbol corresponding to str, creating the symbol if it did not previously exist. See also Symbol#id2name.

'abcdef'.intern   #=> :abcdef



5643
5644
5645
 
# File 'lib/source/ruby.rb', line 5643

def intern
  `$s(this._value)`
end

#length ⇒ Object

call-seq:

str.length -> integer
str.size   -> integer

Returns the number of characters in str.

'abcdef'.length   #=> 6
'ab\ncd'.length   #=> 5



5656
5657
5658
 
# File 'lib/source/ruby.rb', line 5656

def length
  `this._value.length`
end

#ljust ⇒ Object

FIX: Incomplete



5661
5662
 
# File 'lib/source/ruby.rb', line 5661

def ljust
end

#lstrip ⇒ Object

call-seq:

str.lstrip -> string

Returns a copy of str with leading whitespace removed.

'  abcdef'.lstrip   #=> "abcdef"
'\tabcdef'.lstrip   #=> "abcdef"



5672
5673
5674
 
# File 'lib/source/ruby.rb', line 5672

def lstrip
  `$q(this._value.replace(/^\\s*/,''))`
end

#lstrip! ⇒ Object

call-seq:

str.lstrip! -> str

Returns str with leading whitespace removed, or nil if no changes were made.

s = '    abcdef'

s.lstrip!   #=> "abcdef"
s.lstrip!   #=> nil
s           #=> "abcdef"



5688
5689
5690
5691
5692
 
# File 'lib/source/ruby.rb', line 5688

def lstrip!
  `var v=this._value`
  `this._value=v.replace(/^\\s*/,'')`
  return `this._value==v?nil:this`
end

#match(pattern) ⇒ Object

call-seq:

str.match(pattern) -> matchdata or nil

Converts pattern to a Regexp (if it isn’t already one), then invokes its match method on str.

'abcdee'.match('(.)\1')       #=> #<MatchData:120>
'abcdee'.match('(.)\1')[0]    #=> "ee"
'abcdee'.match(/(.)\1/)[0]    #=> "ee"
'abcdee'.match('xx')          #=> nil



5705
5706
5707
 
# File 'lib/source/ruby.rb', line 5705

def match(pattern)
  `$r(pattern._source||pattern._value,pattern._options).m$match(this)`
end

#next ⇒ Object

call-seq:

str.next -> string
str.succ -> string

Returns the successor to str. The successor is calculated by incrementing characters starting from the rightmost alphanumeric (or the rightmost character if there are no alphanumerics) in the string. Incrementing a digit always results in another digit, and incrementing a letter results in another letter of the same case.

If the increment generates a “carry,” the character to the left is also incremented. This process repeats until there is no carry, adding an additional character of the same type as the leftmost alphanumeric, if necessary.

'abcdef'.next     #=> 'abcdeg'
'<<kit9>>'.next   #=> '<<kit10>>'
'1999zzz'.next    #=> '2000aaa'
'ZZZ9999'.next    #=> 'AAAA0000'



5729
5730
5731
5732
5733
5734
5735
5736
 
# File 'lib/source/ruby.rb', line 5729

def next
  `var v=this._value`
  `if(!/[a-zA-Z0-9]/.test(v)){return $q(v);}`
  `if(/^\\d+$/.test(v)){return $q(''+(+v+1))}`
  `for(var i=v.length-1,carry=i>=0,result='';i>=0;--i){var c=v[i],lc=/[a-z]/.test(c),uc=/[A-Z]/.test(c),n=/[0-9]/.test(c);if($T(carry)&&(lc||uc||n)){if(lc||uc){if(c=='z'||c=='Z'){result=(lc?'a':'A')+result;carry=i;}else{result=String.fromCharCode(c.charCodeAt()+1)+result;carry=false;};}else{if(c=='9'){result='0'+result;carry=i}else{result=''+(+c+1)+result;carry=false;};};}else{result=c+result;};}`
  `if($T(carry)){var c=v[carry],insert=/[a-z]/.test(c)?'a':(/[A-Z]/.test(c)?'A':'1');result=result.slice(0,carry)+insert+result.slice(carry,result.length);}`
  return `$q(result)`
end

#next! ⇒ Object

call-seq:

str.next! -> str
str.succ! -> str

Returns str with its contents replaced by its successor. See String#next for details.



5745
5746
5747
5748
5749
5750
5751
5752
5753
 
# File 'lib/source/ruby.rb', line 5745

def next!
  `var v=this._value`
  `if(!/[a-zA-Z0-9]/.test(v)){return $q(v);}`
  `if(/^\\d+$/.test(v)){return $q(''+(+v+1))}`
  `for(var i=v.length-1,carry=i>=0,result='';i>=0;--i){var c=v[i],lc=/[a-z]/.test(c),uc=/[A-Z]/.test(c),n=/[0-9]/.test(c);if($T(carry)&&(lc||uc||n)){if(lc||uc){if(c=='z'||c=='Z'){result=(lc?'a':'A')+result;carry=i;}else{result=String.fromCharCode(c.charCodeAt()+1)+result;carry=false;};}else{if(c=='9'){result='0'+result;carry=i}else{result=''+(+c+1)+result;carry=false;};};}else{result=c+result;};}`
  `if($T(carry)){var c=v[carry],insert=/[a-z]/.test(c)?'a':(/[A-Z]/.test(c)?'A':'1');result=result.slice(0,carry)+insert+result.slice(carry,result.length);}`
  `this._value=result`
  return self
end

#oct ⇒ Object

call-seq:

str.oct -> num

Treats leading characters from str as a string of hexadecimal digits (with an optional sign) and returns the corresponding number. Zero is returned on error.

'0123'.oct      #=> 83
'-337'.hex      #=> -255
'0'.hex         #=> 0
'abcdef'.hex    #=> 0



5767
5768
5769
5770
 
# File 'lib/source/ruby.rb', line 5767

def oct
  `var result=parseInt(this._value,8)`
  return `result.toString()=='NaN'?0:result`
end

#replace(str) ⇒ Object

call-seq:

str.replace(other) -> str

Replaces the contents of str with the contents of other.

s = 'abc'

s.replace('def')    #=> "def"
s                   #=> "def"



5782
5783
5784
 
# File 'lib/source/ruby.rb', line 5782

def replace(str)
  `this._value=str._value`
end

#reverse ⇒ Object

call-seq:

str.reverse -> string

Returns a new string with the characters from str in reverse order.

'abcdef'.reverse    #=> 'fedcba'



5793
5794
5795
 
# File 'lib/source/ruby.rb', line 5793

def reverse
  `$q(this._value.split('').reverse().join(''))`
end

#reverse! ⇒ Object

call-seq:

str.reverse! -> str

Returns str with its characters reversed.

s = 'abcdef'

s.reverse!    #=> 'fedcba'
s             #=> 'fedcba'



5807
5808
5809
5810
 
# File 'lib/source/ruby.rb', line 5807

def reverse!
  `this._value=this._value.split('').reverse().join('')`
  return self
end

#rindex ⇒ Object

FIX: Incomplete



5813
5814
 
# File 'lib/source/ruby.rb', line 5813

def rindex
end

#rjust ⇒ Object

FIX: Incomplete



5817
5818
 
# File 'lib/source/ruby.rb', line 5817

def rjust
end

#rstrip ⇒ Object

call-seq:

str.rstrip -> string

Returns a copy of str with trailing whitespace removed.

'abcdef    '.rstrip   #=> "abcdef"
'abcdef\r\n'.rstrip   #=> "abcdef"



5828
5829
5830
 
# File 'lib/source/ruby.rb', line 5828

def rstrip
  `$q(this._value.replace(/\\s*$/,''))`
end

#rstrip! ⇒ Object

call-seq:

str.rstrip! -> str

Returns str with trailing whitespace removed, or nil if no changes were made.

s = 'abcdef    '

s.rstrip!   #=> "abcdef"
s.rstrip!   #=> nil
s           #=> "abcdef"



5844
5845
5846
5847
5848
 
# File 'lib/source/ruby.rb', line 5844

def rstrip!
  `var v=this._value`
  `this._value=v.replace(/\\s*$/,'')`
  return `this._value==v?nil:this`
end

#scan ⇒ Object

FIX: Incomplete



5851
5852
 
# File 'lib/source/ruby.rb', line 5851

def scan
end

#size ⇒ Object

call-seq:

str.length -> integer
str.size   -> integer

Returns the number of characters in str.

'abcdef'.size   #=> 6
'ab\ncd'.size   #=> 5



5863
5864
5865
 
# File 'lib/source/ruby.rb', line 5863

def size
  `this._value.length`
end

#slice ⇒ Object

call-seq:

str[num]               -> integer or nil
str[num, num]          -> string or nil
str[range]             -> string or nil
str[regexp]            -> string or nil
str[regexp, num]       -> string or nil
str[other]             -> string or nil
str.slice(num)         -> integer or nil
str.slice(num, num)    -> string or nil
str.slice(range)       -> string or nil
str.slice(regexp)      -> string or nil
str.slice(regexp, num) -> string or nil
str.slice(other)       -> string or nil

FIX: Incomplete



5882
5883
 
# File 'lib/source/ruby.rb', line 5882

def slice
end

#slice! ⇒ Object

call-seq:

str.slice!(num)      -> num or nil
str.slice!(num, num) -> string or nil
str.slice!(range)    -> string or nil
str.slice!(regexp)   -> string or nil
str.slice!(other)    -> string or nil

FIX: Incomplete



5893
5894
 
# File 'lib/source/ruby.rb', line 5893

def slice!
end

#split(pattern = /\s+/, limit = nil) ⇒ Object

FIX: Incomplete



5897
5898
5899
5900
5901
 
# File 'lib/source/ruby.rb', line 5897

def split(pattern = /\s+/, limit = nil)
  `var a=this._value.split(pattern._value),result=[]`
  `for(var i=0,l=a.length;i<l;++i){result.push($q(a[i]));}`
  return `result`
end

#squeeze ⇒ Object

FIX: Incomplete



5904
5905
 
# File 'lib/source/ruby.rb', line 5904

def squeeze
end

#strip ⇒ Object

call-seq:

str.strip -> string

Returns a copy of str with leading and trailing whitespace removed.

'   abcdef   '.strip    #=> "abcdef"
'\tabcdef\r\n'.strip    #=> "abcdef"



5915
5916
5917
 
# File 'lib/source/ruby.rb', line 5915

def strip
  `$q(this._value.replace(/^\\s*|\\s*$/,''))`
end

#strip! ⇒ Object

call-seq:

str.strip! -> str

Returns str with leading and trailing whitespace removed, or nil if no changes were made.

s = '   abcdef   '

s.strip!    #=> "abcdef"
s.strip!    #=> nil
s           #=> "abcdef"



5931
5932
5933
5934
5935
 
# File 'lib/source/ruby.rb', line 5931

def strip!
  `var v=this._value`
  `this._value=v.replace(/^\\s*|\\s*$/,'')`
  return `this._value==v?nil:this`
end

#sub ⇒ Object

FIX: Incomplete



5938
5939
 
# File 'lib/source/ruby.rb', line 5938

def sub
end

#sub! ⇒ Object

FIX: Incomplete



5942
5943
 
# File 'lib/source/ruby.rb', line 5942

def sub!
end

#succ ⇒ Object

call-seq:

str.next -> string
str.succ -> string

Returns the successor to str. The successor is calculated by incrementing characters starting from the rightmost alphanumeric (or the rightmost character if there are no alphanumerics) in the string. Incrementing a digit always results in another digit, and incrementing a letter results in another letter of the same case.

If the increment generates a “carry,” the character to the left is also incremented. This process repeats until there is no carry, adding an additional character of the same type as the leftmost alphanumeric, if necessary.

'abcdef'.succ     #=> 'abcdeg'
'<<kit9>>'.succ   #=> '<<kit10>>'
'1999zzz'.succ    #=> '2000aaa'
'ZZZ9999'.succ    #=> 'AAAA0000'



5965
5966
5967
5968
5969
5970
5971
5972
 
# File 'lib/source/ruby.rb', line 5965

def succ
  `var v=this._value`
  `if(!/[a-zA-Z0-9]/.test(v)){return $q(v);}`
  `if(/^\\d+$/.test(v)){return $q(''+(+v+1))}`
  `for(var i=v.length-1,carry=i>=0,result='';i>=0;--i){var c=v[i],lc=/[a-z]/.test(c),uc=/[A-Z]/.test(c),n=/[0-9]/.test(c);if($T(carry)&&(lc||uc||n)){if(lc||uc){if(c=='z'||c=='Z'){result=(lc?'a':'A')+result;carry=i;}else{result=String.fromCharCode(c.charCodeAt()+1)+result;carry=false;};}else{if(c=='9'){result='0'+result;carry=i}else{result=''+(+c+1)+result;carry=false;};};}else{result=c+result;};}`
  `if($T(carry)){var c=v[carry],insert=/[a-z]/.test(c)?'a':(/[A-Z]/.test(c)?'A':'1');result=result.slice(0,carry)+insert+result.slice(carry,result.length);}`
  return `$q(result)`
end

#succ! ⇒ Object

call-seq:

str.next! -> str
str.succ! -> str

Returns str with its contents replaced by its successor. See String#next for details.



5981
5982
5983
5984
5985
5986
5987
5988
5989
 
# File 'lib/source/ruby.rb', line 5981

def succ!
  `var v=this._value`
  `if(!/[a-zA-Z0-9]/.test(v)){return $q(v);}`
  `if(/^\\d+$/.test(v)){return $q(''+(+v+1))}`
  `for(var i=v.length-1,carry=i>=0,result='';i>=0;--i){var c=v[i],lc=/[a-z]/.test(c),uc=/[A-Z]/.test(c),n=/[0-9]/.test(c);if($T(carry)&&(lc||uc||n)){if(lc||uc){if(c=='z'||c=='Z'){result=(lc?'a':'A')+result;carry=i;}else{result=String.fromCharCode(c.charCodeAt()+1)+result;carry=false;};}else{if(c=='9'){result='0'+result;carry=i}else{result=''+(+c+1)+result;carry=false;};};}else{result=c+result;};}`
  `if($T(carry)){var c=v[carry],insert=/[a-z]/.test(c)?'a':(/[A-Z]/.test(c)?'A':'1');result=result.slice(0,carry)+insert+result.slice(carry,result.length);}`
  `this._value=result`
  return self
end

#sum ⇒ Object

FIX: Incomplete



5992
5993
 
# File 'lib/source/ruby.rb', line 5992

def sum
end

#swapcase ⇒ Object

call-seq:

str.swapcase -> string

Returns a copy of str with uppercase alphabetic characters converted to lowercase and lowercase characters converted to uppercase.

'aBc123'.swapcase   #=> "AbC123"



6003
6004
6005
 
# File 'lib/source/ruby.rb', line 6003

def swapcase
  `$q(this._value.replace(/([a-z]+)|([A-Z]+)/g,function($0,$1,$2){return $1?$0.toUpperCase():$0.toLowerCase();}))`
end

#swapcase! ⇒ Object

call-seq:

str.swapcase! -> str or nil

Returns str with its uppercase alphabetic characters converted to lowercase and its lowercase characters converted to uppercase, or nil if no changes were made.

s1 = 'abcDEF'
s2 = '123'

s1.swapcase!    #=> "ABCdef"
s2.swapcase!    #=> nil
s1              #=> "ABCdef"
s2              #=> "123"



6022
6023
6024
6025
6026
 
# File 'lib/source/ruby.rb', line 6022

def swapcase!
  `var v=this._value`
  `this._value=v.replace(/([a-z]+)|([A-Z]+)/g,function($0,$1,$2){return $1?$0.toUpperCase():$0.toLowerCase();})`
  return `this._value==v?nil:this`
end

#to_f ⇒ Object

call-seq:

str.to_f -> float

Returns the result of interpreting leading characters in str as a floating point number, or 0 if there is not a valid number at the start of str.

'1.2345e3'.to_f       #=> 1234.5
'98.6 degrees'.to_f   #=> 98.6
'abc123'.to_f         #=> 0



6039
6040
6041
6042
 
# File 'lib/source/ruby.rb', line 6039

def to_f
  `var result=parseFloat(this)`
  return `result.toString()=='NaN'?0:result`
end

#to_i(base = 10) ⇒ Object

call-seq:

str.to_i -> integer

Returns the result of interpreting leading characters in str as an integer of base base, or 0 if there is not a valid number at the start of str.

'12345'.to_i          #=> 12345
'76 trombones'.to_i   #=> 76
'0a'.to_i             #=> 0
'0a'.to_i(16)         #=> 10
'abcdef'.to_i         #=> 0
'1100101'.to_i(2)     #=> 101
'1100101'.to_i(8)     #=> 294977
'1100101'.to_i(10)    #=> 1100101
'1100101'.to_i(16)    #=> 17826049



6061
6062
6063
6064
 
# File 'lib/source/ruby.rb', line 6061

def to_i(base = 10)
  `var result=parseInt(this,base)`
  return `result.toString()=='NaN'?0:result`
end

#to_s ⇒ Object

call-seq:

str.to_s   -> str
str.to_str -> str

Returns str.



6072
6073
6074
 
# File 'lib/source/ruby.rb', line 6072

def to_s
  return self
end

#to_str ⇒ Object

call-seq:

str.to_s   -> str
str.to_str -> str

Returns str.



6082
6083
6084
 
# File 'lib/source/ruby.rb', line 6082

def to_str
  return self
end

#to_sym ⇒ Object

call-seq:

str.intern -> symbol
str.to_sym -> symbol

Returns the Symbol corresponding to str, creating the symbol if it did not previously exist. See also Symbol#id2name.

'abcdef'.to_sym   #=> :abcdef



6095
6096
6097
 
# File 'lib/source/ruby.rb', line 6095

def to_sym
  `$s(this._value)`
end

#tr ⇒ Object

FIX: Incomplete



6100
6101
 
# File 'lib/source/ruby.rb', line 6100

def tr
end

#tr! ⇒ Object

FIX: Incomplete



6104
6105
 
# File 'lib/source/ruby.rb', line 6104

def tr!
end

#tr_s ⇒ Object

FIX: Incomplete



6108
6109
 
# File 'lib/source/ruby.rb', line 6108

def tr_s
end

#tr_s! ⇒ Object

FIX: Incomplete



6112
6113
 
# File 'lib/source/ruby.rb', line 6112

def tr_s!
end

#upcase ⇒ Object

call-seq:

str.upcase -> string

Returns a copy of str with all lowercase letters replaced with their uppercase counterparts.

'aBCDEf'.upcase   #=> "ABCDEF"



6123
6124
6125
 
# File 'lib/source/ruby.rb', line 6123

def upcase
  `$q(this._value.toUpperCase())`
end

#upcase! ⇒ Object

call-seq:

str.upcase! -> str or nil

Returns str with all lowercase letters replaced with their uppercase counterparts, or nil if no changes were made.

s = 'aBCDEf'

s.upcase!   #=> "ABCDEF"
s.upcase!   #=> nil
s           #=> "ABCDEF"



6139
6140
6141
6142
6143
 
# File 'lib/source/ruby.rb', line 6139

def upcase!
  `var v=this._value`
  `this._value=v.toUpperCase()`
  return `v==this._value?nil:this`
end

#upto(str, &block) ⇒ Object

FIX: Incomplete



6146
6147
 
# File 'lib/source/ruby.rb', line 6146

def upto(str,&block)
end