Class: Hanami::Utils::Hash

Inherits:
Object
  • Object
show all
Extended by:
Transproc::Registry
Defined in:
lib/hanami/utils/hash.rb

Overview

Hash on steroids

Since:

  • 0.1.0

Constant Summary collapse

DUPLICATE_LOGIC =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.

See Also:

Since:

  • 0.6.0

proc do |value|
  case value
  when Hash
    value.deep_dup
  when ::Hash
    Hash.new(value).deep_dup.to_h
  end
end.freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(hash = {}, &blk) ⇒ Hanami::Utils::Hash

Deprecated.

Initialize the hash

Examples:

Passing a Hash

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.new('l' => 23)
hash['l'] # => 23

Passing a block for default

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.new {|h,k| h[k] = [] }
hash['foo'].push 'bar'

hash.to_h # => { 'foo' => ['bar'] }

Parameters:

  • hash (#to_h) (defaults to: {}) —

    the value we want to use to initialize this instance

  • blk (Proc) —

    define the default value

See Also:

Since:

  • 0.1.0



238
239
240
241
 
# File 'lib/hanami/utils/hash.rb', line 238

def initialize(hash = {}, &blk)
  @hash = hash.to_hash
  @hash.default_proc = blk if blk
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &blk) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Overrides Ruby’s method_missing in order to provide ::Hash interface

Raises:

  • (NoMethodError) —

    If doesn’t respond to the given method

Since:

  • 0.3.0



508
509
510
511
512
513
514
515
516
 
# File 'lib/hanami/utils/hash.rb', line 508

def method_missing(method_name, *args, &blk)
  unless respond_to?(method_name)
    raise NoMethodError.new(%(undefined method `#{method_name}' for #{@hash}:#{self.class}))
  end

  h = @hash.__send__(method_name, *args, &blk)
  h = self.class.new(h) if h.is_a?(::Hash)
  h
end

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



162
163
164
165
166
167
168
169
170
171
 
# File 'lib/hanami/utils/hash.rb', line 162

def self.deep_dup(input)
  input.each_with_object({}) do |(k, v), result|
    result[k] = case v
                when ::Hash
                  deep_dup(v)
                else
                  Duplicable.dup(v)
                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:

Returns:

  • (::Hash) —

    the deep serialized hash

Since:

  • 1.1.0



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/hanami/utils/hash.rb', line 197

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



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/hanami/utils/hash.rb', line 109

def self.deep_stringify(input)
  input.each_with_object({}) do |(key, value), output|
    output[key.to_s] =
      case value
      when ::Hash
        deep_stringify(value)
      when Array
        value.map do |item|
          item.is_a?(::Hash) ? deep_stringify(item) : item
        end
      else
        value
      end
  end
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



69
70
71
 
# File 'lib/hanami/utils/hash.rb', line 69

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



89
90
91
 
# File 'lib/hanami/utils/hash.rb', line 89

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



47
48
49
 
# File 'lib/hanami/utils/hash.rb', line 47

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

Instance Method Details

#==(other) ⇒ TrueClass, FalseClass Also known as: eql?

Deprecated.

Equality

Returns:

  • (TrueClass, FalseClass)

Since:

  • 0.3.0



476
477
478
 
# File 'lib/hanami/utils/hash.rb', line 476

def ==(other)
  @hash == other.to_h
end

#[](key) ⇒ Object?

Deprecated.

Retrieves the value object corresponding to the key object.

Parameters:

  • key (Object) —

    the key

Returns:

  • (Object, nil) —

    the correspoding value, if present

See Also:

Since:

  • 0.3.0



424
425
426
 
# File 'lib/hanami/utils/hash.rb', line 424

def [](key)
  @hash[key]
end

#[]=(key, value) ⇒ Object

Deprecated.

Associates the value given by value with the key given by key.

Parameters:

  • key (Object) —

    the key to assign

  • value (Object) —

    the value to assign

See Also:

Since:

  • 0.3.0



437
438
439
 
# File 'lib/hanami/utils/hash.rb', line 437

def []=(key, value)
  @hash[key] = value
end

#deep_dup ⇒ Hash

Deprecated.

Use deep_dup

Returns a deep copy of the current Hanami::Utils::Hash

Examples:

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.new(
  'nil'        => nil,
  'false'      => false,
  'true'       => true,
  'symbol'     => :foo,
  'fixnum'     => 23,
  'bignum'     => 13289301283 ** 2,
  'float'      => 1.0,
  'complex'    => Complex(0.3),
  'bigdecimal' => BigDecimal('12.0001'),
  'rational'   => Rational(0.3),
  'string'     => 'foo bar',
  'hash'       => { a: 1, b: 'two', c: :three },
  'u_hash'     => Hanami::Utils::Hash.new({ a: 1, b: 'two', c: :three })
)

duped = hash.deep_dup

hash.class  # => Hanami::Utils::Hash
duped.class # => Hanami::Utils::Hash

hash.object_id  # => 70147385937100
duped.object_id # => 70147385950620

# unduplicated values
duped['nil']        # => nil
duped['false']      # => false
duped['true']       # => true
duped['symbol']     # => :foo
duped['fixnum']     # => 23
duped['bignum']     # => 176605528590345446089
duped['float']      # => 1.0
duped['complex']    # => (0.3+0i)
duped['bigdecimal'] # => #<BigDecimal:7f9ffe6e2fd0,'0.120001E2',18(18)>
duped['rational']   # => 5404319552844595/18014398509481984)

# it duplicates values
duped['string'].reverse!
duped['string'] # => "rab oof"
hash['string']  # => "foo bar"

# it deeply duplicates Hash, by preserving the class
duped['hash'].class # => Hash
duped['hash'].delete(:a)
hash['hash'][:a]    # => 1

duped['hash'][:b].upcase!
duped['hash'][:b] # => "TWO"
hash['hash'][:b]  # => "two"

# it deeply duplicates Hanami::Utils::Hash, by preserving the class
duped['u_hash'].class # => Hanami::Utils::Hash

Returns:

  • (Hash) —

    a deep duplicated self

Since:

  • 0.3.1



381
382
383
384
385
 
# File 'lib/hanami/utils/hash.rb', line 381

def deep_dup
  self.class.new.tap do |result|
    @hash.each { |k, v| result[k] = Duplicable.dup(v, &DUPLICATE_LOGIC) }
  end
end

#deep_symbolize! ⇒ Hash

Deprecated.

Use deep_symbolize

Converts in-place all the keys to Symbol instances, nested hashes are converted too.

Examples:

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.new 'a' => 23, 'b' => { 'c' => ['x','y','z'] }
hash.deep_symbolize!

hash.keys    # => [:a, :b]
hash.inspect # => {:a=>23, :b=>{:c=>["x", "y", "z"]}}

Returns:

Since:

  • 1.0.0



282
283
284
285
286
287
288
289
290
291
 
# File 'lib/hanami/utils/hash.rb', line 282

def deep_symbolize!
  keys.each do |k|
    v = delete(k)
    v = self.class.new(v).deep_symbolize! if v.respond_to?(:to_hash)

    self[k.to_sym] = v
  end

  self
end

#delete(key) ⇒ Object?

Deprecated.

Deletes the key-value pair and returns the value from hsh whose key is equal to key.

Parameters:

  • key (Object) —

    the key to remove

Returns:

  • (Object, nil) —

    the value hold by the given key, if present

See Also:

Since:

  • 0.3.0



410
411
412
 
# File 'lib/hanami/utils/hash.rb', line 410

def delete(key)
  @hash.delete(key)
end

#hash ⇒ Fixnum

Deprecated.

Returns the hash of the internal @hash

Returns:

  • (Fixnum)

Since:

  • 0.3.0



488
489
490
 
# File 'lib/hanami/utils/hash.rb', line 488

def hash
  @hash.hash
end

#inspect ⇒ String

Deprecated.

Returns a string describing the internal @hash

Returns:

Since:

  • 0.3.0



498
499
500
 
# File 'lib/hanami/utils/hash.rb', line 498

def inspect
  @hash.inspect
end

#keys ⇒ Array

Deprecated.

Returns a new array populated with the keys from this hash

Returns:

  • (Array) —

    the keys

See Also:

Since:

  • 0.3.0



395
396
397
 
# File 'lib/hanami/utils/hash.rb', line 395

def keys
  @hash.keys
end

#respond_to_missing?(method_name, include_private = false) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Overrides Ruby’s respond_to_missing? in order to support ::Hash interface

Returns:

Since:

  • 0.3.0



522
523
524
 
# File 'lib/hanami/utils/hash.rb', line 522

def respond_to_missing?(method_name, include_private = false)
  @hash.respond_to?(method_name, include_private)
end

#stringify! ⇒ Hash

Deprecated.

Use stringify

Converts in-place all the keys to Symbol instances, nested hashes are converted too.

Examples:

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.new a: 23, b: { c: ['x','y','z'] }
hash.stringify!

hash.keys    # => [:a, :b]
hash.inspect # => {"a"=>23, "b"=>{"c"=>["x", "y", "z"]}}

Returns:

Since:

  • 0.3.2



308
309
310
311
312
313
314
315
316
317
 
# File 'lib/hanami/utils/hash.rb', line 308

def stringify!
  keys.each do |k|
    v = delete(k)
    v = self.class.new(v).stringify! if v.respond_to?(:to_hash)

    self[k.to_s] = v
  end

  self
end

#symbolize! ⇒ Hash

Deprecated.

Use symbolize

Converts in-place all the keys to Symbol instances.

Examples:

require 'hanami/utils/hash'

hash = Hanami::Utils::Hash.new 'a' => 23, 'b' => { 'c' => ['x','y','z'] }
hash.symbolize!

hash.keys    # => [:a, :b]
hash.inspect # => { :a => 23, :b => { 'c' => ["x", "y", "z"] } }

Returns:

Since:

  • 0.1.0



258
259
260
261
262
263
264
265
 
# File 'lib/hanami/utils/hash.rb', line 258

def symbolize!
  keys.each do |k|
    v = delete(k)
    self[k.to_sym] = v
  end

  self
end

#to_a ⇒ ::Array

Deprecated.

Converts into a nested array of [ key, value ] arrays.

Returns:

  • (::Array) —

    the array

See Also:

Since:

  • 0.3.0



466
467
468
 
# File 'lib/hanami/utils/hash.rb', line 466

def to_a
  @hash.to_a
end

#to_h ⇒ ::Hash Also known as: to_hash

Deprecated.

Returns a Ruby Hash as duplicated version of self

Returns:

  • (::Hash) —

    the hash

See Also:

Since:

  • 0.3.0



449
450
451
452
453
454
 
# File 'lib/hanami/utils/hash.rb', line 449

def to_h
  @hash.each_with_object({}) do |(k, v), result|
    v = v.to_h if v.respond_to?(:to_hash)
    result[k] = v
  end
end