hashie 3.4.2 → 5.0.0

data/lib/hashie/extensions/coercion.rb

@@ -1,5 +1,9 @@
 module Hashie
-  class CoercionError < StandardError; end
+  class CoercionError < StandardError
+    def initialize(key, value, into, message)
+      super("Cannot coerce property #{key.inspect} from #{value.class} to #{into}: #{message}")
+    end
+  end
 
   module Extensions
     module Coercion
@@ -10,18 +14,24 @@ module Hashie
         Rational   => :to_r,
         String     => :to_s,
         Symbol     => :to_sym
-      }
-
-      ABSTRACT_CORE_TYPES = {
-        Integer => [Fixnum, Bignum],
-        Numeric => [Fixnum, Bignum, Float, Complex, Rational]
-      }
+      }.freeze
+
+      ABSTRACT_CORE_TYPES =
+        if RubyVersion.new(RUBY_VERSION) >= RubyVersion.new('2.4.0')
+          { Numeric => [Integer, Float, Complex, Rational] }
+        else
+          {
+            Integer => [Fixnum, Bignum],
+            Numeric => [Fixnum, Bignum, Float, Complex, Rational]
+          }
+        end
 
       def self.included(base)
         base.send :include, InstanceMethods
-        base.extend ClassMethods # NOTE: we wanna make sure we first define set_value_with_coercion before extending
-
-        base.send :alias_method, :set_value_without_coercion, :[]= unless base.method_defined?(:set_value_without_coercion)
+        base.extend ClassMethods
+        unless base.method_defined?(:set_value_without_coercion)
+          base.send :alias_method, :set_value_without_coercion, :[]=
+        end
         base.send :alias_method, :[]=, :set_value_with_coercion
       end
 
@@ -29,51 +39,17 @@ module Hashie
         def set_value_with_coercion(key, value)
           into = self.class.key_coercion(key) || self.class.value_coercion(value)
 
-          return set_value_without_coercion(key, value) if value.nil? || into.nil?
-
-          begin
-            return set_value_without_coercion(key, coerce_or_init(into).call(value)) unless into.is_a?(Enumerable)
-
-            if into.class <= ::Hash
-              key_coerce = coerce_or_init(into.flatten[0])
-              value_coerce = coerce_or_init(into.flatten[-1])
-              value = into.class[value.map { |k, v| [key_coerce.call(k), value_coerce.call(v)] }]
-            else # Enumerable but not Hash: Array, Set
-              value_coerce = coerce_or_init(into.first)
-              value = into.class.new(value.map { |v| value_coerce.call(v) })
+          unless value.nil? || into.nil?
+            begin
+              value = self.class.fetch_coercion(into).call(value)
+            rescue NoMethodError, TypeError => e
+              raise CoercionError.new(key, value, into, e.message)
             end
-          rescue NoMethodError, TypeError => e
-            raise CoercionError, "Cannot coerce property #{key.inspect} from #{value.class} to #{into}: #{e.message}"
           end
 
           set_value_without_coercion(key, value)
         end
 
-        def coerce_or_init(type)
-          return type if type.is_a? Proc
-
-          if CORE_TYPES.key?(type)
-            lambda do |v|
-              return v if v.is_a? type
-              return v.send(CORE_TYPES[type])
-            end
-          elsif type.respond_to?(:coerce)
-            lambda do |v|
-              return v if v.is_a? type
-              type.coerce(v)
-            end
-          elsif type.respond_to?(:new)
-            lambda do |v|
-              return v if v.is_a? type
-              type.new(v)
-            end
-          else
-            fail TypeError, "#{type} is not a coercable type"
-          end
-        end
-
-        private :coerce_or_init
-
         def custom_writer(key, value, _convert = true)
           self[key] = value
         end
@@ -108,7 +84,7 @@ module Hashie
           attrs.each { |key| key_coercions[key] = into }
         end
 
-        alias_method :coerce_keys, :coerce_key
+        alias coerce_keys coerce_key
 
         # Returns a hash of any existing key coercions.
         def key_coercions
@@ -127,7 +103,8 @@ module Hashie
         #
         # @param [Class] from the type you would like coerced.
         # @param [Class] into the class into which you would like the value coerced.
-        # @option options [Boolean] :strict (true) whether use exact source class only or include ancestors
+        # @option options [Boolean] :strict (true) whether use exact source class
+        #   only or include ancestors
         #
         # @example Coerce all hashes into this special type of hash
         #   class SpecialHash < Hash
@@ -145,7 +122,7 @@ module Hashie
           options = { strict: true }.merge(options)
 
           if ABSTRACT_CORE_TYPES.key? from
-            ABSTRACT_CORE_TYPES[from].each do | type |
+            ABSTRACT_CORE_TYPES[from].each do |type|
               coerce_value type, into, options
             end
           end
@@ -164,6 +141,7 @@ module Hashie
         def strict_value_coercions
           @strict_value_coercions ||= {}
         end
+
         # Return all value coercions that have the :strict rule as false.
         def lenient_value_coercions
           @lenient_value_coercions ||= {}
@@ -175,6 +153,67 @@ module Hashie
           strict_value_coercions[from] || lenient_value_coercions[from]
         end
 
+        def fetch_coercion(type)
+          return type if type.is_a? Proc
+          coercion_cache[type]
+        end
+
+        def coercion_cache
+          @coercion_cache ||= ::Hash.new do |hash, type|
+            hash[type] = build_coercion(type)
+          end
+        end
+
+        def build_coercion(type)
+          if type.is_a? Enumerable
+            if type.class == ::Hash
+              type, key_type, value_type = type.class, *type.first
+              build_hash_coercion(type, key_type, value_type)
+            else
+              value_type = type.first
+              type = type.class
+              build_container_coercion(type, value_type)
+            end
+          elsif CORE_TYPES.key? type
+            build_core_type_coercion(type)
+          elsif type.respond_to? :coerce
+            lambda do |value|
+              return value if value.is_a? type
+              type.coerce(value)
+            end
+          elsif type.respond_to? :new
+            lambda do |value|
+              return value if value.is_a? type
+              type.new(value)
+            end
+          else
+            raise TypeError, "#{type} is not a coercable type"
+          end
+        end
+
+        def build_hash_coercion(type, key_type, value_type)
+          key_coerce = fetch_coercion(key_type)
+          value_coerce = fetch_coercion(value_type)
+          lambda do |value|
+            type[value.map { |k, v| [key_coerce.call(k), value_coerce.call(v)] }]
+          end
+        end
+
+        def build_container_coercion(type, value_type)
+          value_coerce = fetch_coercion(value_type)
+          lambda do |value|
+            type.new(value.map { |v| value_coerce.call(v) })
+          end
+        end
+
+        def build_core_type_coercion(type)
+          name = CORE_TYPES[type]
+          lambda do |value|
+            return value if value.is_a? type
+            return value.send(name)
+          end
+        end
+
         def inherited(klass)
           super
 

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

@@ -0,0 +1,25 @@
+module Hashie
+  module Extensions
+    module Dash
+      module Coercion
+        # Extends a Dash with the ability to define coercion for properties.
+
+        def self.included(base)
+          base.send :include, Hashie::Extensions::Coercion
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # Defines a property on the Dash. Options are the standard
+          # <tt>Hashie::Dash#property</tt> options plus:
+          #
+          # * <tt>:coerce</tt> - The class into which you want the property coerced.
+          def property(property_name, options = {})
+            super
+            coerce_key property_name, options[:coerce] if options[:coerce]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,10 +7,32 @@ module Hashie
           base.send :include, Hashie::Extensions::IndifferentAccess
         end
 
+        def self.maybe_extend(base)
+          return unless requires_class_methods?(base)
+
+          base.extend(ClassMethods)
+        end
+
+        def self.requires_class_methods?(klass)
+          klass <= Hashie::Dash &&
+            !klass.singleton_class.included_modules.include?(ClassMethods)
+        end
+        private_class_method :requires_class_methods?
+
+        def to_h
+          defaults = ::Hash[self.class.properties.map do |prop|
+            [Hashie::Extensions::IndifferentAccess.convert_key(prop), self.class.defaults[prop]]
+          end]
+
+          defaults.merge(self)
+        end
+        alias to_hash to_h
+
         module ClassMethods
           # Check to see if the specified property has already been
           # defined.
           def property?(name)
+            name = translations[name.to_sym] if translation_for?(name)
             name = name.to_s
             !!properties.find { |property| property.to_s == name }
           end
@@ -21,7 +43,7 @@ module Hashie
           end
 
           def transformed_property(property_name, value)
-            transform = transforms[property_name] || transforms[:"#{property_name}"]
+            transform = transforms[property_name] || transforms[property_name.to_sym]
             transform.call(value)
           end
 
@@ -29,6 +51,13 @@ module Hashie
             name = name.to_s
             !!transforms.keys.find { |key| key.to_s == name }
           end
+
+          private
+
+          def translation_for?(name)
+            included_modules.include?(Hashie::Extensions::Dash::PropertyTranslation) &&
+              translation_exists?(name)
+          end
         end
       end
     end

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

@@ -0,0 +1,88 @@
+module Hashie
+  module Extensions
+    module Dash
+      # Extends a Dash with the ability to accept only predefined values on a property.
+      #
+      # == Example
+      #
+      #   class PersonHash < Hashie::Dash
+      #     include Hashie::Extensions::Dash::PredefinedValues
+      #
+      #     property :gender, values: [:male, :female, :prefer_not_to_say]
+      #     property :age, values: (0..150) # a Range
+      #   end
+      #
+      #   person = PersonHash.new(gender: :male, age: -1)
+      #   # => ArgumentError: The value '-1' is not accepted for property 'age'
+      module PredefinedValues
+        def self.included(base)
+          base.instance_variable_set(:@values_for_properties, {})
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        module ClassMethods
+          attr_reader :values_for_properties
+
+          def inherited(klass)
+            super
+            klass.instance_variable_set(:@values_for_properties, values_for_properties.dup)
+          end
+
+          def property(property_name, options = {})
+            super
+
+            return unless (predefined_values = options[:values])
+
+            assert_predefined_values!(predefined_values)
+            set_predefined_values(property_name, predefined_values)
+          end
+
+          private
+
+          def assert_predefined_values!(predefined_values)
+            return if supported_type?(predefined_values)
+
+            raise ArgumentError, %(`values` accepts an Array or a Range.)
+          end
+
+          def supported_type?(predefined_values)
+            [::Array, ::Range].any? { |klass| predefined_values.is_a?(klass) }
+          end
+
+          def set_predefined_values(property_name, predefined_values)
+            @values_for_properties[property_name] = predefined_values
+          end
+        end
+
+        module InstanceMethods
+          def initialize(*)
+            super
+
+            assert_property_values!
+          end
+
+          private
+
+          def assert_property_values!
+            self.class.values_for_properties.each_key do |property|
+              value = send(property)
+
+              if value && !values_for_properties(property).include?(value)
+                fail_property_value_error!(property)
+              end
+            end
+          end
+
+          def fail_property_value_error!(property)
+            raise ArgumentError, "Invalid value for property '#{property}'"
+          end
+
+          def values_for_properties(property)
+            self.class.values_for_properties[property]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,12 +35,12 @@ module Hashie
       #   end
       #
       #   model = DataModelHash.new(id: '123', created: '2014-04-25 22:35:28')
-      #   model.id.class          #=> Fixnum
+      #   model.id.class          #=> Integer (Fixnum if you are using Ruby 2.3 or lower)
       #   model.created_at.class  #=> Time
       module PropertyTranslation
         def self.included(base)
           base.instance_variable_set(:@transforms, {})
-          base.instance_variable_set(:@translations_hash, {})
+          base.instance_variable_set(:@translations_hash, ::Hash.new { |hash, key| hash[key] = {} })
           base.extend(ClassMethods)
           base.send(:include, InstanceMethods)
         end
@@ -58,7 +58,9 @@ module Hashie
           end
 
           def permitted_input_keys
-            @permitted_input_keys ||= properties.map { |property| inverse_translations.fetch property, property }
+            @permitted_input_keys ||=
+              properties
+              .map { |property| inverse_translations.fetch property, property }
           end
 
           # Defines a property on the Trash. Options are as follows:
@@ -72,25 +74,16 @@ module Hashie
           def property(property_name, options = {})
             super
 
-            options[:from] = options[:from] if options[:from]
+            from = options[:from]
+            converter = options[:with]
+            transformer = options[:transform_with]
 
-            if options[:from]
-              if property_name == options[:from]
-                fail ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
-              end
-
-              translations_hash[options[:from]] ||= {}
-              translations_hash[options[:from]][property_name] = options[:with] || options[:transform_with]
-
-              define_method "#{options[:from]}=" do |val|
-                self.class.translations_hash[options[:from]].each do |name, with|
-                  self[name] = with.respond_to?(:call) ? with.call(val) : val
-                end
-              end
-            else
-              if options[:transform_with].respond_to? :call
-                transforms[property_name] = options[:transform_with]
-              end
+            if from
+              fail_self_transformation_error!(property_name) if property_name == from
+              define_translation(from, property_name, converter || transformer)
+              define_writer_for_source_property(from)
+            elsif valid_transformer?(transformer)
+              transforms[property_name] = transformer
             end
           end
 
@@ -107,26 +100,50 @@ module Hashie
           end
 
           def translations
-            @translations ||= {}.tap do |h|
+            @translations ||= {}.tap do |translations|
               translations_hash.each do |(property_name, property_translations)|
-                if property_translations.size > 1
-                  h[property_name] = property_translations.keys
-                else
-                  h[property_name] = property_translations.keys.first
-                end
+                translations[property_name] =
+                  if property_translations.size > 1
+                    property_translations.keys
+                  else
+                    property_translations.keys.first
+                  end
               end
             end
           end
 
           def inverse_translations
-            @inverse_translations ||= {}.tap do |h|
+            @inverse_translations ||= {}.tap do |translations|
               translations_hash.each do |(property_name, property_translations)|
-                property_translations.keys.each do |k|
-                  h[k] = property_name
+                property_translations.each_key do |key|
+                  translations[key] = property_name
                 end
               end
             end
           end
+
+          private
+
+          def define_translation(from, property_name, translator)
+            translations_hash[from][property_name] = translator
+          end
+
+          def define_writer_for_source_property(property)
+            define_method "#{property}=" do |val|
+              __translations[property].each do |name, with|
+                self[name] = with.respond_to?(:call) ? with.call(val) : val
+              end
+            end
+          end
+
+          def fail_self_transformation_error!(property_name)
+            raise ArgumentError,
+                  "Property name (#{property_name}) and :from option must not be the same"
+          end
+
+          def valid_transformer?(transformer)
+            transformer.respond_to? :call
+          end
         end
 
         module InstanceMethods
@@ -136,6 +153,12 @@ module Hashie
           def []=(property, value)
             if self.class.translation_exists? property
               send("#{property}=", value)
+
+              if self.class.transformation_exists? property
+                super property, self.class.transformed_property(property, value)
+              elsif self.class.properties.include?(property)
+                super(property, value)
+              end
             elsif self.class.transformation_exists? property
               super property, self.class.transformed_property(property, value)
             elsif property_exists? property
@@ -160,6 +183,12 @@ module Hashie
             fail_no_property_error!(property) unless self.class.property?(property)
             true
           end
+
+          private
+
+          def __translations
+            self.class.translations_hash
+          end
         end
       end
     end

data/lib/hashie/extensions/deep_fetch.rb

@@ -9,7 +9,8 @@ module Hashie
     #
     #  options.deep_fetch(:user, :non_existent_key) { 'a value' } #=> 'a value'
     #
-    # This is particularly useful for fetching values from deeply nested api responses or params hashes.
+    # This is particularly useful for fetching values from deeply nested api responses
+    #   or params hashes.
     module DeepFetch
       class UndefinedPathError < StandardError; end
 
@@ -19,8 +20,9 @@ module Hashie
             arg = Integer(arg) if obj.is_a? Array
             obj.fetch(arg)
           rescue ArgumentError, IndexError, NoMethodError => e
-            break block.call(arg) if block
-            raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
+            break yield(arg) if block
+            raise UndefinedPathError,
+                  "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
           end
         end
       end

data/lib/hashie/extensions/deep_find.rb

@@ -1,3 +1,4 @@
+require 'hashie/extensions/deep_locate'
 module Hashie
   module Extensions
     module DeepFind
@@ -19,12 +20,17 @@ module Hashie
         _deep_find(key)
       end
 
-      alias_method :deep_detect, :deep_find
+      alias deep_detect deep_find
 
       # Performs a depth-first search on deeply nested data structures for
       # a key and returns all occurrences of the key.
       #
-      #  options = {users: [{location: {address: '123 Street'}}, {location: {address: '234 Street'}}]}
+      #  options = {
+      #    users: [
+      #      { location: {address: '123 Street'} },
+      #      { location: {address: '234 Street'}}
+      #    ]
+      #  }
       #  options.extend(Hashie::Extensions::DeepFind)
       #  options.deep_find_all(:address) # => ['123 Street', '234 Street']
       #
@@ -33,14 +39,17 @@ module Hashie
       #  end
       #
       #  my_hash = MyHash.new
-      #  my_hash[:users] = [{location: {address: '123 Street'}}, {location: {address: '234 Street'}}]
+      #  my_hash[:users] = [
+      #    {location: {address: '123 Street'}},
+      #    {location: {address: '234 Street'}}
+      #  ]
       #  my_hash.deep_find_all(:address) # => ['123 Street', '234 Street']
       def deep_find_all(key)
         matches = _deep_find_all(key)
         matches.empty? ? nil : matches
       end
 
-      alias_method :deep_select, :deep_find_all
+      alias deep_select deep_find_all
 
       private
 
@@ -49,7 +58,7 @@ module Hashie
       end
 
       def _deep_find_all(key, object = self, matches = [])
-        deep_locate_result = Hashie::Extensions::DeepLocate.deep_locate(key, object).tap do |result|
+        deep_locate_result = DeepLocate.deep_locate(key, object).tap do |result|
           result.map! { |element| element[key] }
         end
 

data/lib/hashie/extensions/deep_locate.rb

@@ -14,14 +14,11 @@ module Hashie
       #     ...
       #   ]
       #
-      #   Hashie::Extensions::DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
+      #   DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
       #   # => [{:title=>"Ruby for beginners", :pages=>120}, ...]
       def self.deep_locate(comparator, object)
-        # ensure comparator is a callable
         unless comparator.respond_to?(:call)
-          comparator = lambda do |non_callable_object|
-            ->(key, _, _) { key == non_callable_object }
-          end.call(comparator)
+          comparator = _construct_key_comparator(comparator, object)
         end
 
         _deep_locate(comparator, object)
@@ -58,37 +55,59 @@ module Hashie
       #   # http://ruby-journal.com/becareful-with-space-in-lambda-hash-rocket-syntax-between-ruby-1-dot-9-and-2-dot-0/
       #
       #   books.deep_locate -> (key, value, object) { key == :title && value.include?("Ruby") }
-      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"Ruby for the rest of us", :pages=>576}]
+      #   # => [{:title=>"Ruby for beginners", :pages=>120},
+      #   #     {:title=>"Ruby for the rest of us", :pages=>576}]
       #
       #   books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
-      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"CSS for intermediates", :pages=>80}]
+      #   # => [{:title=>"Ruby for beginners", :pages=>120},
+      #   #     {:title=>"CSS for intermediates", :pages=>80}]
       def deep_locate(comparator)
         Hashie::Extensions::DeepLocate.deep_locate(comparator, self)
       end
 
-      private
+      def self._construct_key_comparator(search_key, object)
+        if object.respond_to?(:indifferent_access?) && object.indifferent_access? ||
+           activesupport_indifferent?(object)
+          search_key = search_key.to_s
+        end
+
+        lambda do |non_callable_object|
+          ->(key, _, _) { key == non_callable_object }
+        end.call(search_key)
+      end
+      private_class_method :_construct_key_comparator
 
       def self._deep_locate(comparator, object, result = [])
         if object.is_a?(::Enumerable)
-          if object.any? do |value|
-            if object.is_a?(::Hash)
-              key, value = value
-            else
-              key = nil
-            end
-
-            comparator.call(key, value, object)
-          end
+          if object.any? { |value| _match_comparator?(value, comparator, object) }
             result.push object
-          else
-            (object.respond_to?(:values) ? object.values : object.entries).each do |value|
-              _deep_locate(comparator, value, result)
-            end
+          end
+
+          (object.respond_to?(:values) ? object.values : object.entries).each do |value|
+            _deep_locate(comparator, value, result)
           end
         end
 
         result
       end
+      private_class_method :_deep_locate
+
+      def self._match_comparator?(value, comparator, object)
+        if object.is_a?(::Hash)
+          key, value = value
+        else
+          key = nil
+        end
+
+        comparator.call(key, value, object)
+      end
+      private_class_method :_match_comparator?
+
+      def self.activesupport_indifferent?(object)
+        defined?(::ActiveSupport::HashWithIndifferentAccess) &&
+          object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
+      end
+      private_class_method :activesupport_indifferent?
     end
   end
 end