Class: Wrest::HashWithIndifferentAccess

Inherits:
Hash
  • Object
show all
Defined in:
lib/wrest/hash_with_indifferent_access.rb

Overview

github.com/rails/rails/commit/1dcad65f8075d5b766082d3fbabdcb20fecb4ccd Implements a hash where keys :foo and "foo" are considered to be the same.

rgb = ActiveSupport::HashWithIndifferentAccess.new

rgb[:black] = '#000000'
rgb[:black]  # => '#000000'
rgb['black'] # => '#000000'

rgb['white'] = '#FFFFFF'
rgb[:white]  # => '#FFFFFF'
rgb['white'] # => '#FFFFFF'

Internally symbols are mapped to strings when used as keys in the entire writing interface (calling []=, merge, etc). This mapping belongs to the public interface. For example, given:

hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)

You are guaranteed that the key is returned as a string:

hash.keys # => ["a"]

Technically other types of keys are accepted:

hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
hash[0] = 0
hash # => {"a"=>1, 0=>0}

but this class is intended for use cases where strings or symbols are the expected keys and it is convenient to understand both as the same. For example the params hash in Ruby on Rails.

Note that core extensions define Hash#with_indifferent_access:

rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access

which may be handy.

Class Method Summary collapse

Instance Method Summary collapse

Methods included from CoreExt::Hash::Conversions

#mutate_using

Constructor Details

#initialize(constructor = nil) ⇒ HashWithIndifferentAccess

Returns a new instance of HashWithIndifferentAccess.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 59

def initialize(constructor = nil)
  if constructor.respond_to?(:to_hash)
    super()
    update(constructor)

    hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
    self.default = hash.default if hash.default
    self.default_proc = hash.default_proc if hash.default_proc
  elsif constructor.nil?
    super()
  else
    super(constructor)
  end
end

Class Method Details

.[](*args) ⇒ Object 



74
75
76
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 74

def self.[](*args)
  new.merge!(Hash[*args])
end

Instance Method Details

#[](key) ⇒ Object

Same as Hash#[] where the key passed as argument can be either a string or a symbol:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = 1

counters['foo'] # => 1
counters[:foo]  # => 1
counters[:zoo]  # => nil



157
158
159
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 157

def [](key)
  super(convert_key(key))
end

#[]=(key, value) ⇒ Object Also known as: store

Assigns a new value to the hash:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:key] = 'value'

This value can be later fetched using either :key or 'key'.



87
88
89
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 87

def []=(key, value)
  regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
end

#assoc(key) ⇒ Object

Same as Hash#assoc where the key passed as argument can be either a string or a symbol:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = 1

counters.assoc('foo') # => ["foo", 1]
counters.assoc(:foo)  # => ["foo", 1]
counters.assoc(:zoo)  # => nil



170
171
172
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 170

def assoc(key)
  super(convert_key(key))
end

#compact ⇒ Object 



371
372
373
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 371

def compact
  dup.tap(&:compact!)
end

#default(*args) ⇒ Object

Same as Hash#default where the key passed as argument can be either a string or a symbol:

hash = ActiveSupport::HashWithIndifferentAccess.new(1)
hash.default                   # => 1

hash = ActiveSupport::HashWithIndifferentAccess.new { |hash, key| key }
hash.default                   # => nil
hash.default('foo')            # => 'foo'
hash.default(:foo)             # => 'foo'



212
213
214
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 212

def default(*args)
  super(*args.map { |arg| convert_key(arg) })
end

#delete(key) ⇒ Object

Removes the specified key from the hash.



288
289
290
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 288

def delete(key)
  super(convert_key(key))
end

#dig(*args) ⇒ Object

Same as Hash#dig where the key passed as argument can be either a string or a symbol:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = { bar: 1 }

counters.dig('foo', 'bar')     # => 1
counters.dig(:foo, :bar)       # => 1
counters.dig(:zoo)             # => nil



197
198
199
200
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 197

def dig(*args)
  args[0] = convert_key(args[0]) if args.size.positive?
  super(*args)
end

#dup ⇒ Object

Returns a shallow copy of the hash.

hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
dup  = hash.dup
dup[:a][:c] = 'c'

hash[:a][:c] # => "c"
dup[:a][:c]  # => "c"



247
248
249
250
251
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 247

def dup
  self.class.new(self).tap do |new_hash|
    set_defaults(new_hash)
  end
end

#except(*keys) ⇒ Object Also known as: without

Returns a hash with indifferent access that includes everything except given keys.

hash = { a: "x", b: "y", c: 10 }.with_indifferent_access
hash.except(:a, "b") # => {c: 10}.with_indifferent_access
hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access



296
297
298
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 296

def except(*keys)
  slice(*self.keys - keys.map { |key| convert_key(key) })
end

#extractable_options? ⇒ Boolean

Returns true so that Array#extract_options! finds members of this class.

Returns:

  • (Boolean) 


47
48
49
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 47

def extractable_options?
  true
end

#fetch(key, *extras) ⇒ Object

Same as Hash#fetch where the key passed as argument can be either a string or a symbol:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = 1

counters.fetch('foo')          # => 1
counters.fetch(:bar, 0)        # => 0
counters.fetch(:bar) { |key| 0 } # => 0
counters.fetch(:zoo)           # => KeyError: key not found: "zoo"



184
185
186
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 184

def fetch(key, *extras)
  super(convert_key(key), *extras)
end

#fetch_values(*indices, &block) ⇒ Object

Returns an array of the values at the specified indices, but also raises an exception when one of the keys can’t be found.

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:a] = 'x'
hash[:b] = 'y'
hash.fetch_values('a', 'b') # => ["x", "y"]
hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
hash.fetch_values('a', 'c') # => KeyError: key not found: "c"



235
236
237
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 235

def fetch_values(*indices, &block)
  super(*indices.map { |key| convert_key(key) }, &block)
end

#key?(key) ⇒ Boolean Also known as: include?, has_key?, member?

Checks the hash for a key matching the argument passed in:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash['key'] = 'value'
hash.key?(:key)  # => true
hash.key?('key') # => true

Returns:

  • (Boolean) 


140
141
142
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 140

def key?(key)
  super(convert_key(key))
end

#merge(*hashes, &block) ⇒ Object

This method has the same semantics of update, except it does not modify the receiver but rather returns a new hash with indifferent access with the result of the merge.



256
257
258
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 256

def merge(*hashes, &block)
  dup.update(*hashes, &block)
end

#nested_under_indifferent_access ⇒ Object 



55
56
57
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 55

def nested_under_indifferent_access
  self
end

#regular_update ⇒ Object 



79
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 79

alias regular_update update

#regular_writer ⇒ Object 



78
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 78

alias regular_writer []=

#reject(*args, &block) ⇒ Object 



334
335
336
337
338
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 334

def reject(*args, &block)
  return to_enum(:reject) unless block_given?

  dup.tap { |hash| hash.reject!(*args, &block) }
end

#replace(other_hash) ⇒ Object

Replaces the contents of this hash with other_hash.

h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}



283
284
285
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 283

def replace(other_hash)
  super(self.class.new(other_hash))
end

#reverse_merge(other_hash) ⇒ Object Also known as: with_defaults

Like merge but the other way around: Merges the receiver into the argument and returns a new hash with indifferent access as result:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash['a'] = nil
hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}



266
267
268
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 266

def reverse_merge(other_hash)
  super(self.class.new(other_hash))
end

#reverse_merge!(other_hash) ⇒ Object Also known as: with_defaults!

Same semantics as reverse_merge but modifies the receiver in-place.



273
274
275
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 273

def reverse_merge!(other_hash)
  super(self.class.new(other_hash))
end

#select(*args, &block) ⇒ Object 



328
329
330
331
332
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 328

def select(*args, &block)
  return to_enum(:select) unless block_given?

  dup.tap { |hash| hash.select!(*args, &block) }
end

#slice(*keys) ⇒ Object 



361
362
363
364
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 361

def slice(*keys)
  keys.map! { |key| convert_key(key) }
  self.class.new(super)
end

#slice!(*keys) ⇒ Object 



366
367
368
369
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 366

def slice!(*keys)
  keys.map! { |key| convert_key(key) }
  super
end

#stringify_keys ⇒ Object 



306
307
308
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 306

def stringify_keys
  transform_keys(&:to_s)
end

#stringify_keys! ⇒ Object 



302
303
304
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 302

def stringify_keys!
  transform_keys!(&:to_s)
end

#symbolize_keys ⇒ Object Also known as: to_options 



310
311
312
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 310

def symbolize_keys
  symbolize_keys!
end

#symbolize_keys! ⇒ Object 



314
315
316
317
318
319
320
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 314

def symbolize_keys!
  transform_keys! do |key|
    key.to_sym
  rescue StandardError
    key
  end
end

#to_hash ⇒ Object

Convert to a regular hash with string keys.



376
377
378
379
380
381
382
383
384
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 376

def to_hash
  a_new_hash = {}
  set_defaults(a_new_hash)

  each do |key, value|
    a_new_hash[key] = convert_value(value, conversion: :to_hash)
  end
  a_new_hash
end

#to_options! ⇒ Object 



324
325
326
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 324

def to_options!
  self
end

#transform_keys(*args, &block) ⇒ Object 



346
347
348
349
350
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 346

def transform_keys(*args, &block)
  return to_enum(:transform_keys) unless block_given?

  dup.tap { |hash| hash.transform_keys!(*args, &block) }
end

#transform_keys! ⇒ Object 



352
353
354
355
356
357
358
359
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 352

def transform_keys!
  return enum_for(:transform_keys!) { size } unless block_given?

  keys.each do |key|
    self[yield(key)] = delete(key)
  end
  self
end

#transform_values(*args, &block) ⇒ Object 



340
341
342
343
344
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 340

def transform_values(*args, &block)
  return to_enum(:transform_values) unless block_given?

  dup.tap { |hash| hash.transform_values!(*args, &block) }
end

#update(*other_hashes, &block) ⇒ Object Also known as: merge!

Updates the receiver in-place, merging in the hashes passed as arguments:

hash_1 = ActiveSupport::HashWithIndifferentAccess.new
hash_1[:key] = 'value'

hash_2 = ActiveSupport::HashWithIndifferentAccess.new
hash_2[:key] = 'New Value!'

hash_1.update(hash_2) # => {"key"=>"New Value!"}

hash = ActiveSupport::HashWithIndifferentAccess.new
hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }

The arguments can be either an ActiveSupport::HashWithIndifferentAccess or a regular Hash. In either case the merge respects the semantics of indifferent access.

If the argument is a regular hash with keys :key and "key" only one of the values end up in the receiver, but which one is unspecified.

When given a block, the value for duplicated keys will be determined by the result of invoking the block with the duplicated key, the value in the receiver, and the value in other_hash. The rules for duplicated keys follow the semantics of indifferent access:

hash_1[:key] = 10
hash_2['key'] = 12
hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}



121
122
123
124
125
126
127
128
129
130
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 121

def update(*other_hashes, &block)
  if other_hashes.size == 1
    update_with_single_argument(other_hashes.first, block)
  else
    other_hashes.each do |other_hash|
      update_with_single_argument(other_hash, block)
    end
  end
  self
end

#values_at(*keys) ⇒ Object

Returns an array of the values at the specified indices:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:a] = 'x'
hash[:b] = 'y'
hash.values_at('a', 'b') # => ["x", "y"]



222
223
224
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 222

def values_at(*keys)
  super(*keys.map { |key| convert_key(key) })
end

#with_indifferent_access ⇒ Object 



51
52
53
 
# File 'lib/wrest/hash_with_indifferent_access.rb', line 51

def with_indifferent_access
  dup
end