Class: String

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
mrblib/string.rb,
mrblib/string.rb,
src/string.c

Overview

15.2.10

Instance Method Summary (collapse)

Methods included from Comparable

#<, #<=, #==, #>, #>=, #between?

Instance Method Details

- (Object) =~(re)

ISO 15.2.10.5.3

Raises:



202
203
204
205
 
# File 'mrblib/string.rb', line 202

def =~(re)
  raise TypeError, "type mismatch: String given" if re.respond_to? :to_str
  re =~ self
end

- (Object) []=(*args)

Modify self by replacing the content of self. The portion of the string affected is determined using the same criteria as String#[].



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'mrblib/string.rb', line 158

def []=(*args)
  anum = args.size
  if anum == 2
    pos, value = args
    if pos.kind_of? String
      posnum = self.index(pos)
      if posnum
        b = self[0, posnum.to_i]
        a = self[(posnum + pos.length)..-1]
        self.replace([b, value, a].join(''))
        return value
      else
        raise IndexError, "string not matched"
      end
    else
      pos += self.length if pos < 0
      if pos < 0 || pos > self.length
        raise IndexError, "index #{args[0]} out of string"
      end
      b = self[0, pos.to_i]
      a = self[pos + 1..-1]
      self.replace([b, value, a].join(''))
      return value
    end
  elsif anum == 3
    pos, len, value = args
    pos += self.length if pos < 0
    if pos < 0 || pos > self.length
      raise IndexError, "index #{args[0]} out of string"
    end
    if len < 0
      raise IndexError, "negative length #{len}"
    end
    b = self[0, pos.to_i]
    a = self[pos + len..-1]
    self.replace([b, value, a].join(''))
    return value
  else
    raise ArgumentError, "wrong number of arguments (#{anum} for 2..3)"
  end
end

- (Object) __sub_replace(pre, m, post)

private method for gsub/sub



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'mrblib/string.rb', line 23

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

- (Object) each_byte(&block)

Call the given block for each byte of self.



145
146
147
148
149
150
151
152
153
 
# File 'mrblib/string.rb', line 145

def each_byte(&block)
  bytes = self.bytes
  pos = 0
  while pos < bytes.size
    block.call(bytes[pos])
    pos += 1
  end
  self
end

- (Object) each_char(&block)

Call the given block for each character of self.



134
135
136
137
138
139
140
141
 
# File 'mrblib/string.rb', line 134

def each_char(&block)
  pos = 0
  while pos < self.size
    block.call(self[pos])
    pos += 1
  end
  self
end

- (Object) each_line(&block)

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

ISO 15.2.10.5.15



12
13
14
15
16
17
18
19
20
 
# File 'mrblib/string.rb', line 12

def each_line(&block)
  offset = 0
  while pos = self.index("\n", 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

- (Object) gsub(*args, &block)

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



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'mrblib/string.rb', line 53

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

- (Object) gsub!(*args, &block)

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



80
81
82
83
84
 
# File 'mrblib/string.rb', line 80

def gsub!(*args, &block)
  str = self.gsub(*args, &block)
  return nil if str == self
  self.replace(str)
end

- (Object) match(re, &block)

ISO 15.2.10.5.27



209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'mrblib/string.rb', line 209

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

- (Object) scan(reg, &block)

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



92
93
94
95
96
97
 
# File 'mrblib/string.rb', line 92

def scan(reg, &block)
  ### *** TODO *** ###
  unless Object.const_defined?(:Regexp)
    raise NotImplementedError, "scan not available (yet)"
  end
end

- (Object) sub(*args, &block)

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



106
107
108
109
110
111
112
113
114
115
116
 
# File 'mrblib/string.rb', line 106

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

- (Object) sub!(*args, &block)

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



125
126
127
128
129
 
# File 'mrblib/string.rb', line 125

def sub!(*args, &block)
  str = self.sub(*args, &block)
  return nil if str == self
  self.replace(str)
end