hashie 3.5.7 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5b7463c46397ff888a6fa1794dda68695b8e5f78
-  data.tar.gz: 407d19363def156021e44da618365cf8657dc94e
+SHA256:
+  metadata.gz: 8995ca652ff77136955a0d399e6b880e84a9e9c6772c25fdd4cc16599bbb0bce
+  data.tar.gz: 15b18e37285c1beb76f751aea7907b684bd5faddb0d4a476f305f5da90315f8d
 SHA512:
-  metadata.gz: 1c8f87a18cf129c5f4d31e38a3196db8503f6b752ded005734f2f42bb9a79a967aa564c0a63f939d6544de454976fc2d8fa05e43b4bc171b7a05169e6a275a68
-  data.tar.gz: c5934315223ca60ee7cb878fe1ace02967fb6a53c949cfa78f1a4be29a7c7b20255831e949ae404ce0b0449fbd9a83323f01693ac1dfe809f437f4053f3db2da
+  metadata.gz: e17ecdf0d6ce04ed2ad95f0451d53f01842ee32932d1a8f58a5a3b4056a94772d6c61b8ba8493b59de5d85fd304df21f24b506053508bf816b25809d9f6ea20f
+  data.tar.gz: 54cf50c12052a424a1a4fba3fd3d34e6b65d8ca3f353b96fc96e3c0e9a7dfa76db5856ec1e8b8572128ec34feae59d22ef7df14674a6d05715d372c0bdfce849

data/CHANGELOG.md

@@ -6,6 +6,28 @@ scheme are considered to be bugs.
 
 [semver]: http://semver.org/spec/v2.0.0.html
 
+## [3.6.0] - 2018-08-13
+
+[3.6.0]: https://github.com/intridea/hashie/compare/v3.5.7...v3.6.0
+
+### Added
+
+* [#455](https://github.com/intridea/hashie/pull/455): Allow overriding methods when passing in a hash - [@lnestor](https://github.com/lnestor).
+
+### Fixed
+
+* [#435](https://github.com/intridea/hashie/pull/435): Mash `default_proc`s are now propagated down to nested sub-Hashes - [@michaelherold](https://github.com/michaelherold).
+* [#436](https://github.com/intridea/hashie/pull/436): Ensure that `Hashie::Extensions::IndifferentAccess` injects itself after a non-destructive merge - [@michaelherold](https://github.com/michaelherold).
+* [#437](https://github.com/intridea/hashie/pull/437): Allow codependent properties to be set on Dash - [@michaelherold](https://github.com/michaelherold).
+* [#438](https://github.com/intridea/hashie/pull/438): Fix: `NameError (uninitialized constant Hashie::Extensions::Parsers::YamlErbParser::Pathname)` in `Hashie::Mash.load` - [@onk](https://github.com/onk).
+* [#457](https://github.com/intridea/hashie/pull/457): Fix `Trash` to allow it to copy properties from other properties - [@michaelherold](https://github.com/michaelherold).
+
+### Miscellaneous
+
+* [#433](https://github.com/intridea/hashie/pull/433): Update Rubocop to the most recent version - [@michaelherold](https://github.com/michaelherold).
+* [#434](https://github.com/intridea/hashie/pull/434): Add documentation around Mash sub-Hashes - [@michaelherold](https://github.com/michaelherold).
+* [#439](https://github.com/intridea/hashie/pull/439): Add an integration spec for Elasticsearch - [@michaelherold](https://github.com/michaelherold).
+
 ## [3.5.7] - 2017-12-19
 
 [3.5.7]: https://github.com/intridea/hashie/compare/v3.5.6...v3.5.7

data/README.md

@@ -1,12 +1,10 @@
 # Hashie
 
 [![Join the chat at https://gitter.im/intridea/hashie](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/intridea/hashie?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
 [![Gem Version](http://img.shields.io/gem/v/hashie.svg)](http://badge.fury.io/rb/hashie)
 [![Build Status](http://img.shields.io/travis/intridea/hashie.svg)](https://travis-ci.org/intridea/hashie)
-[![Dependency Status](https://gemnasium.com/intridea/hashie.svg)](https://gemnasium.com/intridea/hashie)
-[![Code Climate](https://codeclimate.com/github/intridea/hashie.svg)](https://codeclimate.com/github/intridea/hashie)
-[![Coverage Status](https://codeclimate.com/github/intridea/hashie/badges/coverage.svg)](https://codeclimate.com/github/intridea/hashie)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/7a0b42c8a22c945571fd/test_coverage)](https://codeclimate.com/github/intridea/hashie/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/7a0b42c8a22c945571fd/maintainability)](https://codeclimate.com/github/intridea/hashie/maintainability)
 
 Hashie is a growing collection of tools that extend Hashes and make them more useful.
 
@@ -20,7 +18,7 @@ $ gem install hashie
 
 ## Upgrading
 
-You're reading the documentation for the stable release of Hashie, 3.5.7. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
+You're reading the documentation for the stable release of Hashie, 3.6.0. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
 
 ## Hash Extensions
 
@@ -133,7 +131,7 @@ You can also use coerce from the following supertypes with `coerce_value`:
 - Integer
 - Numeric
 
-Hashie does not have built-in support for coercion boolean values, since Ruby does not have a built-in boolean type or standard method for to a boolean. You can coerce to booleans using a custom proc.
+Hashie does not have built-in support for coercing boolean values, since Ruby does not have a built-in boolean type or standard method for coercing to a boolean. You can coerce to booleans using a custom proc.
 
 ### Coercion Proc
 
@@ -245,6 +243,26 @@ overriding.zip   #=> 'a-dee-doo-dah'
 overriding.__zip #=> [[['zip', 'a-dee-doo-dah']]]
 ```
 
+### MethodOverridingInitializer
+
+The MethodOverridingInitializer extension will override hash methods if you pass in a normal hash to the constructor. It aliases any overridden method with two leading underscores. To include only this initializing functionality, you can include the single module `Hashie::Extensions::MethodOverridingInitializer`.
+
+```ruby
+class MyHash < Hash
+end
+
+class MyOverridingHash < Hash
+  include Hashie::Extensions::MethodOverridingInitializer
+end
+
+non_overriding = MyHash.new(zip: 'a-dee-doo-dah')
+non_overriding.zip #=> []
+
+overriding = MyOverridingHash.new(zip: 'a-dee-doo-dah')
+overriding.zip   #=> 'a-dee-doo-dah'
+overriding.__zip #=> [[['zip', 'a-dee-doo-dah']]]
+```
+
 ### IndifferentAccess
 
 This extension can be mixed in to your Hash subclass to allow you to use Strings or Symbols interchangeably as keys; similar to the `params` hash in Rails.
@@ -470,9 +488,11 @@ mash.inspect # => <Hashie::Mash>
 
 **Note:** The `?` method will return false if a key has been set to false or nil. In order to check if a key has been set at all, use the `mash.key?('some_key')` method instead.
 
+### How does Mash handle conflicts with pre-existing methods?
+
 Please note that a Mash will not override methods through the use of the property-like syntax. This can lead to confusion if you expect to be able to access a Mash value through the property-like syntax for a key that conflicts with a method name. However, it protects users of your library from the unexpected behavior of those methods being overridden behind the scenes.
 
-### Example:
+#### Example:
 
 ```ruby
 mash = Hashie::Mash.new
@@ -481,9 +501,40 @@ mash.zip = "Method Override?"
 mash.zip # => [[["name", "My Mash"]], [["zip", "Method Override?"]]]
 ```
 
+Since Mash gives you the ability to set arbitrary keys that then act as methods, Hashie logs when there is a conflict between a key and a pre-existing method. You can set the logger that this logs message to via the global Hashie logger:
+
+```ruby
+Hashie.logger = Rails.logger
+```
+
+You can also disable the logging in subclasses of Mash:
+
+```ruby
+class Response < Hashie::Mash
+  disable_warnings
+end
+```
+
+### How does the wrapping of Mash sub-Hashes work?
+
+Mash duplicates any sub-Hashes that you add to it and wraps them in a Mash. This allows for infinite chaining of nested Hashes within a Mash without modifying the object(s) that are passed into the Mash. When you subclass Mash, the subclass wraps any sub-Hashes in its own class. This preserves any extensions that you mixed into the Mash subclass and allows them to work within the sub-Hashes, in addition to the main containing Mash.
+
+#### Example:
+
+```ruby
+mash = Hashie::Mash.new(name: "Hashie", dependencies: { rake: "< 11", rspec: "~> 3.0" })
+mash.dependencies.class #=> Hashie::Mash
+
+class MyGem < Hashie::Mash; end
+my_gem = MyGem.new(name: "Hashie", dependencies: { rake: "< 11", rspec: "~> 3.0" })
+my_gem.dependencies.class #=> MyGem
+```
+
+### What else can Mash do?
+
 Mash allows you also to transform any files into a Mash objects.
 
-### Example:
+#### Example:
 
 ```yml
 #/etc/config/settings/twitter.yml
@@ -531,20 +582,6 @@ mash = Mash.load('data/user.csv', parser: MyCustomCsvParser)
 mash[1] #=> { name: 'John', lastname: 'Doe' }
 ```
 
-Since Mash gives you the ability to set arbitrary keys that then act as methods, Hashie logs when there is a conflict between a key and a pre-existing method. You can set the logger that this logs message to via the global Hashie logger:
-
-```ruby
-Hashie.logger = Rails.logger
-```
-
-You can also disable the logging in subclasses of Mash:
-
-```ruby
-class Response < Hashie::Mash
-  disable_warnings
-end
-```
-
 ### Mash Extension: KeepOriginalKeys
 
 This extension can be mixed into a Mash to keep the form of any keys passed directly into the Mash. By default, Mash converts keys to strings to give indifferent access. This extension still allows indifferent access, but keeps the form of the keys to eliminate confusion when you're not expecting the keys to change.
@@ -676,6 +713,38 @@ p = Tricky.new('trick' => 'two')
 p.trick # => NoMethodError
 ```
 
+### Potential gotchas
+
+Because Dashes are subclasses of the built-in Ruby Hash class, the double-splat operator takes the Dash as-is without any conversion. This can lead to strange behavior when you use the double-splat operator on a Dash as the first part of a keyword list or built Hash. For example:
+
+```ruby
+class Foo < Hashie::Dash
+  property :bar
+end
+
+foo = Foo.new(bar: 'baz')      #=> {:bar=>"baz"}
+qux = { **foo, quux: 'corge' } #=> {:bar=> "baz", :quux=>"corge"}
+qux.is_a?(Foo)                 #=> true
+qux[:quux]
+#=> raise NoMethodError, "The property 'quux' is not defined for Foo."
+qux.key?(:quux) #=> true
+```
+
+You can work around this problem in two ways:
+
+1. Call `#to_h` on the resulting object to convert it into a Hash.
+2. Use the double-splat operator on the Dash as the last argument in the Hash literal. This will cause the resulting object to be a Hash instead of a Dash, thereby circumventing the problem.
+
+```ruby
+qux = { **foo, quux: 'corge' }.to_h #=> {:bar=> "baz", :quux=>"corge"}
+qux.is_a?(Hash)                     #=> true
+qux[:quux]                          #=> "corge"
+
+qux = { quux: 'corge', **foo } #=> {:quux=>"corge", :bar=> "baz"}
+qux.is_a?(Hash)                #=> true
+qux[:quux]                     #=> "corge"
+```
+
 ### Dash Extension: PropertyTranslation
 
 The `Hashie::Extensions::Dash::PropertyTranslation` mixin extends a Dash with

data/Rakefile

@@ -24,9 +24,9 @@ task :integration_specs do
   run_all_integration_specs(handler: handler, logger: ->(msg) { puts msg })
 
   if status_codes.any?
-    $stderr.puts "#{status_codes.size} integration test(s) failed"
+    warn "#{status_codes.size} integration test(s) failed"
     exit status_codes.last
   end
 end
 
-task default: [:rubocop, :spec, :integration_specs]
+task default: %i[rubocop spec integration_specs]

data/hashie.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   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 Rakefile hashie.gemspec]
   gem.files += Dir['lib/**/*.rb']
   gem.files += Dir['spec/**/*.rb']
   gem.test_files = Dir['spec/**/*.rb']

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,11 @@ 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 +231,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/coercion.rb

@@ -10,14 +10,14 @@ 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]
+                                Integer => [Fixnum, Bignum], # rubocop:disable Lint/UnifiedInteger
+                                Numeric => [Fixnum, Bignum, Float, Complex, Rational] # rubocop:disable Lint/UnifiedInteger
                               }
                             end
 
@@ -78,7 +78,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
@@ -180,7 +180,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/property_translation.rb

@@ -40,7 +40,7 @@ module Hashie
       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
@@ -72,23 +72,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 +98,49 @@ 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 +150,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 +175,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