class StringifyHash

A hash that treats Symbol and String keys interchangeably and recursively merges hashes

Constants

DIV

The dividor between elements when StringifyHash is dumped

EOL

The end of line when dumping

Public Instance Methods

[](k) click to toggle source

Get value for given key, search for both k as String and k as Symbol, if not present return nil

@param [Object] k The key to find, searches for both k as String

and k as Symbol

@example Use this method to return the value for a given key

a['key'] = 'value'
a['key'] == a[:key] == 'value'

@return [nil, Object] Return the Object found at given key,

or nil if no Object found
Calls superclass method
# File lib/stringify-hash.rb, line 24
def [] k
  super(k.to_s) || super(k.to_sym)
end
[]=(k,v) click to toggle source

Set Symbol key to Object value @param [Object] k The key to associated with the value,

converted to Symbol key

@param [Object] v The value to store in the ObjectHash

@example Use this method to set the value for a key

a['key'] = 'value'

@return [Object] Return the Object value just stored

Calls superclass method
# File lib/stringify-hash.rb, line 37
def []=k,v
  super(k.to_sym, v)
end
as_coll( opening, closing, in_lvl, in_inc, &block ) click to toggle source

Helper for formatting collections Computes the indentation level for elements of the collection Yields indentation to block to so the caller can create map of element strings Places delimiters in the correct location Joins everything with correct EOL

!@visibility private

# File lib/stringify-hash.rb, line 146
def as_coll( opening, closing, in_lvl, in_inc, &block )
  delim_indent = in_inc * in_lvl
  elem_indent  = in_inc * (in_lvl + 1)

  open_brace  = opening
  close_brace = delim_indent + closing

  fmtd_coll = block.call( elem_indent )
  str_coll = fmtd_coll.join( ',' + EOL )

  return open_brace + EOL + str_coll + EOL + close_brace
end
delete(k) click to toggle source

Determine key=>value entry in StringifyHash, remove both value at String key and value at Symbol key

@param [Object] k The key to delete in ObjectHash, deletes both k as String and k as Symbol

@example Use this method to set the value for a key

a['key'] = 'value'
a.delete[:key] == 'value'

@return [Object, nil] The Object deleted at value, nil if no Object deleted

Calls superclass method
# File lib/stringify-hash.rb, line 66
def delete k
  super(k.to_s) || super(k.to_sym)
end
dump() click to toggle source

Pretty print the options as JSON

@example

base = { :key => { :subkey1 => 'subval', :subkey2 => 'subval' } }
base.dump
#=>  '{
          "key": {
              "subkey1": "subval",
              "subkey2": 2
          }
      }

@return [String] The description of self

# File lib/stringify-hash.rb, line 296
def dump
  fmt_collection( self, 0, DIV )
end
fmt_assoc( coll, in_lvl = 0, in_inc = DIV ) click to toggle source

Pretty prints an associative collection

@param [#each_pair] coll The collection to be printed @param [Integer] in_lvl The level of indentation @param [String] in_inc The increment to indent

@example

base = { :key => 'value', :key2 => 'value' }
self.fmt_assoc( base )
#=> '{
         "key": "value",
         "key2": "value"
     }'

@return [String] The collection as a pretty JSON object

# File lib/stringify-hash.rb, line 203
def fmt_assoc( coll, in_lvl = 0, in_inc = DIV )
  if coll.empty?
    return '{}'
  else
    as_coll '{', '}', in_lvl, in_inc do |elem_indent|
      coll.map do |key, value|
        assoc_line = elem_indent + '"' + key.to_s + '"' + ': '
        assoc_line += fmt_value( value, in_lvl, in_inc )
      end
    end
  end
end
fmt_basic( value ) click to toggle source

Pretty prints primitive JSON values

@param [Object] value The collection to be printed

@example

self.fmt_value( 4 )
#=> '4'

@example

self.fmt_value( true )
#=> 'true'

@example

self.fmt_value( nil )
#=> 'null'

@example

self.fmt_value( 'string' )
#=> '"string"'

@return [String] The value as a valid JSON primitive

# File lib/stringify-hash.rb, line 275
def fmt_basic( value )
  case value
  when Numeric, TrueClass, FalseClass then value.to_s
  when NilClass then "null"
  else "\"#{value}\""
  end
end
fmt_collection( collection, in_lvl = 0, in_inc = DIV ) click to toggle source

Pretty prints a collection

@param [Enumerable] collection The collection to be printed @param [Integer] in_lvl The level of indentation @param [String] in_inc The increment to indent

@example

base = {:key => { :subkey1 => 'subval', :subkey2 => ['subval'] }}
self.fmt_collection( base )
#=> '{
         "key": {
             "subkey": "subval",
             "subkey2": [
                 "subval"
             ]
         }
     }'

@return [String] The collection as a pretty JSON object

# File lib/stringify-hash.rb, line 178
def fmt_collection( collection, in_lvl = 0, in_inc = DIV )
  if collection.respond_to? :each_pair
    string = fmt_assoc( collection, in_lvl, in_inc )
  else
    string = fmt_list( collection, in_lvl, in_inc )
  end

  return string
end
fmt_list( coll, in_lvl = 0, in_inc = DIV ) click to toggle source

Pretty prints a list collection

@param [#each] coll The collection to be printed @param [Integer] in_lvl The level of indentation @param [String] in_inc The increment to indent

@example

base = [ 'first', 'second' ]
self.fmt_list( base )
#=> '[
         "first",
         "second"
     ]'

@return [String] The collection as a pretty JSON object

# File lib/stringify-hash.rb, line 231
def fmt_list( coll, in_lvl = 0, in_inc = DIV )
  if coll.empty?
    return '[]'
  else
    as_coll '[', ']', in_lvl, in_inc do |indent|
      coll.map do |el|
        indent + fmt_value( el, in_lvl, in_inc )
      end
    end
  end
end
fmt_value( value, in_lvl = 0, in_inc = DIV ) click to toggle source

Chooses between collection and primitive formatting

!@visibility private

# File lib/stringify-hash.rb, line 246
def fmt_value( value, in_lvl = 0, in_inc = DIV )
  if value.kind_of? Enumerable and not value.is_a? String
    fmt_collection( value, in_lvl + 1, in_inc )
  else
    fmt_basic( value )
  end
end
has_key?(k) click to toggle source

Determine if key is stored in ObjectHash @param [Object] k The key to find in ObjectHash, searches for

both k as String and k as Symbol

@example Use this method to set the value for a key

a['key'] = 'value'
a.has_key[:key] == true

@return [Boolean]

Calls superclass method
# File lib/stringify-hash.rb, line 50
def has_key? k
  super(k.to_s) || super(k.to_sym)
end
merge(hash) click to toggle source

Create new StringifyHash from recursively merged self with an OptionsHash or Hash

@param [StringifyHash, Hash] hash The hash to merge from

@example

base = { :key => { :subkey1 => 'subval', :subkey2 => 'subval' } }
hash = { :key => { :subkey1 => 'newval'} }

base.merge(hash)
#=> {:key =>
      {:subkey1 => 'newval',
       :subkey2 => 'subval' }

@return [StringifyHash] The combined hash

# File lib/stringify-hash.rb, line 113
def merge hash
  #make a deep copy into an empty hash object
  merged_hash = rmerge(self.class.new, self)
  rmerge(merged_hash, hash)
end
merge!(hash) click to toggle source

Recursively merge self with an StringifyHash or Hash

@param [StringifyHash, Hash] hash The hash to merge from

@example

base = { :key => { :subkey1 => 'subval', :subkey2 => 'subval' } }
hash = { :key => { :subkey1 => 'newval'} }

base.merge!(hash)
#=> {:key =>
      {:subkey1 => 'newval',
       :subkey2 => 'subval' }

@return [StringifyHash] The combined hash

# File lib/stringify-hash.rb, line 133
def merge! hash
  rmerge(self, hash)
end
rmerge(base, hash) click to toggle source

Recursively merge and StringifyHash with an OptionsHash or Hash

@param [StringifyHash] base The hash to merge into @param [StringifyHash, Hash] hash The hash to merge from

@example

base = { :key => { :subkey1 => 'subval', :subkey2 => 'subval' } }
hash = { :key => { :subkey1 => 'newval'} }

rmerge(base, hash)
#=>  {:key =>
        {:subkey1 => 'newval',
         :subkey2 => 'subval'}}

@return [StringifyHash] The combined bash and hash

# File lib/stringify-hash.rb, line 85
def rmerge base, hash
  return base unless hash.is_a?(Hash) || hash.is_a?(self.class)
  hash.each do |key, v|
    if (base[key].is_a?(Hash) || base[key].is_a?(self.class)) && (hash[key].is_a?(Hash) || hash[key].is_a?(self.class))
      rmerge(base[key], hash[key])
    elsif hash[key].is_a?(Hash)
      base[key] = self.class.new.merge(hash[key])
    else
      base[key]= hash[key]
    end
  end
  base
end