hashie 2.1.2 → 4.1.0

data/lib/hashie/dash.rb

@@ -13,8 +13,9 @@ 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
-    alias_method :to_s, :inspect
+    include Hashie::Extensions::PrettyInspect
+
+    alias to_s inspect
 
     # Defines a property on the Dash. Options are
     # as follows:
@@ -25,11 +26,14 @@ module Hashie
     #
     # * <tt>:required</tt> - Specify the value as required for this
     #   property, to raise an error if a value is unset in a new or
-    #   existing Dash.
+    #   existing Dash. If a Proc is provided, it will be run in the
+    #   context of the Dash instance. If a Symbol is provided, the
+    #   property it represents must not be nil. The property is only
+    #   required if the value is truthy.
+    #
+    # * <tt>:message</tt> - Specify custom error message for required property
     #
     def self.property(property_name, options = {})
-      property_name = property_name.to_sym
-
       properties << property_name
 
       if options.key?(:default)
@@ -38,30 +42,35 @@ module Hashie
         defaults.delete property_name
       end
 
-      unless instance_methods.map { |m| m.to_s }.include?("#{property_name}=")
-        define_method(property_name) { |&block| self.[](property_name.to_s, &block) }
-        property_assignment = property_name.to_s.concat('=').to_sym
-        define_method(property_assignment) { |value| self.[]=(property_name.to_s, value) }
-      end
+      define_getter_for(property_name)
+      define_setter_for(property_name)
+
+      @subclasses.each { |klass| klass.property(property_name, options) } if defined? @subclasses
 
-      if defined? @subclasses
-        @subclasses.each { |klass| klass.property(property_name, options) }
+      condition = options.delete(:required)
+      if condition
+        message = options.delete(:message) || "is required for #{name}."
+        required_properties[property_name] = { condition: condition, message: message }
+      elsif options.key?(:message)
+        raise ArgumentError, 'The :message option should be used with :required option.'
       end
-      required_properties << property_name if options.delete(:required)
     end
 
     class << self
       attr_reader :properties, :defaults
+      attr_reader :getters
       attr_reader :required_properties
     end
     instance_variable_set('@properties', Set.new)
+    instance_variable_set('@getters', Set.new)
     instance_variable_set('@defaults', {})
-    instance_variable_set('@required_properties', Set.new)
+    instance_variable_set('@required_properties', {})
 
     def self.inherited(klass)
       super
       (@subclasses ||= Set.new) << klass
       klass.instance_variable_set('@properties', properties.dup)
+      klass.instance_variable_set('@getters', getters.dup)
       klass.instance_variable_set('@defaults', defaults.dup)
       klass.instance_variable_set('@required_properties', required_properties.dup)
     end
@@ -69,13 +78,25 @@ 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.key? name
+    end
+
+    private_class_method def self.define_getter_for(property_name)
+      return if getters.include?(property_name)
+      define_method(property_name) { |&block| self.[](property_name, &block) }
+      getters << property_name
+    end
+
+    private_class_method def self.define_setter_for(property_name)
+      setter = :"#{property_name}="
+      return if instance_methods.include?(setter)
+      define_method(setter) { |value| self.[]=(property_name, value) }
     end
 
     # You may initialize a Dash with an attributes hash
@@ -85,25 +106,30 @@ module Hashie
 
       self.class.defaults.each_pair do |prop, value|
         self[prop] = begin
-          value.dup
+          val = value.dup
+          if val.is_a?(Proc)
+            val.arity == 1 ? val.call(self) : val.call
+          else
+            val
+          end
         rescue TypeError
           value
         end
       end
 
       initialize_attributes(attributes)
-      assert_required_properties_set!
+      assert_required_attributes_set!
     end
 
-    alias_method :_regular_reader, :[]
-    alias_method :_regular_writer, :[]=
+    alias _regular_reader []
+    alias _regular_writer []=
     private :_regular_reader, :_regular_writer
 
     # Retrieve a value from the Dash (will return the
     # 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 +144,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)
@@ -143,35 +169,72 @@ module Hashie
       self
     end
 
+    def update_attributes!(attributes)
+      update_attributes(attributes)
+
+      self.class.defaults.each_pair do |prop, value|
+        next unless self[prop].nil?
+        self[prop] = begin
+          value.dup
+        rescue TypeError
+          value
+        end
+      end
+      assert_required_attributes_set!
+    end
+
     private
 
     def initialize_attributes(attributes)
+      return unless attributes
+
+      cleaned_attributes = attributes.reject { |_attr, value| value.nil? }
+      update_attributes(cleaned_attributes)
+    end
+
+    def update_attributes(attributes)
+      return unless attributes
+
       attributes.each_pair do |att, value|
         self[att] = value
-      end if attributes
+      end
     end
 
     def assert_property_exists!(property)
-      unless self.class.property?(property)
-        fail NoMethodError, "The property '#{property}' is not defined for this Dash."
-      end
+      fail_no_property_error!(property) unless self.class.property?(property)
     end
 
-    def assert_required_properties_set!
-      self.class.required_properties.each do |required_property|
+    def assert_required_attributes_set!
+      self.class.required_properties.each_key do |required_property|
         assert_property_set!(required_property)
       end
     end
 
     def assert_property_set!(property)
-      if send(property).nil?
-        fail ArgumentError, "The property '#{property}' is required for this Dash."
-      end
+      fail_property_required_error!(property) if send(property).nil? && required?(property)
     end
 
     def assert_property_required!(property, value)
-      if self.class.required?(property) && value.nil?
-        fail ArgumentError, "The property '#{property}' is required for this Dash."
+      fail_property_required_error!(property) if value.nil? && required?(property)
+    end
+
+    def fail_property_required_error!(property)
+      raise ArgumentError,
+            "The property '#{property}' #{self.class.required_properties[property][:message]}"
+    end
+
+    def fail_no_property_error!(property)
+      raise NoMethodError, "The property '#{property}' is not defined for #{self.class.name}."
+    end
+
+    def required?(property)
+      return false unless self.class.required?(property)
+
+      condition = self.class.required_properties[property][:condition]
+      case condition
+      when Proc   then !!instance_exec(&condition)
+      when Symbol then !!send(condition)
+      else             !!condition
       end
     end
   end

data/lib/hashie/extensions/active_support/core_ext/hash.rb

@@ -0,0 +1,14 @@
+module Hashie
+  module Extensions
+    module ActiveSupport
+      module CoreExt
+        module Hash
+          def except(*keys)
+            string_keys = keys.map { |key| convert_key(key) }
+            super(*string_keys)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/array/pretty_inspect.rb

@@ -0,0 +1,19 @@
+module Hashie
+  module Extensions
+    module Array
+      module PrettyInspect
+        def self.included(base)
+          base.send :alias_method, :array_inspect, :inspect
+          base.send :alias_method, :inspect, :hashie_inspect
+        end
+
+        def hashie_inspect
+          ret = "#<#{self.class} ["
+          ret << to_a.map(&:inspect).join(', ')
+          ret << ']>'
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/coercion.rb

@@ -1,27 +1,56 @@
 module Hashie
+  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
+      CORE_TYPES = {
+        Integer    => :to_i,
+        Float      => :to_f,
+        Complex    => :to_c,
+        Rational   => :to_r,
+        String     => :to_s,
+        Symbol     => :to_sym
+      }.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.extend ClassMethods
         base.send :include, InstanceMethods
+        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
 
       module InstanceMethods
-        def []=(key, value)
+        def set_value_with_coercion(key, value)
           into = self.class.key_coercion(key) || self.class.value_coercion(value)
 
-          if value && into
-            if into.respond_to?(:coerce)
-              value = into.coerce(value)
-            else
-              value = into.new(value)
+          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
           end
 
-          super(key, value)
+          set_value_without_coercion(key, value)
         end
 
-        def custom_writer(key, value, convert = true)
+        def custom_writer(key, value, _convert = true)
           self[key] = value
         end
 
@@ -33,6 +62,9 @@ module Hashie
       end
 
       module ClassMethods
+        attr_writer :key_coercions
+        protected :key_coercions=
+
         # Set up a coercion rule such that any time the specified
         # key is set it will be coerced into the specified class.
         # Coercion will occur by first attempting to call Class.coerce
@@ -48,16 +80,15 @@ module Hashie
         #     coerce_key :user, User
         #   end
         def coerce_key(*attrs)
-          @key_coercions ||= {}
           into = attrs.pop
-          attrs.each { |key| @key_coercions[key] = into }
+          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
-          @key_coercions || {}
+          @key_coercions ||= {}
         end
 
         # Returns the specific key coercion for the specified key,
@@ -72,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
@@ -89,11 +121,17 @@ module Hashie
         def coerce_value(from, into, options = {})
           options = { strict: true }.merge(options)
 
+          if ABSTRACT_CORE_TYPES.key? from
+            ABSTRACT_CORE_TYPES[from].each do |type|
+              coerce_value type, into, options
+            end
+          end
+
           if options[:strict]
-            (@strict_value_coercions ||= {})[from] = into
+            strict_value_coercions[from] = into
           else
             while from.superclass && from.superclass != Object
-              (@lenient_value_coercions ||= {})[from] = into
+              lenient_value_coercions[from] = into
               from = from.superclass
             end
           end
@@ -101,11 +139,12 @@ module Hashie
 
         # Return all value coercions that have the :strict rule as true.
         def strict_value_coercions
-          @strict_value_coercions || {}
+          @strict_value_coercions ||= {}
         end
+
         # Return all value coercions that have the :strict rule as false.
         def lenient_value_coercions
-          @value_coercions || {}
+          @lenient_value_coercions ||= {}
         end
 
         # Fetch the value coercion, if any, for the specified object.
@@ -113,6 +152,73 @@ module Hashie
           from = value.class
           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
+
+          klass.key_coercions = key_coercions.dup
+        end
       end
     end
   end