Class: Hash

Inherits:
Object
  • Object
show all
Defined in:
lib/morpheus/ext/hash.rb

Overview

Provide deep_merge. Borrowed from rails active_support github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/deep_merge.rb

Instance Method Summary collapse

Instance Method Details

#booleanize!(true_values = ['true','on'], false_values = ['false','off']) ⇒ Object

convert recognizable strings to booleans



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/morpheus/ext/hash.rb', line 65

def booleanize!(true_values=['true','on'], false_values=['false','off'])
  self.each_pair do |k, v|
    if v.is_a?(Hash)
      self[k].booleanize!
    elsif v.is_a?(Array)
      self[k].each do |it|
        if it.is_a?(Hash)
          it.booleanize!
        elsif self[k] == nil || self[k] == ''
          # meh, preserve 'empty' array elements
        end
      end
    else
      if true_values.include?(v)
        self[k] = true
      elsif false_values.include?(v)
        self[k] = false
      end
    end
  end
  self
end

#capitalize_keys! ⇒ Object 



102
103
104
105
106
107
 
# File 'lib/morpheus/ext/hash.rb', line 102

def capitalize_keys!
  self.keys.each do |k|
    self[k.to_s.capitalize] = self.delete(k)
  end
  self
end

#deep_compact! ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/morpheus/ext/hash.rb', line 43

def deep_compact!
  self.each_pair do |k, v|
    if v.is_a?(Hash)
      self[k].deep_compact!
    elsif v.is_a?(Array)
      self[k].each do |it|
        if it.is_a?(Hash)
          it.deep_compact!
        elsif self[k] == nil || self[k] == ''
          # meh, preserve 'empty' array elements
        end
      end
    else
      if self[k] == nil || self[k] == ''
        self.delete(k)
      end
    end
  end
  self
end

#deep_merge(other_hash, &block) ⇒ Object

Returns a new hash with self and other_hash merged recursively.

h1 = { a: true, b: { c: [1, 2, 3] } }
h2 = { a: false, b: { x: [3, 4, 5] } }

h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }

Like with Hash#merge in the standard library, a block can be provided to merge values:

h1 = { a: 100, b: 200, c: { c1: 100 } }
h2 = { b: 250, c: { c1: 200 } }
h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
# => { a: 100, b: 450, c: { c1: 300 } }



20
21
22
 
# File 'lib/morpheus/ext/hash.rb', line 20

def deep_merge(other_hash, &block)
  dup.deep_merge!(other_hash, &block)
end

#deep_merge!(other_hash, &block) ⇒ Object

Same as deep_merge, but modifies self.



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/morpheus/ext/hash.rb', line 25

def deep_merge!(other_hash, &block)
  other_hash.each_pair do |current_key, other_value|
    this_value = self[current_key]

    self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
      this_value.deep_merge(other_value, &block)
    else
      if block_given? && key?(current_key)
        block.call(current_key, this_value, other_value)
      else
        other_value
      end
    end
  end

  self
end

#downcase_keys! ⇒ Object 



95
96
97
98
99
100
 
# File 'lib/morpheus/ext/hash.rb', line 95

def downcase_keys!
  self.keys.each do |k|
    self[k.to_s.downcase] = self.delete(k)
  end
  self
end

#upcase_keys! ⇒ Object 



88
89
90
91
92
93
 
# File 'lib/morpheus/ext/hash.rb', line 88

def upcase_keys!
  self.keys.each do |k| 
    self[k.to_s.upcase] = self.delete(k)
  end
  self
end