hashie 3.5.7 → 5.0.0

data/UPGRADING.md

@@ -1,6 +1,122 @@
 Upgrading Hashie
 ================
 
+### Upgrading to 5.0.0
+
+#### Mash initialization key conversion
+
+Mash initialization now only converts to string keys which can be represented as symbols.
+
+```ruby
+Hashie::Mash.new(
+  {foo: "bar"} => "baz",
+  "1" => "one string",
+  :"1" => "one sym",
+  1 => "one num"
+)
+
+# Before
+{"{:foo=>\"bar\"}"=>"baz", "1"=>"one num"}
+
+# After
+{{:foo=>"bar"}=>"baz", "1"=>"one sym", 1=>"one num"}
+```
+
+#### Mash#dig with numeric keys
+
+`Hashie::Mash#dig` no longer considers numeric keys for indifferent access.
+
+```ruby
+my_mash = Hashie::Mash.new("1" => "a") # => {"1"=>"a"}
+
+my_mash.dig("1") # => "a"
+my_mash.dig(:"1") # => "a"
+
+# Before
+my_mash.dig(1) # => "a"
+
+# After
+my_mash.dig(1) # => nil
+```
+
+### Upgrading to 4.0.0
+
+#### Non-destructive Hash methods called on Mash
+
+The following non-destructive Hash methods called on Mash will now return an instance of the class it was called on.
+
+| method            | ruby |
+| ----------------- | ---- |
+| #compact          |      |
+| #invert           |      |
+| #reject           |      |
+| #select           |      |
+| #slice            | 2.5  |
+| #transform_keys   | 2.5  |
+| #transform_values | 2.4  |
+
+```ruby
+class Parents < Hashie::Mash; end
+
+parents = Parents.new(father: 'Dad', mother: 'Mom')
+cool_parents = parents.transform_values { |v| v + v[-1] + 'io'}
+
+p cool_parents
+
+# before:
+{"father"=>"Daddio", "mother"=>"Mommio"}
+ => {"father"=>"Daddio", "mother"=>"Mommio"}
+
+# after:
+#<Parents father="Daddio" mother="Mommio">
+=> {"father"=>"Dad", "mother"=>"Mom"}
+```
+
+This may make places where you had to re-make the Mash redundant, and may cause unintended side effects if your application was expecting a plain old ruby Hash.
+
+#### Ruby 2.6: Mash#merge and Mash#merge!
+
+In Ruby > 2.6.0, Hashie now supports passing multiple hash and Mash objects to Mash#merge and Mash#merge!.
+
+#### Hashie::Mash::CannotDisableMashWarnings error class is removed
+
+There shouldn't really be a case that anyone was relying on catching this specific error, but if so, they should change it to rescue Hashie::Extensions::KeyConflictWarning::CannotDisableMashWarnings
+
+### Upgrading to 3.7.0
+
+#### Mash#load takes options
+
+The `Hashie::Mash#load` method now accepts options, changing the interface of `Parser#initialize`. If you have a custom parser, you must update its `initialize` method.
+
+For example, `Hashie::Extensions::Parsers::YamlErbParser` now accepts `permitted_classes`, `permitted_symbols` and `aliases` options.
+
+Before:
+
+```ruby
+class Hashie::Extensions::Parsers::YamlErbParser
+  def initialize(file_path)
+    @file_path = file_path
+  end
+end
+```
+
+After:
+
+```ruby
+class Hashie::Extensions::Parsers::YamlErbParser
+  def initialize(file_path, options = {})
+    @file_path = file_path
+    @options = options
+  end
+end
+```
+
+Options can now be passed into `Mash#load`.
+
+```ruby
+Mash.load(filename, permitted_classes: [])
+```
+
 ### Upgrading to 3.5.2
 
 #### Disable logging in Mash subclasses
@@ -65,7 +181,7 @@ h.abb? # => false
 
 #### Possible coercion changes
 
-The improvements made to coercions in version 3.2.1 [issue #200](https://github.com/intridea/hashie/pull/200) do not break the documented API, but are significant enough that changes may effect undocumented side-effects. Applications that depended on those side-effects will need to be updated.
+The improvements made to coercions in version 3.2.1 [issue #200](https://github.com/hashie/hashie/pull/200) do not break the documented API, but are significant enough that changes may effect undocumented side-effects. Applications that depended on those side-effects will need to be updated.
 
 **Change**: Type coercion no longer creates new objects if the input matches the target type. Previously coerced properties always resulted in the creation of a new object, even when it wasn't necessary. This had the effect of a `dup` or `clone` on coerced properties but not uncoerced ones.
 
@@ -81,7 +197,7 @@ Applications that were attempting to rescuing the internal errors should be upda
 
 #### Compatibility with Rails 4 Strong Parameters
 
-Version 2.1 introduced support to prevent default Rails 4 mass-assignment protection behavior. This was [issue #89](https://github.com/intridea/hashie/issues/89), resolved in [#104](https://github.com/intridea/hashie/pull/104). In version 2.2 this behavior has been removed in [#147](https://github.com/intridea/hashie/pull/147) in favor of a mixin and finally extracted into a separate gem in Hashie 3.0.
+Version 2.1 introduced support to prevent default Rails 4 mass-assignment protection behavior. This was [issue #89](https://github.com/hashie/hashie/issues/89), resolved in [#104](https://github.com/hashie/hashie/pull/104). In version 2.2 this behavior has been removed in [#147](https://github.com/hashie/hashie/pull/147) in favor of a mixin and finally extracted into a separate gem in Hashie 3.0.
 
 To enable 2.1 compatible behavior with Rails 4, use the [hashie_rails](http://rubygems.org/gems/hashie_rails) gem.
 
@@ -89,7 +205,7 @@ To enable 2.1 compatible behavior with Rails 4, use the [hashie_rails](http://ru
 gem 'hashie_rails'
 ```
 
-See [#154](https://github.com/intridea/hashie/pull/154) and [Mash and Rails 4 Strong Parameters](README.md#mash-and-rails-4-strong-parameters) for more details.
+See [#154](https://github.com/hashie/hashie/pull/154) and [Mash and Rails 4 Strong Parameters](README.md#mash-and-rails-4-strong-parameters) for more details.
 
 #### Key Conversions in Hashie::Dash and Hashie::Trash
 
@@ -117,7 +233,7 @@ p.inspect # => { 'name' => 'dB.' }
 p.to_hash # => { 'name' => 'dB.' }
 ```
 
-It was not possible to achieve the behavior of preserving keys, as described in [issue #151](https://github.com/intridea/hashie/issues/151).
+It was not possible to achieve the behavior of preserving keys, as described in [issue #151](https://github.com/hashie/hashie/issues/151).
 
 Version 2.2 does not perform this conversion by default.
 
@@ -164,6 +280,4 @@ instance.to_hash # => { :first => 'First', "last" => 'Last' }
 
 The behavior with `symbolize_keys` and `stringify_keys` is unchanged.
 
-See [#152](https://github.com/intridea/hashie/pull/152) for more information.
-
-
+See [#152](https://github.com/hashie/hashie/pull/152) for more information.

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/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,30 +87,29 @@ 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)
       super(&block)
 
-      self.class.defaults.each_pair do |prop, value|
-        self[prop] = begin
-          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_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
@@ -159,25 +156,48 @@ module Hashie
       self
     end
 
+    def to_h
+      defaults = ::Hash[self.class.properties.map { |prop| [prop, self.class.defaults[prop]] }]
+
+      defaults.merge(self)
+    end
+    alias to_hash to_h
+
     def update_attributes!(attributes)
-      initialize_attributes(attributes)
+      update_attributes(attributes)
 
       self.class.defaults.each_pair do |prop, value|
+        next unless fetch(prop, nil).nil?
         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 if self[prop].nil?
+        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)
@@ -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,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 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 +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