Module: MPatch::Include::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) 


78
79
80
81
82
83
84
85
86
 
# File 'lib/mpatch/hash.rb', line 78

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] }



62
63
64
 
# File 'lib/mpatch/hash.rb', line 62

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

#deep_merge!(other_hash) ⇒ Object

Same as deep_merge, but modifies self.



69
70
71
72
73
74
75
 
# File 'lib/mpatch/hash.rb', line 69

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



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

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



51
52
53
 
# File 'lib/mpatch/hash.rb', line 51

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



45
46
47
48
 
# File 'lib/mpatch/hash.rb', line 45

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

#trim(*args) ⇒ Object

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



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
40
41
42
 
# File 'lib/mpatch/hash.rb', line 11

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

#value_by_keys(*attrs) ⇒ Object

Fetch a nested hash value



114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/mpatch/hash.rb', line 114

def value_by_keys(*attrs)
  attr_count = attrs.size
  current_val = self
  for i in 0..(attr_count-1)
    attr_name = attrs[i]
    return current_val[attr_name] if i == (attr_count-1)
    return nil if current_val[attr_name].nil?
    current_val = current_val[attr_name]
  end
  return nil
end