# File lib/active_support/core_ext/hash/conversions.rb, line 94 94: def typecast_xml_value(value) 95: case value.class.to_s 96: when 'Hash' 97: if value['type'] == 'array' 98: _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) }) 99: if entries.nil? || (c = value['__content__'] && c.blank?) 100: [] 101: else 102: case entries.class.to_s # something weird with classes not matching here. maybe singleton methods breaking is_a? 103: when "Array" 104: entries.collect { |v| typecast_xml_value(v) } 105: when "Hash" 106: [typecast_xml_value(entries)] 107: else 108: raise "can't typecast #{entries.inspect}" 109: end 110: end 111: elsif value['type'] == 'file' || 112: (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?)) 113: content = value["__content__"] 114: if parser = ActiveSupport::XmlMini::PARSING[value["type"]] 115: parser.arity == 1 ? parser.call(content) : parser.call(content, value) 116: else 117: content 118: end 119: elsif value['type'] == 'string' && value['nil'] != 'true' 120: "" 121: # blank or nil parsed values are represented by nil 122: elsif value.blank? || value['nil'] == 'true' 123: nil 124: # If the type is the only element which makes it then 125: # this still makes the value nil, except if type is 126: # a XML node(where type['value'] is a Hash) 127: elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash) 128: nil 129: else 130: xml_value = Hash[value.map { |k,v| [k, typecast_xml_value(v)] }] 131: 132: # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with 133: # how multipart uploaded files from HTML appear 134: xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value 135: end 136: when 'Array' 137: value.map! { |i| typecast_xml_value(i) } 138: value.length > 1 ? value : value.first 139: when 'String' 140: value 141: else 142: raise "can't typecast #{value.class.name} - #{value.inspect}" 143: end 144: end
# File lib/active_support/core_ext/hash/conversions.rb, line 146 146: def unrename_keys(params) 147: case params.class.to_s 148: when "Hash" 149: Hash[params.map { |k,v| [k.to_s.tr("-", "_"), unrename_keys(v)] } ] 150: when "Array" 151: params.map { |v| unrename_keys(v) } 152: else 153: params 154: end 155: end
Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch. Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols as keys, this will fail.
{ :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years" { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key: name" { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
# File lib/active_support/core_ext/hash/keys.rb, line 48 48: def assert_valid_keys(*valid_keys) 49: valid_keys.flatten! 50: each_key do |k| 51: raise(ArgumentError, "Unknown key: #{k}") unless valid_keys.include?(k) 52: end 53: end
Returns a deep copy of hash.
hash = { :a => { :b => 'b' } } dup = hash.deep_dup dup[:a][:c] = 'c' hash[:a][:c] #=> nil dup[:a][:c] #=> "c"
# File lib/active_support/core_ext/hash/deep_dup.rb, line 10 10: def deep_dup 11: duplicate = self.dup 12: duplicate.each_pair do |k,v| 13: tv = duplicate[k] 14: duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v 15: end 16: duplicate 17: end
Returns a new hash with self and other_hash merged recursively.
h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]} h2 = {:x => {:y => [7,8,9]}, :z => "xyz"} h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" } h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
# File lib/active_support/core_ext/hash/deep_merge.rb, line 9 9: def deep_merge(other_hash) 10: dup.deep_merge!(other_hash) 11: end
Same as deep_merge, but modifies self.
# File lib/active_support/core_ext/hash/deep_merge.rb, line 14 14: def deep_merge!(other_hash) 15: other_hash.each_pair do |k,v| 16: tv = self[k] 17: self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v 18: end 19: self 20: end
Returns a hash that represents the difference between two hashes.
Examples:
{1 => 2}.diff(1 => 2) # => {} {1 => 2}.diff(1 => 3) # => {1 => 2} {}.diff(1 => 2) # => {1 => 2} {1 => 2, 3 => 4}.diff(1 => 2) # => {3 => 4}
# File lib/active_support/core_ext/hash/diff.rb, line 10 10: def diff(h2) 11: dup.delete_if { |k, v| h2[k] == v }.merge!(h2.dup.delete_if { |k, v| has_key?(k) }) 12: end
# File lib/active_support/json/encoding.rb, line 245 245: def encode_json(encoder) 246: # values are encoded with use_options = false, because we don't want hash representations from ActiveModel to be 247: # processed once again with as_json with options, as this could cause unexpected results (i.e. missing fields); 248: 249: # on the other hand, we need to run as_json on the elements, because the model representation may contain fields 250: # like Time/Date in their original (not jsonified) form, etc. 251: 252: "{#{map { |k,v| "#{encoder.encode(k.to_s)}:#{encoder.encode(v, false)}" } * ','}}" 253: end
Return a hash that includes everything but the given keys. This is useful for limiting a set of parameters to everything but a few known toggles:
@person.update_attributes(params[:person].except(:admin))
If the receiver responds to convert_key, the method is called on each of the arguments. This allows except to play nice with hashes with indifferent access for instance:
{:a => 1}.with_indifferent_access.except(:a) # => {} {:a => 1}.with_indifferent_access.except("a") # => {}
# File lib/active_support/core_ext/hash/except.rb, line 14 14: def except(*keys) 15: dup.except!(*keys) 16: end
Replaces the hash without the given keys.
# File lib/active_support/core_ext/hash/except.rb, line 19 19: def except!(*keys) 20: keys.each { |key| delete(key) } 21: self 22: end
Removes and returns the key/value pairs matching the given keys.
{:a => 1, :b => 2, :c => 3, :d => 4}.extract!(:a, :b) # => {:a => 1, :b => 2}
# File lib/active_support/core_ext/hash/slice.rb, line 35 35: def extract!(*keys) 36: result = {} 37: keys.each {|key| result[key] = delete(key) } 38: result 39: end
By default, only instances of Hash itself are extractable. Subclasses of Hash may implement this method and return true to declare themselves as extractable. If a Hash is extractable, Array#extract_options! pops it from the Array when it is the last element of the Array.
# File lib/active_support/core_ext/array/extract_options.rb, line 7 7: def extractable_options? 8: instance_of?(Hash) 9: end
Called when object is nested under an object that receives #. This method will be called on the current object by the enclosing object and is aliased to # by default. Subclasses of Hash may overwrite this method to return self if converting to an ActiveSupport::HashWithIndifferentAccess would not be desirable.
b = {:b => 1} {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
Merges the caller into other_hash. For example,
options = options.reverse_merge(:size => 25, :velocity => 10)
is equivalent to
options = {:size => 25, :velocity => 10}.merge(options)
This is particularly useful for initializing an options hash with default values.
# File lib/active_support/core_ext/hash/reverse_merge.rb, line 12 12: def reverse_merge(other_hash) 13: other_hash.merge(self) 14: end
Destructive reverse_merge.
# File lib/active_support/core_ext/hash/reverse_merge.rb, line 17 17: def reverse_merge!(other_hash) 18: # right wins if there is no left 19: merge!( other_hash ){|key,left,right| left } 20: end
Slice a hash to include only the given keys. This is useful for limiting an options hash to valid keys before passing to a method:
def search(criteria = {}) assert_valid_keys(:mass, :velocity, :time) end search(options.slice(:mass, :velocity, :time))
If you have an array of keys you want to limit to, you should splat them:
valid_keys = [:mass, :velocity, :time] search(options.slice(*valid_keys))
# File lib/active_support/core_ext/hash/slice.rb, line 15 15: def slice(*keys) 16: keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key) 17: hash = self.class.new 18: keys.each { |k| hash[k] = self[k] if has_key?(k) } 19: hash 20: end
Replaces the hash with only the given keys. Returns a hash contained the removed key/value pairs
{:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d => 4}
# File lib/active_support/core_ext/hash/slice.rb, line 25 25: def slice!(*keys) 26: keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key) 27: omit = slice(*self.keys - keys) 28: hash = slice(*keys) 29: replace(hash) 30: omit 31: end
Return a new hash with all keys converted to strings.
{ :name => 'Rob', :years => '28' }.stringify_keys #=> { "name" => "Rob", "years" => "28" }
# File lib/active_support/core_ext/hash/keys.rb, line 6 6: def stringify_keys 7: dup.stringify_keys! 8: end
Destructively convert all keys to strings. Same as stringify_keys, but modifies self.
# File lib/active_support/core_ext/hash/keys.rb, line 12 12: def stringify_keys! 13: keys.each do |key| 14: self[key.to_s] = delete(key) 15: end 16: self 17: end
Return a new hash with all keys converted to symbols, as long as they respond to to_sym.
{ 'name' => 'Rob', 'years' => '28' }.symbolize_keys #=> { :name => "Rob", :years => "28" }
# File lib/active_support/core_ext/hash/keys.rb, line 24 24: def symbolize_keys 25: dup.symbolize_keys! 26: end
Destructively convert all keys to symbols, as long as they respond to to_sym. Same as symbolize_keys, but modifies self.
# File lib/active_support/core_ext/hash/keys.rb, line 30 30: def symbolize_keys! 31: keys.each do |key| 32: self[(key.to_sym rescue key) || key] = delete(key) 33: end 34: self 35: end
Returns a string representation of the receiver suitable for use as a URL query string:
{:name => 'David', :nationality => 'Danish'}.to_param # => "name=David&nationality=Danish"
An optional namespace can be passed to enclose the param names:
{:name => 'David', :nationality => 'Danish'}.to_param('user') # => "user[name]=David&user[nationality]=Danish"
The string pairs “key=value” that conform the query string are sorted lexicographically in ascending order.
This method is also aliased as to_query.
# File lib/active_support/core_ext/object/to_param.rb, line 50 50: def to_param(namespace = nil) 51: collect do |key, value| 52: value.to_query(namespace ? "#{namespace}[#{key}]" : key) 53: end.sort * '&' 54: end
Returns a string containing an XML representation of its receiver:
{"foo" => 1, "bar" => 2}.to_xml # => # <?xml version="1.0" encoding="UTF-8"?> # <hash> # <foo type="integer">1</foo> # <bar type="integer">2</bar> # </hash>
To do so, the method loops over the pairs and builds nodes that depend on the values. Given a pair key, value:
If value is a hash there’s a recursive call with key as :root.
If value is an array there’s a recursive call with key as :root, and key singularized as :children.
If value is a callable object it must expect one or two arguments. Depending on the arity, the callable is invoked with the options hash as first argument with key as :root, and key singularized as second argument. The callable can add nodes by using options[:builder].
"foo".to_xml(lambda { |options, key| options[:builder].b(key) }) # => "<b>foo</b>"
If value responds to to_xml the method is invoked with key as :root.
class Foo def to_xml(options) options[:builder].bar "fooing!" end end {:foo => Foo.new}.to_xml(:skip_instruct => true) # => "<hash><bar>fooing!</bar></hash>"
Otherwise, a node with key as tag is created with a string representation of value as text node. If value is nil an attribute “nil” set to “true” is added. Unless the option :skip_types exists and is true, an attribute “type” is added as well according to the following mapping:
XML_TYPE_NAMES = { "Symbol" => "symbol", "Fixnum" => "integer", "Bignum" => "integer", "BigDecimal" => "decimal", "Float" => "float", "TrueClass" => "boolean", "FalseClass" => "boolean", "Date" => "date", "DateTime" => "datetime", "Time" => "datetime" }
By default the root node is “hash”, but that’s configurable via the :root option.
The default XML builder is a fresh instance of Builder::XmlMarkup. You can configure your own builder with the :builder option. The method also accepts options like :dasherize and friends, they are forwarded to the builder.
# File lib/active_support/core_ext/hash/conversions.rb, line 69 69: def to_xml(options = {}) 70: require 'active_support/builder' unless defined?(Builder) 71: 72: options = options.dup 73: options[:indent] ||= 2 74: options[:root] ||= "hash" 75: options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent]) 76: 77: builder = options[:builder] 78: builder.instruct! unless options.delete(:skip_instruct) 79: 80: root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options) 81: 82: builder.__send__(:method_missing, root) do 83: each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) } 84: yield builder if block_given? 85: end 86: end
Returns an ActiveSupport::HashWithIndifferentAccess out of its receiver:
{:a => 1}.with_indifferent_access["a"] # => 1
# File lib/active_support/core_ext/hash/indifferent_access.rb, line 9 9: def with_indifferent_access 10: ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self) 11: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.