Builds a Hash from XML just like Hash.from_xml, but also allows Symbol and YAML.

Returns a Hash containing a collection of pairs when the key is the node name and the value is its content

xml = <<-XML  <?xml version="1.0" encoding="UTF-8"?> <hash> <foo type="integer">1</foo> <bar type="integer">2</bar> </hash> XML hash = Hash.from_xml(xml) # => {"hash"=>{"foo"=>1, "bar"=>2}} 

DisallowedType is raised if the XML contains attributes with type="yaml" or type="symbol". Use Hash.from_trusted_xml to parse this XML.

Custom disallowed_types can also be passed in the form of an array.

xml = <<-XML  <?xml version="1.0" encoding="UTF-8"?> <hash> <foo type="integer">1</foo> <bar type="string">"David"</bar> </hash> XML hash = Hash.from_xml(xml, ['integer']) # => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer" 

Note that passing custom disallowed types will override the default types, which are Symbol and YAML.

Validates all keys in a hash match *valid_keys, raising ArgumentError on a mismatch.

Note that keys are treated differently than HashWithIndifferentAccess, meaning that string and symbol keys will not match.

{ name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age" { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'" { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age) # => passes, raises nothing 

Removes all blank values from the Hash in place and returns self. Uses Object#blank? for determining if a value is blank.

h = { a: "", b: 1, c: nil, d: [], e: false, f: true } h.compact_blank! # => { b: 1, f: true } 

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" 

Returns a new hash with self and other_hash merged recursively.

h1 = { a: true, b: { c: [1, 2, 3] } } h2 = { a: false, b: { x: [3, 4, 5] } } h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } } 

Like with Hash#merge in the standard library, a block can be provided to merge values:

h1 = { a: 100, b: 200, c: { c1: 100 } } h2 = { b: 250, c: { c1: 200 } } h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val } # => { a: 100, b: 450, c: { c1: 300 } } 

Same as deep_merge, but modifies self.

Returns a new hash with all keys converted to strings. This includes the keys from the root hash and from all nested hashes and arrays.

hash = { person: { name: 'Rob', age: '28' } } hash.deep_stringify_keys # => {"person"=>{"name"=>"Rob", "age"=>"28"}} 

Destructively converts all keys to strings. This includes the keys from the root hash and from all nested hashes and arrays.

Returns a new hash with all keys converted to symbols, as long as they respond to to_sym. This includes the keys from the root hash and from all nested hashes and arrays.

hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } } hash.deep_symbolize_keys # => {:person=>{:name=>"Rob", :age=>"28"}} 

Destructively converts all keys to symbols, as long as they respond to to_sym. This includes the keys from the root hash and from all nested hashes and arrays.

Returns a new hash with all keys converted by the block operation. This includes the keys from the root hash and from all nested hashes and arrays.

hash = { person: { name: 'Rob', age: '28' } } hash.deep_transform_keys{ |key| key.to_s.upcase } # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}} 

Destructively converts all keys by using the block operation. This includes the keys from the root hash and from all nested hashes and arrays.

Returns a new hash with all values converted by the block operation. This includes the values from the root hash and from all nested hashes and arrays.

hash = { person: { name: 'Rob', age: '28' } } hash.deep_transform_values{ |value| value.to_s.upcase } # => {person: {name: "ROB", age: "28"}} 

Destructively converts all values by using the block operation. This includes the values from the root hash and from all nested hashes and arrays.

Removes the given keys from hash and returns it.

hash = { a: true, b: false, c: nil } hash.except!(:c) # => { a: true, b: false } hash # => { a: true, b: false } 

Removes and returns the key/value pairs matching the given keys.

hash = { a: 1, b: 2, c: 3, d: 4 } hash.extract!(:a, :b) # => {:a=>1, :b=>2} hash # => {:c=>3, :d=>4} 

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.

Called when object is nested under an object that receives with_indifferent_access. This method will be called on the current object by the enclosing object and is aliased to with_indifferent_access by default. Subclasses of Hash may override 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 # => {"b"=>1} 

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.

Destructive reverse_merge.

Replaces the hash with only the given keys. Returns a hash containing the removed key/value pairs.

hash = { a: 1, b: 2, c: 3, d: 4 } hash.slice!(:a, :b) # => {:c=>3, :d=>4} hash # => {:a=>1, :b=>2} 

Returns a new hash with all keys converted to strings.

hash = { name: 'Rob', age: '28' } hash.stringify_keys # => {"name"=>"Rob", "age"=>"28"} 

Destructively converts all keys to strings. Same as stringify_keys, but modifies self.

Returns a new hash with all keys converted to symbols, as long as they respond to to_sym.

hash = { 'name' => 'Rob', 'age' => '28' } hash.symbolize_keys # => {:name=>"Rob", :age=>"28"} 

Destructively converts all keys to symbols, as long as they respond to to_sym. Same as symbolize_keys, but modifies self.

Returns a string representation of the receiver suitable for use as a URL query string:

{name: 'David', nationality: 'Danish'}.to_query # => "name=David&nationality=Danish" 

An optional namespace can be passed to enclose key names:

{name: 'David', nationality: 'Danish'}.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish" 

The string pairs “key=value” that conform the query string are sorted lexicographically in ascending order.

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: lambda { |options, key| options[:builder].b(key) }}.to_xml # => "<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", "Integer" => "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.

Returns an ActiveSupport::HashWithIndifferentAccess out of its receiver:

{ a: 1 }.with_indifferent_access['a'] # => 1