activesupport 7.0.8.7 → 7.2.2.1

data/lib/active_support/core_ext/class/subclasses.rb

@@ -1,41 +1,24 @@
 # frozen_string_literal: true
 
-require "active_support/ruby_features"
+require "active_support/descendants_tracker"
 
 class Class
-  if ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
-    # Returns an array with all classes that are < than its receiver.
-    #
-    #   class C; end
-    #   C.descendants # => []
-    #
-    #   class B < C; end
-    #   C.descendants # => [B]
-    #
-    #   class A < B; end
-    #   C.descendants # => [B, A]
-    #
-    #   class D < C; end
-    #   C.descendants # => [B, A, D]
-    def descendants
-      subclasses.concat(subclasses.flat_map(&:descendants))
-    end
-  else
-    def descendants
-      ObjectSpace.each_object(singleton_class).reject do |k|
-        k.singleton_class? || k == self
-      end
-    end
-  end
-
-  # Returns an array with the direct children of +self+.
+  # Returns an array with all classes that are < than its receiver.
+  #
+  #   class C; end
+  #   C.descendants # => []
   #
-  #   class Foo; end
-  #   class Bar < Foo; end
-  #   class Baz < Bar; end
+  #   class B < C; end
+  #   C.descendants # => [B]
   #
-  #   Foo.subclasses # => [Bar]
-  def subclasses
-    descendants.select { |descendant| descendant.superclass == self }
-  end unless ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
+  #   class A < B; end
+  #   C.descendants # => [B, A]
+  #
+  #   class D < C; end
+  #   C.descendants # => [B, A, D]
+  def descendants
+    subclasses.concat(subclasses.flat_map(&:descendants))
+  end
+
+  prepend ActiveSupport::DescendantsTracker::ReloadedClassesFiltering
 end

data/lib/active_support/core_ext/date/blank.rb

@@ -11,4 +11,8 @@ class Date # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

data/lib/active_support/core_ext/date/conversions.rb

@@ -52,11 +52,10 @@ class Date
         strftime(formatter)
       end
     else
-      to_default_s
+      to_s
     end
   end
   alias_method :to_formatted_s, :to_fs
-  alias_method :to_default_s, :to_s
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
   def readable_inspect

data/lib/active_support/core_ext/date.rb

@@ -4,5 +4,4 @@ require "active_support/core_ext/date/acts_like"
 require "active_support/core_ext/date/blank"
 require "active_support/core_ext/date/calculations"
 require "active_support/core_ext/date/conversions"
-require "active_support/core_ext/date/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/date/zones"

data/lib/active_support/core_ext/date_and_time/calculations.rb

@@ -157,6 +157,16 @@ module DateAndTime
     end
     alias :at_end_of_quarter :end_of_quarter
 
+    # Returns the quarter for a date/time.
+    #
+    #   Date.new(2010, 1, 31).quarter  # => 1
+    #   Date.new(2010, 4, 12).quarter  # => 2
+    #   Date.new(2010, 9, 15).quarter  # => 3
+    #   Date.new(2010, 12, 25).quarter # => 4
+    def quarter
+      (month / 3.0).ceil
+    end
+
     # Returns a new date/time at the beginning of the year.
     #
     #   today = Date.today # => Fri, 10 Jul 2015

data/lib/active_support/core_ext/date_and_time/compatibility.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/module/redefine_method"
 
 module DateAndTime
   module Compatibility
@@ -11,7 +12,33 @@ module DateAndTime
     # of the receiver. For backwards compatibility we're overriding
     # this behavior, but new apps will have an initializer that sets
     # this to true, because the new behavior is preferred.
-    mattr_accessor :preserve_timezone, instance_writer: false, default: false
+    mattr_accessor :preserve_timezone, instance_accessor: false, default: nil
+
+    singleton_class.silence_redefinition_of_method :preserve_timezone
+
+    #--
+    # This re-implements the behaviour of the mattr_reader, instead
+    # of prepending on to it, to avoid overcomplicating a module that
+    # is in turn included in several places. This will all go away in
+    # Rails 8.0 anyway.
+    def self.preserve_timezone # :nodoc:
+      if @@preserve_timezone.nil?
+        # Only warn once, the first time the value is used (which should
+        # be the first time #to_time is called).
+        ActiveSupport.deprecator.warn(
+          "to_time will always preserve the timezone offset of the receiver in Rails 8.0. " \
+          "To opt in to the new behavior, set `ActiveSupport.to_time_preserves_timezone = true`."
+        )
+
+        @@preserve_timezone = false
+      end
+
+      @@preserve_timezone
+    end
+
+    def preserve_timezone # :nodoc:
+      Compatibility.preserve_timezone
+    end
 
     # Change the output of <tt>ActiveSupport::TimeZone.utc_to_local</tt>.
     #

data/lib/active_support/core_ext/date_time/blank.rb

@@ -11,4 +11,8 @@ class DateTime # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

data/lib/active_support/core_ext/date_time/conversions.rb

@@ -36,11 +36,11 @@ class DateTime
     if formatter = ::Time::DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
-      to_default_s
+      to_s
     end
   end
   alias_method :to_formatted_s, :to_fs
-  alias_method :to_default_s, :to_s if instance_methods(false).include?(:to_s)
+
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.

data/lib/active_support/core_ext/date_time.rb

@@ -5,4 +5,3 @@ require "active_support/core_ext/date_time/blank"
 require "active_support/core_ext/date_time/calculations"
 require "active_support/core_ext/date_time/compatibility"
 require "active_support/core_ext/date_time/conversions"
-require "active_support/core_ext/date_time/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]

data/lib/active_support/core_ext/digest/uuid.rb

@@ -10,8 +10,6 @@ module Digest
     OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
     X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
 
-    mattr_accessor :use_rfc4122_namespaced_uuids, instance_accessor: false, default: false
-
     # Generates a v5 non-random UUID (Universally Unique IDentifier).
     #
     # Using OpenSSL::Digest::MD5 generates version 3 UUIDs; OpenSSL::Digest::SHA1 generates version 5 UUIDs.
@@ -55,22 +53,21 @@ module Digest
       SecureRandom.uuid
     end
 
+    # Returns the nil UUID. This is a special form of UUID that is specified to
+    # have all 128 bits set to zero.
+    def self.nil_uuid
+      "00000000-0000-0000-0000-000000000000"
+    end
+
     def self.pack_uuid_namespace(namespace)
       if [DNS_NAMESPACE, OID_NAMESPACE, URL_NAMESPACE, X500_NAMESPACE].include?(namespace)
         namespace
-      elsif use_rfc4122_namespaced_uuids == true
+      else
         match_data = namespace.match(/\A(\h{8})-(\h{4})-(\h{4})-(\h{4})-(\h{4})(\h{8})\z/)
 
         raise ArgumentError, "Only UUIDs are valid namespace identifiers" unless match_data.present?
 
         match_data.captures.map { |s| s.to_i(16) }.pack("NnnnnN")
-      else
-        ActiveSupport::Deprecation.warn <<~WARNING.squish
-          Providing a namespace ID that is not one of the constants defined on Digest::UUID generates an incorrect UUID value according to RFC 4122.
-          To enable the correct behavior, set the Rails.application.config.active_support.use_rfc4122_namespaced_uuids configuration option to true.
-        WARNING
-
-        namespace
       end
     end
 

data/lib/active_support/core_ext/enumerable.rb

@@ -25,18 +25,6 @@ module Enumerable
   ActiveSupport::EnumerableCoreExt::SoleItemExpectedError = remove_const(:SoleItemExpectedError)
   singleton_class.prepend(ActiveSupport::EnumerableCoreExt::Constants)
 
-  # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
-  # when we omit an identity.
-
-  # :stopdoc:
-
-  # We can't use Refinements here because Refinements with Module which will be prepended
-  # doesn't work well https://bugs.ruby-lang.org/issues/13446
-  alias :_original_sum_with_required_identity :sum
-  private :_original_sum_with_required_identity
-
-  # :startdoc:
-
   # Calculates the minimum from the extracted elements.
   #
   #   payments = [Payment.new(5), Payment.new(15), Payment.new(10)]
@@ -53,50 +41,6 @@ module Enumerable
     map(&key).max
   end
 
-  # Calculates a sum from the elements.
-  #
-  #   payments.sum { |p| p.price * p.tax_rate }
-  #   payments.sum(&:price)
-  #
-  # The latter is a shortcut for:
-  #
-  #   payments.inject(0) { |sum, p| sum + p.price }
-  #
-  # It can also calculate the sum without the use of a block.
-  #
-  #   [5, 15, 10].sum # => 30
-  #   ['foo', 'bar'].sum('') # => "foobar"
-  #   [[1, 2], [3, 1, 5]].sum([]) # => [1, 2, 3, 1, 5]
-  #
-  # The default sum of an empty list is zero. You can override this default:
-  #
-  #   [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  def sum(identity = nil, &block)
-    if identity
-      _original_sum_with_required_identity(identity, &block)
-    elsif block_given?
-      map(&block).sum
-    else
-      first = true
-
-      reduce(nil) do |sum, value|
-        if first
-          first = false
-
-          unless value.is_a?(Numeric) || value.respond_to?(:coerce)
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Rails 7.0 has deprecated Enumerable.sum in favor of Ruby's native implementation available since 2.4.
-              Sum of non-numeric elements requires an initial argument.
-            MSG
-          end
-          value
-        else
-          sum + value
-        end
-      end || 0
-    end
-  end
-
   # Convert an enumerable to a hash, using the block result as the key and the
   # element as the value.
   #
@@ -289,38 +233,22 @@ end
 class Range # :nodoc:
   # Optimize range sum to use arithmetic progression if a block is not given and
   # we have a range of numeric values.
-  def sum(identity = nil)
+  def sum(initial_value = 0)
     if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
       super
     else
       actual_last = exclude_end? ? (last - 1) : last
       if actual_last >= first
-        sum = identity || 0
+        sum = initial_value || 0
         sum + (actual_last - first + 1) * (actual_last + first) / 2
       else
-        identity || 0
+        initial_value || 0
       end
     end
   end
 end
 
-# Using Refinements here in order not to expose our internal method
-using Module.new {
-  refine Array do
-    alias :orig_sum :sum
-  end
-}
-
 class Array # :nodoc:
-  def sum(init = nil, &block)
-    if init.is_a?(Numeric) || first.is_a?(Numeric)
-      init ||= 0
-      orig_sum(init, &block)
-    else
-      super
-    end
-  end
-
   # Removes all blank elements from the +Array+ in place and returns self.
   # Uses Object#blank? for determining if an item is blank.
   #

data/lib/active_support/core_ext/erb/util.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module ActiveSupport
+  module CoreExt
+    module ERBUtil
+      # HTML escapes strings but doesn't wrap them with an ActiveSupport::SafeBuffer.
+      # This method is not for public consumption! Seriously!
+      def html_escape(s) # :nodoc:
+        s = s.to_s
+        if s.html_safe?
+          s
+        else
+          super(ActiveSupport::Multibyte::Unicode.tidy_bytes(s))
+        end
+      end
+      alias :unwrapped_html_escape :html_escape # :nodoc:
+
+      # A utility method for escaping HTML tag characters.
+      # This method is also aliased as <tt>h</tt>.
+      #
+      #   puts html_escape('is a > 0 & a < 10?')
+      #   # => is a &gt; 0 &amp; a &lt; 10?
+      def html_escape(s) # rubocop:disable Lint/DuplicateMethods
+        unwrapped_html_escape(s).html_safe
+      end
+      alias h html_escape
+    end
+
+    module ERBUtilPrivate
+      include ERBUtil
+      private :unwrapped_html_escape, :html_escape, :h
+    end
+  end
+end
+
+class ERB
+  module Util
+    HTML_ESCAPE = { "&" => "&amp;",  ">" => "&gt;",   "<" => "&lt;", '"' => "&quot;", "'" => "&#39;" }
+    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
+
+    # Following XML requirements: https://www.w3.org/TR/REC-xml/#NT-Name
+    TAG_NAME_START_CODEPOINTS = "@:A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}" \
+                                "\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}" \
+                                "\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}"
+    INVALID_TAG_NAME_START_REGEXP = /[^#{TAG_NAME_START_CODEPOINTS}]/
+    TAG_NAME_FOLLOWING_CODEPOINTS = "#{TAG_NAME_START_CODEPOINTS}\\-.0-9\u{B7}\u{0300}-\u{036F}\u{203F}-\u{2040}"
+    INVALID_TAG_NAME_FOLLOWING_REGEXP = /[^#{TAG_NAME_FOLLOWING_CODEPOINTS}]/
+    SAFE_XML_TAG_NAME_REGEXP = /\A[#{TAG_NAME_START_CODEPOINTS}][#{TAG_NAME_FOLLOWING_CODEPOINTS}]*\z/
+    TAG_NAME_REPLACEMENT_CHAR = "_"
+
+    prepend ActiveSupport::CoreExt::ERBUtilPrivate
+    singleton_class.prepend ActiveSupport::CoreExt::ERBUtil
+
+    # A utility method for escaping HTML without affecting existing escaped entities.
+    #
+    #   html_escape_once('1 < 2 &amp; 3')
+    #   # => "1 &lt; 2 &amp; 3"
+    #
+    #   html_escape_once('&lt;&lt; Accept & Checkout')
+    #   # => "&lt;&lt; Accept &amp; Checkout"
+    def html_escape_once(s)
+      ActiveSupport::Multibyte::Unicode.tidy_bytes(s.to_s).gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE).html_safe
+    end
+
+    module_function :html_escape_once
+
+    # A utility method for escaping HTML entities in JSON strings. Specifically, the
+    # &, > and < characters are replaced with their equivalent unicode escaped form -
+    # \u0026, \u003e, and \u003c. The Unicode sequences \u2028 and \u2029 are also
+    # escaped as they are treated as newline characters in some JavaScript engines.
+    # These sequences have identical meaning as the original characters inside the
+    # context of a JSON string, so assuming the input is a valid and well-formed
+    # JSON value, the output will have equivalent meaning when parsed:
+    #
+    #   json = JSON.generate({ name: "</script><script>alert('PWNED!!!')</script>"})
+    #   # => "{\"name\":\"</script><script>alert('PWNED!!!')</script>\"}"
+    #
+    #   json_escape(json)
+    #   # => "{\"name\":\"\\u003C/script\\u003E\\u003Cscript\\u003Ealert('PWNED!!!')\\u003C/script\\u003E\"}"
+    #
+    #   JSON.parse(json) == JSON.parse(json_escape(json))
+    #   # => true
+    #
+    # The intended use case for this method is to escape JSON strings before including
+    # them inside a script tag to avoid XSS vulnerability:
+    #
+    #   <script>
+    #     var currentUser = <%= raw json_escape(current_user.to_json) %>;
+    #   </script>
+    #
+    # It is necessary to +raw+ the result of +json_escape+, so that quotation marks
+    # don't get converted to <tt>&quot;</tt> entities. +json_escape+ doesn't
+    # automatically flag the result as HTML safe, since the raw value is unsafe to
+    # use inside HTML attributes.
+    #
+    # If your JSON is being used downstream for insertion into the DOM, be aware of
+    # whether or not it is being inserted via <tt>html()</tt>. Most jQuery plugins do this.
+    # If that is the case, be sure to +html_escape+ or +sanitize+ any user-generated
+    # content returned by your JSON.
+    #
+    # If you need to output JSON elsewhere in your HTML, you can just do something
+    # like this, as any unsafe characters (including quotation marks) will be
+    # automatically escaped for you:
+    #
+    #   <div data-user-info="<%= current_user.to_json %>">...</div>
+    #
+    # WARNING: this helper only works with valid JSON. Using this on non-JSON values
+    # will open up serious XSS vulnerabilities. For example, if you replace the
+    # +current_user.to_json+ in the example above with user input instead, the browser
+    # will happily <tt>eval()</tt> that string as JavaScript.
+    #
+    # The escaping performed in this method is identical to those performed in the
+    # Active Support JSON encoder when +ActiveSupport.escape_html_entities_in_json+ is
+    # set to true. Because this transformation is idempotent, this helper can be
+    # applied even if +ActiveSupport.escape_html_entities_in_json+ is already true.
+    #
+    # Therefore, when you are unsure if +ActiveSupport.escape_html_entities_in_json+
+    # is enabled, or if you are unsure where your JSON string originated from, it
+    # is recommended that you always apply this helper (other libraries, such as the
+    # JSON gem, do not provide this kind of protection by default; also some gems
+    # might override +to_json+ to bypass Active Support's encoder).
+    def json_escape(s)
+      result = s.to_s.dup
+      result.gsub!(">", '\u003e')
+      result.gsub!("<", '\u003c')
+      result.gsub!("&", '\u0026')
+      result.gsub!("\u2028", '\u2028')
+      result.gsub!("\u2029", '\u2029')
+      s.html_safe? ? result.html_safe : result
+    end
+
+    module_function :json_escape
+
+    # A utility method for escaping XML names of tags and names of attributes.
+    #
+    #   xml_name_escape('1 < 2 & 3')
+    #   # => "1___2___3"
+    #
+    # It follows the requirements of the specification: https://www.w3.org/TR/REC-xml/#NT-Name
+    def xml_name_escape(name)
+      name = name.to_s
+      return "" if name.blank?
+      return name if name.match?(SAFE_XML_TAG_NAME_REGEXP)
+
+      starting_char = name[0]
+      starting_char.gsub!(INVALID_TAG_NAME_START_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
+
+      return starting_char if name.size == 1
+
+      following_chars = name[1..-1]
+      following_chars.gsub!(INVALID_TAG_NAME_FOLLOWING_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
+
+      starting_char << following_chars
+    end
+    module_function :xml_name_escape
+
+    # Tokenizes a line of ERB.  This is really just for error reporting and
+    # nobody should use it.
+    def self.tokenize(source) # :nodoc:
+      require "strscan"
+      source = StringScanner.new(source.chomp)
+      tokens = []
+
+      start_re = /<%(?:={1,2}|-|\#|%)?/m
+      finish_re = /(?:[-=])?%>/m
+
+      while !source.eos?
+        pos = source.pos
+        source.scan_until(/(?:#{start_re}|#{finish_re})/)
+        raise NotImplementedError if source.matched.nil?
+        len = source.pos - source.matched.bytesize - pos
+
+        case source.matched
+        when start_re
+          tokens << [:TEXT, source.string[pos, len]] if len > 0
+          tokens << [:OPEN, source.matched]
+          if source.scan(/(.*?)(?=#{finish_re}|\z)/m)
+            tokens << [:CODE, source.matched] unless source.matched.empty?
+            tokens << [:CLOSE, source.scan(finish_re)] unless source.eos?
+          else
+            raise NotImplementedError
+          end
+        when finish_re
+          tokens << [:CODE, source.string[pos, len]] if len > 0
+          tokens << [:CLOSE, source.matched]
+        else
+          raise NotImplementedError, source.matched
+        end
+
+        unless source.eos? || source.exist?(start_re) || source.exist?(finish_re)
+          tokens << [:TEXT, source.rest]
+          source.terminate
+        end
+      end
+
+      tokens
+    end
+  end
+end

data/lib/active_support/core_ext/hash/conversions.rb

@@ -68,7 +68,7 @@ class Hash
   #
   # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
   #
-  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
+  # The default XML builder is a fresh instance of +Builder::XmlMarkup+. You can
   # configure your own builder with the <tt>:builder</tt> option. The method also accepts
   # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
   def to_xml(options = {})

data/lib/active_support/core_ext/hash/deep_merge.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
+require "active_support/deep_mergeable"
+
 class Hash
+  include ActiveSupport::DeepMergeable
+
+  ##
+  # :method: deep_merge
+  # :call-seq: deep_merge(other_hash, &block)
+  #
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
   #   h1 = { a: true, b: { c: [1, 2, 3] } }
@@ -15,20 +23,20 @@ class Hash
   #   h2 = { b: 250, c: { c1: 200 } }
   #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
   #   # => { a: 100, b: 450, c: { c1: 300 } }
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
+  #
+  #--
+  # Implemented by ActiveSupport::DeepMergeable#deep_merge.
+
+  ##
+  # :method: deep_merge!
+  # :call-seq: deep_merge!(other_hash, &block)
+  #
+  # Same as #deep_merge, but modifies +self+.
+  #
+  #--
+  # Implemented by ActiveSupport::DeepMergeable#deep_merge!.
 
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash, &block)
-    merge!(other_hash) do |key, this_val, other_val|
-      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-        this_val.deep_merge(other_val, &block)
-      elsif block_given?
-        block.call(key, this_val, other_val)
-      else
-        other_val
-      end
-    end
+  def deep_merge?(other) # :nodoc:
+    other.is_a?(Hash)
   end
 end

data/lib/active_support/core_ext/hash/keys.rb

@@ -8,13 +8,13 @@ class Hash
   #   hash.stringify_keys
   #   # => {"name"=>"Rob", "age"=>"28"}
   def stringify_keys
-    transform_keys(&:to_s)
+    transform_keys { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Destructively converts all keys to strings. Same as
   # +stringify_keys+, but modifies +self+.
   def stringify_keys!
-    transform_keys!(&:to_s)
+    transform_keys! { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -82,14 +82,14 @@ class Hash
   #   hash.deep_stringify_keys
   #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
   def deep_stringify_keys
-    deep_transform_keys(&:to_s)
+    deep_transform_keys { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Destructively converts all keys to strings.
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   def deep_stringify_keys!
-    deep_transform_keys!(&:to_s)
+    deep_transform_keys! { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as

data/lib/active_support/core_ext/module/attr_internal.rb

@@ -19,16 +19,27 @@ class Module
   end
   alias_method :attr_internal, :attr_internal_accessor
 
-  class << self; attr_accessor :attr_internal_naming_format end
-  self.attr_internal_naming_format = "@_%s"
+  class << self
+    attr_reader :attr_internal_naming_format
 
-  private
-    def attr_internal_ivar_name(attr)
-      Module.attr_internal_naming_format % attr
+    def attr_internal_naming_format=(format)
+      if format.start_with?("@")
+        ActiveSupport.deprecator.warn <<~MESSAGE
+          Setting `attr_internal_naming_format` with a `@` prefix is deprecated and will be removed in Rails 8.0.
+
+          You can simply replace #{format.inspect} by #{format.delete_prefix("@").inspect}.
+        MESSAGE
+
+        format = format.delete_prefix("@")
+      end
+      @attr_internal_naming_format = format
     end
+  end
+  self.attr_internal_naming_format = "_%s"
 
+  private
     def attr_internal_define(attr_name, type)
-      internal_name = attr_internal_ivar_name(attr_name).delete_prefix("@")
+      internal_name = Module.attr_internal_naming_format % attr_name
       # use native attr_* methods as they are faster on some Ruby implementations
       public_send("attr_#{type}", internal_name)
       attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer