Class: Hash

### Home Classes Methods

### In Files

- lib/extlib/hash.rb

### Parent

Object

### Methods

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

### Files

- LICENSE
- README.rdoc

### Class/Module Index

Quicksearch

- Extlib
- Extlib::Assertions
- Extlib::ByteArray
- Extlib::Hook
- Extlib::Hook::ClassMethods
- Extlib::Inflection
- Extlib::LocalObjectSpace
- Extlib::Logger
- Extlib::Pooling
- Extlib::Pooling::InvalidResourceError
- Extlib::Pooling::Pool
- Extlib::SimpleSet
- Gem
- Gem::SourceIndex
- Gem::Specification
- LazyModule
- LazyModule::ClassMethods
- Array
- Class
- DateTime
- Dictionary
- FalseClass
- Hash
- LazyArray
- Mash
- Module
- NilClass
- Numeric
- Object
- ObjectSpace
- Pathname
- REXMLUtilityNode
- String
- Struct
- Symbol
- Time
- ToHashParser
- TrueClass
- VirtualFile

No matching classes.

# Hash

### Constants

URI_ENCODE_PATTERN

### Public Class Methods

from_xml( xml ) click to toggle source

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`

    # File lib/extlib/hash.rb, line 84
    def from_xml( xml )
      ToHashParser.from_xml(xml)
    end

### Public Instance Methods

add_html_class!(html_class) click to toggle source

@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 #=> nil @example hash.add_html_class!(:selected) @example hash #=> "selected" @example hash.add_html_class!("class1 class2") @example hash #=> "selected class1 class2"

    # File lib/extlib/hash.rb, line 212
    def add_html_class!(html_class)
      if self[:class]
        self[:class] = "#{self[:class]} #{html_class}"
      else
        self[:class] = html_class.to_s
      end
    end

environmentize_keys!() click to toggle source

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" } }

    # File lib/extlib/hash.rb, line 253
    def environmentize_keys!
      keys.each do |key|
        val = delete(key)
        next if val.nil?
        self[key.to_s.upcase] = val
      end
      self
    end

except(*rejected) click to toggle source

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

    # File lib/extlib/hash.rb, line 184
    def except(*rejected)
      hash = self.dup
      rejected.each {|k| hash.delete(k) }
      hash
    end

normalize_param(key, value) click to toggle source

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

    # File lib/extlib/hash.rb, line 132
    def normalize_param(key, value)
      param = ''
      stack = []

      if value.is_a?(Array)
        param << value.map { |element| normalize_param("#{key}[]", element) }.join
      elsif value.is_a?(Hash)
        stack << [key,value]
      else
        param << [key,value].map {|v| URI.encode(v.to_s, URI_ENCODE_PATTERN)}.join('=') + '&'
      end

      stack.each do |parent, hash|
        hash.each do |k, v|
          if v.is_a?(Hash)
            stack << ["#{parent}[#{k}]", v]
          else
            param << normalize_param("#{parent}[#{k}]", v)
          end
        end
      end

      param
    end

only(*allowed) click to toggle source

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

    # File lib/extlib/hash.rb, line 167
    def only(*allowed)
      hash = {}
      allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
      hash
    end

protect_keys!() click to toggle source

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 }

    # File lib/extlib/hash.rb, line 228
    def protect_keys!
      keys.each {|key| self[key.to_s] = delete(key) }
    end

to_html_attributes() click to toggle source
Alias for: to_xml_attributes
to_mash() click to toggle source

Convert to Mash. This class has semantics of ActiveSupport's HashWithIndifferentAccess and we only have it so that people can write params instead of params.

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

    # File lib/extlib/hash.rb, line 94
    def to_mash
      hash = Mash.new(self)
      hash.default = default
      hash
    end

to_params() click to toggle source

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

    # File lib/extlib/hash.rb, line 115
    def to_params
      params = self.map { |k,v| normalize_param(k,v) }.join
      params.chop! # trailing &
      params
    end

to_xml_attributes() click to toggle source

@return [String] The hash as attributes for an XML tag.

@example

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

    # File lib/extlib/hash.rb, line 195
    def to_xml_attributes
      map do |k,v|
        %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
      end.join(' ')
    end

Also aliased as: to_html_attributes
unprotect_keys!() click to toggle source

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 }

    # File lib/extlib/hash.rb, line 239
    def unprotect_keys!
      keys.each do |key|
        (self[Object.full_const_get(key)] = delete(key)) rescue nil
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.