activesupport 7.0.8.4 → 7.1.0.beta1

data/lib/active_support/core_ext/object/with.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Object
+  # Set and restore public attributes around a block.
+  #
+  #   client.timeout # => 5
+  #   client.with(timeout: 1) do
+  #     client.timeout # => 1
+  #   end
+  #   client.timeout # => 5
+  #
+  # This method is a shorthand for the common begin/ensure pattern:
+  #
+  #   old_value = object.attribute
+  #   begin
+  #     object.attribute = new_value
+  #     # do things
+  #   ensure
+  #     object.attribute = old_value
+  #   end
+  #
+  # It can be used on any object as long as both the reader and writer methods
+  # are public.
+  def with(**attributes)
+    old_values = {}
+    begin
+      attributes.each do |key, value|
+        old_values[key] = public_send(key)
+        public_send("#{key}=", value)
+      end
+      yield
+    ensure
+      old_values.each do |key, old_value|
+        public_send("#{key}=", old_value)
+      end
+    end
+  end
+end
+
+# #with isn't usable on immediates, so we might as well undefine the
+# method in common immediate classes to avoid potential confusion.
+[NilClass, TrueClass, FalseClass, Integer, Float, Symbol].each do |klass|
+  klass.undef_method(:with)
+end

data/lib/active_support/core_ext/object/with_options.rb

@@ -5,9 +5,9 @@ require "active_support/option_merger"
 class Object
   # An elegant way to factor duplication out of options passed to a series of
   # method calls. Each method called in the block, with the block variable as
-  # the receiver, will have its options merged with the default +options+ hash
-  # provided. Each method called on the block variable must take an options
-  # hash as its final argument.
+  # the receiver, will have its options merged with the default +options+
+  # <tt>Hash</tt> or <tt>Hash</tt>-like object provided. Each method called on
+  # the block variable must take an options hash as its final argument.
   #
   # Without <tt>with_options</tt>, this code contains duplication:
   #

data/lib/active_support/core_ext/object.rb

@@ -13,4 +13,5 @@ require "active_support/core_ext/object/instance_variables"
 require "active_support/core_ext/object/json"
 require "active_support/core_ext/object/to_param"
 require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/object/with"
 require "active_support/core_ext/object/with_options"

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+class Pathname
+  # An Pathname is blank if it's empty:
+  #
+  #   Pathname.new("").blank?      # => true
+  #   Pathname.new(" ").blank?     # => false
+  #   Pathname.new("test").blank?  # => false
+  #
+  # @return [true, false]
+  def blank?
+    to_s.empty?
+  end
+end

data/lib/active_support/core_ext/pathname/existence.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 class Pathname
   # Returns the receiver if the named file exists otherwise returns +nil+.
   # <tt>pathname.existence</tt> is equivalent to

data/lib/active_support/core_ext/pathname.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/pathname/blank"
 require "active_support/core_ext/pathname/existence"

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

@@ -1,13 +1,28 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = \Range With Format
   module RangeWithFormat
     RANGE_FORMATS = {
       db: -> (start, stop) do
-        case start
-        when String then "BETWEEN '#{start}' AND '#{stop}'"
-        else
-          "BETWEEN '#{start.to_fs(:db)}' AND '#{stop.to_fs(:db)}'"
+        if start && stop
+          case start
+          when String then "BETWEEN '#{start}' AND '#{stop}'"
+          else
+            "BETWEEN '#{start.to_fs(:db)}' AND '#{stop.to_fs(:db)}'"
+          end
+        elsif start
+          case start
+          when String then ">= '#{start}'"
+          else
+            ">= '#{start.to_fs(:db)}'"
+          end
+        elsif stop
+          case stop
+          when String then "<= '#{stop}'"
+          else
+            "<= '#{stop.to_fs(:db)}'"
+          end
         end
       end
     }
@@ -19,9 +34,15 @@ module ActiveSupport
     #   range = (1..100)           # => 1..100
     #
     #   range.to_s                 # => "1..100"
-    #   range.to_fs(:db)            # => "BETWEEN '1' AND '100'"
+    #   range.to_fs(:db)           # => "BETWEEN '1' AND '100'"
     #
-    # == Adding your own range formats to to_s
+    #   range = (1..)              # => 1..
+    #   range.to_fs(:db)           # => ">= '1'"
+    #
+    #   range = (..100)            # => ..100
+    #   range.to_fs(:db)           # => "<= '100'"
+    #
+    # == Adding your own range formats to to_fs
     # You can add your own formats to the Range::RANGE_FORMATS hash.
     # Use the format name as the hash key and a Proc instance.
     #
@@ -29,7 +50,7 @@ module ActiveSupport
     #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_fs(:db)} and #{stop.to_fs(:db)}" }
     def to_fs(format = :default)
       if formatter = RANGE_FORMATS[format]
-        formatter.call(first, last)
+        formatter.call(self.begin, self.end)
       else
         to_s
       end

data/lib/active_support/core_ext/range/{overlaps.rb → overlap.rb}

@@ -2,9 +2,11 @@
 
 class Range
   # Compare two ranges and see if they overlap each other
-  #  (1..5).overlaps?(4..6) # => true
-  #  (1..5).overlaps?(7..9) # => false
-  def overlaps?(other)
+  #  (1..5).overlap?(4..6) # => true
+  #  (1..5).overlap?(7..9) # => false
+  def overlap?(other)
     other.begin == self.begin || cover?(other.begin) || other.cover?(self.begin)
   end
+
+  alias :overlaps? :overlap?
 end

data/lib/active_support/core_ext/range.rb

@@ -1,7 +1,6 @@
 # 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/overlaps"
+require "active_support/core_ext/range/overlap"
 require "active_support/core_ext/range/each"

data/lib/active_support/core_ext/securerandom.rb

@@ -16,12 +16,18 @@ module SecureRandom
   #
   #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
   #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"
-  def self.base58(n = 16)
-    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-      idx = byte % 64
-      idx = SecureRandom.random_number(58) if idx >= 58
-      BASE58_ALPHABET[idx]
-    end.join
+  if RUBY_VERSION >= "3.3"
+    def self.base58(n = 16)
+      SecureRandom.alphanumeric(n, chars: BASE58_ALPHABET)
+    end
+  else
+    def self.base58(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(58) if idx >= 58
+        BASE58_ALPHABET[idx]
+      end.join
+    end
   end
 
   # SecureRandom.base36 generates a random base36 string in lowercase.
@@ -35,11 +41,17 @@ module SecureRandom
   #
   #   p SecureRandom.base36 # => "4kugl2pdqmscqtje"
   #   p SecureRandom.base36(24) # => "77tmhrhjfvfdwodq8w7ev2m7"
-  def self.base36(n = 16)
-    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-      idx = byte % 64
-      idx = SecureRandom.random_number(36) if idx >= 36
-      BASE36_ALPHABET[idx]
-    end.join
+  if RUBY_VERSION >= "3.3"
+    def self.base36(n = 16)
+      SecureRandom.alphanumeric(n, chars: BASE36_ALPHABET)
+    end
+  else
+    def self.base36(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(36) if idx >= 36
+        BASE36_ALPHABET[idx]
+      end.join
+    end
   end
 end

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

@@ -45,7 +45,7 @@ class String
     self
   end
 
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  # Truncates a given +text+ to length <tt>truncate_to</tt> if +text+ is longer than <tt>truncate_to</tt>:
   #
   #   'Once upon a time in a world far far away'.truncate(27)
   #   # => "Once upon a time in a wo..."
@@ -58,16 +58,20 @@ class String
   #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
   #   # => "Once upon a time in a..."
   #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>length</tt>:
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...").
+  # The total length will not exceed <tt>truncate_to</tt> unless both +text+ and <tt>:omission</tt>
+  # are longer than <tt>truncate_to</tt>:
   #
   #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
   #   # => "And they f... (continued)"
-  def truncate(truncate_at, options = {})
-    return dup unless length > truncate_at
+  #
+  #   'And they found that many people were sleeping better.'.truncate(4, omission: '... (continued)')
+  #   # => "... (continued)"
+  def truncate(truncate_to, options = {})
+    return dup unless length > truncate_to
 
     omission = options[:omission] || "..."
-    length_with_room_for_omission = truncate_at - omission.length
+    length_with_room_for_omission = truncate_to - omission.length
     stop = \
       if options[:separator]
         rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
@@ -78,7 +82,7 @@ class String
     +"#{self[0, stop]}#{omission}"
   end
 
-  # Truncates +text+ to at most <tt>bytesize</tt> bytes in length without
+  # Truncates +text+ to at most <tt>truncate_to</tt> bytes in length without
   # breaking string encoding by splitting multibyte characters or breaking
   # grapheme clusters ("perceptual characters") by truncating at combining
   # characters.
@@ -91,20 +95,22 @@ class String
   #   => "🔪🔪🔪🔪…"
   #
   # The truncated text ends with the <tt>:omission</tt> string, defaulting
-  # to "…", for a total length not exceeding <tt>bytesize</tt>.
-  def truncate_bytes(truncate_at, omission: "…")
+  # to "…", for a total length not exceeding <tt>truncate_to</tt>.
+  #
+  # Raises +ArgumentError+ when the bytesize of <tt>:omission</tt> exceeds <tt>truncate_to</tt>.
+  def truncate_bytes(truncate_to, omission: "…")
     omission ||= ""
 
     case
-    when bytesize <= truncate_at
+    when bytesize <= truncate_to
       dup
-    when omission.bytesize > truncate_at
-      raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
-    when omission.bytesize == truncate_at
+    when omission.bytesize > truncate_to
+      raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_to} bytes"
+    when omission.bytesize == truncate_to
       omission.dup
     else
       self.class.new.tap do |cut|
-        cut_at = truncate_at - omission.bytesize
+        cut_at = truncate_to - omission.bytesize
 
         each_grapheme_cluster do |grapheme|
           if cut.bytesize + grapheme.bytesize <= cut_at

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

@@ -112,7 +112,7 @@ class String
 
   # Capitalizes all the words and replaces some characters in the string to create
   # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-  # used in the Rails internals.
+  # used in the \Rails internals.
   #
   # The trailing '_id','Id'.. can be kept and capitalized by setting the
   # optional parameter +keep_id_suffix+ to true.
@@ -216,7 +216,7 @@ class String
     ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
   end
 
-  # Creates the name of a table like Rails does for models to table names. This method
+  # Creates the name of a table like \Rails does for models to table names. This method
   # uses the +pluralize+ method on the last word in the string.
   #
   #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
@@ -228,7 +228,7 @@ class String
     ActiveSupport::Inflector.tableize(self)
   end
 
-  # Creates a class name from a plural table name like Rails does for table names to models.
+  # Creates a class name from a plural table name like \Rails does for table names to models.
   # Note that this returns a string and not a class. (To convert to an actual class
   # follow +classify+ with +constantize+.)
   #
@@ -240,7 +240,7 @@ class String
     ActiveSupport::Inflector.classify(self)
   end
 
-  # Capitalizes the first word, turns underscores into spaces, and (by default)strips a
+  # Capitalizes the first word, turns underscores into spaces, and (by default) strips a
   # trailing '_id' if present.
   # Like +titleize+, this is meant for creating pretty output.
   #
@@ -263,7 +263,7 @@ class String
     ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
   end
 
-  # Converts just the first character to uppercase.
+  # Converts the first character to uppercase.
   #
   #   'what a Lovely Day'.upcase_first # => "What a Lovely Day"
   #   'w'.upcase_first                 # => "W"
@@ -274,6 +274,17 @@ class String
     ActiveSupport::Inflector.upcase_first(self)
   end
 
+  # Converts the first character to lowercase.
+  #
+  #   'If they enjoyed The Matrix'.downcase_first # => "if they enjoyed The Matrix"
+  #   'I'.downcase_first                          # => "i"
+  #   ''.downcase_first                           # => ""
+  #
+  # See ActiveSupport::Inflector.downcase_first.
+  def downcase_first
+    ActiveSupport::Inflector.downcase_first(self)
+  end
+
   # Creates a foreign key name from a class name.
   # +separate_class_name_and_id_with_underscore+ sets whether
   # the method should put '_' between the name and 'id'.

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

@@ -1,151 +1,8 @@
 # frozen_string_literal: true
 
-require "erb"
-require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/erb/util"
 require "active_support/multibyte/unicode"
 
-class ERB
-  module Util
-    HTML_ESCAPE = { "&" => "&amp;",  ">" => "&gt;",   "<" => "&lt;", '"' => "&quot;", "'" => "&#39;" }
-    JSON_ESCAPE = { "&" => '\u0026', ">" => '\u003e', "<" => '\u003c', "\u2028" => '\u2028', "\u2029" => '\u2029' }
-    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>.
-    #
-    #   puts html_escape('is a > 0 & a < 10?')
-    #   # => is a &gt; 0 &amp; a &lt; 10?
-    def html_escape(s)
-      unwrapped_html_escape(s).html_safe
-    end
-
-    silence_redefinition_of_method :h
-    alias h html_escape
-
-    module_function :h
-
-    singleton_class.silence_redefinition_of_method :html_escape
-    module_function :html_escape
-
-    # HTML escapes strings but doesn't wrap them with an ActiveSupport::SafeBuffer.
-    # This method is not for public consumption! Seriously!
-    def unwrapped_html_escape(s) # :nodoc:
-      s = s.to_s
-      if s.html_safe?
-        s
-      else
-        CGI.escapeHTML(ActiveSupport::Multibyte::Unicode.tidy_bytes(s))
-      end
-    end
-    module_function :unwrapped_html_escape
-
-    # 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)
-      result = ActiveSupport::Multibyte::Unicode.tidy_bytes(s.to_s).gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    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.gsub(JSON_ESCAPE_REGEXP, JSON_ESCAPE)
-      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?
-
-      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
-
 class Object
   def html_safe?
     false
@@ -162,7 +19,7 @@ module ActiveSupport # :nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
       capitalize chomp chop delete delete_prefix delete_suffix
-      downcase lstrip next reverse rstrip scrub slice squeeze strip
+      downcase lstrip next reverse rstrip scrub squeeze strip
       succ swapcase tr tr_s unicode_normalize upcase
     )
 
@@ -174,7 +31,7 @@ module ActiveSupport # :nodoc:
     # 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."
+        super "Could not concatenate to the buffer because it is not HTML safe."
       end
     end
 
@@ -184,13 +41,26 @@ module ActiveSupport # :nodoc:
 
         return unless new_string
 
-        new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
-        new_safe_buffer.instance_variable_set :@html_safe, true
-        new_safe_buffer
+        string_into_safe_buffer(new_string, true)
       else
         to_str[*args]
       end
     end
+    alias_method :slice, :[]
+
+    def slice!(*args)
+      new_string = super
+
+      return new_string if !html_safe? || new_string.nil?
+
+      string_into_safe_buffer(new_string, true)
+    end
+
+    def chr
+      return super unless html_safe?
+
+      string_into_safe_buffer(super, true)
+    end
 
     def safe_concat(value)
       raise SafeConcatError unless html_safe?
@@ -207,7 +77,10 @@ module ActiveSupport # :nodoc:
       @html_safe = other.html_safe?
     end
 
-    def clone_empty
+    def clone_empty # :nodoc:
+      ActiveSupport.deprecator.warn <<~EOM
+        ActiveSupport::SafeBuffer#clone_empty is deprecated and will be removed in Rails 7.2.
+      EOM
       self[0, 0]
     end
 
@@ -235,11 +108,11 @@ module ActiveSupport # :nodoc:
       super(implicit_html_escape_interpolated_argument(value))
     end
 
-    def []=(*args)
-      if args.length == 3
-        super(args[0], args[1], implicit_html_escape_interpolated_argument(args[2]))
+    def []=(arg1, arg2, arg3 = nil)
+      if arg3
+        super(arg1, arg2, implicit_html_escape_interpolated_argument(arg3))
       else
-        super(args[0], implicit_html_escape_interpolated_argument(args[1]))
+        super(arg1, implicit_html_escape_interpolated_argument(arg2))
       end
     end
 
@@ -247,7 +120,7 @@ module ActiveSupport # :nodoc:
       dup.concat(other)
     end
 
-    def *(*)
+    def *(_)
       new_string = super
       new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
       new_safe_buffer.instance_variable_set(:@html_safe, @html_safe)
@@ -265,9 +138,9 @@ module ActiveSupport # :nodoc:
       self.class.new(super(escaped_args))
     end
 
-    def html_safe?
-      defined?(@html_safe) && @html_safe
-    end
+    attr_reader :html_safe
+    alias_method :html_safe?, :html_safe
+    remove_method :html_safe
 
     def to_s
       self
@@ -332,22 +205,7 @@ module ActiveSupport # :nodoc:
         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)
+          CGI.escapeHTML(arg.to_str)
         end
       end
 
@@ -356,6 +214,12 @@ module ActiveSupport # :nodoc:
       rescue ArgumentError
         # Can't create binding from C level Proc
       end
+
+      def string_into_safe_buffer(new_string, is_html_safe)
+        new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
+        new_safe_buffer.instance_variable_set :@html_safe, is_html_safe
+        new_safe_buffer
+      end
   end
 end
 

data/lib/active_support/core_ext/thread/backtrace/location.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Thread::Backtrace::Location # :nodoc:
+  if defined?(ErrorHighlight) && Gem::Version.new(ErrorHighlight::VERSION) >= Gem::Version.new("0.4.0")
+    def spot(ex)
+      ErrorHighlight.spot(ex, backtrace_location: self)
+    end
+  else
+    def spot(ex)
+    end
+  end
+end