Class: HashWithIndifferentAccess

Inherits:
Hash show all
Defined in:
lib/active_support/core_ext/hash/indifferent_access.rb

Overview

This class has dubious semantics and we only have it so that people can write params instead of params and they get the same value for both keys.

Constant Summary

Constants included from ActiveSupport::CoreExtensions::Hash::Conversions

ActiveSupport::CoreExtensions::Hash::Conversions::XML_FORMATTING, ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING, ActiveSupport::CoreExtensions::Hash::Conversions::XML_TYPE_NAMES

Instance Method Summary collapse

Methods inherited from Hash

#as_json, #except, #slice, #to_json

Methods included from ActiveSupport::CoreExtensions::Hash::Except

#except, #except!

Methods included from ActiveSupport::CoreExtensions::Hash::Slice

#slice, #slice!

Methods included from ActiveSupport::CoreExtensions::Hash::Diff

#diff

Methods included from ActiveSupport::CoreExtensions::Hash::Conversions

included, #rename_key, #to_query, #to_xml

Methods included from ActiveSupport::CoreExtensions::Hash::ReverseMerge

#reverse_merge!

Methods included from ActiveSupport::CoreExtensions::Hash::DeepMerge

#deep_merge, #deep_merge!

Methods included from ActiveSupport::CoreExtensions::Hash::IndifferentAccess

#with_indifferent_access

Methods included from ActiveSupport::CoreExtensions::Hash::Keys

#assert_valid_keys, #stringify_keys, #symbolize_keys

Constructor Details

#initialize(constructor = {}) ⇒ HashWithIndifferentAccess

Returns a new instance of HashWithIndifferentAccess.



6
7
8
9
10
11
12
13
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 6

def initialize(constructor = {})
  if constructor.is_a?(Hash)
    super()
    update(constructor)
  else
    super(constructor)
  end
end

Instance Method Details

#[]=(key, value) ⇒ Object

Assigns a new value to the hash:

hash = HashWithIndifferentAccess.new
hash[:key] = "value"



31
32
33
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 31

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

#default(key = nil) ⇒ Object 



15
16
17
18
19
20
21
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 15

def default(key = nil)
  if key.is_a?(Symbol) && include?(key = key.to_s)
    self[key]
  else
    super
  end
end

#delete(key) ⇒ Object

Removes a specified key from the hash.



101
102
103
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 101

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

#dup ⇒ Object

Returns an exact copy of the hash.



84
85
86
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 84

def dup
  HashWithIndifferentAccess.new(self)
end

#fetch(key, *extras) ⇒ Object

Fetches the value for the specified key, same as doing hash



68
69
70
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 68

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

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

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

hash = HashWithIndifferentAccess.new
hash["key"] = "value"
hash.key? :key  # => true
hash.key? "key" # => true

Returns:

  • (Boolean) 


59
60
61
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 59

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

#merge(hash) ⇒ Object

Merges the instantized and the specified hashes together, giving precedence to the values from the second hash Does not overwrite the existing hash.



90
91
92
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 90

def merge(hash)
  self.dup.update(hash)
end

#regular_update ⇒ Object 



24
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 24

alias_method :regular_update, :update

#regular_writer ⇒ Object 



23
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 23

alias_method :regular_writer, :[]=

#reverse_merge(other_hash) ⇒ Object

Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second. This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.



96
97
98
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 96

def reverse_merge(other_hash)
  super other_hash.with_indifferent_access
end

#stringify_keys! ⇒ Object 



105
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 105

def stringify_keys!; self end

#symbolize_keys! ⇒ Object 



106
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 106

def symbolize_keys!; self end

#to_hash ⇒ Object

Convert to a Hash with String keys.



110
111
112
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 110

def to_hash
  Hash.new(default).merge(self)
end

#to_options! ⇒ Object 



107
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 107

def to_options!; self end

#update(other_hash) ⇒ Object Also known as: merge!

Updates the instantized hash with values from the second:

hash_1 = HashWithIndifferentAccess.new
hash_1[:key] = "value"

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

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



45
46
47
48
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 45

def update(other_hash)
  other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
  self
end

#values_at(*indices) ⇒ Object

Returns an array of the values at the specified indices:

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



79
80
81
 
# File 'lib/active_support/core_ext/hash/indifferent_access.rb', line 79

def values_at(*indices)
  indices.collect {|key| self[convert_key(key)]}
end