class Hashie::Mash


mash.author # => <Mash name=“Michael Bleigh”>
mash.author!.name = “Michael Bleigh”
mash = Mash.new
mash.author! # => <Mash>
mash.author # => nil
mash = Mash.new
== Bang Example
mash.f.last # => 12
mash.f.first.g # => 44
mash.a.d.e # => “abc”
mash.a.b # => 23
mash = Mash.new(hash)
hash = {:a => {:b => 23, :d => {:e => “abc”}}, :f => [{:g => 44, :h => 29}, 12]}
== Hash Conversion Example
mash.name? # => true
mash.name # => “Bob”
mash.name = “Bob”
mash.name? # => false
mash = Mash.new
== Basic Example
* Bang (!): Forces the existence of this key, used for deep Mashes. Think of it as “touch” for mashes.
* Existence (?): Returns true or false depending on whether that key has been set.
* Assignment (=): Sets the attribute of the given method name.
* No punctuation: Returns the value of the hash for that key, or nil if none exists.
based on the following rules:
A Mash will look at the methods you pass it and perform operations
with some additional goodies.
without the overhead of actually doing so. Think of it as OpenStruct
as an API-accessing library that wants to fake robust objects
accessors for hash keys. This is useful for such implementations
Mash allows you to create pseudo-objects that have method-like

def [](key)

any key passed in to a string before retrieving.
Retrieves an attribute set in the Mash. Will convert 
def [](key)
  regular_reader(convert_key(key))
end

def []=(key,value) #:nodoc:

:nodoc:
into Mashes for nesting purposes.
a string before it is set, and Hashes will be converted
Sets an attribute in the Mash. Key will be converted to 
def []=(key,value) #:nodoc:
  regular_writer(convert_key(key), convert_value(value))
end

def convert_key(key) #:nodoc:

:nodoc: 
def convert_key(key) #:nodoc:
  key.to_s
end

def convert_value(val, duping=false) #:nodoc:

:nodoc: 
def convert_value(val, duping=false) #:nodoc:
  case val
    when ::Hash
      val = val.dup if duping
      self.class.new(val)
    when Array
      val.collect{ |e| convert_value(e) }
    else
      val
  end
end

def deep_merge(other_hash)

current mash.
Performs a deep_update on a duplicate of the 
def deep_merge(other_hash)
  dup.deep_merge!(other_hash)
end

def deep_update(other_hash)

in hash, merging each hash in the hierarchy.
Recursively merges this mash with the passed 
def deep_update(other_hash)
  other_hash.each_pair do |k,v|
    regular_writer(convert_key(k), convert_value(other_hash[k], true))
  end
  self
end

def dup

Duplicates the current mash as a new mash. 
def dup
  Mash.new(self, self.default)
end

def id #:nodoc:

:nodoc: 
def id #:nodoc:
  key?("id") ? self["id"] : super
end

def initialize(source_hash = nil, default = nil, &blk)

them as well.
descending into arrays and hashes, converting
convert it to a Mash including recursively
If you pass in an existing hash, it will 
def initialize(source_hash = nil, default = nil, &blk)
  deep_update(source_hash) if source_hash
  default ? super(default) : super(&blk)
end

def initializing_reader(key)

if there isn't a value already assigned to the key requested.
This is the bang method reader, it will return a new Mash 
def initializing_reader(key)
  ck = convert_key(key)
  regular_writer(ck, Hashie::Mash.new) unless key?(ck)
  regular_reader(ck)
end

def key?(key) 

def key?(key)
  super(convert_key(key))
end

def method_missing(method_name, *args) 

def method_missing(method_name, *args)
  return self[method_name] if key?(method_name)
  match = method_name.to_s.match(/(.*?)([?=!]?)$/)
  case match[2]
  when "="
    self[match[1]] = args.first
  when "?"
    key?(match[1])
  when "!"
    initializing_reader(match[1])
  else
    default(method_name)
  end
end

def to_hash

Converts a mash back to a hash (with stringified keys) 
def to_hash
  Hash.new(default).merge(self)
end