module Extras::Hash

Public Instance Methods

any_key?(*keys) click to toggle source

Check to see if any of the given keys exist.


# File lib/extras/hash.rb, line 121
def any_key?(*keys)
  keys.any? do |k|
    key?(k)
  end
end
deep_merge(new_h) click to toggle source

Merge hash into hash into hash into hash.


# File lib/extras/hash.rb, line 104
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) click to toggle source

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


# File lib/extras/hash.rb, line 57
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) click to toggle source

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


# File lib/extras/hash.rb, line 76
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) click to toggle source

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


# File lib/extras/hash.rb, line 37
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) click to toggle source

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


# File lib/extras/hash.rb, line 90
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