Module: Hanami::Utils::Hash

Extended by:
Dry::Transformer::Registry
Defined in:
lib/hanami/utils/hash.rb

Overview

Hash transformations

Since:

  • 0.1.0

Class Method Summary collapse

Class Method Details

.deep_dup(input) ⇒ ::Hash

Deep duplicates hash values

The output of this function is a deep duplicate of the input. Any further modification on the input, won’t be reflected on the output and viceversa.

Examples:

Basic Usage

require 'hanami/utils/hash'

input  = { "a" => { "b" => { "c" => [1, 2, 3] } } }
output = Hanami::Utils::Hash.deep_dup(input)
  # => {"a"=>{"b"=>{"c"=>[1,2,3]}}}

output.class
  # => Hash

# mutations on input aren't reflected on output

input["a"]["b"]["c"] << 4
output.dig("a", "b", "c")
  # => [1, 2, 3]

# mutations on output aren't reflected on input

output["a"].delete("b")
input
  # => {"a"=>{"b"=>{"c"=>[1,2,3,4]}}}

Parameters:

  • input (::Hash) —

    the input

Returns:

  • (::Hash) —

    the deep duplicate of input

Since:

  • 1.0.1



135
136
137
138
139
140
141
142
143
144
 
# File 'lib/hanami/utils/hash.rb', line 135

def self.deep_dup(input)
  input.transform_values do |v|
    case v
    when ::Hash
      deep_dup(v)
    else
      v.dup
    end
  end
end

.deep_serialize(input) ⇒ ::Hash

Deep serializes given object into a ‘Hash`

Please note that the returning ‘Hash` will use symbols as keys.

Examples:

Basic Usage

require 'hanami/utils/hash'
require 'ostruct'

class Data < OpenStruct
  def to_hash
    to_h
  end
end

input = Data.new("foo" => "bar", baz => [Data.new(hello: "world")])

Hanami::Utils::Hash.deep_serialize(input)
  # => {:foo=>"bar", :baz=>[{:hello=>"world"}]}

Parameters:

  • input (#to_hash) —

    the input

Returns:

  • (::Hash) —

    the deep serialized hash

Since:

  • 1.1.0



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/hanami/utils/hash.rb', line 170

def self.deep_serialize(input)
  input.to_hash.each_with_object({}) do |(key, value), output|
    output[key.to_sym] =
      case value
      when ->(h) { h.respond_to?(:to_hash) }
        deep_serialize(value)
      when Array
        value.map do |item|
          item.respond_to?(:to_hash) ? deep_serialize(item) : item
        end
      else
        value
      end
  end
end

.deep_stringify(input) ⇒ ::Hash

Deeply stringifies the given hash

Examples:

Basic Usage

require "hanami/utils/hash"

hash = Hanami::Utils::Hash.deep_stringify(foo: "bar", baz: {a: 1})
  # => {"foo"=>"bar", "baz"=>{"a"=>1}}

hash.class
  # => Hash

Parameters:

  • input (::Hash) —

    the input

Returns:

  • (::Hash) —

    the deep stringified hash

Since:

  • 1.1.1



94
95
96
 
# File 'lib/hanami/utils/hash.rb', line 94

def self.deep_stringify(input)
  self[:deep_stringify_keys].call(input)
end

.deep_symbolize(input) ⇒ ::Hash

Performs deep symbolize on the given hash

Examples:

Basic Usage

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.deep_symbolize("foo" => "bar", "baz" => {"a" => 1})
  # => {:foo=>"bar", :baz=>{a:=>1}}

hash.class
  # => Hash

Parameters:

  • input (::Hash) —

    the input

Returns:

  • (::Hash) —

    the deep symbolized hash

See Also:

Since:

  • 1.0.1



54
55
56
 
# File 'lib/hanami/utils/hash.rb', line 54

def self.deep_symbolize(input)
  self[:deep_symbolize_keys].call(input)
end

.stringify(input) ⇒ ::Hash

Stringifies the given hash

Examples:

Basic Usage

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.stringify(foo: "bar", baz: {a: 1})
  # => {"foo"=>"bar", "baz"=>{:a=>1}}

hash.class
  # => Hash

Parameters:

  • input (::Hash) —

    the input

Returns:

  • (::Hash) —

    the stringified hash

Since:

  • 1.0.1



74
75
76
 
# File 'lib/hanami/utils/hash.rb', line 74

def self.stringify(input)
  self[:stringify_keys].call(input)
end

.symbolize(input) ⇒ ::Hash

Symbolize the given hash

Examples:

Basic Usage

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.symbolize("foo" => "bar", "baz" => {"a" => 1})
  # => {:foo=>"bar", :baz=>{"a"=>1}}

hash.class
  # => Hash

Parameters:

  • input (::Hash) —

    the input

Returns:

  • (::Hash) —

    the symbolized hash

See Also:

Since:

  • 1.0.1



32
33
34
 
# File 'lib/hanami/utils/hash.rb', line 32

def self.symbolize(input)
  self[:symbolize_keys].call(input)
end