hashie 3.4.2 → 5.0.0

data/Rakefile

@@ -7,9 +7,26 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
+  spec.exclude_pattern = 'spec/integration/**/*_spec.rb'
 end
 
 require 'rubocop/rake_task'
 RuboCop::RakeTask.new(:rubocop)
 
-task default: [:rubocop, :spec]
+require_relative 'spec/support/integration_specs'
+task :integration_specs do
+  next if ENV['CI']
+  status_codes = []
+  handler = lambda do |status_code|
+    status_codes << status_code unless status_code.zero?
+  end
+
+  run_all_integration_specs(handler: handler, logger: ->(msg) { puts msg })
+
+  if status_codes.any?
+    warn "#{status_codes.size} integration test(s) failed"
+    exit status_codes.last
+  end
+end
+
+task default: %i[rubocop spec integration_specs]

data/UPGRADING.md

@@ -1,6 +1,158 @@
 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
+
+If you subclass `Hashie::Mash`, you can now disable the logging we do about
+overriding existing methods with keys. This looks like:
+
+```ruby
+class MyMash < Hashie::Mash
+  disable_warnings
+end
+```
+
+### Upgrading to 3.4.7
+
+#### Procs as default values for Dash
+
+```ruby
+class MyHash < Hashie::Dash
+  property :time, default: -> { Time.now }
+end
+```
+
+In versions < 3.4.7 `Time.now` will be evaluated when `time` property is accessed directly first time.
+In version >= 3.4.7 `Time.now` is evaluated in time of object initialization.
+### Upgrading to 3.4.4
+
+#### Mash subclasses and reverse_merge
+
+```ruby
+class MyMash < Hashie::Mash
+end
+```
+
+In versions >= 3.4.4 `MyMash#reverse_merge` returns an instance of `MyMash` but in previous versions it was a `Hashie::Mash` instance.
+
 ### Upgrading to 3.2.2
 
 #### Testing if key defined
@@ -29,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.
 
@@ -45,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.
 
@@ -53,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
 
@@ -81,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.
 
@@ -128,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,15 +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         += Dir['lib/**/*.rb']
-  gem.files         += Dir['spec/**/*.rb']
-  gem.test_files    = Dir['spec/**/*.rb']
+  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.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '~> 3.0'
+  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/array.rb

@@ -0,0 +1,21 @@
+require 'hashie/extensions/array/pretty_inspect'
+require 'hashie/extensions/ruby_version_check'
+
+module Hashie
+  class Array < ::Array
+    include Hashie::Extensions::Array::PrettyInspect
+    include Hashie::Extensions::RubyVersionCheck
+    with_minimum_ruby('2.3.0') do
+      def dig(*indexes)
+        converted_indexes = indexes.map do |idx|
+          begin
+            Integer(idx)
+          rescue ArgumentError
+            idx
+          end
+        end
+        super(*converted_indexes)
+      end
+    end
+  end
+end

data/lib/hashie/clash.rb

@@ -54,7 +54,7 @@ module Hashie
       case args.length
       when 1
         val = args.first
-        val = self[key].merge(val) if self[key].is_a?(::Hash) && val.is_a?(::Hash)
+        val = self.class.new(self[key]).merge(val) if self[key].is_a?(::Hash) && val.is_a?(::Hash)
       else
         val = args
       end
@@ -64,22 +64,34 @@ module Hashie
     end
 
     def method_missing(name, *args) #:nodoc:
-      name = name.to_s
-      if name.match(/!$/) && args.empty?
+      if args.empty? && name.to_s.end_with?('!')
         key = name[0...-1].to_sym
 
-        if self[key].nil?
-          self[key] = Clash.new({}, self)
-        elsif self[key].is_a?(::Hash) && !self[key].is_a?(Clash)
-          self[key] = Clash.new(self[key], self)
+        case self[key]
+        when NilClass
+          self[key] = self.class.new({}, self)
+        when Clash
+          self[key]
+        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
-
-        self[key]
       elsif args.any?
-        key = name.to_sym
-        merge_store(key, *args)
+        merge_store(name, *args)
+      else
+        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

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,26 +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
-          val.is_a?(Proc) && val.arity > 0 ? val.call(self) : val
-        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
@@ -155,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)
@@ -195,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)
@@ -207,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/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