hashie 3.5.7 → 3.6.0

data/lib/hashie/extensions/deep_fetch.rb

@@ -19,7 +19,7 @@ module Hashie
             arg = Integer(arg) if obj.is_a? Array
             obj.fetch(arg)
           rescue ArgumentError, IndexError, NoMethodError => e
-            break block.call(arg) if block
+            break yield(arg) if block
             raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
           end
         end

data/lib/hashie/extensions/deep_find.rb

@@ -19,7 +19,7 @@ module Hashie
         _deep_find(key)
       end
 
-      alias_method :deep_detect, :deep_find
+      alias deep_detect deep_find
 
       # Performs a depth-first search on deeply nested data structures for
       # a key and returns all occurrences of the key.
@@ -40,7 +40,7 @@ module Hashie
         matches.empty? ? nil : matches
       end
 
-      alias_method :deep_select, :deep_find_all
+      alias deep_select deep_find_all
 
       private
 

data/lib/hashie/extensions/deep_locate.rb

@@ -61,8 +61,6 @@ module Hashie
         Hashie::Extensions::DeepLocate.deep_locate(comparator, self)
       end
 
-      private
-
       def self._construct_key_comparator(search_key, object)
         search_key = search_key.to_s if defined?(::ActiveSupport::HashWithIndifferentAccess) && object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
         search_key = search_key.to_s if object.respond_to?(:indifferent_access?) && object.indifferent_access?
@@ -71,12 +69,11 @@ module Hashie
           ->(key, _, _) { key == non_callable_object }
         end.call(search_key)
       end
+      private_class_method :_construct_key_comparator
 
       def self._deep_locate(comparator, object, result = [])
         if object.is_a?(::Enumerable)
-          if object.any? { |value| _match_comparator?(value, comparator, object) }
-            result.push object
-          end
+          result.push object if object.any? { |value| _match_comparator?(value, comparator, object) }
           (object.respond_to?(:values) ? object.values : object.entries).each do |value|
             _deep_locate(comparator, value, result)
           end
@@ -84,6 +81,7 @@ module Hashie
 
         result
       end
+      private_class_method :_deep_locate
 
       def self._match_comparator?(value, comparator, object)
         if object.is_a?(::Hash)
@@ -94,6 +92,7 @@ module Hashie
 
         comparator.call(key, value, object)
       end
+      private_class_method :_match_comparator?
     end
   end
 end

data/lib/hashie/extensions/deep_merge.rb

@@ -20,15 +20,14 @@ module Hashie
 
       def _recursive_merge(hash, other_hash, &block)
         other_hash.each do |k, v|
-          hash[k] = if hash.key?(k) && hash[k].is_a?(::Hash) && v.is_a?(::Hash)
-                      _recursive_merge(hash[k], v, &block)
-                    else
-                      if hash.key?(k) && block_given?
-                        block.call(k, hash[k], v)
-                      else
-                        v.respond_to?(:deep_dup) ? v.deep_dup : v
-                      end
-                    end
+          hash[k] =
+            if hash.key?(k) && hash[k].is_a?(::Hash) && v.is_a?(::Hash)
+              _recursive_merge(hash[k], v, &block)
+            elsif hash.key?(k) && block_given?
+              yield(k, hash[k], v)
+            else
+              v.respond_to?(:deep_dup) ? v.deep_dup : v
+            end
         end
         hash
       end

data/lib/hashie/extensions/indifferent_access.rb

@@ -32,12 +32,12 @@ module Hashie
           alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
           alias_method :[]=, :indifferent_writer
           alias_method :store, :indifferent_writer
-          %w(default update replace fetch delete key? values_at).each do |m|
+          %w[default update replace fetch delete key? values_at].each do |m|
             alias_method "regular_#{m}", m unless method_defined?("regular_#{m}")
             alias_method m, "indifferent_#{m}"
           end
 
-          %w(include? member? has_key?).each do |key_alias|
+          %w[include? member? has_key?].each do |key_alias|
             alias_method key_alias, :indifferent_key?
           end
 
@@ -75,7 +75,7 @@ module Hashie
       # their proper indifferent state. Used when IndifferentAccess
       # is injecting itself into member hashes.
       def convert!
-        keys.each do |k|
+        keys.each do |k| # rubocop:disable Performance/HashEachMethods
           regular_writer convert_key(k), indifferent_value(regular_delete(k))
         end
         self
@@ -133,8 +133,10 @@ module Hashie
         self
       end
 
-      def merge(*)
-        super.convert!
+      def merge(*args)
+        result = super
+        IndifferentAccess.inject!(result) if hash_lacking_indifference?(result)
+        result.convert!
       end
 
       def merge!(*)

data/lib/hashie/extensions/mash/keep_original_keys.rb

@@ -14,14 +14,12 @@ module Hashie
       #   mash['string_key'] == mash[:string_key]  #=> true
       #   mash[:symbol_key] == mash['symbol_key']  #=> true
       module KeepOriginalKeys
-        private
-
         def self.included(descendant)
-          unless descendant <= Hashie::Mash
-            fail ArgumentError, "#{descendant} is not a kind of Hashie::Mash"
-          end
+          raise ArgumentError, "#{descendant} is not a kind of Hashie::Mash" unless descendant <= Hashie::Mash
         end
 
+        private
+
         # Converts the key when necessary to access the correct Mash key.
         #
         # @param [Object, String, Symbol] key the key to access.

data/lib/hashie/extensions/mash/safe_assignment.rb

@@ -3,7 +3,7 @@ module Hashie
     module Mash
       module SafeAssignment
         def custom_writer(key, *args) #:nodoc:
-          fail ArgumentError, "The property #{key} clashes with an existing method." if !key?(key) && respond_to?(key, true)
+          raise ArgumentError, "The property #{key} clashes with an existing method." if !key?(key) && respond_to?(key, true)
           super
         end
 

data/lib/hashie/extensions/mash/symbolize_keys.rb

@@ -19,7 +19,7 @@ module Hashie
         # @return [void]
         # @raise [ArgumentError] when the base class isn't a Mash
         def self.included(base)
-          fail ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
+          raise ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
         end
 
         private

data/lib/hashie/extensions/method_access.rb

@@ -27,7 +27,7 @@ module Hashie
     #
     #   user.not_declared # => NoMethodError
     module MethodReader
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         return true if key?(name.to_s) || key?(name.to_sym)
         super
       end
@@ -67,15 +67,13 @@ module Hashie
     #   h['awesome'] # => 'sauce'
     #
     module MethodWriter
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         return true if name.to_s =~ /=$/
         super
       end
 
       def method_missing(name, *args)
-        if args.size == 1 && name.to_s =~ /(.*)=$/
-          return self[convert_key(Regexp.last_match[1])] = args.first
-        end
+        return self[convert_key(Regexp.last_match[1])] = args.first if args.size == 1 && name.to_s =~ /(.*)=$/
 
         super
       end
@@ -106,7 +104,7 @@ module Hashie
     #   h.def? # => false
     #   h.hji? # => NoMethodError
     module MethodQuery
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         if query_method?(name) && indifferent_key?(key_from_query_method(name))
           true
         else
@@ -156,6 +154,22 @@ module Hashie
       end
     end
 
+    # A module shared between MethodOverridingWriter and MethodOverridingInitializer
+    # to contained shared logic. This module aids in redefining existing hash methods.
+    module RedefineMethod
+      protected
+
+      def method?(name)
+        methods.map(&:to_s).include?(name)
+      end
+
+      def redefine_method(method_name)
+        eigenclass = class << self; self; end
+        eigenclass.__send__(:alias_method, "__#{method_name}", method_name)
+        eigenclass.__send__(:define_method, method_name, -> { self[method_name] })
+      end
+    end
+
     # MethodOverridingWriter gives you #key_name= shortcuts for
     # writing to your hash. It allows methods to be overridden by
     # #key_name= shortcuts and aliases those methods with two
@@ -181,6 +195,8 @@ module Hashie
     #   h.__zip # => [[['awesome', 'sauce'], ['zip', 'a-dee-doo-dah']]]
     #
     module MethodOverridingWriter
+      include RedefineMethod
+
       def convert_key(key)
         key.to_s
       end
@@ -205,16 +221,6 @@ module Hashie
       def already_overridden?(name)
         method?("__#{name}")
       end
-
-      def method?(name)
-        methods.map(&:to_s).include?(name)
-      end
-
-      def redefine_method(method_name)
-        eigenclass = class << self; self; end
-        eigenclass.__send__(:alias_method, "__#{method_name}", method_name)
-        eigenclass.__send__(:define_method, method_name, -> { self[method_name] })
-      end
     end
 
     # A macro module that will automatically include MethodReader,
@@ -225,10 +231,34 @@ module Hashie
     # underscores.
     module MethodAccessWithOverride
       def self.included(base)
-        [MethodReader, MethodOverridingWriter, MethodQuery].each do |mod|
+        [MethodReader, MethodOverridingWriter, MethodQuery, MethodOverridingInitializer].each do |mod|
           base.send :include, mod
         end
       end
     end
+
+    # MethodOverridingInitializer allows you to override default hash
+    # methods when passing in values from an existing hash. The overriden
+    # methods are aliased with two leading underscores.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MethodOverridingInitializer
+    #   end
+    #
+    #   h = MyHash.new(zip: 'a-dee-doo-dah')
+    #   h.zip # => 'a-dee-doo-dah'
+    #   h.__zip # => [[['zip', 'a-dee-doo-dah']]]
+    module MethodOverridingInitializer
+      include RedefineMethod
+
+      def initialize(hash = {})
+        hash.each do |key, value|
+          skey = key.to_s
+          redefine_method(skey) if method?(skey)
+          self[skey] = value
+        end
+      end
+    end
   end
 end

data/lib/hashie/extensions/parsers/yaml_erb_parser.rb

@@ -1,5 +1,7 @@
 require 'yaml'
 require 'erb'
+require 'pathname'
+
 module Hashie
   module Extensions
     module Parsers
@@ -12,7 +14,7 @@ module Hashie
         def perform
           template = ERB.new(@content)
           template.filename = @file_path
-          YAML.load template.result
+          YAML.safe_load template.result
         end
 
         def self.perform(file_path)

data/lib/hashie/extensions/strict_key_access.rb

@@ -46,27 +46,26 @@ module Hashie
       end
 
       def default(_ = nil)
-        fail DefaultError
+        raise DefaultError
       end
 
       def default=(_)
-        fail DefaultError
+        raise DefaultError
       end
 
       def default_proc
-        fail DefaultError
+        raise DefaultError
       end
 
       def default_proc=(_)
-        fail DefaultError
+        raise DefaultError
       end
 
       def key(value)
-        result = super
-        if result.nil? && (!key?(result) || self[result] != value)
-          fail KeyError, "key not found with value of #{value.inspect}"
-        else
-          result
+        super.tap do |result|
+          if result.nil? && (!key?(result) || self[result] != value)
+            raise KeyError, "key not found with value of #{value.inspect}"
+          end
         end
       end
     end

data/lib/hashie/extensions/stringify_keys.rb

@@ -44,7 +44,7 @@ module Hashie
         #   test # => {'abc' => 'def'}
         def stringify_keys!(hash)
           hash.extend(Hashie::Extensions::StringifyKeys) unless hash.respond_to?(:stringify_keys!)
-          hash.keys.each do |k|
+          hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
             stringify_keys_recursively!(hash[k])
             hash[k.to_s] = hash.delete(k)
           end

data/lib/hashie/extensions/symbolize_keys.rb

@@ -44,7 +44,7 @@ module Hashie
         #   test # => {:abc => 'def'}
         def symbolize_keys!(hash)
           hash.extend(Hashie::Extensions::SymbolizeKeys) unless hash.respond_to?(:symbolize_keys!)
-          hash.keys.each do |k|
+          hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
             symbolize_keys_recursively!(hash[k])
             hash[k.to_sym] = hash.delete(k)
           end

data/lib/hashie/hash.rb

@@ -17,7 +17,7 @@ module Hashie
     # Converts a mash back to a hash (with stringified or symbolized keys)
     def to_hash(options = {})
       out = {}
-      keys.each do |k|
+      each_key do |k|
         assignment_key = if options[:stringify_keys]
                            k.to_s
                          elsif options[:symbolize_keys]
@@ -28,10 +28,10 @@ module Hashie
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[assignment_key] << (Hash === array_object ? flexibly_convert_to_hash(array_object, options) : array_object)
+            out[assignment_key] << (array_object.is_a?(Hash) ? flexibly_convert_to_hash(array_object, options) : array_object)
           end
         else
-          out[assignment_key] = (Hash === self[k] || self[k].respond_to?(:to_hash)) ? flexibly_convert_to_hash(self[k], options) : self[k]
+          out[assignment_key] = self[k].is_a?(Hash) || self[k].respond_to?(:to_hash) ? flexibly_convert_to_hash(self[k], options) : self[k]
         end
       end
       out
@@ -45,7 +45,7 @@ module Hashie
     private
 
     def flexibly_convert_to_hash(object, options = {})
-      if object.method(:to_hash).arity == 0
+      if object.method(:to_hash).arity.zero?
         object.to_hash
       else
         object.to_hash(options)

data/lib/hashie/mash.rb

@@ -61,7 +61,7 @@ module Hashie
     include Hashie::Extensions::PrettyInspect
     include Hashie::Extensions::RubyVersionCheck
 
-    ALLOWED_SUFFIXES = %w(? ! = _)
+    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.')
@@ -74,7 +74,7 @@ module Hashie
     # @api semipublic
     # @return [void]
     def self.disable_warnings
-      fail CannotDisableMashWarnings if self == Hashie::Mash
+      raise CannotDisableMashWarnings if self == Hashie::Mash
       @disable_warnings = true
     end
 
@@ -99,9 +99,9 @@ module Hashie
       @_mashes ||= new
 
       return @_mashes[path] if @_mashes.key?(path)
-      fail ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
+      raise ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
 
-      parser = options.fetch(:parser) {  Hashie::Extensions::Parsers::YamlErbParser }
+      parser = options.fetch(:parser) { Hashie::Extensions::Parsers::YamlErbParser }
       @_mashes[path] = new(parser.perform(path)).freeze
     end
 
@@ -114,7 +114,7 @@ module Hashie
       end
     end
 
-    alias_method :to_s, :inspect
+    alias to_s inspect
 
     # If you pass in an existing hash, it will
     # convert it to a Mash including recursively
@@ -125,10 +125,10 @@ module Hashie
       default ? super(default) : super(&blk)
     end
 
-    class << self; alias_method :[], :new; end
+    class << self; alias [] new; end
 
-    alias_method :regular_reader, :[]
-    alias_method :regular_writer, :[]=
+    alias regular_reader []
+    alias regular_writer []=
 
     # Retrieves an attribute set in the Mash. Will convert
     # any key passed in to a string before retrieving.
@@ -149,8 +149,8 @@ module Hashie
       regular_writer(key, convert ? convert_value(value) : value)
     end
 
-    alias_method :[], :custom_reader
-    alias_method :[]=, :custom_writer
+    alias [] custom_reader
+    alias []= custom_writer
 
     # This is the bang method reader, it will return a new Mash
     # if there isn't a value already assigned to the key requested.
@@ -183,26 +183,26 @@ module Hashie
       super(*keys.map { |key| convert_key(key) })
     end
 
-    alias_method :regular_dup, :dup
+    alias regular_dup dup
     # Duplicates the current mash as a new mash.
     def dup
-      self.class.new(self, default)
+      self.class.new(self, default, &default_proc)
     end
 
-    alias_method :regular_key?, :key?
+    alias regular_key? key?
     def key?(key)
       super(convert_key(key))
     end
-    alias_method :has_key?, :key?
-    alias_method :include?, :key?
-    alias_method :member?, :key?
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
 
     # Performs a deep_update on a duplicate of the
     # current mash.
     def deep_merge(other_hash, &blk)
       dup.deep_update(other_hash, &blk)
     end
-    alias_method :merge, :deep_merge
+    alias merge deep_merge
 
     # Recursively merges this mash with the passed
     # in hash, merging each hash in the hierarchy.
@@ -213,15 +213,15 @@ module Hashie
           custom_reader(key).deep_update(v, &blk)
         else
           value = convert_value(v, true)
-          value = convert_value(blk.call(key, self[k], value), true) if blk && self.key?(k)
+          value = convert_value(yield(key, self[k], value), true) if blk && key?(k)
           custom_writer(key, value, false)
         end
       end
       self
     end
-    alias_method :deep_merge!, :deep_update
-    alias_method :update, :deep_update
-    alias_method :merge!, :update
+    alias deep_merge! deep_update
+    alias update deep_update
+    alias merge! update
 
     # Assigns a value to a key
     def assign_property(name, value)
@@ -263,7 +263,7 @@ module Hashie
       method_name.end_with?(*ALLOWED_SUFFIXES) && key?(method_name.chop)
     end
 
-    def method_missing(method_name, *args, &blk)
+    def method_missing(method_name, *args, &blk) # rubocop:disable Style/MethodMissing
       return self.[](method_name, &blk) if key?(method_name)
       name, suffix = method_name_and_suffix(method_name)
       case suffix