Class: Hash

Inherits:
Object show all
Defined in:
lib/mug/bool.rb,
lib/mug/hash/map.rb,
lib/mug/hash/when.rb,
lib/mug/hash/merge.rb,
lib/mug/hash/operations.rb

Instance Method Summary collapse

Instance Method Details

#+(other_hash) ⇒ Object

Adds the contents of other_hash to hsh. Entries with duplicate keys are overwritten with the values from other_hash



24
25
26
 
# File 'lib/mug/hash/operations.rb', line 24

def + other_hash
  merge other_hash
end

#<<(o) ⇒ Object

Appends stuff to the hash.

If o is a Hash, this is identical to calling #merge! If o is an Array with two elements, it is interpreted as [key,value] If o can be converted to a hash with #to_h, this is identical to calling #merge! Otherwise an ArgumentError is raised.

Example:

h = {}
h << {:a=>0}       # h = {:a=>0}
h << {:b=>2,:c=>3} # h = {:a=>0,:b=>2,:c=>3}
h << [:a,1]        # h = {:a=>1,:b=>2,:c=>3}



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/mug/hash/operations.rb', line 42

def << o
  if o.respond_to? :to_hash
    merge! o.to_hash
  elsif o.respond_to?(:to_a) && (a = o.to_a) && a.length == 2
    tap { store a[0], a[1] }
  elsif o.respond_to? :to_h
    merge! o.to_h
  else
    raise ArgumentError, "#{o.class.name} is not a Hash"
  end
end

#map_keys(&_block) ⇒ Object

Returns a new hash which is a copy of the current hash but each key is replaced by the result of running it through block.

If block returns duplicate keys, they will be overwritten in the resulting hash.

{'a'=>1, 'b'=>2}.map_keys { |k| k*2 } #=> {'aa'=>1, 'bb'=>2}
{'a'=>1, 'b'=>2}.map_keys { "cat" }   #=> {'cat'=>2}



39
40
41
42
43
44
45
46
 
# File 'lib/mug/hash/map.rb', line 39

def map_keys &_block # :yields: key
  return enum_for(:map_keys) unless block_given?
  hsh = {}
  each do |k, v|
    hsh[ yield k ] = v
  end
  hsh
end

#map_keys!(&block) ⇒ Object

Replaces the keys in hsh by running them each through block.

If block returns duplicate keys, they will be overwritten in turn.

See: #map_keys



55
56
57
58
 
# File 'lib/mug/hash/map.rb', line 55

def map_keys! &block # :yields: key
  return enum_for(:map_keys!) unless block_given?
  replace map_keys(&block)
end

#map_pairs(&_block) ⇒ Object

Returns a new hash which is a copy of the current hash but each key-value pair is replaced by the result of running it through block.

If block returns duplicate keys, they will be overwritten in the resulting hash.

{'a'=>1, 'b'=>2}.map_pairs { |k,v| [k*2, v+1] } #=> {'aa'=>2, 'bb'=>3}
{'a'=>1, 'b'=>2}.map_pairs { ["cat","dog"] }   #=> {'cat'=>'dog'}



70
71
72
73
74
75
76
77
78
 
# File 'lib/mug/hash/map.rb', line 70

def map_pairs &_block # :yields: key, value
  return enum_for(:map_pairs) unless block_given?
  hsh = {}
  each do |k, v|
    a, b = yield k, v
    hsh[a] = b
  end
  hsh
end

#map_pairs!(&block) ⇒ Object

Replaces the values in hsh by running them each through block.

See: #map_values



85
86
87
88
 
# File 'lib/mug/hash/map.rb', line 85

def map_pairs! &block # :yields: key, value
  return enum_for(:map_pairs!) unless block_given?
  replace map_pairs(&block)
end

#map_values(&_block) ⇒ Object

Returns a new hash which is a copy of the current hash but each value is replaced by the result of running it through block.

{'a'=>1, 'b'=>2}.map_values { |v| v*2 } #=> {'a'=>2, 'b'=>4}
{'a'=>1, 'b'=>2}.map_values { "cat" }   #=> {'a'=>"cat", 'b'=>"cat"}



10
11
12
13
14
15
16
17
 
# File 'lib/mug/hash/map.rb', line 10

def map_values &_block # :yields: value
  return enum_for(:map_values) unless block_given?
  hsh = {}
  each do |k, v|
    hsh[k] = yield v
  end
  hsh
end

#map_values!(&block) ⇒ Object

Replaces the values in hsh by running them each through block.

See: #map_values



24
25
26
27
 
# File 'lib/mug/hash/map.rb', line 24

def map_values! &block # :yields: value
  return enum_for(:map_values!) unless block_given?
  replace map_values(&block)
end

#merge_left(other_hash) ⇒ Object

Returns a new hash containing the contents of other_hash and the contents of hsh. The value for each duplicate key is the value in hsh when it exists.



9
10
11
 
# File 'lib/mug/hash/merge.rb', line 9

def merge_left other_hash
  merge(other_hash) {|key, left, right| left.nil? ? right : left }
end

#merge_left!(other_hash) ⇒ Object

Adds the contents of other_hash to hsh. Entries with duplicate keys are overwritten with the values from other_hash if the values in hsh are nil.



27
28
29
 
# File 'lib/mug/hash/merge.rb', line 27

def merge_left! other_hash
  merge!(other_hash) {|key, left, right| left.nil? ? right : left }
end

#merge_right(other_hash) ⇒ Object

Returns a new hash containing the contents of other_hash and the contents of hsh. The value for each duplicate key is the value in other_hash when it exists.



18
19
20
 
# File 'lib/mug/hash/merge.rb', line 18

def merge_right other_hash
  merge(other_hash) {|key, left, right| right.nil? ? left : right }
end

#merge_right!(other_hash) ⇒ Object

Adds the contents of other_hash to hsh. Entries with duplicate keys are overwritten with the values from other_hash unless the values in other_hash are nil.



36
37
38
 
# File 'lib/mug/hash/merge.rb', line 36

def merge_right! other_hash
  merge!(other_hash) {|key, left, right| right.nil? ? left : right }
end

#to_b ⇒ Object

Converts hsh to a boolean. Returns true if not empty.



76
77
78
 
# File 'lib/mug/bool.rb', line 76

def to_b
  !empty?
end

#when(o) ⇒ Object

Use a Hash like a case statement.

case key
when /foo/ then "FOO"
when /bar/ then "BAR"
else "DEFAULT"
end

becomes:

h = {
  /foo/ => "FOO",
  /bar/ => "BAR",
}
h.default = "DEFAULT"
h.when key



22
23
24
25
26
27
 
# File 'lib/mug/hash/when.rb', line 22

def when o
  each_pair do |k, v|
    return v if k === o
  end
  default o
end

#|(other_hash) ⇒ Object

Returns a new Hash, whose value is the same as this one, with any extras in other_hash added in.

Useful for default options.

Example:

opts = {:a => 1, :b => 2 }
dflt = {:a => 0, :x => 9 }
opts |= dflt # => opts = {:a=>1, :b=>2, :x=>9}



15
16
17
 
# File 'lib/mug/hash/operations.rb', line 15

def | other_hash
  other_hash.merge self
end