hashie 2.1.2 → 3.0.0

data/lib/hashie.rb

@@ -1,17 +1,14 @@
 module Hashie
-  autoload :Clash,          'hashie/clash'
-  autoload :Dash,           'hashie/dash'
-  autoload :Hash,           'hashie/hash'
-  autoload :HashExtensions, 'hashie/hash_extensions'
-  autoload :Mash,           'hashie/mash'
-  autoload :PrettyInspect,  'hashie/hash_extensions'
-  autoload :Trash,          'hashie/trash'
-  autoload :Rash,           'hashie/rash'
+  autoload :Clash,              'hashie/clash'
+  autoload :Dash,               'hashie/dash'
+  autoload :Hash,               'hashie/hash'
+  autoload :Mash,               'hashie/mash'
+  autoload :Trash,              'hashie/trash'
+  autoload :Rash,               'hashie/rash'
 
   module Extensions
     autoload :Coercion,          'hashie/extensions/coercion'
     autoload :DeepMerge,         'hashie/extensions/deep_merge'
-    autoload :KeyConversion,     'hashie/extensions/key_conversion'
     autoload :IgnoreUndeclared,  'hashie/extensions/ignore_undeclared'
     autoload :IndifferentAccess, 'hashie/extensions/indifferent_access'
     autoload :MergeInitializer,  'hashie/extensions/merge_initializer'
@@ -19,8 +16,18 @@ module Hashie
     autoload :MethodQuery,       'hashie/extensions/method_access'
     autoload :MethodReader,      'hashie/extensions/method_access'
     autoload :MethodWriter,      'hashie/extensions/method_access'
-    autoload :StringifyKeys,     'hashie/extensions/key_conversion'
-    autoload :SymbolizeKeys,     'hashie/extensions/key_conversion'
+    autoload :StringifyKeys,     'hashie/extensions/stringify_keys'
+    autoload :SymbolizeKeys,     'hashie/extensions/symbolize_keys'
     autoload :DeepFetch,         'hashie/extensions/deep_fetch'
+    autoload :PrettyInspect,     'hashie/extensions/pretty_inspect'
+    autoload :KeyConversion,     'hashie/extensions/key_conversion'
+
+    module Mash
+      autoload :ActiveModel,     'hashie/extensions/mash/active_model'
+    end
+
+    module Dash
+      autoload :IndifferentAccess, 'hashie/extensions/dash/indifferent_access'
+    end
   end
 end

data/lib/hashie/dash.rb

@@ -13,7 +13,8 @@ module Hashie
   # It is preferrable to a Struct because of the in-class
   # API for defining properties as well as per-property defaults.
   class Dash < Hash
-    include PrettyInspect
+    include Hashie::Extensions::PrettyInspect
+
     alias_method :to_s, :inspect
 
     # Defines a property on the Dash. Options are
@@ -28,8 +29,6 @@ module Hashie
     #   existing Dash.
     #
     def self.property(property_name, options = {})
-      property_name = property_name.to_sym
-
       properties << property_name
 
       if options.key?(:default)
@@ -39,9 +38,9 @@ module Hashie
       end
 
       unless instance_methods.map { |m| m.to_s }.include?("#{property_name}=")
-        define_method(property_name) { |&block| self.[](property_name.to_s, &block) }
+        define_method(property_name) { |&block| self.[](property_name, &block) }
         property_assignment = property_name.to_s.concat('=').to_sym
-        define_method(property_assignment) { |value| self.[]=(property_name.to_s, value) }
+        define_method(property_assignment) { |value| self.[]=(property_name, value) }
       end
 
       if defined? @subclasses
@@ -69,13 +68,13 @@ module Hashie
     # Check to see if the specified property has already been
     # defined.
     def self.property?(name)
-      properties.include? name.to_sym
+      properties.include? name
     end
 
     # Check to see if the specified property is
     # required.
     def self.required?(name)
-      required_properties.include? name.to_sym
+      required_properties.include? name
     end
 
     # You may initialize a Dash with an attributes hash
@@ -103,7 +102,7 @@ module Hashie
     # property's default value if it hasn't been set).
     def [](property)
       assert_property_exists! property
-      value = super(property.to_s)
+      value = super(property)
       # If the value is a lambda, proc, or whatever answers to call, eval the thing!
       if value.is_a? Proc
         self[property] = value.call # Set the result of the call as a value
@@ -118,7 +117,7 @@ module Hashie
     def []=(property, value)
       assert_property_required! property, value
       assert_property_exists! property
-      super(property.to_s, value)
+      super(property, value)
     end
 
     def merge(other_hash)

data/lib/hashie/extensions/coercion.rb

@@ -21,7 +21,7 @@ module Hashie
           super(key, value)
         end
 
-        def custom_writer(key, value, convert = true)
+        def custom_writer(key, value, _convert = true)
           self[key] = value
         end
 

data/lib/hashie/extensions/dash/indifferent_access.rb

@@ -0,0 +1,21 @@
+module Hashie
+  module Extensions
+    module Dash
+      module IndifferentAccess
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, Hashie::Extensions::IndifferentAccess
+        end
+
+        module ClassMethods
+          # Check to see if the specified property has already been
+          # defined.
+          def property?(name)
+            name = name.to_s
+            !!properties.find { |property| property.to_s == name }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/deep_fetch.rb

@@ -18,7 +18,7 @@ module Hashie
           begin
             arg = Integer(arg) if obj.kind_of? Array
             obj.fetch(arg)
-          rescue ArgumentError, IndexError => e
+          rescue ArgumentError, IndexError, NoMethodError => e
             break block.call(arg) if block
             raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
           end

data/lib/hashie/extensions/ignore_undeclared.rb

@@ -5,7 +5,7 @@ module Hashie
     # raising an error. This is useful when using a Trash to
     # capture a subset of a larger hash.
     #
-    # Note that attempting to retrieve an undeclared property
+    # Note that attempting to retrieve or set an undeclared property
     # will still raise a NoMethodError, even if a value for
     # that property was provided at initialization.
     #
@@ -36,6 +36,10 @@ module Hashie
           end
         end if attributes
       end
+
+      def property_exists?(property)
+        self.class.property?(property)
+      end
     end
   end
 end

data/lib/hashie/extensions/key_conversion.rb

@@ -1,87 +1,5 @@
 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] = 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] = 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

data/lib/hashie/extensions/pretty_inspect.rb

@@ -0,0 +1,19 @@
+module Hashie
+  module Extensions
+    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}"
+        keys.sort_by { |key| key.to_s }.each do |key|
+          ret << " #{key}=#{self[key].inspect}"
+        end
+        ret << '>'
+        ret
+      end
+    end
+  end
+end

data/lib/hashie/extensions/stringify_keys.rb

@@ -0,0 +1,44 @@
+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] = 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
+  end
+end

data/lib/hashie/extensions/symbolize_keys.rb

@@ -0,0 +1,44 @@
+module Hashie
+  module Extensions
+    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] = 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
+  end
+end

data/lib/hashie/hash.rb

@@ -1,25 +1,37 @@
-require 'hashie/hash_extensions'
+require 'hashie/extensions/stringify_keys'
+require 'hashie/extensions/pretty_inspect'
 
 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 HashExtensions
+    include Hashie::Extensions::PrettyInspect
+    include Hashie::Extensions::StringifyKeys
+
+    # Convert this hash into a Mash
+    def to_mash
+      ::Hashie::Mash.new(self)
+    end
 
     # Converts a mash back to a hash (with stringified or symbolized keys)
     def to_hash(options = {})
       out = {}
       keys.each do |k|
-        assignment_key = k.to_s
-        assignment_key = assignment_key.to_sym if options[:symbolize_keys]
+        assignment_key = if options[:stringify_keys]
+                           k.to_s
+                         elsif options[:symbolize_keys]
+                           k.to_s.to_sym
+                         else
+                           k
+                         end
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
             out[assignment_key] << (Hash === array_object ? flexibly_convert_to_hash(array_object, options) : array_object)
           end
         else
-          out[assignment_key] = (Hash === self[k] || self[k].respond_to?(:to_hash)) ? flexibly_convert_to_hash(self[k], options) : self[k]
+          out[assignment_key] = Hash === self[k] ? flexibly_convert_to_hash(self[k], options) : self[k]
         end
       end
       out

data/lib/hashie/mash.rb

@@ -55,8 +55,10 @@ module Hashie
   #   mash.author # => <Mash>
   #
   class Mash < Hash
+    include Hashie::Extensions::PrettyInspect
+
     ALLOWED_SUFFIXES = %w(? ! = _)
-    include Hashie::PrettyInspect
+
     alias_method :to_s, :inspect
 
     # If you pass in an existing hash, it will
@@ -185,11 +187,15 @@ module Hashie
       self
     end
 
-    # Will return true if the Mash has had a key
-    # set in addition to normal respond_to? functionality.
-    def respond_to?(method_name, include_private = false)
-      return true if key?(method_name) || prefix_method?(method_name)
-      super
+    def respond_to_missing?(method_name, *args)
+      return true if key?(method_name)
+      _, suffix = method_suffix(method_name)
+      case suffix
+      when '=', '?', '!', '_'
+        return true
+      else
+        super
+      end
     end
 
     def prefix_method?(method_name)
@@ -199,17 +205,16 @@ module Hashie
 
     def method_missing(method_name, *args, &blk)
       return self.[](method_name, &blk) if key?(method_name)
-      suffixes_regex = ALLOWED_SUFFIXES.join
-      match = method_name.to_s.match(/(.*?)([#{suffixes_regex}]?)$/)
-      case match[2]
+      name, suffix = method_suffix(method_name)
+      case suffix
       when '='
-        self[match[1]] = args.first
+        self[name] = args.first
       when '?'
-        !!self[match[1]]
+        !!self[name]
       when '!'
-        initializing_reader(match[1])
+        initializing_reader(name)
       when '_'
-        underbang_reader(match[1])
+        underbang_reader(name)
       else
         default(method_name)
       end
@@ -217,6 +222,12 @@ module Hashie
 
     protected
 
+    def method_suffix(method_name)
+      suffixes_regex = ALLOWED_SUFFIXES.join
+      match = method_name.to_s.match(/(.*?)([#{suffixes_regex}]?)$/)
+      [match[1], match[2]]
+    end
+
     def convert_key(key) #:nodoc:
       key.to_s
     end