Class: String

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
mrblib/string.rb,
mrbgems/mruby-sprintf/mrblib/string.rb,
mrbgems/mruby-string-ext/mrblib/string.rb

Overview

String

ISO 15.2.10

Instance Method Summary collapse

Methods included from Comparable

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

Instance Method Details

#%(args) ⇒ Object

call-seq:

str % arg   -> new_str
str % args  -> new_str

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 or Hash containing the values to be substituted. See sprintf for details of the format string.

"%05d" % 123                              #=> "00123"
"%-5s: %016x" % [ "ID", self.object_id ]  #=> "ID   : 00002b054ec93168"
"foo = %{foo}" % { :foo => 'bar' }        #=> "foo = bar"
"%{foo}f" % { :foo => 1 }                 #=> "1f"


17
18
19
20
21
22
23
 
# File 'mrbgems/mruby-sprintf/mrblib/string.rb', line 17

def %(args)
  if args.is_a? Array
    sprintf(self, *args)
  else
    sprintf(self, args)
  end
end

#__upto_endless(&block) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'mrbgems/mruby-string-ext/mrblib/string.rb', line 146

def __upto_endless(&block)
  len = self.length
  # both edges are all digits
  bi = self.to_i(10)
  if bi > 0 or bi == "0"*len
    while true
      s = bi.to_s
      s = s.rjust(len, "0") if s.length < len
      yield s
      bi += 1
    end
    return self
  end
  bs = self
  while true
    yield bs
    bs = bs.succ
  end
  self
end

#chars(&block) ⇒ Object

call-seq:

str.chars                   -> array
str.chars {|char| block }   -> str

Returns an array of characters in str when called without a block. When called with a block, passes each character to the block.

"hello".chars                #=> ["h", "e", "l", "l", "o"]
"hello".chars {|c| print c } #=> "hello"


27
28
29
30
31
32
33
34
 
# File 'mrbgems/mruby-string-ext/mrblib/string.rb', line 27

def chars(&block)
  if block_given?
    __chars.each(&block)
    self
  else
    __chars
  end
end

#codepoints(&block) ⇒ Object Also known as: each_codepoint 



36
37
38
39
40
41
42
43
44
45
46
 
# File 'mrbgems/mruby-string-ext/mrblib/string.rb', line 36

def codepoints(&block)
  cp = __codepoints()
  if block_given?
    cp.each do|x|
      block.call(x)
    end
    self
  else
    cp
  end
end

#each_byte(&block) ⇒ Object

Call the given block for each byte of self.



151
152
153
154
155
156
157
158
159
 
# File 'mrblib/string.rb', line 151

def each_byte(&block)
  return to_enum(:each_byte, &block) unless block
  pos = 0
  while pos < bytesize
    block.call(getbyte(pos))
    pos += 1
  end
  self
end

#each_char(&block) ⇒ Object

Call the given block for each character of self.



6
7
8
9
10
11
12
13
14
 
# File 'mrbgems/mruby-string-ext/mrblib/string.rb', line 6

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

#each_line(separator = "\n", &block) ⇒ Object

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

ISO 15.2.10.5.15

Raises:

  • (TypeError) 


14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'mrblib/string.rb', line 14

def each_line(separator = "\n", &block)
  return to_enum(:each_line, separator) unless block

  if separator.nil?
    block.call(self)
    return self
  end
  raise TypeError unless separator.is_a?(String)

  paragraph_mode = false
  if separator.empty?
    paragraph_mode = true
    separator = "\n\n"
  end
  start = 0
  string = dup
  self_len = self.bytesize
  sep_len = separator.bytesize

  while (pointer = string.byteindex(separator, start))
    pointer += sep_len
    pointer += 1 while paragraph_mode && string.getbyte(pointer) == 10 # 10 == \n
    block.call(string.byteslice(start, pointer - start))
    start = pointer
  end
  return self if start == self_len

  block.call(string.byteslice(start, self_len - start))
  self
end

#gsub(*args, &block) ⇒ Object

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

Raises:

  • (ArgumentError) 


52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'mrblib/string.rb', line 52

def gsub(*args, &block)
  return to_enum(:gsub, *args) if args.length == 1 && !block
  raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..2)" unless (1..2).include?(args.length)

  pattern, replace = *args
  plen = pattern.length
  if args.length == 2 && block
    block = nil
  end
  offset = 0
  result = []
  while found = self.byteindex(pattern, offset)
    result << self.byteslice(offset, found - offset)
    offset = found + plen
    result << if block
      block.call(pattern).to_s
    else
      self.__sub_replace(replace, pattern, found)
    end
    if plen == 0
      result << self.byteslice(offset, 1)
      offset += 1
    end
  end
  result << self.byteslice(offset..-1) if offset < length
  result.join
end

#gsub!(*args, &block) ⇒ Object

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

Raises:

  • (FrozenError) 


87
88
89
90
91
92
93
 
# File 'mrblib/string.rb', line 87

def gsub!(*args, &block)
  raise FrozenError, "can't modify frozen String" if frozen?
  return to_enum(:gsub!, *args) if args.length == 1 && !block
  str = self.gsub(*args, &block)
  return nil unless self.index(args[0])
  self.replace(str)
end

#lines(&blk) ⇒ Object

call-seq:

string.lines                ->  array of string
string.lines {|s| block}    ->  array of string

Returns strings per line;

a = "abc\ndef"
a.lines    #=> ["abc\n", "def"]

If a block is given, it works the same as each_line.



60
61
62
63
64
65
66
67
68
69
70
 
# File 'mrbgems/mruby-string-ext/mrblib/string.rb', line 60

def lines(&blk)
  lines = self.__lines
  if blk
    lines.each do |line|
      blk.call(line)
    end
    self
  else
    lines
  end
end

#sub(*args, &block) ⇒ Object

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



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'mrblib/string.rb', line 112

def sub(*args, &block)
  unless (1..2).include?(args.length)
    raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 2)"
  end

  pattern, replace = *args
  if args.length == 2 && block
    block = nil
  end
  result = []
  found = self.index(pattern)
  return self.dup unless found
  result << self.byteslice(0, found)
  offset = found + pattern.length
  result << if block
    block.call(pattern).to_s
  else
    self.__sub_replace(replace, pattern, found)
  end
  result << self.byteslice(offset..-1) if offset < length
  result.join
end

#sub!(*args, &block) ⇒ Object

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

Raises:

  • (FrozenError) 


142
143
144
145
146
147
 
# File 'mrblib/string.rb', line 142

def sub!(*args, &block)
  raise FrozenError, "can't modify frozen String" if frozen?
  str = self.sub(*args, &block)
  return nil unless self.index(args[0])
  self.replace(str)
end

#upto(max, exclusive = false, &block) ⇒ Object

call-seq: 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"]

Raises:

  • (TypeError) 


102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'mrbgems/mruby-string-ext/mrblib/string.rb', line 102

def upto(max, exclusive=false, &block)
  return to_enum(:upto, max, exclusive) unless block
  raise TypeError, "no implicit conversion of #{max.class} into String" unless max.kind_of? String

  len = self.length
  maxlen = max.length
  # single character
  if len == 1 and maxlen == 1
    c = self.ord
    e = max.ord
    while c <= e
      break if exclusive and c == e
      yield c.chr(__ENCODING__)
      c += 1
    end
    return self
  end
  # both edges are all digits
  bi = self.to_i(10)
  ei = max.to_i(10)
  if (bi > 0 or bi == "0"*len) and (ei > 0 or ei == "0"*maxlen)
    while bi <= ei
      break if exclusive and bi == ei
      s = bi.to_s
      s = s.rjust(len, "0") if s.length < len
      yield s
      bi += 1
    end
    return self
  end
  bs = self
  while true
    n = (bs <=> max)
    break if n > 0
    break if exclusive and n == 0
    yield bs
    break if n == 0
    bsiz = bs.size
    break if bsiz > max.size || bsiz == 0
    bs = bs.succ
  end
  self
end