Module: Extras::Hash

Included in:
Hash
Defined in:
lib/extras/hash.rb

Defined Under Namespace

Modules: ClassMethods

Instance Method Summary collapse

Instance Method Details

#any_key?(*keys) ⇒ Boolean

Check to see if any of the given keys exist.

Returns:

  • (Boolean) 


110
111
112
113
114
 
# File 'lib/extras/hash.rb', line 110

def any_key?(*keys)
  keys.any? do |k|
    key?(k)
  end
end

#deep_merge(new_h) ⇒ Object

Merge hash into hash into hash into hash.



93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/extras/hash.rb', line 93

def deep_merge(new_h)
  merge(new_h) do |_, ov, nv|
    if ov.respond_to?(:deep_merge) && nv.respond_to?(:deep_merge)
      then ov.deep_merge(
        nv
      )

    else
      nv
    end
  end
end

#stringify(allowed_keys: nil, allowed_vals: nil) ⇒ Object

Stringify keys and values of the current hash, skipping objects that are allowed to be skipped (leaving them as is, untouched.)



46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/extras/hash.rb', line 46

def stringify(allowed_keys: nil, allowed_vals: nil)
  keys = allowed_keys || self.class.allowed[:keys]
  vals = allowed_vals || self.class.allowed[:vals]

  each_with_object({}) do |(k, v), h|
    v = v.to_s if !v.respond_to?(:stringify) && !vals.include?(v.class)
    k = k.to_s unless keys.include?(k.class)

    h[k] = !v.respond_to?(:stringify) ? v : v.stringify({
      :allowed_keys => allowed_keys,
      :allowed_vals => allowed_vals
    })
  end
end

#stringify_keys(allowed: nil) ⇒ Object

Stringify the keys of the current hash, skipping allowed objects.



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

def stringify_keys(allowed: nil)
  allowed ||= self.class.allowed[:keys]
  each_with_object({}) do |(k, v), h|
    k = k.to_s unless allowed.include?(k.class)
    h[k] = !v.respond_to?(:stringify_keys) ? v : v.stringify_keys({
      :allowed => allowed
    })
  end
end

#symbolize(allowed_keys: nil, allowed_vals: nil) ⇒ Object

Symbolize keys and values of the current hash, skipping allowed objects.



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

def symbolize(allowed_keys: nil, allowed_vals: nil)
  keys = allowed_keys || self.class.allowed[:keys]
  vals = allowed_vals || self.class.allowed[:vals]

  each_with_object({}) do |(k, v), h|
    k = k.to_sym unless !k.respond_to?(:to_sym) || keys.include?(k.class)
    v = v.to_sym unless !v.respond_to?(:to_sym) || vals.include?(v.class)

    h[k] = !v.respond_to?(:symbolize) ? v : v.symbolize({
      :allowed_keys => allowed_keys,
      :allowed_vals => allowed_vals
    })
  end
end

#symbolize_keys(allowed: nil) ⇒ Object

Symbolize the keys of the current hash, skipping allowed objects.



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

def symbolize_keys(allowed: nil)
  allowed ||= self.class.allowed[:keys]
  each_with_object({}) do |(k, v), h|
    k = k.to_sym if k.respond_to?(:to_sym) && !allowed.include?(k.class)
    h[k] = !v.respond_to?(:symbolize_keys) ? v : v.symbolize_keys({
      :allowed => allowed
    })
  end
end