hashie 3.6.0 → 4.0.0

data/lib/hashie/mash.rb

@@ -2,6 +2,7 @@ require 'hashie/hash'
 require 'hashie/array'
 require 'hashie/utils'
 require 'hashie/logger'
+require 'hashie/extensions/key_conflict_warning'
 
 module Hashie
   # Mash allows you to create pseudo-objects that have method-like
@@ -16,8 +17,10 @@ module Hashie
   # * No punctuation: Returns the value of the hash for that key, or nil if none exists.
   # * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
   # * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
-  # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
-  # * Under Bang (<tt>_</tt>): Like Bang, but returns a new Mash rather than creating a key.  Used to test existance in deep Mashes.
+  # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it
+  #   as "touch" for mashes.
+  # * Under Bang (<tt>_</tt>): Like Bang, but returns a new Mash rather than creating a key.
+  #   Used to test existance in deep Mashes.
   #
   # == Basic Example
   #
@@ -60,41 +63,10 @@ module Hashie
   class Mash < Hash
     include Hashie::Extensions::PrettyInspect
     include Hashie::Extensions::RubyVersionCheck
+    extend Hashie::Extensions::KeyConflictWarning
 
     ALLOWED_SUFFIXES = %w[? ! = _].freeze
 
-    class CannotDisableMashWarnings < StandardError
-      def initialize(message = 'You cannot disable warnings on the base Mash class. Please subclass the Mash and disable it in the subclass.')
-        super(message)
-      end
-    end
-
-    # Disable the logging of warnings based on keys conflicting keys/methods
-    #
-    # @api semipublic
-    # @return [void]
-    def self.disable_warnings
-      raise CannotDisableMashWarnings if self == Hashie::Mash
-      @disable_warnings = true
-    end
-
-    # Checks whether this class disables warnings for conflicting keys/methods
-    #
-    # @api semipublic
-    # @return [Boolean]
-    def self.disable_warnings?
-      @disable_warnings ||= false
-    end
-
-    # Inheritance hook that sets class configuration when inherited.
-    #
-    # @api semipublic
-    # @return [void]
-    def self.inherited(subclass)
-      super
-      subclass.disable_warnings if disable_warnings?
-    end
-
     def self.load(path, options = {})
       @_mashes ||= new
 
@@ -102,7 +74,7 @@ module Hashie
       raise ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
 
       parser = options.fetch(:parser) { Hashie::Extensions::Parsers::YamlErbParser }
-      @_mashes[path] = new(parser.perform(path)).freeze
+      @_mashes[path] = new(parser.perform(path, options.except(:parser))).freeze
     end
 
     def to_module(mash_method_name = :settings)
@@ -114,6 +86,10 @@ module Hashie
       end
     end
 
+    def with_accessors!
+      extend Hashie::Extensions::Mash::DefineAccessors
+    end
+
     alias to_s inspect
 
     # If you pass in an existing hash, it will
@@ -125,6 +101,19 @@ module Hashie
       default ? super(default) : super(&blk)
     end
 
+    # Creates a new anonymous subclass with key conflict
+    # warnings disabled. You may pass an array of method
+    # symbols to restrict the disabled warnings to.
+    # Hashie::Mash.quiet.new(hash) all warnings disabled.
+    # Hashie::Mash.quiet(:zip).new(hash) only zip warning
+    # is disabled.
+    def self.quiet(*method_keys)
+      @memoized_classes ||= {}
+      @memoized_classes[method_keys] ||= Class.new(self) do
+        disable_warnings(*method_keys)
+      end
+    end
+
     class << self; alias [] new; end
 
     alias regular_reader []
@@ -183,6 +172,31 @@ module Hashie
       super(*keys.map { |key| convert_key(key) })
     end
 
+    # Returns a new instance of the class it was called on, with nil values
+    # removed.
+    def compact
+      self.class.new(super)
+    end
+
+    # Returns a new instance of the class it was called on, using its keys as
+    # values, and its values as keys. The new values and keys will always be
+    # strings.
+    def invert
+      self.class.new(super)
+    end
+
+    # Returns a new instance of the class it was called on, containing elements
+    # for which the given block returns false.
+    def reject(&blk)
+      self.class.new(super(&blk))
+    end
+
+    # Returns a new instance of the class it was called on, containing elements
+    # for which the given block returns true.
+    def select(&blk)
+      self.class.new(super(&blk))
+    end
+
     alias regular_dup dup
     # Duplicates the current mash as a new mash.
     def dup
@@ -202,14 +216,42 @@ module Hashie
     def deep_merge(other_hash, &blk)
       dup.deep_update(other_hash, &blk)
     end
-    alias merge deep_merge
 
     # Recursively merges this mash with the passed
     # in hash, merging each hash in the hierarchy.
     def deep_update(other_hash, &blk)
+      _deep_update(other_hash, &blk)
+      self
+    end
+
+    with_minimum_ruby('2.6.0') do
+      # Performs a deep_update on a duplicate of the
+      # current mash.
+      def deep_merge(*other_hashes, &blk)
+        dup.deep_update(*other_hashes, &blk)
+      end
+
+      # Recursively merges this mash with the passed
+      # in hash, merging each hash in the hierarchy.
+      def deep_update(*other_hashes, &blk)
+        other_hashes.each do |other_hash|
+          _deep_update(other_hash, &blk)
+        end
+        self
+      end
+    end
+
+    # Alias these lexically so they get the correctly defined
+    # #deep_merge and #deep_update based on ruby version.
+    alias merge deep_merge
+    alias deep_merge! deep_update
+    alias update deep_update
+    alias merge! update
+
+    def _deep_update(other_hash, &blk)
       other_hash.each_pair do |k, v|
         key = convert_key(k)
-        if regular_reader(key).is_a?(Mash) && v.is_a?(::Hash)
+        if v.is_a?(::Hash) && key?(key) && regular_reader(key).is_a?(Mash)
           custom_reader(key).deep_update(v, &blk)
         else
           value = convert_value(v, true)
@@ -217,11 +259,8 @@ module Hashie
           custom_writer(key, value, false)
         end
       end
-      self
     end
-    alias deep_merge! deep_update
-    alias update deep_update
-    alias merge! update
+    private :_deep_update
 
     # Assigns a value to a key
     def assign_property(name, value)
@@ -296,6 +335,23 @@ module Hashie
       end
     end
 
+    with_minimum_ruby('2.4.0') do
+      def transform_values(&blk)
+        self.class.new(super(&blk))
+      end
+    end
+
+    with_minimum_ruby('2.5.0') do
+      def slice(*keys)
+        string_keys = keys.map { |key| convert_key(key) }
+        self.class.new(super(*string_keys))
+      end
+
+      def transform_keys(&blk)
+        self.class.new(super(&blk))
+      end
+    end
+
     protected
 
     def method_name_and_suffix(method_name)
@@ -337,7 +393,7 @@ module Hashie
     private
 
     def log_built_in_message(method_key)
-      return if self.class.disable_warnings?
+      return if self.class.disable_warnings?(method_key)
 
       method_information = Hashie::Utils.method_information(method(method_key))
 
@@ -350,7 +406,7 @@ module Hashie
     end
 
     def log_collision?(method_key)
-      respond_to?(method_key) && !self.class.disable_warnings? &&
+      respond_to?(method_key) && !self.class.disable_warnings?(method_key) &&
         !(regular_key?(method_key) || regular_key?(method_key.to_s))
     end
   end

data/lib/hashie/railtie.rb

@@ -7,6 +7,13 @@ begin
       initializer 'hashie.configure_logger', after: 'initialize_logger' do
         Hashie.logger = Rails.logger
       end
+
+      initializer 'hashie.patch_hash_except', after: 'load_active_support' do
+        if Rails::VERSION::MAJOR >= 6
+          require 'hashie/extensions/active_support/core_ext/hash'
+          Hashie::Mash.send(:include, Hashie::Extensions::ActiveSupport::CoreExt::Hash)
+        end
+      end
     end
   end
 rescue LoadError => e

data/lib/hashie/rash.rb

@@ -117,7 +117,7 @@ module Hashie
         end
 
       when Regexp
-        # Reverse operation: `rash[/regexp/]` returns all the hash's string keys which match the regexp
+        # Reverse operation: `rash[/regexp/]` returns all string keys matching the regexp
         @hash.each do |key, val|
           yield val if key.is_a?(String) && query =~ key
         end

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.6.0'.freeze
+  VERSION = '4.0.0'.freeze
 end

data/spec/hashie/dash_spec.rb

@@ -129,12 +129,14 @@ describe DashTest do
   context 'writing to properties' do
     it 'fails writing a required property to nil' do
       expect { subject.first_name = nil }.to raise_error(*property_required_error('first_name'))
-      expect { required_message.first_name = nil }.to raise_error(*property_required_custom_error('first_name'))
+      expect { required_message.first_name = nil }
+        .to raise_error(*property_required_custom_error('first_name'))
     end
 
     it 'fails writing a required property to nil using []=' do
       expect { subject[:first_name] = nil }.to raise_error(*property_required_error('first_name'))
-      expect { required_message[:first_name] = nil }.to raise_error(*property_required_custom_error('first_name'))
+      expect { required_message[:first_name] = nil }
+        .to raise_error(*property_required_custom_error('first_name'))
     end
 
     it 'fails writing to a non-existent property using []=' do
@@ -263,11 +265,13 @@ describe DashTest do
     end
 
     it 'fails with non-existent properties' do
-      expect { subject.merge(middle_name: 'James') }.to raise_error(*no_property_error('middle_name'))
+      expect { subject.merge(middle_name: 'James') }
+        .to raise_error(*no_property_error('middle_name'))
     end
 
     it 'errors out when attempting to set a required property to nil' do
-      expect { subject.merge(first_name: nil) }.to raise_error(*property_required_error('first_name'))
+      expect { subject.merge(first_name: nil) }
+        .to raise_error(*property_required_error('first_name'))
     end
 
     context 'given a block' do
@@ -366,8 +370,12 @@ describe DashTest do
     let(:params) { { first_name: 'Alice', email: 'alice@example.com' } }
 
     context 'when there is coercion' do
-      let(:params_before) { { city: 'nyc', person: { first_name: 'Bob', email: 'bob@example.com' } } }
-      let(:params_after) { { city: 'sfo', person: { first_name: 'Alice', email: 'alice@example.com' } } }
+      let(:params_before) do
+        { city: 'nyc', person: { first_name: 'Bob', email: 'bob@example.com' } }
+      end
+      let(:params_after) do
+        { city: 'sfo', person: { first_name: 'Alice', email: 'alice@example.com' } }
+      end
 
       subject { DashWithCoercion.new(params_before) }
 
@@ -505,7 +513,8 @@ end
 
 describe ConditionallyRequiredTest do
   it 'does not allow a conditionally required property to be set to nil if required' do
-    expect { ConditionallyRequiredTest.new(username: 'bob.smith', password: nil) }.to raise_error(ArgumentError, "The property 'password' must be set, too.")
+    expect { ConditionallyRequiredTest.new(username: 'bob.smith', password: nil) }
+      .to raise_error(ArgumentError, "The property 'password' must be set, too.")
   end
 
   it 'allows a conditionally required property to be set to nil if not required' do
@@ -513,7 +522,8 @@ describe ConditionallyRequiredTest do
   end
 
   it 'allows a conditionally required property to be set if required' do
-    expect { ConditionallyRequiredTest.new(username: 'bob.smith', password: '$ecure!') }.not_to raise_error
+    expect { ConditionallyRequiredTest.new(username: 'bob.smith', password: '$ecure!') }
+      .not_to raise_error
   end
 end
 

data/spec/hashie/extensions/coercion_spec.rb

@@ -283,7 +283,8 @@ describe Hashie::Extensions::Coercion do
 
       it 'raises errors for non-coercable types' do
         subject.coerce_key :foo, NotInitializable
-        expect { instance[:foo] = 'true' }.to raise_error(Hashie::CoercionError, /NotInitializable is not a coercable type/)
+        expect { instance[:foo] = 'true' }
+          .to raise_error(Hashie::CoercionError, /NotInitializable is not a coercable type/)
       end
 
       it 'can coerce false' do
@@ -458,8 +459,12 @@ describe Hashie::Extensions::Coercion do
           coerce_key :categories, Array[CategoryHash]
         end
 
-        let(:category) { CategoryHash.new(type: 'rubygem', products: [Hashie::Mash.new(name: 'Hashie')]) }
-        let(:product) { ProductHash.new(name: 'Hashie', categories: [Hashie::Mash.new(type: 'rubygem')]) }
+        let(:category) do
+          CategoryHash.new(type: 'rubygem', products: [Hashie::Mash.new(name: 'Hashie')])
+        end
+        let(:product) do
+          ProductHash.new(name: 'Hashie', categories: [Hashie::Mash.new(type: 'rubygem')])
+        end
 
         it 'coerces CategoryHash[:products] correctly' do
           expected = [ProductHash]
@@ -559,22 +564,26 @@ describe Hashie::Extensions::Coercion do
 
       it 'raises a CoercionError when coercion is not possible' do
         type =
-          if Hashie::Extensions::RubyVersion.new(RUBY_VERSION) >= Hashie::Extensions::RubyVersion.new('2.4.0')
+          if Hashie::Extensions::RubyVersion.new(RUBY_VERSION) >=
+             Hashie::Extensions::RubyVersion.new('2.4.0')
             Integer
           else
-            Fixnum # rubocop:disable Lint/UnifiedInteger
+            Fixnum
           end
 
         subject.coerce_value type, Symbol
-        expect { instance[:hi] = 1 }.to raise_error(Hashie::CoercionError, /Cannot coerce property :hi from #{type} to Symbol/)
+        expect { instance[:hi] = 1 }.to raise_error(
+          Hashie::CoercionError, /Cannot coerce property :hi from #{type} to Symbol/
+        )
       end
 
       it 'coerces Integer to String' do
         type =
-          if Hashie::Extensions::RubyVersion.new(RUBY_VERSION) >= Hashie::Extensions::RubyVersion.new('2.4.0')
+          if Hashie::Extensions::RubyVersion.new(RUBY_VERSION) >=
+             Hashie::Extensions::RubyVersion.new('2.4.0')
             Integer
           else
-            Fixnum # rubocop:disable Lint/UnifiedInteger
+            Fixnum
           end
 
         subject.coerce_value type, String

data/spec/hashie/extensions/deep_find_spec.rb

@@ -36,7 +36,8 @@ describe Hashie::Extensions::DeepFind do
 
   describe '#deep_find_all' do
     it 'detects all values from a nested hash' do
-      expect(instance.deep_find_all(:title)).to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
+      expect(instance.deep_find_all(:title))
+        .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
     end
 
     it 'returns nil if it does not find any matches' do
@@ -64,7 +65,8 @@ describe Hashie::Extensions::DeepFind do
       end
 
       it 'detects all values from a nested hash' do
-        expect(instance.deep_find_all(:title)).to eq([{ type: :string }, 'Call of the Wild', 'Moby Dick', 'Main Library'])
+        expect(instance.deep_find_all(:title))
+          .to eq([{ type: :string }, 'Call of the Wild', 'Moby Dick', 'Main Library'])
       end
     end
   end
@@ -91,8 +93,10 @@ describe Hashie::Extensions::DeepFind do
 
     describe '#deep_find_all' do
       it 'indifferently detects all values from a nested hash' do
-        expect(instance.deep_find_all(:title)).to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-        expect(instance.deep_find_all('title')).to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
+        expect(instance.deep_find_all(:title))
+          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
+        expect(instance.deep_find_all('title'))
+          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
       end
 
       it 'indifferently returns nil if it does not find any matches' do
@@ -125,8 +129,10 @@ describe Hashie::Extensions::DeepFind do
 
     describe '#deep_find_all' do
       it 'indifferently detects all values from a nested hash' do
-        expect(instance.deep_find_all(:title)).to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-        expect(instance.deep_find_all('title')).to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
+        expect(instance.deep_find_all(:title))
+          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
+        expect(instance.deep_find_all('title'))
+          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
       end
 
       it 'indifferently returns nil if it does not find any matches' do

data/spec/hashie/extensions/deep_locate_spec.rb

@@ -56,7 +56,8 @@ describe Hashie::Extensions::DeepLocate do
   describe '.deep_locate' do
     context 'if called with a non-callable comparator' do
       it 'creates a key comparator on-th-fly' do
-        expect(described_class.deep_locate(:lsr10, hash)).to eq([hash[:query][:bool][:must_not][0][:range]])
+        expect(described_class.deep_locate(:lsr10, hash))
+          .to eq([hash[:query][:bool][:must_not][0][:range]])
       end
     end
 

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -13,9 +13,13 @@ describe Hashie::Extensions::DeepMerge do
   end
 
   context 'without &block' do
-    let(:h1) { subject.new.merge(a: 'a', a1: 42, b: 'b', c: { c1: 'c1', c2: { a: 'b' }, c3: { d1: 'd1' } }) }
+    let(:h1) do
+      subject.new.merge(a: 'a', a1: 42, b: 'b', c: { c1: 'c1', c2: { a: 'b' }, c3: { d1: 'd1' } })
+    end
     let(:h2) { { a: 1, a1: 1, c: { c1: 2, c2: 'c2', c3: { d2: 'd2' } }, e: { e1: 1 } } }
-    let(:expected_hash) { { a: 1, a1: 1, b: 'b', c: { c1: 2, c2: 'c2', c3: { d1: 'd1', d2: 'd2' } }, e: { e1: 1 } } }
+    let(:expected_hash) do
+      { a: 1, a1: 1, b: 'b', c: { c1: 2, c2: 'c2', c3: { d1: 'd1', d2: 'd2' } }, e: { e1: 1 } }
+    end
 
     it 'deep merges two hashes' do
       expect(h1.deep_merge(h2)).to eq expected_hash