activesupport 6.1.0 → 7.0.4.1

data/lib/active_support/core_ext/range.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/range/conversions"
+require "active_support/core_ext/range/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/range/compare_range"
-require "active_support/core_ext/range/include_time_with_zone"
 require "active_support/core_ext/range/overlaps"
 require "active_support/core_ext/range/each"

data/lib/active_support/core_ext/securerandom.rb

@@ -12,7 +12,7 @@ module SecureRandom
   #
   # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
   #
-  # The result may contain alphanumeric characters except 0, O, I and l.
+  # The result may contain alphanumeric characters except 0, O, I, and l.
   #
   #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
   #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"

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

@@ -5,10 +5,10 @@ require "active_support/core_ext/time/calculations"
 
 class String
   # Converts a string to a Time value.
-  # The +form+ can be either :utc or :local (default :local).
+  # The +form+ can be either +:utc+ or +:local+ (default +:local+).
   #
   # The time is parsed using Time.parse method.
-  # If +form+ is :local, then the time is in the system timezone.
+  # If +form+ is +:local+, then the time is in the system timezone.
   # If the date part is missing then the current date is used and if
   # the time part is missing then it is assumed to be 00:00:00.
   #

data/lib/active_support/core_ext/string/filters.rb

@@ -106,7 +106,7 @@ class String
       self.class.new.tap do |cut|
         cut_at = truncate_at - omission.bytesize
 
-        scan(/\X/) do |grapheme|
+        each_grapheme_cluster do |grapheme|
           if cut.bytesize + grapheme.bytesize <= cut_at
             cut << grapheme
           else

data/lib/active_support/core_ext/string/inflections.rb

@@ -260,7 +260,7 @@ class String
   #   'author_id'.humanize                          # => "Author"
   #   'author_id'.humanize(capitalize: false)       # => "author"
   #   '_id'.humanize                                # => "Id"
-  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
+  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author id"
   #
   # See ActiveSupport::Inflector.humanize.
   def humanize(capitalize: true, keep_id_suffix: false)

data/lib/active_support/core_ext/string/inquiry.rb

@@ -4,7 +4,7 @@ require "active_support/string_inquirer"
 require "active_support/environment_inquirer"
 
 class String
-  # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,
+  # Wraps the current string in the ActiveSupport::StringInquirer class,
   # which gives you a prettier way to test for equality.
   #
   #   env = 'production'.inquiry

data/lib/active_support/core_ext/string/output_safety.rb

@@ -11,6 +11,14 @@ class ERB
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
     JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u
 
+    # Following XML requirements: https://www.w3.org/TR/REC-xml/#NT-Name
+    TAG_NAME_START_REGEXP_SET = "@: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}"
+    TAG_NAME_START_REGEXP = /[^#{TAG_NAME_START_REGEXP_SET}]/
+    TAG_NAME_FOLLOWING_REGEXP = /[^#{TAG_NAME_START_REGEXP_SET}\-.0-9\u{B7}\u{0300}-\u{036F}\u{203F}-\u{2040}]/
+    TAG_NAME_REPLACEMENT_CHAR = "_"
+
     # A utility method for escaping HTML tag characters.
     # This method is also aliased as <tt>h</tt>.
     #
@@ -84,7 +92,7 @@ class ERB
     # 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 +html()+. Most jQuery plugins do this.
+    # 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.
     #
@@ -97,7 +105,7 @@ class ERB
     # 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 eval() that string as JavaScript.
+    # 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
@@ -115,6 +123,26 @@ class ERB
     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?
+
+      starting_char = name[0].gsub(TAG_NAME_START_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
+
+      return starting_char if name.size == 1
+
+      following_chars = name[1..-1].gsub(TAG_NAME_FOLLOWING_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
+
+      starting_char + following_chars
+    end
+    module_function :xml_name_escape
   end
 end
 
@@ -130,7 +158,7 @@ class Numeric
   end
 end
 
-module ActiveSupport #:nodoc:
+module ActiveSupport # :nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
       capitalize chomp chop delete delete_prefix delete_suffix
@@ -143,7 +171,7 @@ module ActiveSupport #:nodoc:
     alias_method :original_concat, :concat
     private :original_concat
 
-    # Raised when <tt>ActiveSupport::SafeBuffer#safe_concat</tt> is called on unsafe buffers.
+    # Raised when ActiveSupport::SafeBuffer#safe_concat is called on unsafe buffers.
     class SafeConcatError < StandardError
       def initialize
         super "Could not concatenate to the buffer because it is not html safe."
@@ -184,27 +212,30 @@ module ActiveSupport #:nodoc:
     end
 
     def concat(value)
-      super(html_escape_interpolated_argument(value))
+      unless value.nil?
+        super(implicit_html_escape_interpolated_argument(value))
+      end
+      self
     end
     alias << concat
 
     def insert(index, value)
-      super(index, html_escape_interpolated_argument(value))
+      super(index, implicit_html_escape_interpolated_argument(value))
     end
 
     def prepend(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
     end
 
     def replace(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
     end
 
     def []=(*args)
       if args.length == 3
-        super(args[0], args[1], html_escape_interpolated_argument(args[2]))
+        super(args[0], args[1], implicit_html_escape_interpolated_argument(args[2]))
       else
-        super(args[0], html_escape_interpolated_argument(args[1]))
+        super(args[0], implicit_html_escape_interpolated_argument(args[1]))
       end
     end
 
@@ -222,9 +253,9 @@ module ActiveSupport #:nodoc:
     def %(args)
       case args
       when Hash
-        escaped_args = args.transform_values { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = args.transform_values { |arg| explicit_html_escape_interpolated_argument(arg) }
       else
-        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = Array(args).map { |arg| explicit_html_escape_interpolated_argument(arg) }
       end
 
       self.class.new(super(escaped_args))
@@ -262,39 +293,60 @@ module ActiveSupport #:nodoc:
     end
 
     UNSAFE_STRING_METHODS_WITH_BACKREF.each do |unsafe_method|
-      if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
-            if block                                      #   if block
-              to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
-            end                                           #   end
-          end                                             # end
-
-          def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
-            @html_safe = false                            #   @html_safe = false
-            if block                                      #   if block
-              super(*args) { |*params|                    #     super(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              super                                       #     super
-            end                                           #   end
-          end                                             # end
-        EOT
-      end
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
+          if block                                      #   if block
+            to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
+          end                                           #   end
+        end                                             # end
+
+        def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
+          @html_safe = false                            #   @html_safe = false
+          if block                                      #   if block
+            super(*args) { |*params|                    #     super(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            super                                       #     super
+          end                                           #   end
+        end                                             # end
+      EOT
     end
 
     private
-      def html_escape_interpolated_argument(arg)
+      def explicit_html_escape_interpolated_argument(arg)
         (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
       end
 
+      def implicit_html_escape_interpolated_argument(arg)
+        if !html_safe? || arg.html_safe?
+          arg
+        else
+          arg_string = begin
+            arg.to_str
+          rescue NoMethodError => error
+            if error.name == :to_str
+              str = arg.to_s
+              ActiveSupport::Deprecation.warn <<~MSG.squish
+                Implicit conversion of #{arg.class} into String by ActiveSupport::SafeBuffer
+                is deprecated and will be removed in Rails 7.1.
+                You must explicitly cast it to a String.
+              MSG
+              str
+            else
+              raise
+            end
+          end
+          CGI.escapeHTML(arg_string)
+        end
+      end
+
       def set_block_back_references(block, match_data)
         block.binding.eval("proc { |m| $~ = m }").call(match_data)
       rescue ArgumentError

data/lib/active_support/core_ext/symbol/starts_ends_with.rb

@@ -1,14 +1,6 @@
 # frozen_string_literal: true
 
 class Symbol
-  def start_with?(*prefixes)
-    to_s.start_with?(*prefixes)
-  end unless method_defined?(:start_with?)
-
-  def end_with?(*suffixes)
-    to_s.end_with?(*suffixes)
-  end unless method_defined?(:end_with?)
-
   alias :starts_with? :start_with?
   alias :ends_with? :end_with?
 end

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

@@ -42,8 +42,8 @@ class Time
 
     # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
     # instances can be used when called with a single argument
-    def at_with_coercion(*args)
-      return at_without_coercion(*args) if args.size != 1
+    def at_with_coercion(*args, **kwargs)
+      return at_without_coercion(*args, **kwargs) if args.size != 1 || !kwargs.empty?
 
       # Time.at can be called with a time or numerical value
       time_or_number = args.first
@@ -126,8 +126,8 @@ class Time
   # Returns a new Time where one or more of the elements have been changed according
   # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
   # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
-  # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
-  # and minute is passed, then sec, usec and nsec is set to 0. The +options+ parameter
+  # the hour is passed, then minute, sec, usec, and nsec is set to 0. If the hour
+  # and minute is passed, then sec, usec, and nsec is set to 0. The +options+ parameter
   # takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>,
   # <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>,
   # <tt>:offset</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
@@ -159,6 +159,8 @@ class Time
       ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, new_offset)
     elsif utc?
       ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
+    elsif zone&.respond_to?(:utc_to_local)
+      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
     elsif zone
       ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec)
     else
@@ -275,7 +277,7 @@ class Time
   end
   alias :at_end_of_minute :end_of_minute
 
-  def plus_with_duration(other) #:nodoc:
+  def plus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
     else
@@ -285,7 +287,7 @@ class Time
   alias_method :plus_without_duration, :+
   alias_method :+, :plus_with_duration
 
-  def minus_with_duration(other) #:nodoc:
+  def minus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.until(self)
     else
@@ -303,7 +305,7 @@ class Time
     other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
   end
   alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion
+  alias_method :-, :minus_with_coercion # rubocop:disable Lint/DuplicateMethods
 
   # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
   # can be chronologically compared with a Time

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "time"
 require "active_support/inflector/methods"
 require "active_support/values/time_zone"
 
@@ -26,22 +27,22 @@ class Time
 
   # Converts to a formatted string. See DATE_FORMATS for built-in formats.
   #
-  # This method is aliased to <tt>to_s</tt>.
+  # This method is aliased to <tt>to_formatted_s</tt>.
   #
   #   time = Time.now                    # => 2007-01-18 06:10:17 -06:00
   #
+  #   time.to_fs(:time)                  # => "06:10"
   #   time.to_formatted_s(:time)         # => "06:10"
-  #   time.to_s(:time)                   # => "06:10"
   #
-  #   time.to_formatted_s(:db)           # => "2007-01-18 06:10:17"
-  #   time.to_formatted_s(:number)       # => "20070118061017"
-  #   time.to_formatted_s(:short)        # => "18 Jan 06:10"
-  #   time.to_formatted_s(:long)         # => "January 18, 2007 06:10"
-  #   time.to_formatted_s(:long_ordinal) # => "January 18th, 2007 06:10"
-  #   time.to_formatted_s(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
-  #   time.to_formatted_s(:iso8601)      # => "2007-01-18T06:10:17-06:00"
+  #   time.to_fs(:db)           # => "2007-01-18 06:10:17"
+  #   time.to_fs(:number)       # => "20070118061017"
+  #   time.to_fs(:short)        # => "18 Jan 06:10"
+  #   time.to_fs(:long)         # => "January 18, 2007 06:10"
+  #   time.to_fs(:long_ordinal) # => "January 18th, 2007 06:10"
+  #   time.to_fs(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_fs(:iso8601)      # => "2007-01-18T06:10:17-06:00"
   #
-  # == Adding your own time formats to +to_formatted_s+
+  # == Adding your own time formats to +to_fs+
   # You can add your own formats to the Time::DATE_FORMATS hash.
   # Use the format name as the hash key and either a strftime string
   # or Proc instance that takes a time argument as the value.
@@ -49,15 +50,16 @@ class Time
   #   # config/initializers/time_formats.rb
   #   Time::DATE_FORMATS[:month_and_year] = '%B %Y'
   #   Time::DATE_FORMATS[:short_ordinal]  = ->(time) { time.strftime("%B #{time.day.ordinalize}") }
-  def to_formatted_s(format = :default)
+  def to_fs(format = :default)
     if formatter = DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
+      # Change to `to_s` when deprecation is gone. Also deprecate `to_default_s`.
       to_default_s
     end
   end
+  alias_method :to_formatted_s, :to_fs
   alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_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/time/deprecated_conversions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "time"
+
+class Time
+  NOT_SET = Object.new # :nodoc:
+  def to_s(format = NOT_SET) # :nodoc:
+    if formatter = DATE_FORMATS[format]
+      ActiveSupport::Deprecation.warn(
+        "Time#to_s(#{format.inspect}) is deprecated. Please use Time#to_fs(#{format.inspect}) instead."
+      )
+      formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+    elsif format == NOT_SET
+      to_default_s
+    else
+      ActiveSupport::Deprecation.warn(
+        "Time#to_s(#{format.inspect}) is deprecated. Please use Time#to_fs(#{format.inspect}) instead."
+      )
+      to_default_s
+    end
+  end
+end

data/lib/active_support/core_ext/time/zones.rb

@@ -12,7 +12,7 @@ class Time
     # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
     # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
     def zone
-      Thread.current[:time_zone] || zone_default
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] || zone_default
     end
 
     # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread.
@@ -21,8 +21,8 @@ class Time
     #
     # * A Rails TimeZone object.
     # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
-    # * A TZInfo::Timezone object.
-    # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
+    # * A <tt>TZInfo::Timezone</tt> object.
+    # * An identifier for a <tt>TZInfo::Timezone</tt> object (e.g., "America/New_York").
     #
     # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
     # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
@@ -39,7 +39,7 @@ class Time
     #     end
     #   end
     def zone=(time_zone)
-      Thread.current[:time_zone] = find_zone!(time_zone)
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] = find_zone!(time_zone)
     end
 
     # Allows override of <tt>Time.zone</tt> locally inside supplied block;
@@ -55,7 +55,7 @@ class Time
     #     end
     #   end
     #
-    # NOTE: This won't affect any <tt>ActiveSupport::TimeWithZone</tt>
+    # NOTE: This won't affect any ActiveSupport::TimeWithZone
     # objects that have already been created, e.g. any model timestamp
     # attributes that have been read before the block will remain in
     # the application's default timezone.
@@ -80,24 +80,9 @@ class Time
     #   Time.find_zone! false              # => false
     #   Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
     def find_zone!(time_zone)
-      if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone)
-        time_zone
-      else
-        # Look up the timezone based on the identifier (unless we've been
-        # passed a TZInfo::Timezone)
-        unless time_zone.respond_to?(:period_for_local)
-          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
-        end
+      return time_zone unless time_zone
 
-        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-        if time_zone.is_a?(ActiveSupport::TimeZone)
-          time_zone
-        else
-          ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
-        end
-      end
-    rescue TZInfo::InvalidTimezoneIdentifier
-      raise ArgumentError, "Invalid Timezone: #{time_zone}"
+      ActiveSupport::TimeZone[time_zone] || raise(ArgumentError, "Invalid Timezone: #{time_zone}")
     end
 
     # Returns a TimeZone instance matching the time zone provided.

data/lib/active_support/core_ext/time.rb

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

data/lib/active_support/core_ext/uri.rb

@@ -1,29 +1,5 @@
 # frozen_string_literal: true
 
-require "uri"
-
-if RUBY_VERSION < "2.6.0"
-  require "active_support/core_ext/module/redefine_method"
-  URI::Parser.class_eval do
-    silence_redefinition_of_method :unescape
-    def unescape(str, escaped = /%[a-fA-F\d]{2}/)
-      # TODO: Are we actually sure that ASCII == UTF-8?
-      # YK: My initial experiments say yes, but let's be sure please
-      enc = str.encoding
-      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-      str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
-    end
-  end
-end
-
-module URI
-  class << self
-    def parser
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        URI.parser is deprecated and will be removed in Rails 6.2.
-        Use `URI::DEFAULT_PARSER` instead.
-      MSG
-      URI::DEFAULT_PARSER
-    end
-  end
-end
+ActiveSupport::Deprecation.warn(<<-MSG.squish)
+  `active_support/core_ext/uri` is deprecated and will be removed in Rails 7.1.
+MSG

data/lib/active_support/core_ext.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).each do |path|
+Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
+  next if path.end_with?("core_ext/uri.rb")
   require path
 end

data/lib/active_support/current_attributes.rb

@@ -2,6 +2,7 @@
 
 require "active_support/callbacks"
 require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
   # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
@@ -97,25 +98,37 @@ module ActiveSupport
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
       def attribute(*names)
-        generated_attribute_methods.module_eval do
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
-            define_method(name) do
-              attributes[name.to_sym]
+            owner.define_cached_method(name, namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}" <<
+                "attributes[:#{name}]" <<
+                "end"
             end
-
-            define_method("#{name}=") do |attribute|
-              attributes[name.to_sym] = attribute
+            owner.define_cached_method("#{name}=", namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "attributes[:#{name}] = value" <<
+                "end"
             end
           end
         end
 
-        names.each do |name|
-          define_singleton_method(name) do
-            instance.public_send(name)
-          end
-
-          define_singleton_method("#{name}=") do |attribute|
-            instance.public_send("#{name}=", attribute)
+        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
+          names.each do |name|
+            owner.define_cached_method(name, namespace: :current_attributes_delegation) do |batch|
+              batch <<
+                "def #{name}" <<
+                "instance.#{name}" <<
+                "end"
+            end
+            owner.define_cached_method("#{name}=", namespace: :current_attributes_delegation) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "instance.#{name} = value" <<
+                "end"
+            end
           end
         end
       end
@@ -148,7 +161,7 @@ module ActiveSupport
         end
 
         def current_instances
-          Thread.current[:current_attributes_instances] ||= {}
+          IsolatedExecutionState[:current_attributes_instances] ||= {}
         end
 
         def current_instances_key
@@ -163,6 +176,11 @@ module ActiveSupport
 
           send(name, *args, &block)
         end
+        ruby2_keywords(:method_missing)
+
+        def respond_to_missing?(name, _)
+          super || instance.respond_to?(name)
+        end
     end
 
     attr_accessor :attributes