mash 0.0.2 → 0.0.3

data/History.txt

@@ -1,3 +1,12 @@
+=== 0.0.3 / 2008-04-19
+
+* [] no longer defaults to a new Mash, will return nil if
+* Attribute-esque method names will yield the default value if not set
+* Hash extended with #to_mash and #stringify_keys
+* Added #dup and #deep_merge
+* Aliased the default Hash methods so they are still accessible
+* Cleaned up the recursive conversion process
+
 === 0.0.2 / 2008-04-12
 
 * Added bang(!) method support

data/README.txt

@@ -32,7 +32,7 @@ RubyGem:
   
 Git:
 
-  git clone git://github.com/mbleigh/mash
+  git clone git://github.com/mbleigh/mash.git
 
 == LICENSE:
 

data/lib/mash.rb

@@ -40,14 +40,14 @@
 #   mash.author # => <Mash name="Michael Bleigh">
 #
 class Mash < Hash
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
   
   # If you pass in an existing hash, it will
   # convert it to a Mash including recursively
   # descending into arrays and hashes, converting
   # them as well.
   def initialize(source_hash = nil)
-    mash_a_hash(source_hash) if source_hash
+    deep_update(source_hash) if source_hash
     super(nil)
   end
   
@@ -55,15 +55,56 @@ class Mash < Hash
     self["id"] ? self["id"] : super
   end
   
-  def [](key) #:nodoc:
-    key = key.to_s
-    return Mash.new unless key?(key)    
-    super
+  # Borrowed from Merb's Mash object.
+  #
+  # ==== Parameters
+  # key<Object>:: The default value for the mash. Defaults to nil.
+  #
+  # ==== Alternatives
+  # If key is a Symbol and it is a key in the mash, then the default value will
+  # be set to the value matching the key.
+  def default(key = nil) 
+    if key.is_a?(Symbol) && key?(key) 
+      self[key] 
+    else 
+      super 
+    end 
   end
   
+  alias_method :regular_reader, :[]
+  alias_method :regular_writer, :[]=
+  
+  # Retrieves an attribute set in the Mash. Will convert
+  # any key passed in to a string before retrieving.
+  def [](key)
+    key = convert_key(key)
+    regular_reader(key)
+  end
+  
+  # Sets an attribute in the Mash. Key will be converted to
+  # a string before it is set.
   def []=(key,value) #:nodoc:
-    key = key.to_s
-    super
+    key = convert_key(key)
+    regular_writer(key,convert_value(value))
+  end
+  
+  # This is the bang method reader, it will return a new Mash
+  # if there isn't a value already assigned to the key requested.
+  def initializing_reader(key)
+    return self[key] if key?(key)
+    self[key] = Mash.new
+  end
+  
+  # Duplicates the current mash as a new mash.
+  def dup
+    Mash.new(self)
+  end
+  
+  alias_method :regular_inspect, :inspect
+  
+  alias_method :picky_key?, :key?
+  def key?(key)
+    picky_key?(convert_key(key))
   end
   
   # Prints out a pretty object-like string of the
@@ -76,8 +117,53 @@ class Mash < Hash
     ret << ">"
     ret
   end
+  alias_method :to_s, :inspect
+  
+  # Performs a deep_update on a duplicate of the
+  # current mash.
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
   
-  alias :to_s :inspect
+  # Recursively merges this mash with the passed
+  # in hash, merging each hash in the hierarchy.
+  def deep_update(other_hash)
+    stringified_hash = other_hash.stringify_keys
+    stringified_hash.each_pair do |k,v|
+      k = convert_key(k)
+      self[k] = self[k].to_mash if self[k].is_a?(Hash) unless self[k].is_a?(Mash)
+      if self[k].is_a?(Hash) && stringified_hash[k].is_a?(Hash)
+        self[k].deep_merge!(stringified_hash[k])
+      else
+        self.send(k + "=", convert_value(stringified_hash[k]))
+      end
+    end
+  end
+  alias_method :deep_merge!, :deep_update
+  
+  # ==== Parameters
+  # other_hash<Hash>::
+  # A hash to update values in the mash with. Keys will be
+  # stringified and Hashes will be converted to Mashes.
+  #
+  # ==== Returns
+  # Mash:: The updated mash.
+  def update(other_hash)
+    other_hash.each_pair do |key, value|
+      if respond_to?(convert_key(key) + "=")
+        self.send(convert_key(key) + "=", convert_value(value))
+      else
+        regular_writer(convert_key(key), convert_value(value))
+      end
+    end
+    self
+  end
+  alias_method :merge!, :update
+  
+  # Converts a mash back to a hash (with stringified keys)
+  def to_hash
+    Hash.new(default).merge(self)
+  end
   
   def method_missing(method_name, *args) #:nodoc:
     if (match = method_name.to_s.match(/(.*)=$/)) && args.size == 1
@@ -85,12 +171,11 @@ class Mash < Hash
     elsif (match = method_name.to_s.match(/(.*)\?$/)) && args.size == 0
       key?(match[1])
     elsif (match = method_name.to_s.match(/(.*)!$/)) && args.size == 0
-      return self[match[1]] if key?(match[1])
-      self[match[1]] = Mash.new
-    elsif keys.include?(method_name.to_s)
+      initializing_reader(match[1])
+    elsif key?(method_name)
       self[method_name]
     elsif match = method_name.to_s.match(/^([a-z][a-z0-9A-Z_]+)$/)
-      nil
+      default
     else
       super
     end
@@ -98,32 +183,44 @@ class Mash < Hash
   
   protected
   
-  def mash_a_hash(hash) #:nodoc:
-    hash.each do |k,v|
-      case v
-        when Hash
-          v = Mash.new(v) if v.is_a?(Hash)
-        when Array
-          v = collect_mashed_hashes_in(v) if v.is_a?(Array)
-      end
-      
-      # we use the method call instead of []= here so that
-      # it can be easily overridden for custom behavior in
-      # inheriting objects
-      self.send "#{k.to_s}=", v
-    end
+  def convert_key(key) #:nodoc:
+    key.to_s
   end
   
-  def collect_mashed_hashes_in(array) #:nodoc:
-    array.collect do |value|
-      case value
-        when Hash
-          Mash.new(value)
-        when Array
-          collect_mashed_hashes_in(value)
-        else
-          value
-      end
+  def convert_value(value) #:nodoc:
+    case value
+      when Hash
+        value.is_a?(Mash) ? value : value.to_mash
+      when Array
+        value.collect{ |e| convert_value(e) }
+      else
+        value
     end
   end
+end
+
+class Hash
+  # Returns a new Mash initialized from this Hash.
+  def to_mash
+    mash = Mash.new(self)
+    mash.default = default
+    mash
+  end
+  
+  # Returns a duplicate of the current hash with
+  # all of the keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+  
+  # Converts all of the keys to strings
+  def stringify_keys!
+    keys.each{|k| 
+      v = delete(k)
+      self[k.to_s] = v
+      v.stringify_keys! if v.is_a?(Hash)
+      v.each{|p| p.stringify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
+    }
+    self
+  end
 end

data/spec/mash_spec.rb

@@ -50,6 +50,10 @@ describe Mash do
     @mash.name!.should == "Bob"
   end
   
+  it "#initializing_reader should return a Mash when passed a non-existent key" do
+    @mash.initializing_reader(:abc).is_a?(Mash).should be_true
+  end
+  
   it "should allow for multi-level assignment through bang methods" do
     @mash.author!.name = "Michael Bleigh"
     @mash.author.should == Mash.new(:name => "Michael Bleigh")
@@ -57,6 +61,14 @@ describe Mash do
     @mash.author.website.should == Mash.new(:url => "http://www.mbleigh.com/")
   end
   
+  it "#deep_update should recursively mash mashes and hashes together" do
+    @mash.first_name = "Michael"
+    @mash.last_name = "Bleigh"
+    @mash.details = {:email => "michael@asf.com"}.to_mash
+    @mash.deep_update({:details => {:email => "michael@intridea.com"}})
+    @mash.details.email.should == "michael@intridea.com"
+  end
+  
   context "#initialize" do
     it "should convert an existing hash to a Mash" do
       converted = Mash.new({:abc => 123, :name => "Bob"})
@@ -77,4 +89,26 @@ describe Mash do
       converted.a.last.should == 23
     end
   end
+end
+
+describe Hash do
+  it "should be convertible to a Mash" do
+    mash = {:some => "hash"}.to_mash
+    mash.is_a?(Mash).should be_true
+    mash.some.should == "hash"
+  end
+  
+  it "#stringify_keys! should turn all keys into strings" do
+    hash = {:a => "hey", 123 => "bob"}
+    hash.stringify_keys!
+    hash.should == {"a" => "hey", "123" => "bob"}
+  end
+  
+  it "#stringify_keys should return a hash with stringified keys" do
+    hash = {:a => "hey", 123 => "bob"}
+    stringified_hash = hash.stringify_keys
+    hash.should == {:a => "hey", 123 => "bob"}
+    stringified_hash.should == {"a" => "hey", "123" => "bob"}
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mash
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-12 00:00:00 -04:00
+date: 2008-04-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: mash-hash
-rubygems_version: 1.1.0
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended