hashie 3.5.7 → 4.1.0

data/hashie.gemspec

@@ -7,16 +7,22 @@ Gem::Specification.new do |gem|
   gem.email         = ['michael@intridea.com', 'jollyjerry@gmail.com']
   gem.description   = 'Hashie is a collection of classes and mixins that make hashes more powerful.'
   gem.summary       = 'Your friendly neighborhood hash library.'
-  gem.homepage      = 'https://github.com/intridea/hashie'
+  gem.homepage      = 'https://github.com/hashie/hashie'
   gem.license       = 'MIT'
 
   gem.require_paths = ['lib']
-  gem.files         = %w(.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE README.md UPGRADING.md Rakefile hashie.gemspec)
+  gem.files = %w[.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE README.md UPGRADING.md]
+  gem.files += %w[Rakefile hashie.gemspec]
   gem.files += Dir['lib/**/*.rb']
-  gem.files += Dir['spec/**/*.rb']
-  gem.test_files = Dir['spec/**/*.rb']
 
-  gem.add_development_dependency 'rake', '< 11'
-  gem.add_development_dependency 'rspec', '~> 3.0'
-  gem.add_development_dependency 'rspec-pending_for', '~> 0.1'
+  if gem.respond_to?(:metadata)
+    gem.metadata = {
+      'bug_tracker_uri'   => 'https://github.com/hashie/hashie/issues',
+      'changelog_uri'     => 'https://github.com/hashie/hashie/blob/master/CHANGELOG.md',
+      'documentation_uri' => 'https://www.rubydoc.info/gems/hashie',
+      'source_code_uri'   => 'https://github.com/hashie/hashie'
+    }
+  end
+
+  gem.add_development_dependency 'bundler'
 end

data/lib/hashie.rb

@@ -12,26 +12,26 @@ module Hashie
   autoload :Utils,              'hashie/utils'
 
   module Extensions
-    autoload :Coercion,          'hashie/extensions/coercion'
-    autoload :DeepMerge,         'hashie/extensions/deep_merge'
-    autoload :IgnoreUndeclared,  'hashie/extensions/ignore_undeclared'
-    autoload :IndifferentAccess, 'hashie/extensions/indifferent_access'
-    autoload :MergeInitializer,  'hashie/extensions/merge_initializer'
-    autoload :MethodAccess,      'hashie/extensions/method_access'
-    autoload :MethodQuery,       'hashie/extensions/method_access'
-    autoload :MethodReader,      'hashie/extensions/method_access'
-    autoload :MethodWriter,      'hashie/extensions/method_access'
-    autoload :StringifyKeys,     'hashie/extensions/stringify_keys'
-    autoload :SymbolizeKeys,     'hashie/extensions/symbolize_keys'
-    autoload :DeepFetch,         'hashie/extensions/deep_fetch'
-    autoload :DeepFind,          'hashie/extensions/deep_find'
-    autoload :DeepLocate,        'hashie/extensions/deep_locate'
-    autoload :PrettyInspect,     'hashie/extensions/pretty_inspect'
-    autoload :KeyConversion,     'hashie/extensions/key_conversion'
+    autoload :Coercion,           'hashie/extensions/coercion'
+    autoload :DeepMerge,          'hashie/extensions/deep_merge'
+    autoload :IgnoreUndeclared,   'hashie/extensions/ignore_undeclared'
+    autoload :IndifferentAccess,  'hashie/extensions/indifferent_access'
+    autoload :MergeInitializer,   'hashie/extensions/merge_initializer'
+    autoload :MethodAccess,       'hashie/extensions/method_access'
+    autoload :MethodQuery,        'hashie/extensions/method_access'
+    autoload :MethodReader,       'hashie/extensions/method_access'
+    autoload :MethodWriter,       'hashie/extensions/method_access'
+    autoload :StringifyKeys,      'hashie/extensions/stringify_keys'
+    autoload :SymbolizeKeys,      'hashie/extensions/symbolize_keys'
+    autoload :DeepFetch,          'hashie/extensions/deep_fetch'
+    autoload :DeepFind,           'hashie/extensions/deep_find'
+    autoload :DeepLocate,         'hashie/extensions/deep_locate'
+    autoload :PrettyInspect,      'hashie/extensions/pretty_inspect'
+    autoload :KeyConversion,      'hashie/extensions/key_conversion'
     autoload :MethodAccessWithOverride, 'hashie/extensions/method_access'
-    autoload :StrictKeyAccess,   'hashie/extensions/strict_key_access'
-    autoload :RubyVersion,       'hashie/extensions/ruby_version'
-    autoload :RubyVersionCheck,  'hashie/extensions/ruby_version_check'
+    autoload :StrictKeyAccess,    'hashie/extensions/strict_key_access'
+    autoload :RubyVersion,        'hashie/extensions/ruby_version'
+    autoload :RubyVersionCheck,   'hashie/extensions/ruby_version_check'
 
     module Parsers
       autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'
@@ -45,8 +45,10 @@ module Hashie
 
     module Mash
       autoload :KeepOriginalKeys, 'hashie/extensions/mash/keep_original_keys'
+      autoload :PermissiveRespondTo, 'hashie/extensions/mash/permissive_respond_to'
       autoload :SafeAssignment, 'hashie/extensions/mash/safe_assignment'
       autoload :SymbolizeKeys, 'hashie/extensions/mash/symbolize_keys'
+      autoload :DefineAccessors, 'hashie/extensions/mash/define_accessors'
     end
 
     module Array

data/lib/hashie/clash.rb

@@ -75,7 +75,7 @@ module Hashie
         when Hash
           self[key] = self.class.new(self[key], self)
         else
-          fail ChainError, 'Tried to chain into a non-hash key.'
+          raise ChainError, 'Tried to chain into a non-hash key.'
         end
       elsif args.any?
         merge_store(name, *args)
@@ -83,5 +83,16 @@ module Hashie
         super
       end
     end
+
+    def respond_to_missing?(method_name, _include_private = false)
+      method_name = method_name.to_s
+
+      if method_name.end_with?('!')
+        key = method_name[0...-1].to_sym
+        [NilClass, Clash, Hash].include?(self[key].class)
+      else
+        true
+      end
+    end
   end
 end

data/lib/hashie/dash.rb

@@ -15,7 +15,7 @@ module Hashie
   class Dash < Hash
     include Hashie::Extensions::PrettyInspect
 
-    alias_method :to_s, :inspect
+    alias to_s inspect
 
     # Defines a property on the Dash. Options are
     # as follows:
@@ -42,30 +42,27 @@ module Hashie
         defaults.delete property_name
       end
 
-      unless instance_methods.map(&:to_s).include?("#{property_name}=")
-        define_method(property_name) { |&block| self.[](property_name, &block) }
-        property_assignment = "#{property_name}=".to_sym
-        define_method(property_assignment) { |value| self.[]=(property_name, value) }
-      end
+      define_getter_for(property_name)
+      define_setter_for(property_name)
 
-      if defined? @subclasses
-        @subclasses.each { |klass| klass.property(property_name, options) }
-      end
+      @subclasses.each { |klass| klass.property(property_name, options) } if defined? @subclasses
 
       condition = options.delete(:required)
       if condition
         message = options.delete(:message) || "is required for #{name}."
         required_properties[property_name] = { condition: condition, message: message }
-      else
-        fail ArgumentError, 'The :message option should be used with :required option.' if options.key?(:message)
+      elsif options.key?(:message)
+        raise ArgumentError, 'The :message option should be used with :required option.'
       end
     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', {})
 
@@ -73,6 +70,7 @@ module Hashie
       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
@@ -89,6 +87,18 @@ module Hashie
       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
     # just like you would many other kinds of data objects.
     def initialize(attributes = {}, &block)
@@ -111,8 +121,8 @@ module Hashie
       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
@@ -160,14 +170,15 @@ module Hashie
     end
 
     def update_attributes!(attributes)
-      initialize_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 if self[prop].nil?
+        end
       end
       assert_required_attributes_set!
     end
@@ -175,9 +186,18 @@ module Hashie
     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)
@@ -199,11 +219,12 @@ module Hashie
     end
 
     def fail_property_required_error!(property)
-      fail ArgumentError, "The property '#{property}' #{self.class.required_properties[property][:message]}"
+      raise ArgumentError,
+            "The property '#{property}' #{self.class.required_properties[property][:message]}"
     end
 
     def fail_no_property_error!(property)
-      fail NoMethodError, "The property '#{property}' is not defined for #{self.class.name}."
+      raise NoMethodError, "The property '#{property}' is not defined for #{self.class.name}."
     end
 
     def required?(property)
@@ -211,9 +232,9 @@ module Hashie
 
       condition = self.class.required_properties[property][:condition]
       case condition
-      when Proc   then !!(instance_exec(&condition))
-      when Symbol then !!(send(condition))
-      else             !!(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/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,22 +14,24 @@ module Hashie
         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
+      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
 
@@ -37,7 +43,7 @@ module Hashie
             begin
               value = self.class.fetch_coercion(into).call(value)
             rescue NoMethodError, TypeError => e
-              raise CoercionError, "Cannot coerce property #{key.inspect} from #{value.class} to #{into}: #{e.message}"
+              raise CoercionError.new(key, value, into, e.message)
             end
           end
 
@@ -78,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
@@ -97,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
@@ -159,10 +166,10 @@ module Hashie
 
         def build_coercion(type)
           if type.is_a? Enumerable
-            if type.class <= ::Hash
+            if type.class == ::Hash
               type, key_type, value_type = type.class, *type.first
               build_hash_coercion(type, key_type, value_type)
-            else # Enumerable but not Hash: Array, Set
+            else
               value_type = type.first
               type = type.class
               build_container_coercion(type, value_type)
@@ -180,7 +187,7 @@ module Hashie
               type.new(value)
             end
           else
-            fail TypeError, "#{type} is not a coercable type"
+            raise TypeError, "#{type} is not a coercable type"
           end
         end
 

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

@@ -7,11 +7,23 @@ 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?
+
         module ClassMethods
           # Check to see if the specified property has already been
           # defined.
           def property?(name)
-            name = translations[name.to_sym] if included_modules.include?(Hashie::Extensions::Dash::PropertyTranslation) && translation_exists?(name)
+            name = translations[name.to_sym] if translation_for?(name)
             name = name.to_s
             !!properties.find { |property| property.to_s == name }
           end
@@ -30,6 +42,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/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,23 +74,16 @@ module Hashie
           def property(property_name, options = {})
             super
 
-            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]
+            from = options[:from]
+            converter = options[:with]
+            transformer = 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
 
@@ -105,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
@@ -134,6 +153,7 @@ module Hashie
           def []=(property, value)
             if self.class.translation_exists? property
               send("#{property}=", value)
+              super(property, value) if self.class.properties.include?(property)
             elsif self.class.transformation_exists? property
               super property, self.class.transformed_property(property, value)
             elsif property_exists? property
@@ -158,6 +178,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