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 139
def =~(re)
  if re.respond_to? :to_str
    raise TypeError, "type mismatch: String given"
  end
  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 131
def []=(pos, value)
  b = self[0, pos]
  a = self[pos+1..-1]
  self.replace([b, value, a].join(''))
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 118
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 107
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 30
def gsub(*args, &block)
  if args.size == 2
    split(args[0], -1).join(args[1])
  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 47
def gsub!(*args, &block)
  str = self.gsub(*args, &block)
  if str != self
    self.replace(str)
    self
  else
    nil
  end
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 148
def match(re, &block)
  re.match(self, &block)
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 63
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
      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]
    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]
      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]
      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 77
def sub(*args, &block)
  if args.size == 2
    split(args[0], 2).join(args[1])
  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 94
def sub!(*args, &block)
  str = self.sub(*args, &block)
  if str != self
    self.replace(str)
    self
  else
    nil
  end
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus