Class: HashWithIndifferentAccess

Inherits:
Hash
  • Object
show all
Defined in:
lib/cadove/models/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

Constructor Details

#initialize(constructor = {}) ⇒ HashWithIndifferentAccess

Returns a new instance of HashWithIndifferentAccess.



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



105
106
107
 
# File 'lib/cadove/models/indifferent_access.rb', line 105

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

#dup ⇒ Object

Returns an exact copy of the hash.



84
85
86
 
# File 'lib/cadove/models/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/cadove/models/indifferent_access.rb', line 68

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

#invert ⇒ Object 



100
101
102
 
# File 'lib/cadove/models/indifferent_access.rb', line 100

def invert
  super.with_indifferent_access
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/cadove/models/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/cadove/models/indifferent_access.rb', line 90

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

#regular_update ⇒ Object 



24
 
# File 'lib/cadove/models/indifferent_access.rb', line 24

alias_method :regular_update, :update

#regular_writer ⇒ Object 



23
 
# File 'lib/cadove/models/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/cadove/models/indifferent_access.rb', line 96

def reverse_merge(other_hash)
  super other_hash.with_indifferent_access
end

#stringify_keys! ⇒ Object 



109
 
# File 'lib/cadove/models/indifferent_access.rb', line 109

def stringify_keys!; self end

#symbolize_keys! ⇒ Object 



110
 
# File 'lib/cadove/models/indifferent_access.rb', line 110

def symbolize_keys!; self end

#to_hash ⇒ Object

Convert to a Hash with String keys.



114
115
116
 
# File 'lib/cadove/models/indifferent_access.rb', line 114

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

#to_options! ⇒ Object 



111
 
# File 'lib/cadove/models/indifferent_access.rb', line 111

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

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