Class: HashWithIndifferentAccess

Inherits:
Hash
  • Object
show all
Defined in:
lib/ext/misc/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.

Instance Method Summary collapse

Methods inherited from Hash

#with_indifferent_access

Constructor Details

#initialize(constructor = {}) ⇒ HashWithIndifferentAccess

Returns a new instance of HashWithIndifferentAccess.



6
7
8
9
10
11
12
13
 
# File 'lib/ext/misc/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/ext/misc/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/ext/misc/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.



95
96
97
 
# File 'lib/ext/misc/indifferent_access.rb', line 95

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

#dup ⇒ Object

Returns an exact copy of the hash.



84
85
86
 
# File 'lib/ext/misc/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/ext/misc/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/ext/misc/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/ext/misc/indifferent_access.rb', line 90

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

#regular_update ⇒ Object 



24
 
# File 'lib/ext/misc/indifferent_access.rb', line 24

alias_method :regular_update, :update

#regular_writer ⇒ Object 



23
 
# File 'lib/ext/misc/indifferent_access.rb', line 23

alias_method :regular_writer, :[]=

#stringify_keys! ⇒ Object 



99
 
# File 'lib/ext/misc/indifferent_access.rb', line 99

def stringify_keys!; self end

#symbolize_keys! ⇒ Object 



100
 
# File 'lib/ext/misc/indifferent_access.rb', line 100

def symbolize_keys!; self end

#to_hash ⇒ Object

Convert to a Hash with String keys.



104
105
106
 
# File 'lib/ext/misc/indifferent_access.rb', line 104

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

#to_options! ⇒ Object 



101
 
# File 'lib/ext/misc/indifferent_access.rb', line 101

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/ext/misc/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/ext/misc/indifferent_access.rb', line 79

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