In Files

  • minirake
  • mrbgems/mruby-sprintf/mrblib/string.rb
  • mrbgems/mruby-string-ext/mrblib/string.rb
  • mrblib/string.rb

String

Public Instance Methods

%(args) click to toggle source
 
               # File mrbgems/mruby-sprintf/mrblib/string.rb, line 2
def %(args)
  if args.is_a? Array
    sprintf(self, *args)
  else
    sprintf(self, args)
  end
end
            
=~(re) click to toggle source

ISO 15.2.10.5.3

 
               # File mrblib/string.rb, line 168
def =~(re)
  raise TypeError, "type mismatch: String given" if re.respond_to? :to_str
  re =~ self
end
            
[]=(pos, value) click to toggle source

Modify self by replacing the content of self at the position pos with value.

 
               # File mrblib/string.rb, line 159
def []=(pos, value)
  pos += self.length if pos < 0
  b = self[0, pos]
  a = self[pos + 1..-1]
  self.replace([b, value, a].join(''))
end
            
__sub_replace(pre, m, post) click to toggle source

private method for gsub/sub

 
               # File mrblib/string.rb, line 24
def __sub_replace(pre, m, post)
  s = ""
  i = 0
  while j = index("\\", i)
    break if j == length-1
    t = case self[j+1]
        when "\\"
          "\\"
        when "`"
          pre
        when "&", "0"
          m
        when "'"
          post
        else
          self[j, 2]
        end
    s += self[i, j-i] + t
    i = j + 2
  end
  s + self[i, length-i]
end
            
casecmp(other_str) → -1, 0, +1 or nil click to toggle source

Case-insensitive version of String#<=>.

"abcdef".casecmp("abcde")     #=> 1
"aBcDeF".casecmp("abcdef")    #=> 0
"abcdef".casecmp("abcdefg")   #=> -1
"abcdef".casecmp("ABCDEF")    #=> 0
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 122
def casecmp(str)
  self.downcase <=> str.to_str.downcase
rescue NoMethodError
  raise TypeError, "no implicit conversion of #{str.class} into String"
end
            
clear → string click to toggle source

Makes string empty.

a = "abcde"
a.clear    #=> ""
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 12
def clear
  self.replace("")
end
            
each_byte(&block) click to toggle source

Call the given block for each byte of self.

 
               # File mrblib/string.rb, line 146
def each_byte(&block)
  bytes = self.bytes
  pos = 0
  while pos < bytes.size
    block.call(bytes[pos])
    pos += 1
  end
  self
end
            
each_char(&block) click to toggle source

Call the given block for each character of self.

 
               # File mrblib/string.rb, line 135
def each_char(&block)
  pos = 0
  while pos < self.size
    block.call(self[pos])
    pos += 1
  end
  self
end
            
each_line(&block) click to toggle source

Calls the given block for each line and pass the respective line.

ISO 15.2.10.5.15

 
               # File mrblib/string.rb, line 12
def each_line(&block)
  # expect that str.index accepts an Integer for 1st argument as a byte data
  offset = 0
  while pos = self.index(0x0a, offset)
    block.call(self[offset, pos + 1 - offset])
    offset = pos + 1
  end
  block.call(self[offset, self.size - offset]) if self.size > offset
  self
end
            
ext(newext='') click to toggle source
 
               # File minirake, line 11
def ext(newext='')
  return self.dup if ['.', '..'].include? self
  if newext != ''
    newext = (newext =~ /^\./) ? newext : ("." + newext)
  end
  self.chomp(File.extname(self)) << newext
end
            
gsub(*args, &block) click to toggle source

Replace all matches of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Return the final value.

ISO 15.2.10.5.18

 
               # File mrblib/string.rb, line 54
def gsub(*args, &block)
  if args.size == 2
    s = ""
    i = 0
    while j = index(args[0], i)
      seplen = args[0].length
      k = j + seplen
      pre = self[0, j]
      post = self[k, length-k]
      s += self[i, j-i] + args[1].__sub_replace(pre, args[0], post)
      i = k
    end
    s + self[i, length-i]
  elsif args.size == 1 && block
    split(args[0], -1).join(block.call(args[0]))
  else
    raise ArgumentError, "wrong number of arguments"
  end
end
            
gsub!(*args, &block) click to toggle source

Replace all matches of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Modify self with the final value.

ISO 15.2.10.5.19

 
               # File mrblib/string.rb, line 81
def gsub!(*args, &block)
  str = self.gsub(*args, &block)
  return nil if str == self
  self.replace(str)
end
            
insert(index, other_str) → str click to toggle source

Inserts other_str before the character at the given index, modifying str. Negative indices count from the end of the string, and insert after the given character. The intent is insert aString so that it starts at the given index.

"abcd".insert(0, 'X')    #=> "Xabcd"
"abcd".insert(3, 'X')    #=> "abcXd"
"abcd".insert(4, 'X')    #=> "abcdX"
"abcd".insert(-3, 'X')   #=> "abXcd"
"abcd".insert(-1, 'X')   #=> "abcdX"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 237
def insert(idx, str)
  pos = idx.to_i
  pos += self.size + 1 if pos < 0

  raise IndexError, "index #{idx.to_i} out of string" if pos < 0 || pos > self.size

  return self + str if pos == -1
  return str + self if pos == 0
  return self[0..pos - 1] + str + self[pos..-1]
end
            
ljust(integer, padstr=' ') → new_str click to toggle source

If integer is greater than the length of str, returns a new String of length integer with str left justified and padded with padstr; otherwise, returns str.

"hello".ljust(4)            #=> "hello"
"hello".ljust(20)           #=> "hello               "
"hello".ljust(20, '1234')   #=> "hello123412341234123"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 259
def ljust(idx, padstr = ' ')
  if idx <= self.size
    return self
  end
  newstr = self.dup
  newstr << padstr
  while newstr.size <= idx
    newstr << padstr
  end
  return newstr.slice(0,idx)
end
            
lstrip → new_str click to toggle source

Returns a copy of str with leading whitespace removed. See also String#rstrip and String#strip.

"  hello  ".lstrip   #=> "hello  "
"hello".lstrip       #=> "hello"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 26
def lstrip
  a = 0
  z = self.size - 1
  a += 1 while " \f\n\r\t\v".include?(self[a]) and a <= z
  (z >= 0) ? self[a..z] : ""
end
            
lstrip! → self or nil click to toggle source

Removes leading whitespace from str, returning nil if no change was made. See also String#rstrip! and String#strip!.

"  hello  ".lstrip   #=> "hello  "
"hello".lstrip!      #=> nil
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 78
def lstrip!
  s = self.lstrip
  (s == self) ? nil : self.replace(s)
end
            
match(re, &block) click to toggle source

ISO 15.2.10.5.27

 
               # File mrblib/string.rb, line 175
def match(re, &block)
  if re.respond_to? :to_str
    if Object.const_defined?(:Regexp)
      r = Regexp.new(re)
      r.match(self, &block)
    else
      raise NotImplementedError, "String#match needs Regexp class"
    end
  else
    re.match(self, &block)
  end
end
            
partition(sep) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 128
def partition(sep)
  raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String
  n = index(sep)
  unless n.nil?
    m = n + sep.size
    [ slice(0, n), sep, slice(m, size - m) ]
  else
    [ self, "", "" ]
  end
end
            
pathmap(spec=nil, &block) click to toggle source
 
               # File minirake, line 19
def pathmap(spec=nil, &block)
  return self if spec.nil?
  result = ''
  spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
    case frag
    when '%f'
      result << File.basename(self)
    when '%n'
      result << File.basename(self).ext
    when '%d'
      result << File.dirname(self)
    when '%x'
      result << File.extname(self)
    when '%X'
      result << self.ext
    when '%p'
      result << self
    when '%s'
      result << (File::ALT_SEPARATOR || File::SEPARATOR)
    when '%-'
      # do nothing
    when '%%'
      result << "%"
    when /%(-?\d+)d/
      result << pathmap_partial($1.to_i)
    when /^%\{([^}]*)\}(\d*[dpfnxX])/
      patterns, operator = $1, $2
      result << pathmap('%' + operator).pathmap_replace(patterns, &block)
    when /^%/
      fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
    else
      result << frag
    end
  end
  result
end
            
rpartition(sep) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 139
def rpartition(sep)
  raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String
  n = rindex(sep)
  unless n.nil?
    m = n + sep.size
    [ slice(0, n), sep, slice(m, size - m) ]
  else
    [ "", "", self ]
  end
end
            
rstrip → new_str click to toggle source

Returns a copy of str with trailing whitespace removed. See also String#lstrip and String#strip.

"  hello  ".rstrip   #=> "  hello"
"hello".rstrip       #=> "hello"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 43
def rstrip
  a = 0
  z = self.size - 1
  z -= 1 while " \f\n\r\t\v\0".include?(self[z]) and a <= z
  (z >= 0) ? self[a..z] : ""
end
            
rstrip! → self or nil click to toggle source

Removes trailing whitespace from str, returning nil if no change was made. See also String#lstrip! and String#strip!.

"  hello  ".rstrip   #=> "  hello"
"hello".rstrip!      #=> nil
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 94
def rstrip!
  s = self.rstrip
  (s == self) ? nil : self.replace(s)
end
            
scan(reg, &block) click to toggle source

Calls the given block for each match of pattern If no block is given return an array with all matches of pattern.

ISO 15.2.10.5.32

 
               # File mrblib/string.rb, line 93
def scan(reg, &block)
  ### *** TODO *** ###
  unless Object.const_defined?(:Regexp)
    raise NotImplementedError, "scan not available (yet)"
  end
end
            
slice!(fixnum) → new_str or nil click to toggle source
slice!(fixnum, fixnum) → new_str or nil
slice!(range) → new_str or nil
slice!(other_str) → new_str or nil

Deletes the specified portion from str, and returns the portion deleted.

string = "this is a string"
string.slice!(2)        #=> "i"
string.slice!(3..6)     #=> " is "
string.slice!("r")      #=> "r"
string                  #=> "thsa sting"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 166
def slice!(arg1, arg2=nil)
  raise "wrong number of arguments (for 1..2)" if arg1.nil? && arg2.nil?

  if !arg1.nil? && !arg2.nil?
    idx = arg1
    idx += self.size if arg1 < 0
    if idx >= 0 && idx <= self.size && arg2 > 0
      str = self[idx, arg2]
    else
      return nil
    end
  else
    validated = false
    if arg1.kind_of?(Range)
      beg = arg1.begin
      ed = arg1.end
      beg += self.size if beg < 0
      ed += self.size if ed < 0
      ed -= 1 if arg1.exclude_end?
      validated = true
    elsif arg1.kind_of?(String)
      validated = true
    else
      idx = arg1
      idx += self.size if arg1 < 0
      validated = true if idx >=0 && arg1 < self.size   
    end
    if validated
      str = self[arg1]
    else
      return nil
    end
  end
  unless str.nil? || str == ""
    if !arg1.nil? && !arg2.nil?
      idx = arg1 >= 0 ? arg1 : self.size+arg1
      str2 = self[0...idx] + self[idx+arg2..-1].to_s
    else
      if arg1.kind_of?(Range)
        idx = beg >= 0 ? beg : self.size+beg
        idx2 = ed>= 0 ? ed : self.size+ed
        str2 = self[0...idx] + self[idx2+1..-1].to_s
      elsif arg1.kind_of?(String)
        idx = self.index(arg1)
        str2 = self[0...idx] + self[idx+arg1.size..-1] unless idx.nil?
      else
        idx = arg1 >= 0 ? arg1 : self.size+arg1
        str2 = self[0...idx] + self[idx+1..-1].to_s
      end
    end
    self.replace(str2) unless str2.nil?
  end
  str
end
            
strip → new_str click to toggle source

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

"    hello    ".strip   #=> "hello"
"\tgoodbye\r\n".strip   #=> "goodbye"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 59
def strip
  a = 0
  z = self.size - 1
  a += 1 while " \f\n\r\t\v".include?(self[a]) and a <= z
  z -= 1 while " \f\n\r\t\v\0".include?(self[z]) and a <= z
  (z >= 0) ? self[a..z] : ""
end
            
strip! → str or nil click to toggle source

Removes leading and trailing whitespace from str. Returns nil if str was not altered.

 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 106
def strip!
  s = self.strip
  (s == self) ? nil : self.replace(s)
end
            
sub(*args, &block) click to toggle source

Replace only the first match of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Return the final value.

ISO 15.2.10.5.36

 
               # File mrblib/string.rb, line 107
def sub(*args, &block)
  if args.size == 2
    pre, post = split(args[0], 2)
    return self unless post # The sub target wasn't found in the string
    pre + args[1].__sub_replace(pre, args[0], post) + post
  elsif args.size == 1 && block
    split(args[0], 2).join(block.call(args[0]))
  else
    raise ArgumentError, "wrong number of arguments"
  end
end
            
sub!(*args, &block) click to toggle source

Replace only the first match of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Modify self with the final value.

ISO 15.2.10.5.37

 
               # File mrblib/string.rb, line 126
def sub!(*args, &block)
  str = self.sub(*args, &block)
  return nil if str == self
  self.replace(str)
end
            
upto(other_str, excl=false, &block) click to toggle source
str.upto(other_str, exclusive=false) {|s| block }   -> str
str.upto(other_str, exclusive=false)                -> an_enumerator

Iterates through successive values, starting at str and ending at other_str inclusive, passing each value in turn to the block. The String#succ method is used to generate each value. If optional second argument exclusive is omitted or is false, the last value will be included; otherwise it will be excluded.

If no block is given, an enumerator is returned instead.

"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
  print s, ' '
end

produces:

a8 a9 b0 b1 b2 b3 b4 b5 b6
a8 a9 b0 b1 b2 b3 b4 b5 b6

If str and other_str contains only ascii numeric characters, both are recognized as decimal numbers. In addition, the width of string (e.g. leading zeros) is handled appropriately.

"9".upto("11").to_a   #=> ["9", "10", "11"]
"25".upto("5").to_a   #=> []
"07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 300
def upto(other_str, excl=false, &block)
  return to_enum :upto, other_str, excl unless block

  str = self
  n = self.<=>other_str
  return self if n > 0 || (self == other_str && excl)
  while true
    block.call(str)
    return self if !excl && str == other_str
    str = str.succ
    return self if excl && str == other_str
  end
end