Class: Hash

Inherits:
Object show all
Includes:
Enumerable
Defined in:
ext/enterprise_script_service/mruby/mrblib/hash.rb,
ext/enterprise_script_service/mruby/mrblib/hash.rb,
ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb

Overview

Hash is enumerable

ISO 15.2.13.3

Constant Summary

Constants included from Enumerable

Enumerable::NONE

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Enumerable

#all?, #any?, #chain, #collect, #count, #cycle, #detect, #drop, #drop_while, #each_cons, #each_slice, #each_with_index, #each_with_object, #entries, #filter_map, #find_all, #find_index, #first, #flat_map, #grep, #group_by, #hash, #include?, #inject, #lazy, #max, #max_by, #min, #min_by, #minmax, #minmax_by, #none?, #one?, #partition, #reverse_each, #sort, #sort_by, #take, #take_while, #tally, #uniq, #zip

Class Method Details

.[](*object) ⇒ Object

call-seq:

Hash[ key, value, ... ] -> new_hash
Hash[ [ [key, value], ... ] ] -> new_hash
Hash[ object ] -> new_hash

Creates a new hash populated with the given objects.

Similar to the literal ‘{ key => value, … }`. In the first form, keys and values occur in pairs, so there must be an even number of arguments.

The second and third form take a single argument which is either an array of key-value pairs or an object convertible to a hash.

Hash["a", 100, "b", 200] #=> {"a"=>100, "b"=>200}
Hash[ [ ["a", 100], ["b", 200] ] ] #=> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] #=> {"a"=>100, "b"=>200}


26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 26

def self.[](*object)
  length = object.length
  if length == 1
    o = object[0]
    if Hash === o
      h = self.new
      o.each { |k, v| h[k] = v }
      return h
    elsif o.respond_to?(:to_a)
      h = self.new
      o.to_a.each do |i|
        raise ArgumentError, "wrong element type #{i.class} (expected array)" unless i.respond_to?(:to_a)
        k, v = nil
        case i.size
        when 2
          k = i[0]
          v = i[1]
        when 1
          k = i[0]
        else
          raise ArgumentError, "invalid number of elements (#{i.size} for 1..2)"
        end
        h[k] = v
      end
      return h
    end
  end
  unless length % 2 == 0
    raise ArgumentError, 'odd number of arguments for Hash'
  end
  h = self.new
  0.step(length - 2, 2) do |i|
    h[object[i]] = object[i + 1]
  end
  h
end

Instance Method Details

#<(hash) ⇒ Object

call-seq:

  hash < other -> true or false

Returns <code>true</code> if <i>hash</i> is subset of
<i>other</i>.

   h1 = {a:1, b:2}
   h2 = {a:1, b:2, c:3}
   h1 < h2    #=> true
   h2 < h1    #=> false
   h1 < h1    #=> false

Raises:


312
313
314
315
316
317
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 312

def <(hash)
  raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
  size < hash.size and all? {|key, val|
    hash.key?(key) and hash[key] == val
  }
end

#<=(hash) ⇒ Object

call-seq:

  hash <= other -> true or false

Returns <code>true</code> if <i>hash</i> is subset of
<i>other</i> or equals to <i>other</i>.

   h1 = {a:1, b:2}
   h2 = {a:1, b:2, c:3}
   h1 <= h2   #=> true
   h2 <= h1   #=> false
   h1 <= h1   #=> true

Raises:


332
333
334
335
336
337
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 332

def <=(hash)
  raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
  size <= hash.size and all? {|key, val|
    hash.key?(key) and hash[key] == val
  }
end

#==(hash) ⇒ Object

Equality—Two hashes are equal if they each contain the same number

of keys and if each key-value pair is equal to (according to
<code>Object#==</code>) the corresponding elements in the other
hash.

ISO 15.2.13.4.1


13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 13

def ==(hash)
  return true if self.equal?(hash)
  unless Hash === hash
    return false
  end
  return false if self.size != hash.size
  self.each do |k,v|
    return false unless hash.key?(k)
    return false unless self[k] == hash[k]
  end
  return true
end

#>(hash) ⇒ Object

call-seq:

  hash > other -> true or false

Returns <code>true</code> if <i>other</i> is subset of
<i>hash</i>.

   h1 = {a:1, b:2}
   h2 = {a:1, b:2, c:3}
   h1 > h2    #=> false
   h2 > h1    #=> true
   h1 > h1    #=> false

Raises:


352
353
354
355
356
357
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 352

def >(hash)
  raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
  size > hash.size and hash.all? {|key, val|
    key?(key) and self[key] == val
  }
end

#>=(hash) ⇒ Object

call-seq:

  hash >= other -> true or false

Returns <code>true</code> if <i>other</i> is subset of
<i>hash</i> or equals to <i>hash</i>.

   h1 = {a:1, b:2}
   h2 = {a:1, b:2, c:3}
   h1 >= h2   #=> false
   h2 >= h1   #=> true
   h1 >= h1   #=> true

Raises:


372
373
374
375
376
377
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 372

def >=(hash)
  raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
  size >= hash.size and hash.all? {|key, val|
    key?(key) and self[key] == val
  }
end

#_inspect(recur_list) ⇒ Object

internal method for Hash inspection


189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 189

def _inspect(recur_list)
  return "{}" if self.size == 0
  return "{...}" if recur_list[self.object_id]
  recur_list[self.object_id] = true
  ary=[]
  keys=self.keys
  vals=self.values
  size=keys.size
  i=0
  while i<size
    ary<<(keys[i]._inspect(recur_list) + "=>" + vals[i]._inspect(recur_list))
    i+=1
  end
  "{"+ary.join(", ")+"}"
end

#compact ⇒ Object

call-seq:

hsh.compact     -> new_hsh

Returns a new hash with the nil values/key pairs removed

h = { a: 1, b: false, c: nil }
h.compact     #=> { a: 1, b: false }
h             #=> { a: 1, b: false, c: nil }


133
134
135
136
137
138
139
140
141
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 133

def compact
  h = {}
  self.keys.select{|k|
    self[k] != nil
  }.each {|k|
    h[k] = self[k]
  }
  h
end

#compact! ⇒ Object

call-seq:

hsh.compact!    -> hsh

Removes all nil values from the hash. Returns the hash. Returns nil if the hash does not contain nil values.

h = { a: 1, b: false, c: nil }
h.compact!     #=> { a: 1, b: false }


109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 109

def compact!
  keys = self.keys
  nk = keys.select{|k|
    self[k] != nil
  }
  return nil if (keys.size == nk.size)
  h = {}
  nk.each {|k|
    h[k] = self[k]
  }
  h
  self.replace(h)
end

#delete(key, &block) ⇒ Object

Delete the element with the key key. Return the value of the element if key was found. Return nil if nothing was found. If a block is given, call the block with the value of the element.

ISO 15.2.13.4.8


52
53
54
55
56
57
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 52

def delete(key, &block)
  if block && !self.has_key?(key)
    return block.call(key)
  end
  self.__delete(key)
end

#delete_if(&block) ⇒ Object

call-seq:

   hsh.delete_if {| key, value | block }  -> hsh
   hsh.delete_if                          -> an_enumerator

Deletes every key-value pair from <i>hsh</i> for which <i>block</i>
evaluates to <code>true</code>.

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

   h = { "a" => 100, "b" => 200, "c" => 300 }
   h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}


199
200
201
202
203
204
205
206
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 199

def delete_if(&block)
  return to_enum :delete_if unless block

  self.each do |k, v|
    self.delete(k) if block.call(k, v)
  end
  self
end

#dig(idx, *args) ⇒ Object

call-seq:

hsh.dig(key,...)                 -> object

Extracts the nested value specified by the sequence of key objects by calling dig at each step, returning nil if any intermediate step is nil.


387
388
389
390
391
392
393
394
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 387

def dig(idx,*args)
  n = self[idx]
  if args.size > 0
    n&.dig(*args)
  else
    n
  end
end

#each(&block) ⇒ Object Also known as: each_pair

Calls the given block for each element of self and pass the key and value of each element.

call-seq:

hsh.each      {| key, value | block } -> hsh
hsh.each_pair {| key, value | block } -> hsh
hsh.each                              -> an_enumerator
hsh.each_pair                         -> an_enumerator

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

h = { "a" => 100, "b" => 200 }
h.each {|key, value| puts "#{key} is #{value}" }

produces:

a is 100 b is 200

ISO 15.2.13.4.9


81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 81

def each(&block)
  return to_enum :each unless block

  keys = self.keys
  vals = self.values
  len = self.size
  i = 0
  while i < len
    block.call [keys[i], vals[i]]
    i += 1
  end
  self
end

#each_key(&block) ⇒ Object

Calls the given block for each element of self and pass the key of each element.

call-seq:

hsh.each_key {| key | block } -> hsh
hsh.each_key                  -> an_enumerator

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

h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }

produces:

a
b

ISO 15.2.13.4.10


114
115
116
117
118
119
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 114

def each_key(&block)
  return to_enum :each_key unless block

  self.keys.each{|k| block.call(k)}
  self
end

#each_value(&block) ⇒ Object

Calls the given block for each element of self and pass the value of each element.

call-seq:

hsh.each_value {| value | block } -> hsh
hsh.each_value                    -> an_enumerator

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

h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }

produces:

100
200

ISO 15.2.13.4.11


140
141
142
143
144
145
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 140

def each_value(&block)
  return to_enum :each_value unless block

  self.values.each{|v| block.call(v)}
  self
end

#eql?(hash) ⇒ Boolean

Returns true if hash and other are both hashes with the same content compared by eql?.

ISO 15.2.13.4.32 (x)

Returns:

  • (Boolean) 

31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 31

def eql?(hash)
  return true if self.equal?(hash)
  unless Hash === hash
    return false
  end
  return false if self.size != hash.size
  self.each do |k,v|
    return false unless hash.key?(k)
    return false unless self[k].eql?(hash[k])
  end
  return true
end

#fetch(key, none = NONE, &block) ⇒ Object

call-seq:

   hsh.fetch(key [, default] )       -> obj
   hsh.fetch(key) {| key | block }   -> obj

Returns a value from the hash for the given key. If the key can't be
found, there are several options: With no other arguments, it will
raise an <code>KeyError</code> exception; if <i>default</i> is
given, then that will be returned; if the optional code block is
specified, then that will be run and its result returned.

   h = { "a" => 100, "b" => 200 }
   h.fetch("a")                            #=> 100
   h.fetch("z", "go fish")                 #=> "go fish"
   h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"

The following example shows that an exception is raised if the key
is not found and a default value is not supplied.

   h = { "a" => 100, "b" => 200 }
   h.fetch("z")

<em>produces:</em>

   prog.rb:2:in 'fetch': key not found (KeyError)
    from prog.rb:2


171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 171

def fetch(key, none=NONE, &block)
  unless self.key?(key)
    if block
      block.call(key)
    elsif none != NONE
      none
    else
      raise KeyError, "Key not found: #{key.inspect}"
    end
  else
    self[key]
  end
end

#fetch_values(*keys, &block) ⇒ Object

call-seq:

hsh.fetch_values(key, ...)                 -> array
hsh.fetch_values(key, ...) { |key| block } -> array

Returns an array containing the values associated with the given keys but also raises KeyError when one of keys can’t be found. Also see Hash#values_at and Hash#fetch.

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }

h.fetch_values("cow", "cat")                   #=> ["bovine", "feline"]
h.fetch_values("cow", "bird")                  # raises KeyError
h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]


492
493
494
495
496
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 492

def fetch_values(*keys, &block)
  keys.map do |k|
    self.fetch(k, &block)
  end
end

#flatten(level = 1) ⇒ Object

call-seq:

   hash.flatten -> an_array
   hash.flatten(level) -> an_array

Returns a new array that is a one-dimensional flattening of this
hash. That is, for every key or value that is an array, extract
its elements into the new array.  Unlike Array#flatten, this
method does not flatten recursively by default.  The optional
<i>level</i> argument determines the level of recursion to flatten.

   a =  {1=> "one", 2 => [2,"two"], 3 => "three"}
   a.flatten    # => [1, "one", 2, [2, "two"], 3, "three"]
   a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]


224
225
226
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 224

def flatten(level=1)
  self.to_a.flatten(level)
end

#inspect ⇒ Object Also known as: to_s

ISO 15.2.13.4.30 (x)


208
209
210
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 208

def inspect
  self._inspect({})
end

#invert ⇒ Object

call-seq:

   hsh.invert -> new_hash

Returns a new hash created by using <i>hsh</i>'s values as keys, and
the keys as values.

   h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
   h.invert   #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"}


239
240
241
242
243
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 239

def invert
  h = self.class.new
  self.each {|k, v| h[v] = k }
  h
end

#keep_if(&block) ⇒ Object

call-seq:

   hsh.keep_if {| key, value | block }  -> hsh
   hsh.keep_if                          -> an_enumerator

Deletes every key-value pair from <i>hsh</i> for which <i>block</i>
evaluates to false.

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


256
257
258
259
260
261
262
263
264
265
266
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 256

def keep_if(&block)
  return to_enum :keep_if unless block

  keys = []
  self.each do |k, v|
    unless block.call([k, v])
      self.delete(k)
    end
  end
  self
end

#key(val) ⇒ Object

call-seq:

   hsh.key(value)    -> key

Returns the key of an occurrence of a given value. If the value is
not found, returns <code>nil</code>.

   h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
   h.key(200)   #=> "b"
   h.key(300)   #=> "c"
   h.key(999)   #=> nil


281
282
283
284
285
286
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 281

def key(val)
  self.each do |k, v|
    return k if v == val
  end
  nil
end

#merge(other, &block) ⇒ Object

Return a hash which contains the content of self and other. If a block is given it will be called for each element with a duplicate key. The value of the block will be the final value of this element.

ISO 15.2.13.4.22

Raises:


175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 175

def merge(other, &block)
  raise TypeError, "Hash required (#{other.class} given)" unless Hash === other
  h = self.dup
  if block
    other.each_key{|k|
      h[k] = (self.has_key?(k))? block.call(k, self[k], other[k]): other[k]
    }
  else
    other.each_key{|k| h[k] = other[k]}
  end
  h
end

#merge!(other, &block) ⇒ Object Also known as: update

call-seq:

   hsh.merge!(other_hash)                                 -> hsh
   hsh.merge!(other_hash){|key, oldval, newval| block}    -> hsh

Adds the contents of _other_hash_ to _hsh_.  If no block is specified,
entries with duplicate keys are overwritten with the values from
_other_hash_, otherwise the value of each duplicate key is determined by
calling the block with the key, its value in _hsh_ and its value in
_other_hash_.

   h1 = { "a" => 100, "b" => 200 }
   h2 = { "b" => 254, "c" => 300 }
   h1.merge!(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}

   h1 = { "a" => 100, "b" => 200 }
   h2 = { "b" => 254, "c" => 300 }
   h1.merge!(h2) { |key, v1, v2| v1 }
                   #=> {"a"=>100, "b"=>200, "c"=>300}

Raises:


84
85
86
87
88
89
90
91
92
93
94
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 84

def merge!(other, &block)
  raise TypeError, "Hash required (#{other.class} given)" unless Hash === other
  if block
    other.each_key{|k|
      self[k] = (self.has_key?(k))? block.call(k, self[k], other[k]): other[k]
    }
  else
    other.each_key{|k| self[k] = other[k]}
  end
  self
end

#reject(&block) ⇒ Object

call-seq:

   hsh.reject {|key, value| block}   -> a_hash
   hsh.reject                        -> an_enumerator

Returns a new hash consisting of entries for which the block returns false.

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

   h = { "a" => 100, "b" => 200, "c" => 300 }
   h.reject {|k,v| k < "b"}  #=> {"b" => 200, "c" => 300}
   h.reject {|k,v| v > 100}  #=> {"a" => 100}

1.8/1.9 Hash#reject returns Hash; ISO says nothing.


255
256
257
258
259
260
261
262
263
264
265
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 255

def reject(&block)
  return to_enum :reject unless block

  h = {}
  self.each{|k,v|
    unless block.call([k, v])
      h[k] = v
    end
  }
  h
end

#reject!(&block) ⇒ Object

call-seq:

   hsh.reject! {| key, value | block }  -> hsh or nil
   hsh.reject!                          -> an_enumerator

Equivalent to <code>Hash#delete_if</code>, but returns
<code>nil</code> if no changes were made.

1.8/1.9 Hash#reject! returns Hash; ISO says nothing.


224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 224

def reject!(&block)
  return to_enum :reject! unless block

  keys = []
  self.each{|k,v|
    if block.call([k, v])
      keys.push(k)
    end
  }
  return nil if keys.size == 0
  keys.each{|k|
    self.delete(k)
  }
  self
end

#replace(hash) ⇒ Object Also known as: initialize_copy

Replaces the contents of hsh with the contents of other hash

ISO 15.2.13.4.23

Raises:


151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 151

def replace(hash)
  raise TypeError, "Hash required (#{hash.class} given)" unless Hash === hash
  self.clear
  hash.each_key{|k|
    self[k] = hash[k]
  }
  if hash.default_proc
    self.default_proc = hash.default_proc
  else
    self.default = hash.default
  end
  self
end

#select(&block) ⇒ Object Also known as: filter

call-seq:

   hsh.select {|key, value| block}   -> a_hash
   hsh.select                        -> an_enumerator

Returns a new hash consisting of entries for which the block returns true.

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

   h = { "a" => 100, "b" => 200, "c" => 300 }
   h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
   h.select {|k,v| v < 200}  #=> {"a" => 100}

1.9 Hash#select returns Hash; ISO says nothing


308
309
310
311
312
313
314
315
316
317
318
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 308

def select(&block)
  return to_enum :select unless block

  h = {}
  self.each{|k,v|
    if block.call([k, v])
      h[k] = v
    end
  }
  h
end

#select!(&block) ⇒ Object Also known as: filter!

call-seq:

   hsh.select! {| key, value | block }  -> hsh or nil
   hsh.select!                          -> an_enumerator

Equivalent to <code>Hash#keep_if</code>, but returns
<code>nil</code> if no changes were made.

1.9 Hash#select! returns Hash; ISO says nothing.


277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'ext/enterprise_script_service/mruby/mrblib/hash.rb', line 277

def select!(&block)
  return to_enum :select! unless block

  keys = []
  self.each{|k,v|
    unless block.call([k, v])
      keys.push(k)
    end
  }
  return nil if keys.size == 0
  keys.each{|k|
    self.delete(k)
  }
  self
end

#to_h ⇒ Object

call-seq:

   hsh.to_h     -> hsh or new_hash

Returns +self+. If called on a subclass of Hash, converts
the receiver to a Hash object.


295
296
297
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 295

def to_h
  self
end

#to_proc ⇒ Object 


473
474
475
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 473

def to_proc
  ->x{self[x]}
end

#transform_keys(&block) ⇒ Object

call-seq:

hsh.transform_keys {|key| block } -> new_hash
hsh.transform_keys                -> an_enumerator

Returns a new hash, with the keys computed from running the block once for each key in the hash, and the values unchanged.

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


406
407
408
409
410
411
412
413
414
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 406

def transform_keys(&block)
  return to_enum :transform_keys unless block
  hash = {}
  self.keys.each do |k|
    new_key = block.call(k)
    hash[new_key] = self[k]
  end
  hash
end

#transform_keys!(&block) ⇒ Object

call-seq:

hsh.transform_keys! {|key| block } -> hsh
hsh.transform_keys!                -> an_enumerator

Invokes the given block once for each key in hsh, replacing it with the new key returned by the block, and then returns hsh.

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


425
426
427
428
429
430
431
432
433
434
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 425

def transform_keys!(&block)
  return to_enum :transform_keys! unless block
  self.keys.each do |k|
    value = self[k]
    self.__delete(k)
    k = block.call(k) if block
    self[k] = value
  end
  self
end

#transform_values(&b) ⇒ Object

call-seq:

hsh.transform_values {|value| block } -> new_hash
hsh.transform_values                  -> an_enumerator

Returns a new hash with the results of running the block once for every value. This method does not change the keys.

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


446
447
448
449
450
451
452
453
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 446

def transform_values(&b)
  return to_enum :transform_values unless block_given?
  hash = {}
  self.keys.each do |k|
    hash[k] = yield(self[k])
  end
  hash
end

#transform_values!(&b) ⇒ Object

call-seq:

hsh.transform_values! {|key| block } -> hsh
hsh.transform_values!                -> an_enumerator

Invokes the given block once for each value in the hash, replacing with the new value returned by the block, and then returns hsh.

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


465
466
467
468
469
470
471
 
# File 'ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/mrblib/hash.rb', line 465

def transform_values!(&b)
  return to_enum :transform_values! unless block_given?
  self.keys.each do |k|
    self[k] = yield(self[k])
  end
  self
end