Class: Hash

Class | Hash
In: | lib/extlib/hash.rb
Parent: | Object

### Methods

add_html_class! environmentize_keys! except from_xml normalize_param only protect_keys! to_html_attributes to_mash to_params to_xml_attributes unprotect_keys!

### Public Class methods

from_xml( xml )

Converts valid XML into a Ruby Hash structure.

Mixed content is treated as text and any tags in it are left unparsed

Any attributes other than type on a node containing a text node will be discarded

Typecasting is performed on elements that have a `type` attribute:
  integer:: Returns an Integer

  boolean: | Anything other than "true" evaluates to false.
  datetime: | Returns a Time object. See Time documentation for valid Time strings.
  date: | Returns a Date object. See Date documentation for valid Date strings.

Keys are automatically converted to `snake_case`

[Simple]

      <user gender='m'>
        <age type='integer'>35</age>
        <name>Home Simpson</name>
        <dob type='date'>1988-01-01</dob>
        <joined-at type='datetime'>2000-04-28 23:01</joined-at>
        <is-cool type='boolean'>true</is-cool>
      </user>

Becomes:

      { "user" => {
          "gender"    => "m",
          "age"       => 35,
          "name"      => "Home Simpson",
          "dob"       => DateObject( 1998-01-01 ),
          "joined_at" => TimeObject( 2000-04-28 23:01),
          "is_cool"   => true
        }
      }

[Mixed Content]

      <story>
        A Quick <em>brown</em> Fox
      </story>

Evaluates to:

      { "story" => "A Quick <em>brown</em> Fox" }

[Attributes other than type on a node containing text]

      <story is-good='false'>
        A Quick <em>brown</em> Fox
      </story>

Are ignored:

      { "story" => "A Quick <em>brown</em> Fox" }

[Other attributes in addition to `type`]

      <bicep unit='inches' type='integer'>60</bicep>

Evaluates with a typecast to an integer. But unit attribute is ignored:

      { "bicep" => 60 }

@param [String] xml A string representation of valid XML.

@return [Hash] A hash created by parsing `xml`

### Public Instance methods

add_html_class!(html_class)

@param html_class<to_s>

      The HTML class to add to the :class key. The html_class will be
      concatenated to any existing classes.

@example hash[:class] #=> nil @example hash.add_html_class!(:selected) @example hash[:class] #=> "selected" @example hash.add_html_class!("class1 class2") @example hash[:class] #=> "selected class1 class2"

environmentize_keys!()

Destructively and non-recursively convert each key to an uppercase string, deleting nil values along the way.

@return <Hash> The newly environmentized hash.

@example

      { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys!
        #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } }

except(*rejected)

Create a hash with all key/value pairs in receiver except `rejected`

       { :one => 1, :two => 2, :three => 3 }.except(:one)
        #=> { :two => 2, :three => 3 }

@param [Array[String, Symbol]] *rejected The hash keys to exclude.

@return [Hash] A new hash without the selected keys.

@api public

normalize_param(key, value)

Convert a key, value pair into a URL query param string

      normalize_param(:name, "Bob")   #=> "name=Bob&"

@param [Object] key The key for the param. @param [Object] value The value for the param.

@return <String> This key value pair as a param

@api public

only(*allowed)

Create a hash with only key/value pairs in receiver and `allowed`

      { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }

@param [Array[String, Symbol]] *allowed The hash keys to include.

@return [Hash] A new hash with only the selected keys.

@api public

protect_keys!()

Converts all keys into string values. This is used during reloading to prevent problems when classes are no longer declared.

@return <Array> An array of they hash‘s keys

@example

      hash = { One => 1, Two => 2 }.proctect_keys!
      hash # => { "One" => 1, "Two" => 2 }

to_html_attributes()

Alias for to_xml_attributes

to_mash()

Convert to Mash. This class has semantics of ActiveSupport‘s HashWithIndifferentAccess and we only have it so that people can write params[:key] instead of params[‘key’].

@return [Mash] This hash as a Mash for string or symbol key access.

to_params()

Convert to URL query param string

      { :name => "Bob",
        :address => {
          :street => '111 Ruby Ave.',
          :city => 'Ruby Central',
          :phones => ['111-111-1111', '222-222-2222']
        }
      }.to_params
        #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."

@return [String] This hash as a query string

@api public

to_xml_attributes()

@return <String> The hash as attributes for an XML tag.

@example

      { :one => 1, "two"=>"TWO" }.to_xml_attributes
        #=> 'one="1" two="TWO"'

unprotect_keys!()

Attempts to convert all string keys into Class keys. We run this after reloading to convert protected hashes back into usable hashes.

@example

      # Provided that classes One and Two are declared in this scope:
      hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
      hash # => { One => 1, Two => 2 }

[Validate]