hashie 5.2.0 → 6.0.0

data/lib/hashie/extensions/method_access.rb

@@ -132,7 +132,7 @@ module Hashie
       #   hash.respond_to?(:name?) # => true
       #   hash.respond_to?(:missing?) # => false
       def respond_to_missing?(name, include_private = false)
-        if query_method?(name) && indifferent_key?(key_from_query_method(name))
+        if _query_method?(name) && _indifferent_key?(_key_from_query_method(name))
           true
         else
           super
@@ -146,9 +146,9 @@ module Hashie
       def method_missing(name, *args)
         return super unless args.empty?
 
-        if query_method?(name)
-          key = key_from_query_method(name)
-          if indifferent_key?(key)
+        if _query_method?(name)
+          key = _key_from_query_method(name)
+          if _indifferent_key?(key)
             !!(self[key] || self[key.to_sym])
           else
             super
@@ -160,16 +160,16 @@ module Hashie
 
       private
 
-      def indifferent_key?(name)
+      def _indifferent_key?(name)
         name = name.to_s
         key?(name) || key?(name.to_sym)
       end
 
-      def key_from_query_method(query_method)
+      def _key_from_query_method(query_method)
         query_method.to_s[0..-2]
       end
 
-      def query_method?(name)
+      def _query_method?(name)
         name.to_s.end_with?('?')
       end
     end
@@ -204,13 +204,13 @@ module Hashie
     #   hash.size # => 'large'
     #   hash.__size # => 1
     module RedefineMethod
-      protected
+      private
 
-      def method?(name)
+      def _method?(name)
         methods.map(&:to_s).include?(name)
       end
 
-      def redefine_method(method_name)
+      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] })
@@ -262,7 +262,7 @@ module Hashie
       def method_missing(name, *args)
         if args.size == 1 && name.to_s =~ /(.*)=$/
           key = Regexp.last_match[1]
-          redefine_method(key) if method?(key) && !already_overridden?(key)
+          _redefine_method(key) if _method?(key) && !_already_overridden?(key)
           return self[convert_key(key)] = args.first
         end
 
@@ -279,10 +279,10 @@ module Hashie
         super
       end
 
-      protected
+      private
 
-      def already_overridden?(name)
-        method?("__#{name}")
+      def _already_overridden?(name)
+        _method?("__#{name}")
       end
     end
 
@@ -344,7 +344,7 @@ module Hashie
 
         hash.each do |key, value|
           skey = key.to_s
-          redefine_method(skey) if method?(skey)
+          _redefine_method(skey) if _method?(skey)
           self[skey] = value
         end
       end

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

@@ -33,7 +33,7 @@ module Hashie
         def perform
           template = ERB.new(@content)
           template.filename = @file_path
-          yaml_safe_load(template.result)
+          _yaml_safe_load(template.result)
         end
       end
     end

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

@@ -48,7 +48,7 @@ module Hashie
         #     file.close!
         #   end
         def perform
-          yaml_safe_load(@content)
+          _yaml_safe_load(@content)
         end
 
         # @example Load YAML in one step
@@ -67,7 +67,7 @@ module Hashie
 
         private
 
-        def yaml_safe_load(content)
+        def _yaml_safe_load(content)
           YAML.safe_load(
             content,
             permitted_classes: @options.fetch(:permitted_classes) { [] },

data/lib/hashie/extensions/persistable.rb

@@ -98,7 +98,7 @@ module Hashie
         raise ArgumentError, 'a persistence path is required' if path.nil?
 
         path = File.expand_path(File.path(path))
-        yaml = Psych.dump(persistable_data(self))
+        yaml = Psych.dump(_persistable_data(self))
         Tempfile.create(['.hashie-', '.yaml'], File.dirname(path)) do |file|
           file.chmod(File.stat(path).mode & 0o777) if File.exist?(path)
           file.write(yaml)
@@ -112,7 +112,7 @@ module Hashie
 
       private
 
-      def persistable_data(value, ancestors = [])
+      def _persistable_data(value, ancestors = [])
         raise ArgumentError, 'cannot persist cyclic data' if ancestors.any? { |ancestor| ancestor.equal?(value) }
 
         case value
@@ -120,10 +120,10 @@ module Hashie
           value.each_with_object({}) do |(key, child), data|
             raise TypeError, 'persisted hash keys must be strings or symbols' unless key.is_a?(String) || key.is_a?(Symbol)
 
-            data[persistable_data(key)] = persistable_data(child, ancestors + [value])
+            data[_persistable_data(key)] = _persistable_data(child, ancestors + [value])
           end
         when ::Array
-          value.map { |child| persistable_data(child, ancestors + [value]) }
+          value.map { |child| _persistable_data(child, ancestors + [value]) }
         when String
           value.dup
         when Symbol, Integer, Float, TrueClass, FalseClass, NilClass

data/lib/hashie/extensions/ruby_version.rb

@@ -32,7 +32,7 @@ module Hashie
       #   version = Hashie::Extensions::RubyVersion.new('3.2.0.rc1')
       #   version.segments # => [3, 2, 0, 'rc', 1]
       def initialize(version)
-        @segments = split_to_segments(version)
+        @segments = _split_to_segments(version)
       end
 
       # @example Ignore trailing zeros and order prereleases before releases
@@ -67,7 +67,7 @@ module Hashie
 
       private
 
-      def split_to_segments(version)
+      def _split_to_segments(version)
         version.scan(/[0-9]+|[a-z]+/i).map do |segment|
           /^\d+$/ =~ segment ? segment.to_i : segment
         end.freeze

data/lib/hashie/extensions/stringify_keys.rb

@@ -68,16 +68,17 @@ module Hashie
         # Stringify all keys recursively within nested
         # hashes and arrays.
         # @api private
-        def stringify_keys_recursively!(object)
+        def _stringify_keys_recursively!(object)
           case object
           when ::Array
             object.each do |i|
-              stringify_keys_recursively!(i)
+              _stringify_keys_recursively!(i)
             end
           when ::Hash
             stringify_keys!(object)
           end
         end
+        private :_stringify_keys_recursively!
 
         # Converts all keys in a hash recursively to strings, in place.
         #
@@ -92,7 +93,7 @@ module Hashie
         def stringify_keys!(hash)
           hash.extend(Hashie::Extensions::StringifyKeys) unless hash.respond_to?(:stringify_keys!)
           hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
-            stringify_keys_recursively!(hash[k])
+            _stringify_keys_recursively!(hash[k])
             hash[k.to_s] = hash.delete(k)
           end
           hash

data/lib/hashie/extensions/symbolize_keys.rb

@@ -69,16 +69,17 @@ module Hashie
         # Symbolize all keys recursively within nested
         # hashes and arrays.
         # @api private
-        def symbolize_keys_recursively!(object)
+        def _symbolize_keys_recursively!(object)
           case object
           when ::Array
             object.each do |i|
-              symbolize_keys_recursively!(i)
+              _symbolize_keys_recursively!(i)
             end
           when ::Hash
             symbolize_keys!(object)
           end
         end
+        private :_symbolize_keys_recursively!
 
         # Converts keys in a hash recursively to symbols, in place.
         #
@@ -93,7 +94,7 @@ module Hashie
         def symbolize_keys!(hash)
           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])
+            _symbolize_keys_recursively!(hash[k])
             hash[convert_key(k)] = hash.delete(k)
           end
           hash

data/lib/hashie/hash.rb

@@ -41,10 +41,10 @@ module Hashie
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[assignment_key] << maybe_convert_to_hash(array_object, options)
+            out[assignment_key] << _maybe_convert_to_hash(array_object, options)
           end
         else
-          out[assignment_key] = maybe_convert_to_hash(self[k], options)
+          out[assignment_key] = _maybe_convert_to_hash(self[k], options)
         end
       end
       out
@@ -61,13 +61,13 @@ module Hashie
 
     private
 
-    def maybe_convert_to_hash(object, options)
+    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)
+      _flexibly_convert_to_hash(object, options)
     end
 
-    def flexibly_convert_to_hash(object, options = {})
+    def _flexibly_convert_to_hash(object, options = {})
       if object.method(:to_hash).arity.zero?
         object.to_hash
       else

data/lib/hashie/mash.rb

@@ -72,8 +72,8 @@ module Hashie
 
     ALLOWED_SUFFIXES = %w[? ! = _].freeze
 
-    # Loads a YAML file. The default parser evaluates ERB templates, so only
-    # use this default with trusted files. Pass YamlParser to avoid ERB.
+    # Loads YAML without evaluating ERB. Pass YamlErbParser explicitly to
+    # evaluate templates from trusted files.
     #
     # @example Load and cache a frozen configuration from a YAML file
     #   require 'tempfile'
@@ -96,7 +96,7 @@ module Hashie
       raise ArgumentError, "file not found: `#{path}`" unless File.file?(path)
 
       options = options.dup
-      parser = options.delete(:parser) { Hashie::Extensions::Parsers::YamlErbParser }
+      parser = options.delete(:parser) { Hashie::Extensions::Parsers::YamlParser }
       @_mashes[path] = new(parser.perform(path, options)).freeze
     end
 
@@ -128,8 +128,8 @@ module Hashie
 
     # If you pass in an existing hash, it will
     # convert it to a Mash including recursively
-    # descending into arrays and hashes, converting
-    # them as well.
+    # descending into arrays and plain hashes, converting
+    # them as well. Nested custom Hash subclasses retain their identity.
     #
     # @example Recursively convert hashes nested in arrays
     #   mash = Hashie::Mash.new(users: [{ name: 'Ada' }])
@@ -202,7 +202,7 @@ module Hashie
     #   mash.keys # => ['user']
     #   mash.user.name # => 'Ada'
     def custom_writer(key, value, convert = true) # :nodoc:
-      log_built_in_message(key) if key.respond_to?(:to_sym) && log_collision?(key.to_sym)
+      _log_built_in_message(key) if key.respond_to?(:to_sym) && _log_collision?(key.to_sym)
       regular_writer(convert_key(key), convert ? convert_value(value) : value)
     end
 
@@ -410,7 +410,7 @@ module Hashie
     def _deep_update(other_hash, &blk)
       other_hash.each_pair do |k, v|
         key = convert_key(k)
-        if v.is_a?(::Hash) && key?(key) && regular_reader(key).is_a?(Mash)
+        if (v.instance_of?(::Hash) || v.is_a?(Mash)) && key?(key) && regular_reader(key).is_a?(Mash)
           custom_reader(key).deep_update(v, &blk)
         else
           value = convert_value(v, true)
@@ -473,7 +473,7 @@ module Hashie
     def respond_to_missing?(method_name, *args)
       return true if key?(method_name)
 
-      suffix = method_suffix(method_name)
+      suffix = _method_suffix(method_name)
       if suffix
         true
       else
@@ -500,7 +500,7 @@ module Hashie
     def method_missing(method_name, *args, &blk)
       return self.[](method_name, &blk) if key?(method_name)
 
-      name, suffix = method_name_and_suffix(method_name)
+      name, suffix = _method_name_and_suffix(method_name)
       case suffix
       when '='
         assign_property(name, args.first)
@@ -581,9 +581,9 @@ module Hashie
       self.class.new(super(*string_keys))
     end
 
-    protected
+    private
 
-    def method_name_and_suffix(method_name)
+    def _method_name_and_suffix(method_name)
       method_name = method_name.to_s
       if method_name.end_with?(*ALLOWED_SUFFIXES)
         [method_name[0..-2], method_name[-1]]
@@ -592,11 +592,13 @@ module Hashie
       end
     end
 
-    def method_suffix(method_name)
+    def _method_suffix(method_name)
       method_name = method_name.to_s
       method_name[-1] if method_name.end_with?(*ALLOWED_SUFFIXES)
     end
 
+    protected
+
     # Symbol#name returns the symbol's interned frozen string, where
     # Symbol#to_s allocates a new one on every read and write.
     def convert_key(key) # :nodoc:
@@ -609,9 +611,11 @@ module Hashie
       case val
       when self.class
         val.dup
-      when Hash
+      when Mash
         duping ? val.dup : val
       when ::Hash
+        return val unless val.instance_of?(::Hash)
+
         val = val.dup if duping
         self.class.new(val)
       when ::Array
@@ -623,7 +627,7 @@ module Hashie
 
     private
 
-    def log_built_in_message(method_key)
+    def _log_built_in_message(method_key)
       return if self.class.disable_warnings?(method_key)
 
       method_information = Hashie::Utils.method_information(method(method_key))
@@ -636,11 +640,11 @@ module Hashie
       )
     end
 
-    def log_collision?(method_key)
+    def _log_collision?(method_key)
       return false unless method_key.is_a?(String) || method_key.is_a?(Symbol)
       return false unless respond_to?(method_key)
 
-      _, suffix = method_name_and_suffix(method_key)
+      _, suffix = _method_name_and_suffix(method_key)
 
       (!suffix || suffix == '=') &&
         !self.class.disable_warnings?(method_key) &&

data/lib/hashie/rash.rb

@@ -145,7 +145,7 @@ module Hashie
 
       case query
       when String
-        optimize_if_necessary!
+        _optimize_if_necessary!
 
         # see if any of the regexps match the string
         @regexes.each do |regex|
@@ -193,7 +193,7 @@ module Hashie
 
     private
 
-    def optimize_if_necessary!
+    def _optimize_if_necessary!
       return unless (@lookups += 1) >= @optimize_every
 
       @regexes = @regexes.sort_by { |regex| -@regex_counts[regex] }

data/lib/hashie/utils.rb

@@ -37,7 +37,7 @@ module Hashie
     #   Hashie::Utils.safe_dup(:name) # => :name
     def self.safe_dup(value)
       case value
-      when Complex, FalseClass, NilClass, Rational, Method, Symbol, TrueClass, *integer_classes
+      when Complex, FalseClass, NilClass, Rational, Method, Symbol, TrueClass, *_integer_classes
         value
       else
         value.dup
@@ -48,8 +48,9 @@ module Hashie
     #
     # @api private
     # @return [Array<Class>]
-    def self.integer_classes
+    def self._integer_classes
       @integer_classes ||= [Integer]
     end
+    private_class_method :_integer_classes
   end
 end

data/lib/hashie/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashie
-  VERSION = '5.2.0'
+  VERSION = '6.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashie
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-23 00:00:00.000000000 Z
+date: 2026-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Your friendly neighborhood hash library.