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.



5224
5225
5226
 
# File 'lib/source/ruby.rb', line 5224

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"



5240
5241
5242
5243
 
# File 'lib/source/ruby.rb', line 5240

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 "



5252
5253
5254
5255
 
# File 'lib/source/ruby.rb', line 5252

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'



5265
5266
5267
 
# File 'lib/source/ruby.rb', line 5265

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"



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

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



5308
5309
5310
5311
5312
5313
5314
5315
 
# File 'lib/source/ruby.rb', line 5308

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.



5323
5324
5325
5326
 
# File 'lib/source/ruby.rb', line 5323

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

#=~(str) ⇒ Object

FIX: Incomplete



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

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



5347
5348
 
# File 'lib/source/ruby.rb', line 5347

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



5360
5361
 
# File 'lib/source/ruby.rb', line 5360

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"



5373
5374
5375
5376
 
# File 'lib/source/ruby.rb', line 5373

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"



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

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



5406
5407
5408
5409
5410
5411
5412
5413
 
# File 'lib/source/ruby.rb', line 5406

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



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

def center
end

#chomp ⇒ Object

FIX: Incomplete



5420
5421
 
# File 'lib/source/ruby.rb', line 5420

def chomp
end

#chomp! ⇒ Object

FIX: Incomplete



5424
5425
 
# File 'lib/source/ruby.rb', line 5424

def chomp!
end

#chop ⇒ Object

FIX: Incomplete



5428
5429
 
# File 'lib/source/ruby.rb', line 5428

def chop
end

#chop! ⇒ Object

FIX: Incomplete



5432
5433
 
# File 'lib/source/ruby.rb', line 5432

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"



5450
5451
5452
5453
 
# File 'lib/source/ruby.rb', line 5450

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

#count ⇒ Object

FIX: Incomplete



5456
5457
 
# File 'lib/source/ruby.rb', line 5456

def count
end

#crypt ⇒ Object

FIX: Incomplete



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

def crypt
end

#delete ⇒ Object

FIX: Incomplete



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

def delete
end

#delete! ⇒ Object

FIX: Incomplete



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

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"



5479
5480
5481
 
# File 'lib/source/ruby.rb', line 5479

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"



5495
5496
5497
5498
5499
 
# File 'lib/source/ruby.rb', line 5495

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

#each ⇒ Object

FIX: Incomplete



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

def each
end

#each_byte ⇒ Object

FIX: Incomplete



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

def each_byte
end

#each_line ⇒ Object

FIX: Incomplete



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

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) 


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

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) 


5530
5531
5532
5533
 
# File 'lib/source/ruby.rb', line 5530

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

#gsub ⇒ Object

FIX: Incomplete



5536
5537
 
# File 'lib/source/ruby.rb', line 5536

def gsub
end

#gsub! ⇒ Object

FIX: Incomplete



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

def gsub!
end

#hash ⇒ Object

:nodoc:



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

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



5559
5560
5561
5562
 
# File 'lib/source/ruby.rb', line 5559

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) 


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

def include?(obj)
  `new(RegExp)(typeof(obj)=='number'?String.fromCharCode(obj):obj._value).test(this._value)`
end

#index ⇒ Object

FIX: Incomplete



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

def index
end

#insert ⇒ Object

FIX: Incomplete



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

def insert
end

#inspect ⇒ Object

FIX: Incomplete



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

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



5600
5601
5602
 
# File 'lib/source/ruby.rb', line 5600

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



5613
5614
5615
 
# File 'lib/source/ruby.rb', line 5613

def length
  `this._value.length`
end

#ljust ⇒ Object

FIX: Incomplete



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

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"



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

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"



5645
5646
5647
5648
5649
 
# File 'lib/source/ruby.rb', line 5645

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



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

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'



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

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.



5702
5703
5704
5705
5706
5707
5708
5709
5710
 
# File 'lib/source/ruby.rb', line 5702

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



5724
5725
5726
5727
 
# File 'lib/source/ruby.rb', line 5724

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"



5739
5740
5741
 
# File 'lib/source/ruby.rb', line 5739

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'



5750
5751
5752
 
# File 'lib/source/ruby.rb', line 5750

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'



5764
5765
5766
5767
 
# File 'lib/source/ruby.rb', line 5764

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

#rindex ⇒ Object

FIX: Incomplete



5770
5771
 
# File 'lib/source/ruby.rb', line 5770

def rindex
end

#rjust ⇒ Object

FIX: Incomplete



5774
5775
 
# File 'lib/source/ruby.rb', line 5774

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"



5785
5786
5787
 
# File 'lib/source/ruby.rb', line 5785

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"



5801
5802
5803
5804
5805
 
# File 'lib/source/ruby.rb', line 5801

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

#scan ⇒ Object

FIX: Incomplete



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

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



5820
5821
5822
 
# File 'lib/source/ruby.rb', line 5820

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



5839
5840
 
# File 'lib/source/ruby.rb', line 5839

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



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

def slice!
end

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

FIX: Incomplete



5854
5855
5856
5857
5858
 
# File 'lib/source/ruby.rb', line 5854

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



5861
5862
 
# File 'lib/source/ruby.rb', line 5861

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"



5872
5873
5874
 
# File 'lib/source/ruby.rb', line 5872

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"



5888
5889
5890
5891
5892
 
# File 'lib/source/ruby.rb', line 5888

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

#sub ⇒ Object

FIX: Incomplete



5895
5896
 
# File 'lib/source/ruby.rb', line 5895

def sub
end

#sub! ⇒ Object

FIX: Incomplete



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

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'



5922
5923
5924
5925
5926
5927
5928
5929
 
# File 'lib/source/ruby.rb', line 5922

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.



5938
5939
5940
5941
5942
5943
5944
5945
5946
 
# File 'lib/source/ruby.rb', line 5938

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



5949
5950
 
# File 'lib/source/ruby.rb', line 5949

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"



5960
5961
5962
 
# File 'lib/source/ruby.rb', line 5960

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"



5979
5980
5981
5982
5983
 
# File 'lib/source/ruby.rb', line 5979

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



5996
5997
5998
5999
 
# File 'lib/source/ruby.rb', line 5996

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



6018
6019
6020
6021
 
# File 'lib/source/ruby.rb', line 6018

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.



6029
6030
6031
 
# File 'lib/source/ruby.rb', line 6029

def to_s
  return self
end

#to_str ⇒ Object

call-seq:

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

Returns str.



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

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



6052
6053
6054
 
# File 'lib/source/ruby.rb', line 6052

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

#tr ⇒ Object

FIX: Incomplete



6057
6058
 
# File 'lib/source/ruby.rb', line 6057

def tr
end

#tr! ⇒ Object

FIX: Incomplete



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

def tr!
end

#tr_s ⇒ Object

FIX: Incomplete



6065
6066
 
# File 'lib/source/ruby.rb', line 6065

def tr_s
end

#tr_s! ⇒ Object

FIX: Incomplete



6069
6070
 
# File 'lib/source/ruby.rb', line 6069

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"



6080
6081
6082
 
# File 'lib/source/ruby.rb', line 6080

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"



6096
6097
6098
6099
6100
 
# File 'lib/source/ruby.rb', line 6096

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

#upto(str, &block) ⇒ Object

FIX: Incomplete



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

def upto(str,&block)
end