Class: String

Inherits:
Object show all
Defined in:
lib/source/ruby.rb,
lib/source/redshift/request.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.



5305
5306
5307
# File 'lib/source/ruby.rb', line 5305

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"


5321
5322
5323
5324
# File 'lib/source/ruby.rb', line 5321

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 "


5333
5334
5335
5336
# File 'lib/source/ruby.rb', line 5333

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'


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

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"


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

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


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

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.



5404
5405
5406
5407
# File 'lib/source/ruby.rb', line 5404

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

#=~(str) ⇒ Object

FIX: Incomplete



5410
5411
# File 'lib/source/ruby.rb', line 5410

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



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

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



5441
5442
# File 'lib/source/ruby.rb', line 5441

def []=
end

#capitalizeObject

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"


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

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"


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

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


5487
5488
5489
5490
5491
5492
5493
5494
# File 'lib/source/ruby.rb', line 5487

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

#centerObject

FIX: Incomplete



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

def center
end

#chompObject

FIX: Incomplete



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

def chomp
end

#chomp!Object

FIX: Incomplete



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

def chomp!
end

#chopObject

FIX: Incomplete



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

def chop
end

#chop!Object

FIX: Incomplete



5513
5514
# File 'lib/source/ruby.rb', line 5513

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"


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

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

#countObject

FIX: Incomplete



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

def count
end

#cryptObject

FIX: Incomplete



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

def crypt
end

#deleteObject

FIX: Incomplete



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

def delete
end

#delete!Object

FIX: Incomplete



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

def delete!
end

#downcaseObject

call-seq:

str.downcase -> string

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

'aBCDEf'.downcase   #=> "abcdef"


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

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"


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

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

#eachObject

FIX: Incomplete



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

def each
end

#each_byteObject

FIX: Incomplete



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

def each_byte
end

#each_lineObject

FIX: Incomplete



5591
5592
# File 'lib/source/ruby.rb', line 5591

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)


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

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)


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

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

#gsubObject

FIX: Incomplete



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

def gsub
end

#gsub!Object

FIX: Incomplete



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

def gsub!
end

#hashObject

:nodoc:



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

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

#hexObject

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


5640
5641
5642
5643
# File 'lib/source/ruby.rb', line 5640

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)


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

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

#indexObject

FIX: Incomplete



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

def index
end

#insertObject

FIX: Incomplete



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

def insert
end

#inspectObject

FIX: Incomplete



5668
5669
5670
# File 'lib/source/ruby.rb', line 5668

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

#internObject

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


5681
5682
5683
# File 'lib/source/ruby.rb', line 5681

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

#lengthObject

call-seq:

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

Returns the number of characters in str.

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


5694
5695
5696
# File 'lib/source/ruby.rb', line 5694

def length
  `this.__value__.length`
end

#ljustObject

FIX: Incomplete



5699
5700
# File 'lib/source/ruby.rb', line 5699

def ljust
end

#lstripObject

call-seq:

str.lstrip -> string

Returns a copy of str with leading whitespace removed.

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


5710
5711
5712
# File 'lib/source/ruby.rb', line 5710

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"


5726
5727
5728
5729
5730
# File 'lib/source/ruby.rb', line 5726

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


5743
5744
5745
# File 'lib/source/ruby.rb', line 5743

def match(pattern)
  `$r(pattern.__source__||pattern.__value__,pattern.__options__).m$match(this)`
end

#nextObject

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'


5767
5768
5769
5770
5771
5772
5773
5774
# File 'lib/source/ruby.rb', line 5767

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.



5783
5784
5785
5786
5787
5788
5789
5790
5791
# File 'lib/source/ruby.rb', line 5783

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

#octObject

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


5805
5806
5807
5808
# File 'lib/source/ruby.rb', line 5805

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"


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

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

#reverseObject

call-seq:

str.reverse -> string

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

'abcdef'.reverse    #=> 'fedcba'


5831
5832
5833
# File 'lib/source/ruby.rb', line 5831

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'


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

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

#rindexObject

FIX: Incomplete



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

def rindex
end

#rjustObject

FIX: Incomplete



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

def rjust
end

#rstripObject

call-seq:

str.rstrip -> string

Returns a copy of str with trailing whitespace removed.

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


5866
5867
5868
# File 'lib/source/ruby.rb', line 5866

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"


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

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

#scanObject

FIX: Incomplete



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

def scan
end

#sizeObject

call-seq:

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

Returns the number of characters in str.

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


5901
5902
5903
# File 'lib/source/ruby.rb', line 5901

def size
  `this.__value__.length`
end

#sliceObject

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



5920
5921
# File 'lib/source/ruby.rb', line 5920

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



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

def slice!
end

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

FIX: Incomplete



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

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

#squeezeObject

FIX: Incomplete



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

def squeeze
end

#stripObject

call-seq:

str.strip -> string

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

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


5953
5954
5955
# File 'lib/source/ruby.rb', line 5953

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"


5969
5970
5971
5972
5973
# File 'lib/source/ruby.rb', line 5969

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

#strip_scripts(evaluate = false) ⇒ Object

call-seq:

str.strip_scripts(evaluate = false) -> string

Returns a copy of str with the contents of any <script> tags removed. If evaluate is set to true, the stripped scripts will be evaluated.



222
223
224
225
226
227
# File 'lib/source/redshift/request.rb', line 222

def strip_scripts(evaluate = false)
  scripts = ''
  result = `$q(this.__value__.replace(/<script[^>]*>([\\s\\S]*?)<\\/script>/gi,function(){scripts.__value__+=arguments[1]+'\\n';return '';}))`
  Document.execute_js(scripts) if evaluate
  return result
end

#subObject

FIX: Incomplete



5976
5977
# File 'lib/source/ruby.rb', line 5976

def sub
end

#sub!Object

FIX: Incomplete



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

def sub!
end

#succObject

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'


6003
6004
6005
6006
6007
6008
6009
6010
# File 'lib/source/ruby.rb', line 6003

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.



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

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

#sumObject

FIX: Incomplete



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

def sum
end

#swapcaseObject

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"


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

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"


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

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_fObject

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


6077
6078
6079
6080
# File 'lib/source/ruby.rb', line 6077

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


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

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

#to_sObject

call-seq:

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

Returns str.



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

def to_s
  return self
end

#to_strObject

call-seq:

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

Returns str.



6120
6121
6122
# File 'lib/source/ruby.rb', line 6120

def to_str
  return self
end

#to_symObject

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


6133
6134
6135
# File 'lib/source/ruby.rb', line 6133

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

#trObject

FIX: Incomplete



6138
6139
# File 'lib/source/ruby.rb', line 6138

def tr
end

#tr!Object

FIX: Incomplete



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

def tr!
end

#tr_sObject

FIX: Incomplete



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

def tr_s
end

#tr_s!Object

FIX: Incomplete



6150
6151
# File 'lib/source/ruby.rb', line 6150

def tr_s!
end

#upcaseObject

call-seq:

str.upcase -> string

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

'aBCDEf'.upcase   #=> "ABCDEF"


6161
6162
6163
# File 'lib/source/ruby.rb', line 6161

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"


6177
6178
6179
6180
6181
# File 'lib/source/ruby.rb', line 6177

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

#upto(str, &block) ⇒ Object

FIX: Incomplete



6184
6185
# File 'lib/source/ruby.rb', line 6184

def upto(str,&block)
end