hashie 0.1.3 → 0.1.4

data/.gitignore

@@ -2,4 +2,5 @@
 .DS_Store
 coverage
 rdoc
-pkg
+pkg
+*.gem

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/hashie.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hashie}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Bleigh"]
-  s.date = %q{2009-11-12}
+  s.date = %q{2009-11-13}
   s.description = %q{Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).}
   s.email = %q{michael@intridea.com}
   s.extra_rdoc_files = [

data/lib/hashie/dash.rb

@@ -7,7 +7,7 @@ module Hashie
   # optional defaults) and only those keys may be set or read.
   #
   # Dashes are useful when you need to create a very simple
-  # lightweight data object that needs even fewer options and 
+  # lightweight data object that needs even fewer options and
   # resources than something like a DataMapper resource.
   #
   # It is preferrable to a Struct because of the in-class
@@ -15,67 +15,66 @@ module Hashie
   class Dash < Hashie::Hash
     include Hashie::PrettyInspect
     alias_method :to_s, :inspect
-    
+
     # Defines a property on the Dash. Options are
     # as follows:
-    # 
-    # * <tt>:default</tt> - Specify a default value for this property, 
+    #
+    # * <tt>:default</tt> - Specify a default value for this property,
     #   to be returned before a value is set on the property in a new
     #   Dash.
     #
     def self.property(property_name, options = {})
       property_name = property_name.to_sym
-      
+
       (@properties ||= []) << property_name
       (@defaults ||= {})[property_name] = options.delete(:default)
-      
+
       class_eval <<-RUBY
         def #{property_name}
           self[:#{property_name}]
         end
-        
+
         def #{property_name}=(val)
           self[:#{property_name}] = val
         end
       RUBY
     end
-    
+
     # Get a String array of the currently defined
     # properties on this Dash.
     def self.properties
       @properties.collect{|p| p.to_s}
     end
-    
+
     # Check to see if the specified property has already been
     # defined.
     def self.property?(prop)
       properties.include?(prop.to_s)
     end
-    
+
     # The default values that have been set for this Dash
     def self.defaults
       @defaults
     end
-    
+
     # You may initialize a Dash with an attributes hash
     # just like you would many other kinds of data objects.
     def initialize(attributes = {})
       self.class.properties.each do |prop|
-        puts "#{prop}="
         self.send("#{prop}=", self.class.defaults[prop.to_sym])
       end
-      
+
       attributes.each_pair do |att, value|
         self.send("#{att}=", value)
       end
     end
-    
+
     # Retrieve a value from the Dash (will return the
     # property's default value if it hasn't been set).
     def [](property_name)
       super(property_name.to_sym)
     end
-    
+
     # Set a value on the Dash in a Hash-like way. Only works
     # on pre-existing properties.
     def []=(property, value)
@@ -86,4 +85,4 @@ module Hashie
       end
     end
   end
-end
+end

data/lib/hashie/hash_extensions.rb

@@ -7,34 +7,36 @@ module Hashie
         base.send :alias_method, hashie_method, "hashie_#{hashie_method}" unless base.instance_methods.include?(hashie_method)
       end
     end
-    
+
     # Destructively convert all of the keys of a Hash
     # to their string representations.
     def hashie_stringify_keys!
       self.keys.each do |k|
-        self[k.to_s] = self.delete(k)
+        unless String === k
+          self[k.to_s] = self.delete(k)
+        end
       end
       self
     end
-  
+
     # Convert all of the keys of a Hash
     # to their string representations.
     def hashie_stringify_keys
       self.dup.stringify_keys!
     end
-    
+
     # Convert this hash into a Mash
     def to_mash
       Hashie::Mash.new(self)
     end
   end
-  
+
   module PrettyInspect
     def self.included(base)
       base.send :alias_method, :hash_inspect, :inspect
       base.send :alias_method, :inspect, :hashie_inspect
     end
-    
+
     def hashie_inspect
       ret = "<##{self.class.to_s}"
       keys.sort.each do |key|
@@ -44,4 +46,4 @@ module Hashie
       ret
     end
   end
-end
+end

data/lib/hashie/mash.rb

@@ -7,14 +7,14 @@ module Hashie
   #
   # A Mash will look at the methods you pass it and perform operations
   # based on the following rules:
-  # 
+  #
   # * No punctuation: Returns the value of the hash for that key, or nil if none exists.
   # * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
   # * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
   # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
   #
   # == Basic Example
-  #    
+  #
   #   mash = Mash.new
   #   mash.name? # => false
   #   mash.name = "Bob"
@@ -22,7 +22,7 @@ module Hashie
   #   mash.name? # => true
   #
   # == Hash Conversion  Example
-  #   
+  #
   #   hash = {:a => {:b => 23, :d => {:e => "abc"}}, :f => [{:g => 44, :h => 29}, 12]}
   #   mash = Mash.new(hash)
   #   mash.a.b # => 23
@@ -35,7 +35,7 @@ module Hashie
   #   mash = Mash.new
   #   mash.author # => nil
   #   mash.author! # => <Mash>
-  #   
+  #
   #   mash = Mash.new
   #   mash.author!.name = "Michael Bleigh"
   #   mash.author # => <Mash name="Michael Bleigh">
@@ -43,146 +43,100 @@ module Hashie
   class Mash < Hashie::Hash
     include Hashie::PrettyInspect
     alias_method :to_s, :inspect
-    
+
     # 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, default = nil, &blk)
       deep_update(source_hash) if source_hash
-      super default if default
-      super &blk if blk
+      default ? super(default) : super(&blk)
     end
-    
+
     class << self; alias [] new; end
 
     def id #:nodoc:
-      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) && key?(key.to_s) 
-        self[key] 
-      else 
-        key ? super : super()
-      end 
+      key?("id") ? self["id"] : super
     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)
+      regular_reader(convert_key(key))
     end
-    
+
     # Sets an attribute in the Mash. Key will be converted to
     # a string before it is set, and Hashes will be converted
     # into Mashes for nesting purposes.
     def []=(key,value) #:nodoc:
-      key = convert_key(key)
-      regular_writer(key, convert_value(value))
+      regular_writer(convert_key(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)
-      self[key] = Hashie::Mash.new unless key?(key)
-      self[key]
+      ck = convert_key(key)
+      regular_writer(ck, Hashie::Mash.new) unless key?(ck)
+      regular_reader(ck)
     end
-    
-    alias_method :regular_dup, :dup  
+
+    alias_method :regular_dup, :dup
     # Duplicates the current mash as a new mash.
     def dup
       Mash.new(self, self.default)
     end
-    
-    alias_method :picky_key?, :key?
+
     def key?(key)
-      picky_key?(convert_key(key))
+      super(convert_key(key))
     end
-    
+
     # 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)
-      other_hash = Hashie::Hash[other_hash].stringify_keys!
-      
       other_hash.each_pair do |k,v|
-        k = convert_key(k)
-        self[k] = Hashie::Mash.new(self[k]).to_mash if self[k].is_a?(Hash) unless self[k].is_a?(Hashie::Mash)
-        if self[k].is_a?(Hashie::Mash) && other_hash[k].is_a?(Hash)
-          self[k] = self[k].deep_merge(other_hash[k])
-        else
-          self[k] = convert_value(other_hash[k],true)
-        end
+        regular_writer(convert_key(k), convert_value(other_hash[k], true))
       end
-      
       self
     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 :update, :deep_update
     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
-      elsif (match = method_name.to_s.match(/(.*)\?$/)) && args.size == 0
-        key?(match[1])
-      elsif (match = method_name.to_s.match(/(.*)!$/)) && args.size == 0
-        initializing_reader(match[1])
-      elsif key?(method_name)
-        self[method_name]
-      elsif match = method_name.to_s.match(/^([a-z][a-z0-9A-Z_]+)$/)
-        default(method_name)
-      else
-        super
-      end
-    end
-    
+
+   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
+
     protected
-    
+
     def convert_key(key) #:nodoc:
       key.to_s
     end
-    
+
     def convert_value(val, duping=false) #:nodoc:
       case val
         when ::Hash

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hashie
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Michael Bleigh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-12 00:00:00 -05:00
+date: 2009-11-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency