Parent

Class/Module Index [+]

Quicksearch

HashWithIndifferentAccess

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.

Public Class Methods

new(constructor = {}) click to toggle source
# 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

Public Instance Methods

[]=(key, value) click to toggle source

Assigns a new value to the hash:

hash = HashWithIndifferentAccess.new
hash[:key] = "value"
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 31
def []=(key, value)
  regular_writer(convert_key(key), convert_value(value))
end
Also aliased as: regular_writer
default(key = nil) click to toggle source
# 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) click to toggle source

Removes a specified key from the hash.

# File lib/active_support/core_ext/hash/indifferent_access.rb, line 101
def delete(key)
  super(convert_key(key))
end
dup() click to toggle source

Returns an exact copy of the hash.

# File lib/active_support/core_ext/hash/indifferent_access.rb, line 84
def dup
  HashWithIndifferentAccess.new(self)
end
fetch(key, *extras) click to toggle source

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

# File lib/active_support/core_ext/hash/indifferent_access.rb, line 68
def fetch(key, *extras)
  super(convert_key(key), *extras)
end
has_key?(key) click to toggle source
Alias for: key?
include?(key) click to toggle source
Alias for: key?
key?(key) click to toggle source

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
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 59
def key?(key)
  super(convert_key(key))
end
Also aliased as: include?, has_key?, member?
member?(key) click to toggle source
Alias for: key?
merge(hash) click to toggle source

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

# File lib/active_support/core_ext/hash/indifferent_access.rb, line 90
def merge(hash)
  self.dup.update(hash)
end
merge!(other_hash) click to toggle source
Alias for: update
regular_update(other_hash) click to toggle source
Alias for: update
regular_writer(key, value) click to toggle source
Alias for: []=
reverse_merge(other_hash) click to toggle source

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.

# 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!() click to toggle source
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 105
def stringify_keys!; self end
symbolize_keys!() click to toggle source
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 106
def symbolize_keys!; self end
to_hash() click to toggle source

Convert to a Hash with String keys.

# File lib/active_support/core_ext/hash/indifferent_access.rb, line 110
def to_hash
  Hash.new(default).merge(self)
end
to_options!() click to toggle source
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 107
def to_options!; self end
update(other_hash) click to toggle source

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!"}
# 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
Also aliased as: regular_update, merge!
values_at(*indices) click to toggle source

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"]
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 79
def values_at(*indices)
  indices.collect {|key| self[convert_key(key)]}
end

Protected Instance Methods

convert_key(key) click to toggle source
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 115
def convert_key(key)
  key.kind_of?(Symbol) ? key.to_s : key
end
convert_value(value) click to toggle source
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 119
def convert_value(value)
  case value
  when Hash
    value.with_indifferent_access
  when Array
    value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
  else
    value
  end
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.