hashie 2.1.2 → 4.1.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)
+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

@@ -0,0 +1,245 @@
+Upgrading Hashie
+================
+
+### 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
+
+In versions <= 3.2.1 Hash object being questioned doesn't return a boolean value as it's mentioned in README.md
+
+```ruby
+class MyHash < Hash
+  include Hashie::Extensions::MethodAccess
+end
+
+h = MyHash.new
+h.abc = 'def'
+h.abc  # => 'def'
+h.abc? # => 'def'
+```
+
+In versions >= 3.2.2 it returns a boolean value
+
+```ruby
+h.abc? # => true
+h.abb? # => false
+```
+
+### Upgrading to 3.2.1
+
+#### Possible coercion changes
+
+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.
+
+If necessary, `dup` or `clone` your own objects. Do not assume Hashie will do it for you.
+
+**Change**: Failed coercion attempts now raise Hashie::CoercionError.
+
+Hashie now raises a Hashie::CoercionError that details on the property that could not be coerced, the source and target type of the coercion, and the internal error. Previously only the internal error was raised.
+
+Applications that were attempting to rescuing the internal errors should be updated to rescue Hashie::CoercionError instead.
+
+### Upgrading to 3.0
+
+#### 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/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.
+
+```
+gem 'hashie_rails'
+```
+
+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
+
+Version 2.1 and older of Hashie::Dash and Hashie::Trash converted keys to strings by default. This is no longer the case in 2.2.
+
+Consider the following code.
+
+```ruby
+class Person < Hashie::Dash
+  property :name
+end
+
+p = Person.new(name: 'dB.')
+```
+
+Version 2.1 behaves as follows.
+
+```ruby
+p.name # => 'dB.'
+p[:name] # => 'dB.'
+p['name'] # => 'dB.'
+
+# not what I put in
+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/hashie/hashie/issues/151).
+
+Version 2.2 does not perform this conversion by default.
+
+```ruby
+p.name # => 'dB.'
+p[:name] # => 'dB.'
+# p['name'] # => NoMethodError
+
+p.inspect # => { :name => 'dB.' }
+p.to_hash # => { :name => 'dB.' }
+```
+
+To enable behavior compatible with older versions, use `Hashie::Extensions::Dash::IndifferentAccess`.
+
+```ruby
+class Person < Hashie::Dash
+  include Hashie::Extensions::Dash::IndifferentAccess
+  property :name
+end
+```
+
+#### Key Conversions in Hashie::Hash#to_hash
+
+Version 2.1 or older of Hash#to_hash converted keys to strings automatically.
+
+```ruby
+instance = Hashie::Hash[first: 'First', 'last' => 'Last']
+instance.to_hash # => { "first" => 'First', "last" => 'Last' }
+```
+
+It was possible to symbolize keys by passing `:symbolize_keys`, however it was not possible to retrieve the hash with initial key values.
+
+```ruby
+instance.to_hash(symbolize_keys: true) # => { :first => 'First', :last => 'Last' }
+instance.to_hash(stringify_keys: true) # => { "first" => 'First', "last" => 'Last' }
+```
+
+Version 2.2 no longer converts keys by default.
+
+```ruby
+instance = Hashie::Hash[first: 'First', 'last' => 'Last']
+instance.to_hash # => { :first => 'First', "last" => 'Last' }
+```
+
+The behavior with `symbolize_keys` and `stringify_keys` is unchanged.
+
+See [#152](https://github.com/hashie/hashie/pull/152) for more information.

data/hashie.gemspec

@@ -1,20 +1,28 @@
 require File.expand_path('../lib/hashie/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Michael Bleigh", "Jerry Cheung"]
-  gem.email         = ["michael@intridea.com", "jollyjerry@gmail.com"]
-  gem.description   = %q{Hashie is a collection of classes and mixins that make hashes more powerful.}
-  gem.summary       = %q{Your friendly neighborhood hash library.}
-  gem.homepage      = 'https://github.com/intridea/hashie'
+  gem.name          = 'hashie'
+  gem.version       = Hashie::VERSION
+  gem.authors       = ['Michael Bleigh', 'Jerry Cheung']
+  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/hashie/hashie'
+  gem.license       = 'MIT'
 
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.name          = "hashie"
   gem.require_paths = ['lib']
-  gem.version       = Hashie::VERSION
-  gem.license       = "MIT"
+  gem.files = %w[.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE README.md UPGRADING.md]
+  gem.files += %w[Rakefile hashie.gemspec]
+  gem.files += Dir['lib/**/*.rb']
+
+  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 'rake'
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'bundler'
 end

data/lib/hashie.rb

@@ -1,26 +1,65 @@
+require 'hashie/logger'
+require 'hashie/version'
+
 module Hashie
-  autoload :Clash,          'hashie/clash'
-  autoload :Dash,           'hashie/dash'
-  autoload :Hash,           'hashie/hash'
-  autoload :HashExtensions, 'hashie/hash_extensions'
-  autoload :Mash,           'hashie/mash'
-  autoload :PrettyInspect,  'hashie/hash_extensions'
-  autoload :Trash,          'hashie/trash'
-  autoload :Rash,           'hashie/rash'
+  autoload :Clash,              'hashie/clash'
+  autoload :Dash,               'hashie/dash'
+  autoload :Hash,               'hashie/hash'
+  autoload :Mash,               'hashie/mash'
+  autoload :Trash,              'hashie/trash'
+  autoload :Rash,               'hashie/rash'
+  autoload :Array,              'hashie/array'
+  autoload :Utils,              'hashie/utils'
 
   module Extensions
-    autoload :Coercion,          'hashie/extensions/coercion'
-    autoload :DeepMerge,         'hashie/extensions/deep_merge'
-    autoload :KeyConversion,     'hashie/extensions/key_conversion'
-    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/key_conversion'
-    autoload :SymbolizeKeys,     'hashie/extensions/key_conversion'
-    autoload :DeepFetch,         'hashie/extensions/deep_fetch'
+    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'
+
+    module Parsers
+      autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'
+    end
+
+    module Dash
+      autoload :IndifferentAccess, 'hashie/extensions/dash/indifferent_access'
+      autoload :PropertyTranslation, 'hashie/extensions/dash/property_translation'
+      autoload :Coercion, 'hashie/extensions/dash/coercion'
+    end
+
+    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
+      autoload :PrettyInspect, 'hashie/extensions/array/pretty_inspect'
+    end
+  end
+
+  class << self
+    include Hashie::Extensions::StringifyKeys::ClassMethods
+    include Hashie::Extensions::SymbolizeKeys::ClassMethods
   end
+
+  require 'hashie/railtie' if defined?(::Rails)
 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