hashie 3.5.7 → 5.0.0

data/lib/hashie/extensions/dash/property_translation.rb

@@ -35,12 +35,12 @@ module Hashie
       #   end
       #
       #   model = DataModelHash.new(id: '123', created: '2014-04-25 22:35:28')
-      #   model.id.class          #=> Fixnum
+      #   model.id.class          #=> Integer (Fixnum if you are using Ruby 2.3 or lower)
       #   model.created_at.class  #=> Time
       module PropertyTranslation
         def self.included(base)
           base.instance_variable_set(:@transforms, {})
-          base.instance_variable_set(:@translations_hash, {})
+          base.instance_variable_set(:@translations_hash, ::Hash.new { |hash, key| hash[key] = {} })
           base.extend(ClassMethods)
           base.send(:include, InstanceMethods)
         end
@@ -58,7 +58,9 @@ module Hashie
           end
 
           def permitted_input_keys
-            @permitted_input_keys ||= properties.map { |property| inverse_translations.fetch property, property }
+            @permitted_input_keys ||=
+              properties
+              .map { |property| inverse_translations.fetch property, property }
           end
 
           # Defines a property on the Trash. Options are as follows:
@@ -72,23 +74,16 @@ module Hashie
           def property(property_name, options = {})
             super
 
-            if options[:from]
-              if property_name == options[:from]
-                fail ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
-              end
-
-              translations_hash[options[:from]] ||= {}
-              translations_hash[options[:from]][property_name] = options[:with] || options[:transform_with]
+            from = options[:from]
+            converter = options[:with]
+            transformer = options[:transform_with]
 
-              define_method "#{options[:from]}=" do |val|
-                self.class.translations_hash[options[:from]].each do |name, with|
-                  self[name] = with.respond_to?(:call) ? with.call(val) : val
-                end
-              end
-            else
-              if options[:transform_with].respond_to? :call
-                transforms[property_name] = options[:transform_with]
-              end
+            if from
+              fail_self_transformation_error!(property_name) if property_name == from
+              define_translation(from, property_name, converter || transformer)
+              define_writer_for_source_property(from)
+            elsif valid_transformer?(transformer)
+              transforms[property_name] = transformer
             end
           end
 
@@ -105,26 +100,50 @@ module Hashie
           end
 
           def translations
-            @translations ||= {}.tap do |h|
+            @translations ||= {}.tap do |translations|
               translations_hash.each do |(property_name, property_translations)|
-                if property_translations.size > 1
-                  h[property_name] = property_translations.keys
-                else
-                  h[property_name] = property_translations.keys.first
-                end
+                translations[property_name] =
+                  if property_translations.size > 1
+                    property_translations.keys
+                  else
+                    property_translations.keys.first
+                  end
               end
             end
           end
 
           def inverse_translations
-            @inverse_translations ||= {}.tap do |h|
+            @inverse_translations ||= {}.tap do |translations|
               translations_hash.each do |(property_name, property_translations)|
-                property_translations.keys.each do |k|
-                  h[k] = property_name
+                property_translations.each_key do |key|
+                  translations[key] = property_name
                 end
               end
             end
           end
+
+          private
+
+          def define_translation(from, property_name, translator)
+            translations_hash[from][property_name] = translator
+          end
+
+          def define_writer_for_source_property(property)
+            define_method "#{property}=" do |val|
+              __translations[property].each do |name, with|
+                self[name] = with.respond_to?(:call) ? with.call(val) : val
+              end
+            end
+          end
+
+          def fail_self_transformation_error!(property_name)
+            raise ArgumentError,
+                  "Property name (#{property_name}) and :from option must not be the same"
+          end
+
+          def valid_transformer?(transformer)
+            transformer.respond_to? :call
+          end
         end
 
         module InstanceMethods
@@ -134,6 +153,12 @@ module Hashie
           def []=(property, value)
             if self.class.translation_exists? property
               send("#{property}=", value)
+
+              if self.class.transformation_exists? property
+                super property, self.class.transformed_property(property, value)
+              elsif self.class.properties.include?(property)
+                super(property, value)
+              end
             elsif self.class.transformation_exists? property
               super property, self.class.transformed_property(property, value)
             elsif property_exists? property
@@ -158,6 +183,12 @@ module Hashie
             fail_no_property_error!(property) unless self.class.property?(property)
             true
           end
+
+          private
+
+          def __translations
+            self.class.translations_hash
+          end
         end
       end
     end

data/lib/hashie/extensions/deep_fetch.rb

@@ -9,7 +9,8 @@ module Hashie
     #
     #  options.deep_fetch(:user, :non_existent_key) { 'a value' } #=> 'a value'
     #
-    # This is particularly useful for fetching values from deeply nested api responses or params hashes.
+    # This is particularly useful for fetching values from deeply nested api responses
+    #   or params hashes.
     module DeepFetch
       class UndefinedPathError < StandardError; end
 
@@ -19,8 +20,9 @@ module Hashie
             arg = Integer(arg) if obj.is_a? Array
             obj.fetch(arg)
           rescue ArgumentError, IndexError, NoMethodError => e
-            break block.call(arg) if block
-            raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
+            break yield(arg) if block
+            raise UndefinedPathError,
+                  "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
           end
         end
       end

data/lib/hashie/extensions/deep_find.rb

@@ -1,3 +1,4 @@
+require 'hashie/extensions/deep_locate'
 module Hashie
   module Extensions
     module DeepFind
@@ -19,12 +20,17 @@ 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.
       #
-      #  options = {users: [{location: {address: '123 Street'}}, {location: {address: '234 Street'}}]}
+      #  options = {
+      #    users: [
+      #      { location: {address: '123 Street'} },
+      #      { location: {address: '234 Street'}}
+      #    ]
+      #  }
       #  options.extend(Hashie::Extensions::DeepFind)
       #  options.deep_find_all(:address) # => ['123 Street', '234 Street']
       #
@@ -33,14 +39,17 @@ module Hashie
       #  end
       #
       #  my_hash = MyHash.new
-      #  my_hash[:users] = [{location: {address: '123 Street'}}, {location: {address: '234 Street'}}]
+      #  my_hash[:users] = [
+      #    {location: {address: '123 Street'}},
+      #    {location: {address: '234 Street'}}
+      #  ]
       #  my_hash.deep_find_all(:address) # => ['123 Street', '234 Street']
       def deep_find_all(key)
         matches = _deep_find_all(key)
         matches.empty? ? nil : matches
       end
 
-      alias_method :deep_select, :deep_find_all
+      alias deep_select deep_find_all
 
       private
 
@@ -49,7 +58,7 @@ module Hashie
       end
 
       def _deep_find_all(key, object = self, matches = [])
-        deep_locate_result = Hashie::Extensions::DeepLocate.deep_locate(key, object).tap do |result|
+        deep_locate_result = DeepLocate.deep_locate(key, object).tap do |result|
           result.map! { |element| element[key] }
         end
 

data/lib/hashie/extensions/deep_locate.rb

@@ -14,10 +14,12 @@ module Hashie
       #     ...
       #   ]
       #
-      #   Hashie::Extensions::DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
+      #   DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
       #   # => [{:title=>"Ruby for beginners", :pages=>120}, ...]
       def self.deep_locate(comparator, object)
-        comparator = _construct_key_comparator(comparator, object) unless comparator.respond_to?(:call)
+        unless comparator.respond_to?(:call)
+          comparator = _construct_key_comparator(comparator, object)
+        end
 
         _deep_locate(comparator, object)
       end
@@ -53,30 +55,34 @@ module Hashie
       #   # http://ruby-journal.com/becareful-with-space-in-lambda-hash-rocket-syntax-between-ruby-1-dot-9-and-2-dot-0/
       #
       #   books.deep_locate -> (key, value, object) { key == :title && value.include?("Ruby") }
-      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"Ruby for the rest of us", :pages=>576}]
+      #   # => [{:title=>"Ruby for beginners", :pages=>120},
+      #   #     {:title=>"Ruby for the rest of us", :pages=>576}]
       #
       #   books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
-      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"CSS for intermediates", :pages=>80}]
+      #   # => [{:title=>"Ruby for beginners", :pages=>120},
+      #   #     {:title=>"CSS for intermediates", :pages=>80}]
       def deep_locate(comparator)
         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?
+        if object.respond_to?(:indifferent_access?) && object.indifferent_access? ||
+           activesupport_indifferent?(object)
+          search_key = search_key.to_s
+        end
 
         lambda do |non_callable_object|
           ->(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
+
           (object.respond_to?(:values) ? object.values : object.entries).each do |value|
             _deep_locate(comparator, value, result)
           end
@@ -84,6 +90,7 @@ module Hashie
 
         result
       end
+      private_class_method :_deep_locate
 
       def self._match_comparator?(value, comparator, object)
         if object.is_a?(::Hash)
@@ -94,6 +101,13 @@ module Hashie
 
         comparator.call(key, value, object)
       end
+      private_class_method :_match_comparator?
+
+      def self.activesupport_indifferent?(object)
+        defined?(::ActiveSupport::HashWithIndifferentAccess) &&
+          object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
+      end
+      private_class_method :activesupport_indifferent?
     end
   end
 end

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,17 +18,33 @@ 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)
-                    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 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

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,21 +23,26 @@ 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)
           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
 
@@ -68,15 +73,15 @@ module Hashie
       end
 
       def convert_key(key)
-        key.to_s
+        IndifferentAccess.convert_key(key)
       end
 
       # Iterates through the keys and values, reconverting them to
       # their proper indifferent state. Used when IndifferentAccess
       # is injecting itself into member hashes.
       def convert!
-        keys.each do |k|
-          regular_writer convert_key(k), indifferent_value(regular_delete(k))
+        keys.each do |k| # rubocop:disable Performance/HashEachMethods
+          indifferent_writer k, regular_delete(k)
         end
         self
       end
@@ -133,14 +138,42 @@ module Hashie
         self
       end
 
-      def merge(*)
-        super.convert!
+      def merge(*args)
+        result = super
+        return IndifferentAccess.inject!(result) if hash_lacking_indifference?(result)
+        result.convert!
       end
 
       def merge!(*)
         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

@@ -14,14 +14,13 @@ 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
+          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.