hashie 5.2.0 → 6.0.0

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

@@ -10,7 +10,7 @@ module Hashie
       #     include Hashie::Extensions::Dash::Coercion
       #     property :count, coerce: Integer
       #   end
-      #   klass.new(count: '3').count # => 3
+      #   klass.new(count: '3')[:count] # => 3
       module Coercion
         # Extends a Dash with the ability to define coercion for properties.
         #
@@ -19,7 +19,7 @@ module Hashie
         #     include Hashie::Extensions::Dash::Coercion
         #     property :count, coerce: Integer
         #   end
-        #   klass.new(count: '3').count # => 3
+        #   klass.new(count: '3')[:count] # => 3
         def self.included(base)
           base.send :include, Hashie::Extensions::Coercion
           base.extend ClassMethods
@@ -32,7 +32,7 @@ module Hashie
         #     include Hashie::Extensions::Dash::Coercion
         #     property :count, coerce: Integer
         #   end
-        #   klass.new(count: '3').count # => 3
+        #   klass.new(count: '3')[:count] # => 3
         module ClassMethods
           # Defines a property on the Dash. Options are the standard
           # `Hashie::Dash#property` options plus:
@@ -44,7 +44,7 @@ module Hashie
           #     include Hashie::Extensions::Dash::Coercion
           #     property :count, coerce: Integer
           #   end
-          #   klass.new(count: '3').count # => 3
+          #   klass.new(count: '3')[:count] # => 3
           def property(property_name, options = {})
             super
             coerce_key property_name, options[:coerce] if options[:coerce]

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

@@ -29,16 +29,16 @@ module Hashie
         #   klass.property?('name') # => true
         #   klass.singleton_class.included_modules.include?(Hashie::Extensions::Dash::IndifferentAccess::ClassMethods) # => true
         def self.maybe_extend(base)
-          return unless requires_class_methods?(base)
+          return unless _requires_class_methods?(base)
 
           base.extend(ClassMethods)
         end
 
-        def self.requires_class_methods?(klass)
+        def self._requires_class_methods?(klass)
           klass <= Hashie::Dash &&
             !klass.singleton_class.included_modules.include?(ClassMethods)
         end
-        private_class_method :requires_class_methods?
+        private_class_method :_requires_class_methods?
 
         # @example Include defaults under string keys in the returned hash
         #   klass = Class.new(Hashie::Dash) do
@@ -82,7 +82,7 @@ module Hashie
           #   klass.property?('name') # => true
           #   klass.property?(:missing) # => false
           def property?(name)
-            targets = if translation_for?(name)
+            targets = if _translation_for?(name)
                         Array(translations.find { |key, _| key.to_s == name.to_s }.last)
                       else
                         [name]
@@ -132,7 +132,7 @@ module Hashie
 
           private
 
-          def translation_for?(name)
+          def _translation_for?(name)
             included_modules.include?(Hashie::Extensions::Dash::PropertyTranslation) &&
               translation_exists?(name)
           end

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

@@ -43,11 +43,11 @@ module Hashie
         def [](property, &block)
           return super unless @lazy_loader
 
-          assert_property_exists!(property)
-          canonical_property = lazy_property(property)
-          load_property(canonical_property) unless key?(property)
+          _assert_property_exists!(property)
+          canonical_property = _lazy_property(property)
+          _load_property(canonical_property) unless key?(property)
           value = super
-          assert_property_required!(canonical_property, value)
+          _assert_property_required!(canonical_property, value)
           value
         end
 
@@ -111,7 +111,7 @@ module Hashie
           @lazy_attributes = attributes || {}
         end
 
-        def assert_required_attributes_set!
+        def _assert_required_attributes_set!
           super unless @lazy_loader
         end
 
@@ -120,13 +120,13 @@ module Hashie
           @lazy_loading = []
         end
 
-        def lazy_property(property)
+        def _lazy_property(property)
           return property if self.class.properties.include?(property)
 
           self.class.properties.find { |key| key.to_s == property.to_s } || property
         end
 
-        def lazy_attribute_key(property)
+        def _lazy_attribute_key(property)
           return property if @lazy_attributes.key?(property)
           return unless respond_to?(:convert_key)
 
@@ -134,7 +134,7 @@ module Hashie
           converted if @lazy_attributes.key?(converted)
         end
 
-        def load_property(property)
+        def _load_property(property)
           raise ArgumentError, "circular lazy loading for property `#{property}`" if @lazy_loading.include?(property)
 
           @lazy_loading << property
@@ -144,12 +144,12 @@ module Hashie
                      else
                        property
                      end
-            attribute = lazy_attribute_key(property)
+            attribute = _lazy_attribute_key(property)
             if attribute
               source = property
               value = @lazy_attributes[attribute]
             else
-              attribute = lazy_attribute_key(source)
+              attribute = _lazy_attribute_key(source)
               value = attribute ? @lazy_attributes[attribute] : @lazy_loader.call(source)
             end
             if value.nil?

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

@@ -72,23 +72,23 @@ module Hashie
 
             return unless (predefined_values = options[:values])
 
-            assert_predefined_values!(predefined_values)
-            set_predefined_values(property_name, predefined_values)
+            _assert_predefined_values!(predefined_values)
+            _set_predefined_values(property_name, predefined_values)
           end
 
           private
 
-          def assert_predefined_values!(predefined_values)
-            return if supported_type?(predefined_values)
+          def _assert_predefined_values!(predefined_values)
+            return if _supported_type?(predefined_values)
 
             raise ArgumentError, %(`values` accepts an `Array` or a `Range`)
           end
 
-          def supported_type?(predefined_values)
+          def _supported_type?(predefined_values)
             [::Array, ::Range].any? { |klass| predefined_values.is_a?(klass) }
           end
 
-          def set_predefined_values(property_name, predefined_values)
+          def _set_predefined_values(property_name, predefined_values)
             @values_for_properties[property_name] = predefined_values
           end
         end
@@ -112,21 +112,21 @@ module Hashie
           def initialize(*)
             super
 
-            assert_property_values!
+            _assert_property_values!
           end
 
           private
 
-          def assert_property_values!
+          def _assert_property_values!
             self.class.values_for_properties.each_key do |property|
-              value = send(property)
+              value = self[property]
 
-              allowed_values = values_for_properties(property)
-              fail_property_value_error!(property, value, allowed_values) if value && !allowed_values.include?(value)
+              allowed_values = self.class.values_for_properties[property]
+              _fail_property_value_error!(property, value, allowed_values) if value && !allowed_values.include?(value)
             end
           end
 
-          def fail_property_value_error!(property, value, allowed_values)
+          def _fail_property_value_error!(property, value, allowed_values)
             expected_values = if allowed_values.is_a?(::Range)
                                 "a value in `#{allowed_values}`"
                               else
@@ -137,10 +137,6 @@ module Hashie
                   "value `#{value.inspect}` is not allowed for `#{property}`; " \
                   "expected #{expected_values}"
           end
-
-          def values_for_properties(property)
-            self.class.values_for_properties[property]
-          end
         end
       end
     end

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

@@ -127,10 +127,10 @@ module Hashie
             transformer = options[:transform_with]
 
             if from
-              fail_self_transformation_error!(property_name) if property_name.to_s == from.to_s
-              define_translation(from, property_name, converter || transformer)
-              define_writer_for_source_property(from)
-            elsif valid_transformer?(transformer)
+              _fail_self_transformation_error!(property_name) if property_name.to_s == from.to_s
+              _define_translation(from, property_name, converter || transformer)
+              _define_writer_for_source_property(from)
+            elsif _valid_transformer?(transformer)
               transforms[property_name] = transformer
             end
           end
@@ -204,24 +204,25 @@ module Hashie
 
           private
 
-          def define_translation(from, property_name, translator)
+          def _define_translation(from, property_name, translator)
             translations_hash[from][property_name] = translator
           end
 
-          def define_writer_for_source_property(property)
+          def _define_writer_for_source_property(property)
+            setter = :"#{property}="
+            return if method_defined?(setter) || private_method_defined?(setter)
+
             define_method "#{property}=" do |val|
-              __translations[property].each do |name, with|
-                self[name] = with.respond_to?(:call) ? with.call(val) : val
-              end
+              _write_translated_property(property, val)
             end
           end
 
-          def fail_self_transformation_error!(property_name)
+          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)
+          def _valid_transformer?(transformer)
             transformer.respond_to? :call
           end
         end
@@ -249,7 +250,7 @@ module Hashie
           #   dash.name # => 'Ada'
           def []=(property, value)
             if self.class.translation_exists? property
-              send("#{property}=", value)
+              _write_translated_property(property, value)
 
               if self.class.transformation_exists? property
                 super(property, self.class.transformed_property(property, value))
@@ -298,13 +299,20 @@ module Hashie
           #   dash.property_exists?(:name) # => true
           #   expect { dash.property_exists?(:missing) }.to raise_error(NoMethodError)
           def property_exists?(property)
-            fail_no_property_error!(property) unless self.class.property?(property)
+            _fail_no_property_error!(property) unless self.class.property?(property)
             true
           end
 
           private
 
-          def __translations
+          def _write_translated_property(property, value)
+            source = _translations.key?(property) ? property : _translations.keys.find { |key| key.to_s == property.to_s }
+            _translations[source].each do |name, with|
+              self[name] = with.respond_to?(:call) ? with.call(value) : value
+            end
+          end
+
+          def _translations
             self.class.translations_hash
           end
         end

data/lib/hashie/extensions/deep_find.rb

@@ -57,18 +57,18 @@ module Hashie
       #  ]
       #  my_hash.deep_find_all(:address) # => ['123 Street', '234 Street']
       #
-      # @example Collect all values, or nil if absent
+      # @example Collect all values, or an empty array if absent
       #   hash = { users: [{ name: 'Ada' }, { name: 'Grace' }] }.extend(Hashie::Extensions::DeepFind)
       #   hash.deep_find_all(:name) # => ['Ada', 'Grace']
-      #   hash.deep_find_all(:email) # => nil
+      #   hash.deep_find_all(:email) # => []
       def deep_find_all(key)
-        matches = _deep_find_all(key)
-        matches.empty? ? nil : matches
+        _deep_find_all(key)
       end
 
       # @example Select every nested value
       #   hash = { users: [{ name: 'Ada' }, { name: 'Grace' }] }.extend(Hashie::Extensions::DeepFind)
       #   hash.deep_select(:name) # => ['Ada', 'Grace']
+      #   hash.deep_select(:email) # => []
       alias deep_select deep_find_all
 
       private

data/lib/hashie/extensions/deep_grep.rb

@@ -23,47 +23,47 @@ module Hashie
       def self.deep_grep(pattern, object)
         raise ArgumentError, 'pattern must be a Regexp' unless pattern.is_a?(Regexp)
 
-        search(pattern, object, [], {}.compare_by_identity)
+        _search(pattern, object, [], {}.compare_by_identity)
       end
 
-      def self.search(pattern, object, results, ancestors)
+      def self._search(pattern, object, results, ancestors)
         return results if ancestors.key?(object) ||
                           !(object.is_a?(::Hash) || object.is_a?(::Array))
 
         ancestors[object] = true
         if object.is_a?(::Hash)
-          search_hash(pattern, object, results, ancestors)
+          _search_hash(pattern, object, results, ancestors)
         else
-          search_array(pattern, object, results, ancestors)
+          _search_array(pattern, object, results, ancestors)
         end
         ancestors.delete(object)
         results
       end
-      private_class_method :search
+      private_class_method :_search
 
-      def self.search_hash(pattern, object, results, ancestors)
-        results << object if object.any? { |key, value| !matches?(pattern, key) && matches?(pattern, value) }
+      def self._search_hash(pattern, object, results, ancestors)
+        results << object if object.any? { |key, value| !_matches?(pattern, key) && _matches?(pattern, value) }
         object.each do |key, value|
-          if matches?(pattern, key)
+          if _matches?(pattern, key)
             results << { key => value }
           else
-            search(pattern, value, results, ancestors)
+            _search(pattern, value, results, ancestors)
           end
         end
       end
-      private_class_method :search_hash
+      private_class_method :_search_hash
 
-      def self.search_array(pattern, object, results, ancestors)
+      def self._search_array(pattern, object, results, ancestors)
         object.each do |value|
-          matches?(pattern, value) ? results << value : search(pattern, value, results, ancestors)
+          _matches?(pattern, value) ? results << value : _search(pattern, value, results, ancestors)
         end
       end
-      private_class_method :search_array
+      private_class_method :_search_array
 
-      def self.matches?(pattern, value)
+      def self._matches?(pattern, value)
         (value.is_a?(String) || value.is_a?(Symbol)) && pattern.match?(value.to_s)
       end
-      private_class_method :matches?
+      private_class_method :_matches?
     end
   end
 end

data/lib/hashie/extensions/deep_locate.rb

@@ -56,7 +56,7 @@ module Hashie
 
       def self._construct_key_comparator(search_key, object)
         if (object.respond_to?(:indifferent_access?) && object.indifferent_access?) ||
-           activesupport_indifferent?(object)
+           _activesupport_indifferent?(object)
           search_key = search_key.to_s
         end
 
@@ -90,11 +90,11 @@ module Hashie
       end
       private_class_method :_match_comparator?
 
-      def self.activesupport_indifferent?(object)
+      def self._activesupport_indifferent?(object)
         defined?(::ActiveSupport::HashWithIndifferentAccess) &&
           object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
       end
-      private_class_method :activesupport_indifferent?
+      private_class_method :_activesupport_indifferent?
     end
   end
 end

data/lib/hashie/extensions/deep_merge.rb

@@ -34,19 +34,21 @@ 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
+      def _deep_dup(value, incoming: false)
+        case value
+        when ::Hash
+          copy = incoming ? value.dup.clear : value.dup
+          value.each do |key, child|
+            copy[key] = _deep_dup(child, incoming: incoming)
+          end
+          copy
+        when ::Array
+          value.dup.map! { |child| _deep_dup(child, incoming: incoming) }
+        when ::String
+          value.dup
+        else
+          value
         end
-
-        copy
       end
 
       def _recursive_merge(hash, other_hash, &block)
@@ -55,11 +57,11 @@ module Hashie
             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)
+              _recursive_merge(v.dup.clear, v, &block)
             elsif hash.key?(k) && block_given?
               yield(k, hash[k], v)
             else
-              v.respond_to?(:deep_dup) ? v.deep_dup : v
+              _deep_dup(v, incoming: true)
             end
         end
         hash

data/lib/hashie/extensions/deep_merge_initializer.rb

@@ -21,18 +21,18 @@ module Hashie
       def initialize(hash = {}, default = nil, &block)
         default.nil? ? super(&block) : super(default)
         hash.each_pair do |key, value|
-          self[key] = deep_merge_initializer_value(value, default, &block)
+          self[key] = _deep_merge_initializer_value(value, default, &block)
         end
       end
 
       private
 
-      def deep_merge_initializer_value(value, default, &block)
+      def _deep_merge_initializer_value(value, default, &block)
         case value
         when ::Hash
           self.class.new(value, default, &block)
         when ::Array
-          value.map { |item| deep_merge_initializer_value(item, default, &block) }
+          value.map { |item| _deep_merge_initializer_value(item, default, &block) }
         else
           value
         end

data/lib/hashie/extensions/indifferent_access.rb

@@ -115,7 +115,7 @@ module Hashie
       #   value = hash.indifferent_value([{ name: 'Ada' }])
       #   value.first['name'] # => 'Ada'
       def indifferent_value(value)
-        if hash_lacking_indifference?(value)
+        if _hash_lacking_indifference?(value)
           IndifferentAccess.inject!(value)
         elsif value.is_a?(::Array)
           value.replace(value.map { |e| indifferent_value(e) })
@@ -140,7 +140,7 @@ module Hashie
       #   hash.indifferent_update(user: { name: 'Ada' })
       #   hash['user']['name'] # => 'Ada'
       def indifferent_update(other_hash)
-        return regular_update(other_hash) if hash_with_indifference?(other_hash)
+        return regular_update(other_hash) if _hash_with_indifference?(other_hash)
 
         other_hash.each_pair do |k, v|
           self[k] = v
@@ -211,7 +211,7 @@ module Hashie
       #   hash.key?(:age) # => false
       def merge(*args)
         result = super
-        return IndifferentAccess.inject!(result) if hash_lacking_indifference?(result)
+        return IndifferentAccess.inject!(result) if _hash_lacking_indifference?(result)
 
         result.convert!
       end
@@ -260,15 +260,15 @@ module Hashie
         super(*string_keys)
       end
 
-      protected
+      private
 
-      def hash_lacking_indifference?(other)
+      def _hash_lacking_indifference?(other)
         other.is_a?(::Hash) &&
           !(other.respond_to?(:indifferent_access?) &&
             other.indifferent_access?)
       end
 
-      def hash_with_indifference?(other)
+      def _hash_with_indifference?(other)
         other.is_a?(::Hash) &&
           other.respond_to?(:indifferent_access?) &&
           other.indifferent_access?

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

@@ -47,7 +47,9 @@ module Hashie
           def initialize
             mod = self
             define_method(:method_missing) do |method_name, *args, &block|
-              key, suffix = method_name_and_suffix(method_name)
+              return super(method_name, *args, &block) if singleton_class.private_method_defined?(method_name) || singleton_class.protected_method_defined?(method_name)
+
+              key, suffix = _method_name_and_suffix(method_name)
               case suffix
               when '='
                 mod.define_writer(key, method_name)

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

@@ -35,7 +35,7 @@ module Hashie
         def convert_key(key)
           return key if regular_key?(key)
 
-          converted_key = __convert(key)
+          converted_key = _convert(key)
           converted_key && regular_key?(converted_key) ? converted_key : key
         end
 
@@ -44,7 +44,7 @@ module Hashie
         #
         # @param [Object, String, Symbol] key the key to convert.
         # @return [Object, String, Symbol] the converted key.
-        def __convert(key)
+        def _convert(key)
           case key
           when Symbol then key.name
           when String then key.to_sym

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

@@ -52,7 +52,7 @@ module Hashie
         #
         # @api private
         # @private
-        def log_collision?(method_key)
+        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))

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

@@ -93,12 +93,12 @@ module Hashie
           #   klass.new(name: 'Ada', age: 37).age # => 37
           def initialize(*args, &block)
             super
-            assert_required_keys_set!
+            _assert_required_keys_set!
           end
 
           private
 
-          def assert_required_keys_set!
+          def _assert_required_keys_set!
             missing_keys = self.class.required_keys.select { |key| self[key].nil? }
             return if missing_keys.empty?
 

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

@@ -44,7 +44,7 @@ module Hashie
         def method_missing(method_name, *args, &blk)
           return super if key?(method_name)
 
-          name, suffix = method_name_and_suffix(method_name)
+          name, suffix = _method_name_and_suffix(method_name)
           raise KeyError, "key not found: `#{name}`" if !key?(name) && !suffix
 
           super
@@ -54,7 +54,7 @@ module Hashie
         def respond_to_missing?(method_name, *args)
           return true if key?(method_name)
 
-          _, suffix = method_name_and_suffix(method_name)
+          _, suffix = _method_name_and_suffix(method_name)
           return false unless suffix
 
           super