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

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



142
143
144
145
 
# File 'lib/hanami/utils/hash.rb', line 142

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(m, *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.

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

Raises:

  • (NoMethodError) —

    If doesn’t respond to the given method

Since:

  • 0.3.0



399
400
401
402
403
404
405
 
# File 'lib/hanami/utils/hash.rb', line 399

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

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

Class Method Details

.deep_dup(input) ⇒ ::Hash

Deep duplicate hash values

The output of this function is a shallow 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 shallow duplicate of input

Since:

  • 1.0.1



107
108
109
110
111
112
113
114
115
116
 
# File 'lib/hanami/utils/hash.rb', line 107

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_symbolize(input) ⇒ ::Hash

Deep symbolize 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



66
67
68
 
# File 'lib/hanami/utils/hash.rb', line 66

def self.deep_symbolize(input)
  self[:deep_symbolize_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



44
45
46
 
# File 'lib/hanami/utils/hash.rb', line 44

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

Instance Method Details

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

Equality

Returns:

  • (TrueClass, FalseClass)

Since:

  • 0.3.0



369
370
371
 
# File 'lib/hanami/utils/hash.rb', line 369

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

#[](key) ⇒ Object?

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



321
322
323
 
# File 'lib/hanami/utils/hash.rb', line 321

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

#[]=(key, value) ⇒ Object

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



333
334
335
 
# File 'lib/hanami/utils/hash.rb', line 333

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

#deep_dup ⇒ Hash

Return 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.new('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



281
282
283
284
285
 
# File 'lib/hanami/utils/hash.rb', line 281

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

Convert 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



184
185
186
187
188
189
190
191
192
193
 
# File 'lib/hanami/utils/hash.rb', line 184

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?

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



308
309
310
 
# File 'lib/hanami/utils/hash.rb', line 308

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

#hash ⇒ Fixnum

Returns the hash of the internal @hash

Returns:

  • (Fixnum)

Since:

  • 0.3.0



380
381
382
 
# File 'lib/hanami/utils/hash.rb', line 380

def hash
  @hash.hash
end

#inspect ⇒ String

Returns a string describing the internal @hash

Returns:

Since:

  • 0.3.0



389
390
391
 
# File 'lib/hanami/utils/hash.rb', line 389

def inspect
  @hash.inspect
end

#keys ⇒ Array

Returns a new array populated with the keys from this hash

Returns:

  • (Array) —

    the keys

See Also:

Since:

  • 0.3.0



294
295
296
 
# File 'lib/hanami/utils/hash.rb', line 294

def keys
  @hash.keys
end

#respond_to_missing?(m, 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.

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

Returns:

Since:

  • 0.3.0



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

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

#stringify! ⇒ Hash

Convert 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



209
210
211
212
213
214
215
216
217
218
 
# File 'lib/hanami/utils/hash.rb', line 209

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

Convert 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



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

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

  self
end

#to_a ⇒ ::Array

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

Returns:

  • (::Array) —

    the array

See Also:

Since:

  • 0.3.0



360
361
362
 
# File 'lib/hanami/utils/hash.rb', line 360

def to_a
  @hash.to_a
end

#to_h ⇒ ::Hash Also known as: to_hash

Returns a Ruby Hash as duplicated version of self

Returns:

  • (::Hash) —

    the hash

See Also:

Since:

  • 0.3.0



344
345
346
347
348
349
 
# File 'lib/hanami/utils/hash.rb', line 344

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