hashie 3.6.0 → 5.0.0

data/lib/hashie/extensions/deep_merge.rb

@@ -3,7 +3,7 @@ module Hashie
     module DeepMerge
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       def deep_merge(other_hash, &block)
-        copy = dup
+        copy = _deep_dup(self)
         copy.extend(Hashie::Extensions::DeepMerge) unless copy.respond_to?(:deep_merge!)
         copy.deep_merge!(other_hash, &block)
       end
@@ -18,11 +18,28 @@ module Hashie
 
       private
 
+      def _deep_dup(hash)
+        copy = hash.dup
+
+        copy.each do |key, value|
+          copy[key] =
+            if value.is_a?(::Hash)
+              _deep_dup(value)
+            else
+              Hashie::Utils.safe_dup(value)
+            end
+        end
+
+        copy
+      end
+
       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)
+            elsif v.is_a?(::Hash)
+              _recursive_merge({}, v, &block)
             elsif hash.key?(k) && block_given?
               yield(k, hash[k], v)
             else

data/lib/hashie/extensions/ignore_undeclared.rb

@@ -31,12 +31,11 @@ module Hashie
     module IgnoreUndeclared
       def initialize_attributes(attributes)
         return unless attributes
+
         klass = self.class
-        translations = klass.respond_to?(:translations) && klass.translations
-        attributes.each_pair do |att, value|
-          next unless klass.property?(att) || (translations && translations.include?(att))
-          self[att] = value
-        end
+        translations = klass.respond_to?(:translations) && klass.translations || []
+
+        super(attributes.select { |attr, _| klass.property?(attr) || translations.include?(attr) })
       end
 
       def property_exists?(property)

data/lib/hashie/extensions/indifferent_access.rb

@@ -23,10 +23,15 @@ module Hashie
     #   h['baz'] # => 'blip'
     #
     module IndifferentAccess
+      include Hashie::Extensions::RubyVersionCheck
+
+      # @api private
+      def self.convert_key(key)
+        key.to_s
+      end
+
       def self.included(base)
-        Hashie::Extensions::Dash::IndifferentAccess::ClassMethods.tap do |extension|
-          base.extend(extension) if base <= Hashie::Dash && !base.singleton_class.included_modules.include?(extension)
-        end
+        Hashie::Extensions::Dash::IndifferentAccess.maybe_extend(base)
 
         base.class_eval do
           alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
@@ -68,7 +73,7 @@ module Hashie
       end
 
       def convert_key(key)
-        key.to_s
+        IndifferentAccess.convert_key(key)
       end
 
       # Iterates through the keys and values, reconverting them to
@@ -76,7 +81,7 @@ module Hashie
       # is injecting itself into member hashes.
       def convert!
         keys.each do |k| # rubocop:disable Performance/HashEachMethods
-          regular_writer convert_key(k), indifferent_value(regular_delete(k))
+          indifferent_writer k, regular_delete(k)
         end
         self
       end
@@ -135,7 +140,7 @@ module Hashie
 
       def merge(*args)
         result = super
-        IndifferentAccess.inject!(result) if hash_lacking_indifference?(result)
+        return IndifferentAccess.inject!(result) if hash_lacking_indifference?(result)
         result.convert!
       end
 
@@ -143,6 +148,32 @@ module Hashie
         super.convert!
       end
 
+      def to_hash
+        {}.tap do |result|
+          each_pair { |key, value| result[key] = value }
+
+          if default_proc
+            result.default_proc = default_proc
+          else
+            result.default = default
+          end
+        end
+      end
+
+      with_minimum_ruby('2.5.0') do
+        def slice(*keys)
+          string_keys = keys.map { |key| convert_key(key) }
+          super(*string_keys)
+        end
+      end
+
+      with_minimum_ruby('3.0.0') do
+        def except(*keys)
+          string_keys = keys.map { |key| convert_key(key) }
+          super(*string_keys)
+        end
+      end
+
       protected
 
       def hash_lacking_indifference?(other)

data/lib/hashie/extensions/key_conflict_warning.rb

@@ -0,0 +1,55 @@
+module Hashie
+  module Extensions
+    module KeyConflictWarning
+      class CannotDisableMashWarnings < StandardError
+        def initialize
+          super(
+            'You cannot disable warnings on the base Mash class. ' \
+            'Please subclass the Mash and disable it in the subclass.'
+          )
+        end
+      end
+
+      # Disable the logging of warnings based on keys conflicting keys/methods
+      #
+      # @api semipublic
+      # @return [void]
+      def disable_warnings(*method_keys)
+        raise CannotDisableMashWarnings if self == Hashie::Mash
+        if method_keys.any?
+          disabled_warnings.concat(method_keys).tap(&:flatten!).uniq!
+        else
+          disabled_warnings.clear
+        end
+
+        @disable_warnings = true
+      end
+
+      # Checks whether this class disables warnings for conflicting keys/methods
+      #
+      # @api semipublic
+      # @return [Boolean]
+      def disable_warnings?(method_key = nil)
+        return disabled_warnings.include?(method_key) if disabled_warnings.any? && method_key
+        @disable_warnings ||= false
+      end
+
+      # Returns an array of methods that this class disables warnings for.
+      #
+      # @api semipublic
+      # @return [Boolean]
+      def disabled_warnings
+        @_disabled_warnings ||= []
+      end
+
+      # Inheritance hook that sets class configuration when inherited.
+      #
+      # @api semipublic
+      # @return [void]
+      def inherited(subclass)
+        super
+        subclass.disable_warnings(disabled_warnings) if disable_warnings?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Hashie
+  module Extensions
+    module Mash
+      module DefineAccessors
+        def self.included(klass)
+          klass.class_eval do
+            mod = Ext.new
+            include mod
+          end
+        end
+
+        def self.extended(obj)
+          included(obj.singleton_class)
+        end
+
+        class Ext < Module
+          def initialize
+            mod = self
+            define_method(:method_missing) do |method_name, *args, &block|
+              key, suffix = method_name_and_suffix(method_name)
+              case suffix
+              when '='.freeze
+                mod.define_writer(key, method_name)
+              when '?'.freeze
+                mod.define_predicate(key, method_name)
+              when '!'.freeze
+                mod.define_initializing_reader(key, method_name)
+              when '_'.freeze
+                mod.define_underbang_reader(key, method_name)
+              else
+                mod.define_reader(key, method_name)
+              end
+              send(method_name, *args, &block)
+            end
+          end
+
+          def define_reader(key, method_name)
+            define_method(method_name) do |&block|
+              if key? method_name
+                self.[](method_name, &block)
+              else
+                self.[](key, &block)
+              end
+            end
+          end
+
+          def define_writer(key, method_name)
+            define_method(method_name) do |value = nil|
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                assign_property(key, value)
+              end
+            end
+          end
+
+          def define_predicate(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                !!self[key]
+              end
+            end
+          end
+
+          def define_initializing_reader(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                initializing_reader(key)
+              end
+            end
+          end
+
+          def define_underbang_reader(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](key, &proc)
+              else
+                underbang_reader(key)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,7 +15,8 @@ module Hashie
       #   mash[:symbol_key] == mash['symbol_key']  #=> true
       module KeepOriginalKeys
         def self.included(descendant)
-          raise ArgumentError, "#{descendant} is not a kind of Hashie::Mash" unless descendant <= Hashie::Mash
+          error_message = "#{descendant} is not a kind of Hashie::Mash"
+          raise ArgumentError, error_message unless descendant <= Hashie::Mash
         end
 
         private

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

@@ -0,0 +1,61 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Allow a Mash to properly respond to everything
+      #
+      # By default, Mashes only say they respond to methods for keys that exist
+      # in their key set or any of the affix methods (e.g. setter, underbang,
+      # etc.). This causes issues when you try to use them within a
+      # SimpleDelegator or bind to a method for a key that is unset.
+      #
+      # This extension allows a Mash to properly respond to `respond_to?` and
+      # `method` for keys that have not yet been set. This enables full
+      # compatibility with SimpleDelegator and thunk-oriented programming.
+      #
+      # There is a trade-off with this extension: it will run slower than a
+      # regular Mash; insertions and initializations with keys run approximately
+      # 20% slower and cost approximately 19KB of memory per class that you
+      # make permissive.
+      #
+      # @api public
+      # @example Make a new, permissively responding Mash subclass
+      #   class PermissiveMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::PermissiveRespondTo
+      #   end
+      #
+      #   mash = PermissiveMash.new(a: 1)
+      #   mash.respond_to? :b  #=> true
+      module PermissiveRespondTo
+        # The Ruby hook for behavior when including the module
+        #
+        # @api private
+        # @private
+        # @return void
+        def self.included(base)
+          base.instance_variable_set :@_method_cache, base.instance_methods
+          base.define_singleton_method(:method_cache) { @_method_cache }
+        end
+
+        # The Ruby hook for determining what messages a class might respond to
+        #
+        # @api private
+        # @private
+        def respond_to_missing?(_method_name, _include_private = false)
+          true
+        end
+
+        private
+
+        # Override the Mash logging behavior to account for permissiveness
+        #
+        # @api private
+        # @private
+        def log_collision?(method_key)
+          self.class.method_cache.include?(method_key) &&
+            !self.class.disable_warnings?(method_key) &&
+            !(regular_key?(method_key) || regular_key?(method_key.to_s))
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -5,7 +5,7 @@ module Hashie
       #
       # @example
       #   class LazyResponse < Hashie::Mash
-      #     include Hashie::Extensions::Mash::SymbolizedKeys
+      #     include Hashie::Extensions::Mash::SymbolizeKeys
       #   end
       #
       #   response = LazyResponse.new("id" => 123, "name" => "Rey").to_h
@@ -24,13 +24,13 @@ module Hashie
 
         private
 
-        # Converts a key to a symbol
+        # Converts a key to a symbol, if possible
         #
         # @api private
-        # @param [String, Symbol] key the key to convert to a symbol
-        # @return [void]
+        # @param [<K>] key the key to attempt convert to a symbol
+        # @return [Symbol, K]
         def convert_key(key)
-          key.to_sym
+          key.respond_to?(:to_sym) ? key.to_sym : key
         end
       end
     end

data/lib/hashie/extensions/method_access.rb

@@ -73,7 +73,9 @@ module Hashie
       end
 
       def method_missing(name, *args)
-        return self[convert_key(Regexp.last_match[1])] = args.first if args.size == 1 && name.to_s =~ /(.*)=$/
+        if args.size == 1 && name.to_s =~ /(.*)=$/
+          return self[convert_key(Regexp.last_match[1])] = args.first
+        end
 
         super
       end
@@ -231,7 +233,8 @@ module Hashie
     # underscores.
     module MethodAccessWithOverride
       def self.included(base)
-        [MethodReader, MethodOverridingWriter, MethodQuery, MethodOverridingInitializer].each do |mod|
+        [MethodReader, MethodOverridingWriter,
+         MethodQuery, MethodOverridingInitializer].each do |mod|
           base.send :include, mod
         end
       end

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

@@ -6,19 +6,41 @@ module Hashie
   module Extensions
     module Parsers
       class YamlErbParser
-        def initialize(file_path)
+        def initialize(file_path, options = {})
           @content = File.read(file_path)
           @file_path = file_path.is_a?(Pathname) ? file_path.to_s : file_path
+          @options = options
         end
 
         def perform
           template = ERB.new(@content)
           template.filename = @file_path
-          YAML.safe_load template.result
+          permitted_classes = @options.fetch(:permitted_classes) { [] }
+          permitted_symbols = @options.fetch(:permitted_symbols) { [] }
+          aliases = @options.fetch(:aliases) { true }
+
+          yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+        end
+
+        def self.perform(file_path, options = {})
+          new(file_path, options).perform
         end
 
-        def self.perform(file_path)
-          new(file_path).perform
+        private
+
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0') # Ruby 2.6+
+          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+            YAML.safe_load(
+              template.result,
+              permitted_classes: permitted_classes,
+              permitted_symbols: permitted_symbols,
+              aliases: aliases
+            )
+          end
+        else
+          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+            YAML.safe_load(template.result, permitted_classes, permitted_symbols, aliases)
+          end
         end
       end
     end

data/lib/hashie/extensions/ruby_version_check.rb

@@ -9,7 +9,11 @@ module Hashie
 
       module ClassMethods
         def with_minimum_ruby(version)
-          yield if RubyVersion.new(RUBY_VERSION) >= RubyVersion.new(version)
+          yield if with_minimum_ruby?(version)
+        end
+
+        def with_minimum_ruby?(version)
+          RubyVersion.new(RUBY_VERSION) >= RubyVersion.new(version)
         end
       end
     end

data/lib/hashie/extensions/strict_key_access.rb

@@ -1,6 +1,7 @@
 module Hashie
   module Extensions
-    # SRP: This extension will fail an error whenever a key is accessed that does not exist in the hash.
+    # SRP: This extension will fail an error whenever a key is accessed
+    #   that does not exist in the hash.
     #
     #   EXAMPLE:
     #
@@ -15,12 +16,15 @@ module Hashie
     #     >> hash[:cow]
     #       KeyError: key not found: :cow
     #
-    # NOTE: For googlers coming from Python to Ruby, this extension makes a Hash behave more like a "Dictionary".
+    # NOTE: For googlers coming from Python to Ruby, this extension makes a Hash
+    # behave more like a "Dictionary".
     #
     module StrictKeyAccess
       class DefaultError < StandardError
-        def initialize(msg = 'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense', *args)
-          super
+        def initialize
+          super('Setting or using a default with Hashie::Extensions::StrictKeyAccess'\
+                ' does not make sense'
+          )
         end
       end
 

data/lib/hashie/extensions/symbolize_keys.rb

@@ -46,7 +46,7 @@ module Hashie
           hash.extend(Hashie::Extensions::SymbolizeKeys) unless hash.respond_to?(:symbolize_keys!)
           hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
             symbolize_keys_recursively!(hash[k])
-            hash[k.to_sym] = hash.delete(k)
+            hash[convert_key(k)] = hash.delete(k)
           end
           hash
         end
@@ -61,6 +61,17 @@ module Hashie
             symbolize_keys!(new_hash)
           end
         end
+
+        private
+
+        # Converts a key to a symbol, if possible
+        #
+        # @api private
+        # @param [<K>] key the key to attempt convert to a symbol
+        # @return [Symbol, K]
+        def convert_key(key)
+          key.respond_to?(:to_sym) ? key.to_sym : key
+        end
       end
 
       class << self

data/lib/hashie/hash.rb

@@ -18,20 +18,21 @@ module Hashie
     def to_hash(options = {})
       out = {}
       each_key do |k|
-        assignment_key = if options[:stringify_keys]
-                           k.to_s
-                         elsif options[:symbolize_keys]
-                           k.to_s.to_sym
-                         else
-                           k
-                         end
+        assignment_key =
+          if options[:stringify_keys]
+            k.to_s
+          elsif options[:symbolize_keys] && k.respond_to?(:to_sym)
+            k.to_sym
+          else
+            k
+          end
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[assignment_key] << (array_object.is_a?(Hash) ? flexibly_convert_to_hash(array_object, options) : array_object)
+            out[assignment_key] << maybe_convert_to_hash(array_object, options)
           end
         else
-          out[assignment_key] = self[k].is_a?(Hash) || self[k].respond_to?(:to_hash) ? flexibly_convert_to_hash(self[k], options) : self[k]
+          out[assignment_key] = maybe_convert_to_hash(self[k], options)
         end
       end
       out
@@ -44,6 +45,12 @@ module Hashie
 
     private
 
+    def maybe_convert_to_hash(object, options)
+      return object unless object.is_a?(Hash) || object.respond_to?(:to_hash)
+
+      flexibly_convert_to_hash(object, options)
+    end
+
     def flexibly_convert_to_hash(object, options = {})
       if object.method(:to_hash).arity.zero?
         object.to_hash