Module: MPatch::Hash

Defined in:
lib/mpatch/hash.rb

Instance Method Summary collapse

Instance Method Details

#deep_include?(sub_hash) ⇒ Boolean

return bool that does the sub hash all element include the hash who call this or not

Returns:

  • (Boolean) 


75
76
77
78
79
80
81
82
83
 
# File 'lib/mpatch/hash.rb', line 75

def deep_include?(sub_hash)
  sub_hash.keys.all? do |key|
    self.has_key?(key) && if sub_hash[key].is_a?(::Hash)
                            self[key].is_a?(::Hash) && self[key].deep_include?(sub_hash[key])
                          else
                            self[key] == sub_hash[key]
                          end
  end
end

#deep_merge(other_hash) ⇒ Object Also known as: +

Returns a new hash with self and other_hash merged recursively.

h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}

h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }


59
60
61
 
# File 'lib/mpatch/hash.rb', line 59

def deep_merge(other_hash)
  dup.deep_merge!(other_hash)
end

#deep_merge!(other_hash) ⇒ Object

Same as deep_merge, but modifies self.



66
67
68
69
70
71
72
 
# File 'lib/mpatch/hash.rb', line 66

def deep_merge!(other_hash)
  other_hash.each_pair do |k,v|
    tv = self[k]
    self[k] = tv.is_a?(::Hash) && v.is_a?(::Hash) ? tv.deep_merge(v) : v
  end
  self
end

#map_hash(&block) ⇒ Object

map hash will work just alike map but instead of an array it will return a hash obj

"world",:world => "hello".map_hash{|k,v| [ k , 123] } #> :world=>123

"world",:world => "hello".map_hash{|k,v| { k => 123 } } #> :world=>123



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/mpatch/hash.rb', line 93

def map_hash &block

  tmp_hash= self.class.new
  map_hash_obj= self.map &block
  map_hash_obj.each do |hash|

    if hash.class <= ::Array
      hash= self.class[*hash]
    end

    tmp_hash.deep_merge!(hash)

  end

  return tmp_hash
end

#remove(*keys) ⇒ Object

non-destructive version



48
49
50
 
# File 'lib/mpatch/hash.rb', line 48

def remove(*keys)
  self.dup.remove!(*keys)
end

#remove!(*keys) ⇒ Object

pass single or array of keys, which will be removed, returning the remaining hash



42
43
44
45
 
# File 'lib/mpatch/hash.rb', line 42

def remove!(*keys)
  keys.each{|key| self.delete(key) }
  self
end

#trim(*args) ⇒ Object

remove elements by keys, array of keys, hashTags, strings



8
9
10
11
12
13
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
 
# File 'lib/mpatch/hash.rb', line 8

def trim(*args)

  args.each do |one_element|
    case true

      when one_element.class <= ::Hash
        begin
          one_element.each do |key,value|
            if self[key] == value
              self.delete(key)
            end
          end
        end

      when one_element.class <= ::Array
        begin
          one_element.each do |one_key|
            self.delete(one_key)
          end
        end

      when  one_element.class <= ::Symbol,
          one_element.class <= ::String
        begin
          self.delete(one_element)
        end

    end
  end
  return self

end