hashie 2.1.2 → 4.1.0

data/lib/hashie/extensions/deep_merge.rb

@@ -2,28 +2,51 @@ module Hashie
   module Extensions
     module DeepMerge
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
-      def deep_merge(other_hash)
-        dup.deep_merge!(other_hash)
+      def deep_merge(other_hash, &block)
+        copy = _deep_dup(self)
+        copy.extend(Hashie::Extensions::DeepMerge) unless copy.respond_to?(:deep_merge!)
+        copy.deep_merge!(other_hash, &block)
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       # Modifies the receiver in place.
-      def deep_merge!(other_hash)
-        _recursive_merge(self, other_hash)
+      def deep_merge!(other_hash, &block)
+        return self unless other_hash.is_a?(::Hash)
+        _recursive_merge(self, other_hash, &block)
         self
       end
 
       private
 
-      def _recursive_merge(hash, other_hash)
-        if other_hash.is_a?(::Hash) && hash.is_a?(::Hash)
-          other_hash.each do |k, v|
-            hash[k] = hash.key?(k) ? _recursive_merge(hash[k], v) : v
-          end
-          hash
-        else
-          other_hash
+      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
+              v.respond_to?(:deep_dup) ? v.deep_dup : v
+            end
         end
+        hash
       end
     end
   end

data/lib/hashie/extensions/ignore_undeclared.rb

@@ -5,7 +5,7 @@ module Hashie
     # raising an error. This is useful when using a Trash to
     # capture a subset of a larger hash.
     #
-    # Note that attempting to retrieve an undeclared property
+    # Note that attempting to retrieve or set an undeclared property
     # will still raise a NoMethodError, even if a value for
     # that property was provided at initialization.
     #
@@ -30,11 +30,17 @@ module Hashie
     #   p.email      # => NoMethodError
     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|
-          if self.class.property?(att) || (self.class.respond_to?(:translations) && self.class.translations.include?(att.to_sym))
-            self[att] = value
-          end
-        end if attributes
+          next unless klass.property?(att) || (translations && translations.include?(att))
+          self[att] = value
+        end
+      end
+
+      def property_exists?(property)
+        self.class.property?(property)
       end
     end
   end

data/lib/hashie/extensions/indifferent_access.rb

@@ -24,16 +24,18 @@ module Hashie
     #
     module IndifferentAccess
       def self.included(base)
+        Hashie::Extensions::Dash::IndifferentAccess.maybe_extend(base)
+
         base.class_eval do
-          alias_method :regular_writer, :[]=
+          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|
-            alias_method "regular_#{m}", 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
 
@@ -71,17 +73,17 @@ module Hashie
       # their proper indifferent state. Used when IndifferentAccess
       # is injecting itself into member hashes.
       def convert!
-        keys.each do |k|
-          regular_writer convert_key(k), convert_value(regular_delete(k))
+        keys.each do |k| # rubocop:disable Performance/HashEachMethods
+          regular_writer convert_key(k), indifferent_value(regular_delete(k))
         end
         self
       end
 
-      def convert_value(value)
+      def indifferent_value(value)
         if hash_lacking_indifference?(value)
-          IndifferentAccess.inject(value.dup)
+          IndifferentAccess.inject!(value)
         elsif value.is_a?(::Array)
-          value.dup.replace(value.map { |e| convert_value(e) })
+          value.replace(value.map { |e| indifferent_value(e) })
         else
           value
         end
@@ -100,11 +102,11 @@ module Hashie
       end
 
       def indifferent_writer(key, value)
-        regular_writer convert_key(key), convert_value(value)
+        regular_writer convert_key(key), indifferent_value(value)
       end
 
-      def indifferent_fetch(key, *args)
-        regular_fetch convert_key(key), *args
+      def indifferent_fetch(key, *args, &block)
+        regular_fetch convert_key(key), *args, &block
       end
 
       def indifferent_delete(key)
@@ -129,18 +131,28 @@ module Hashie
         self
       end
 
+      def merge(*args)
+        result = super
+        IndifferentAccess.inject!(result) if hash_lacking_indifference?(result)
+        result.convert!
+      end
+
+      def merge!(*)
+        super.convert!
+      end
+
       protected
 
       def hash_lacking_indifference?(other)
         other.is_a?(::Hash) &&
-        !(other.respond_to?(:indifferent_access?) &&
-          other.indifferent_access?)
+          !(other.respond_to?(:indifferent_access?) &&
+            other.indifferent_access?)
       end
 
       def hash_with_indifference?(other)
         other.is_a?(::Hash) &&
-        other.respond_to?(:indifferent_access?) &&
-        other.indifferent_access?
+          other.respond_to?(:indifferent_access?) &&
+          other.indifferent_access?
       end
     end
   end

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/key_conversion.rb

@@ -1,87 +1,5 @@
 module Hashie
   module Extensions
-    module StringifyKeys
-      # Convert all keys in the hash to strings.
-      #
-      # @example
-      #   test = {:abc => 'def'}
-      #   test.stringify_keys!
-      #   test # => {'abc' => 'def'}
-      def stringify_keys!
-        keys.each do |k|
-          stringify_keys_recursively!(self[k])
-          self[k.to_s] = delete(k)
-        end
-        self
-      end
-
-      # Return a new hash with all keys converted
-      # to strings.
-      def stringify_keys
-        dup.stringify_keys!
-      end
-
-      protected
-
-      # Stringify all keys recursively within nested
-      # hashes and arrays.
-      def stringify_keys_recursively!(object)
-        if self.class === object
-          object.stringify_keys!
-        elsif ::Array === object
-          object.each do |i|
-            stringify_keys_recursively!(i)
-          end
-          object
-        elsif object.respond_to?(:stringify_keys!)
-          object.stringify_keys!
-        else
-          object
-        end
-      end
-    end
-
-    module SymbolizeKeys
-      # Convert all keys in the hash to symbols.
-      #
-      # @example
-      #   test = {'abc' => 'def'}
-      #   test.symbolize_keys!
-      #   test # => {:abc => 'def'}
-      def symbolize_keys!
-        keys.each do |k|
-          symbolize_keys_recursively!(self[k])
-          self[k.to_sym] = delete(k)
-        end
-        self
-      end
-
-      # Return a new hash with all keys converted
-      # to symbols.
-      def symbolize_keys
-        dup.symbolize_keys!
-      end
-
-      protected
-
-      # Symbolize all keys recursively within nested
-      # hashes and arrays.
-      def symbolize_keys_recursively!(object)
-        if self.class === object
-          object.symbolize_keys!
-        elsif ::Array === object
-          object.each do |i|
-            symbolize_keys_recursively!(i)
-          end
-          object
-        elsif object.respond_to?(:symbolize_keys!)
-          object.symbolize_keys!
-        else
-          object
-        end
-      end
-    end
-
     module KeyConversion
       def self.included(base)
         base.send :include, SymbolizeKeys

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

@@ -0,0 +1,53 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Overrides the indifferent access of a Mash to keep keys in the
+      # original format given to the Mash.
+      #
+      # @example
+      #   class KeepingMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::KeepOriginalKeys
+      #   end
+      #
+      #   mash = KeepingMash.new(:symbol_key => :symbol, 'string_key' => 'string')
+      #   mash.to_hash  #=> { :symbol_key => :symbol, 'string_key' => 'string' }
+      #   mash['string_key'] == mash[:string_key]  #=> true
+      #   mash[:symbol_key] == mash['symbol_key']  #=> true
+      module KeepOriginalKeys
+        def self.included(descendant)
+          error_message = "#{descendant} is not a kind of Hashie::Mash"
+          raise ArgumentError, error_message 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.
+        # @return [Object] the value assigned to the key.
+        def convert_key(key)
+          if regular_key?(key)
+            key
+          elsif (converted_key = __convert(key)) && regular_key?(converted_key)
+            converted_key
+          else
+            key
+          end
+        end
+
+        # Converts symbol/string keys to their alternative formats, but leaves
+        # other keys alone.
+        #
+        # @param [Object, String, Symbol] key the key to convert.
+        # @return [Object, String, Symbol] the converted key.
+        def __convert(key)
+          case key
+          when Symbol then key.to_s
+          when String then key.to_sym
+          else key
+          end
+        end
+      end
+    end
+  end
+end