hashie 1.2.0 → 2.0.0

data/lib/hashie/extensions/deep_merge.rb

@@ -0,0 +1,21 @@
+module Hashie
+  module Extensions
+    module DeepMerge
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      def deep_merge(other_hash)
+        (class << (h = dup); self; end).send :include, Hashie::Extensions::DeepMerge
+        h.deep_merge!(other_hash)
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_merge!(other_hash)
+        other_hash.each do |k,v|
+          (class << (tv = self[k]); self; end).send :include, Hashie::Extensions::DeepMerge
+          self[k] = tv.is_a?(::Hash) && v.is_a?(::Hash) ? tv.deep_merge(v) : v
+        end
+        self
+      end
+    end
+  end
+end

data/lib/hashie/extensions/indifferent_access.rb

@@ -0,0 +1,114 @@
+module Hashie
+  module Extensions
+    # IndifferentAccess gives you the ability to not care
+    # whether your hash has string or symbol keys. Made famous
+    # in Rails for accessing query and POST parameters, this
+    # is a handy tool for making sure your hash has maximum
+    # utility.
+    #
+    # One unique feature of this mixin is that it will recursively
+    # inject itself into sub-hash instances without modifying
+    # the actual class of the sub-hash.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MergeInitializer
+    #     include Hashie::Extensions::IndifferentAccess
+    #   end
+    #
+    #   h = MyHash.new(:foo => 'bar', 'baz' => 'blip')
+    #   h['foo'] # => 'bar'
+    #   h[:foo]  # => 'bar'
+    #   h[:baz]  # => 'blip'
+    #   h['baz'] # => 'blip'
+    #
+    module IndifferentAccess
+      def self.included(base)
+        base.class_eval do
+          alias_method :regular_writer, :[]=
+          alias_method :[]=, :indifferent_writer
+          %w(default update fetch delete key? values_at).each do |m|
+            alias_method "regular_#{m}", m
+            alias_method m, "indifferent_#{m}"
+          end
+
+          %w(include? member? has_key?).each do |key_alias|
+            alias_method key_alias, :indifferent_key?
+          end
+        end
+      end
+
+      # This will inject indifferent access into an instance of
+      # a hash without modifying the actual class. This is what
+      # allows IndifferentAccess to spread to sub-hashes.
+      def self.inject!(hash)
+        (class << hash; self; end).send :include, IndifferentAccess
+        hash.convert!
+      end
+
+      # Injects indifferent access into a duplicate of the hash
+      # provided. See #inject!
+      def self.inject(hash)
+        inject!(hash.dup)
+      end
+
+      def convert_key(key)
+        key.to_s
+      end
+
+      # Iterates through the keys and values, reconverting them to
+      # their proper indifferent state. Used when IndifferentAccess
+      # is injecting itself into member hashes.
+      def convert!
+        keys.each do |k|
+          regular_writer convert_key(k), convert_value(self.regular_delete(k))
+        end
+        self
+      end
+
+      def convert_value(value)
+        if hash_lacking_indifference?(value)
+          IndifferentAccess.inject(value.dup)
+        elsif value.is_a?(::Array)
+          value.dup.replace(value.map { |e| convert_value(e) })
+        else
+          value
+        end
+      end
+      
+      def indifferent_default(key = nil)
+        return self[convert_key(key)] if key?(key)
+        regular_default(key)
+      end
+
+      def indifferent_update(other_hash)
+        return regular_update(other_hash) if hash_with_indifference?(other_hash)
+        other_hash.each_pair do |k,v|
+          self[k] = v
+        end
+      end
+      
+      def indifferent_writer(key, value);  regular_writer convert_key(key), convert_value(value) end
+      def indifferent_fetch(key, *args);   regular_fetch  convert_key(key), *args                end
+      def indifferent_delete(key);         regular_delete convert_key(key)                       end
+      def indifferent_key?(key);           regular_key?   convert_key(key)                       end
+      def indifferent_values_at(*indices); indices.map{|i| self[i] }                             end
+
+      def indifferent_access?; true end
+      
+      protected
+
+      def hash_lacking_indifference?(other)
+        other.is_a?(::Hash) &&
+        !(other.respond_to?(:indifferent_access?) &&
+          other.indifferent_access?)
+      end
+
+      def hash_with_indifference?(other)
+        other.is_a?(::Hash) &&
+        other.respond_to?(:indifferent_access?) &&
+        other.indifferent_access?
+      end
+    end
+  end
+end

data/lib/hashie/extensions/key_conversion.rb

@@ -0,0 +1,92 @@
+module Hashie
+  module Extensions
+    module StringifyKeys
+      # Convert all keys in the hash to strings.
+      #
+      # @example
+      #   test = {:abc => 'def'}
+      #   test.stringify_keys!
+      #   test # => {'abc' => 'def'}
+      def stringify_keys!
+        keys.each do |k|
+          stringify_keys_recursively!(self[k])
+          self[k.to_s] = self.delete(k)
+        end
+        self
+      end
+
+      # Return a new hash with all keys converted
+      # to strings.
+      def stringify_keys
+        dup.stringify_keys!
+      end
+
+      protected
+
+      # Stringify all keys recursively within nested
+      # hashes and arrays.
+      def stringify_keys_recursively!(object)
+        if self.class === object
+          object.stringify_keys!
+        elsif ::Array === object
+          object.each do |i|
+            stringify_keys_recursively!(i)
+          end
+          object
+        elsif object.respond_to?(:stringify_keys!)
+          object.stringify_keys!
+        else
+          object
+        end
+      end
+    end
+
+    module SymbolizeKeys
+      # Convert all keys in the hash to symbols.
+      #
+      # @example
+      #   test = {'abc' => 'def'}
+      #   test.symbolize_keys!
+      #   test # => {:abc => 'def'}
+      def symbolize_keys!
+        keys.each do |k|
+          symbolize_keys_recursively!(self[k])
+          self[k.to_sym] = self.delete(k)
+        end
+        self
+      end
+
+      # Return a new hash with all keys converted
+      # to symbols.
+      def symbolize_keys
+        dup.symbolize_keys!
+      end
+
+      protected
+
+      # Symbolize all keys recursively within nested
+      # hashes and arrays.
+      def symbolize_keys_recursively!(object)
+        if self.class === object
+          object.symbolize_keys!
+        elsif ::Array === object
+          object.each do |i|
+            symbolize_keys_recursively!(i)
+          end
+          object
+        elsif object.respond_to?(:symbolize_keys!)
+          object.symbolize_keys!
+        else
+          object
+        end
+      end
+    end
+    
+    module KeyConversion
+      def self.included(base)
+        base.send :include, SymbolizeKeys
+        base.send :include, StringifyKeys
+      end
+    end
+  end
+end

data/lib/hashie/extensions/merge_initializer.rb

@@ -0,0 +1,26 @@
+module Hashie
+  module Extensions
+    # The MergeInitializer is a super-simple mixin that allows
+    # you to initialize a subclass of Hash with another Hash
+    # to give you faster startup time for Hash subclasses. Note
+    # that you can still provide a default value as a second
+    # argument to the initializer.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MergeInitializer
+    #   end
+    #
+    #   h = MyHash.new(:abc => 'def')
+    #   h[:abc] # => 'def'
+    #
+    module MergeInitializer
+      def initialize(hash = {}, default = nil, &block)
+        default ? super(default) : super(&block)
+        hash.each do |key, value|
+          self[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/method_access.rb

@@ -0,0 +1,124 @@
+module Hashie
+  module Extensions
+    # MethodReader allows you to access keys of the hash
+    # via method calls. This gives you an OStruct like way
+    # to access your hash's keys. It will recognize keys
+    # either as strings or symbols.
+    #
+    # Note that while nil keys will be returned as nil, 
+    # undefined keys will raise NoMethodErrors. Also note that 
+    # #respond_to? has been patched to appropriately recognize
+    # key methods.
+    #
+    # @example
+    #   class User < Hash
+    #     include Hashie::Extensions::MethodReader
+    #   end
+    #
+    #   user = User.new
+    #   user['first_name'] = 'Michael'
+    #   user.first_name # => 'Michael'
+    #   
+    #   user[:last_name] = 'Bleigh'
+    #   user.last_name # => 'Bleigh'    
+    #
+    #   user[:birthday] = nil
+    #   user.birthday # => nil
+    #
+    #   user.not_declared # => NoMethodError
+    module MethodReader
+      def respond_to?(name, include_private = false)
+        return true if key?(name.to_s) || key?(name.to_sym)
+        super
+      end
+      
+      def method_missing(name, *args)
+        return self[name.to_s] if key?(name.to_s)
+        return self[name.to_sym] if key?(name.to_sym)
+        super
+      end
+    end
+
+    # MethodWriter gives you #key_name= shortcuts for
+    # writing to your hash. Keys are written as strings,
+    # override #convert_key if you would like to have symbols
+    # or something else.
+    #
+    # Note that MethodWriter also overrides #respond_to such
+    # that any #method_name= will respond appropriately as true.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MethodWriter
+    #   end
+    #
+    #   h = MyHash.new
+    #   h.awesome = 'sauce'
+    #   h['awesome'] # => 'sauce'
+    #
+    module MethodWriter
+      def respond_to?(name, include_private = false)
+        return true if name.to_s =~ /=$/
+        super
+      end
+
+      def method_missing(name, *args)
+        if args.size == 1 && name.to_s =~ /(.*)=$/
+          return self[convert_key($1)] = args.first
+        end
+
+        super
+      end
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+
+    # MethodQuery gives you the ability to check for the truthiness
+    # of a key via method calls. Note that it will return false if
+    # the key is set to a non-truthful value, not if the key isn't
+    # set at all. Use #key? for checking if a key has been set.
+    #
+    # MethodQuery will check against both string and symbol names
+    # of the method for existing keys. It also patches #respond_to
+    # to appropriately detect the query methods.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MethodQuery
+    #   end
+    #
+    #   h = MyHash.new
+    #   h['abc'] = 123
+    #   h.abc? # => true
+    #   h['def'] = nil
+    #   h.def? # => false
+    #   h.hji? # => NoMethodError
+    module MethodQuery
+      def respond_to?(name, include_private = false)
+        return true if name.to_s =~ /(.*)\?$/ && (key?($1) || key?($1.to_sym))
+        super
+      end
+
+      def method_missing(name, *args)
+        if args.empty? && name.to_s =~ /(.*)\?$/ && (key?($1) || key?($1.to_sym))
+          return self[$1] || self[$1.to_sym]
+        end
+
+        super
+      end
+    end
+
+    # A macro module that will automatically include MethodReader,
+    # MethodWriter, and MethodQuery, giving you the ability to read,
+    # write, and query keys in a hash using method call shortcuts.
+    module MethodAccess
+      def self.included(base)
+        [MethodReader, MethodWriter, MethodQuery].each do |mod|
+          base.send :include, mod
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/structure.rb

@@ -0,0 +1,47 @@
+module Hashie
+  module Extensions
+    # The Structure extension provides facilities for declaring
+    # properties that a Hash can have. This provides for the
+    # creation of structures that still behave like hashes but
+    # do not allow setting non-allowed keys.
+    #
+    # @example
+    #   class RestrictedHash < Hash
+    #     include Hashie::Extensions::MergeInitializer
+    #     include Hashie::Extensions::Structure
+    #
+    #     key :first
+    #     key :second, :default => 'foo'
+    #   end
+    #
+    #   h = RestrictedHash.new(:first => 1)
+    #   h[:first]  # => 1
+    #   h[:second] # => 'foo'
+    #   h[:third]  # => ArgumentError
+    #
+    module Structure
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          @permitted_keys = superclass.permitted_keys if superclass.respond_to?(:permitted_keys)
+        end
+      end
+
+      module ClassMethods
+        def key(key, options = {})
+          (@permitted_keys ||= []) << key
+
+          if options[:default]
+            (@default_values ||= {})[key] = options.delete(:default)
+          end
+
+          permitted_keys
+        end
+
+        def permitted_keys
+          @permitted_keys
+        end
+      end
+    end
+  end
+end

data/lib/hashie/hash.rb

@@ -4,15 +4,21 @@ module Hashie
   # A Hashie Hash is simply a Hash that has convenience
   # functions baked in such as stringify_keys that may
   # not be available in all libraries.
-  class Hash < Hash
-    include Hashie::HashExtensions
+  class Hash < ::Hash
+    include HashExtensions
 
-    # Converts a mash back to a hash.
-    def to_hash(options = {})
+    # Converts a mash back to a hash (with stringified keys)
+    def to_hash
       out = {}
       keys.each do |k|
-        key = options[:symbolize_keys] ? k.to_sym : k.to_s
-        out[key] = Hashie::Hash === self[k] ? self[k].to_hash : self[k]
+        if self[k].is_a?(Array)
+          out[k] ||= []
+          self[k].each do |array_object|
+            out[k] << (Hash === array_object ? array_object.to_hash : array_object)
+          end
+        else
+          out[k] = Hash === self[k] ? self[k].to_hash : self[k]
+        end
       end
       out
     end