@@ -47,7 +47,7 @@ class Mash < Hash # 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,6 +55,22 @@ class Mash < Hash self["id"] ? self["id"] : super end + # 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) && include?(key = convert_key(key)) + self[key] + else + super + end + end + alias_method :regular_reader, :[] alias_method :regular_writer, :[]= @@ -68,8 +84,8 @@ class Mash < Hash # 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 - regular_writer(key,value) + key = convert_key(key) + regular_writer(key,convert_value(value)) end # This is the bang method reader, it will return a new Mash @@ -79,6 +95,11 @@ class Mash < Hash 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? @@ -96,9 +117,54 @@ 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 + + # 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 self[match[1]] = args.first @@ -121,32 +187,14 @@ class Mash < Hash key.to_s end - 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 - 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 @@ -158,4 +206,21 @@ class Hash 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 \ No newline at end of file lib/mash.rb @@ -61,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"}) @@ -89,4 +97,18 @@ describe Hash do 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 \ No newline at end of file spec/mash_spec.rb 763608015d03b573b90392134d5e928abf546d29 Michael Bleigh michael@intridea.com http://github.com/mbleigh/mash/commit/63d23cf23f85898bb2ec923f75ee268d440ae5f6 63d23cf23f85898bb2ec923f75ee268d440ae5f6 2008-04-19T05:47:14-07:00 2008-04-19T05:47:14-07:00 - Substantial cleanup of existing code - Added dup, deep_merge(!), and key - Added stringify_keys(!) to Hash - Used some nice tricks from the Merb Hash object 0a33a3054723b7f26354a003cee0609150c82d2c Michael Bleigh michael@intridea.com