activesupport 7.0.8.6 → 7.1.0.beta1

data/lib/active_support/error_reporter.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Active Support \Error Reporter
+  #
   # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
   #
-  # To rescue and report any unhandled error, you can use the +handle+ method:
+  # To rescue and report any unhandled error, you can use the #handle method:
   #
   #   Rails.error.handle do
   #     do_something!
@@ -11,35 +13,19 @@ module ActiveSupport
   #
   # If an error is raised, it will be reported and swallowed.
   #
-  # Alternatively if you want to report the error but not swallow it, you can use +record+
+  # Alternatively, if you want to report the error but not swallow it, you can use #record:
   #
   #   Rails.error.record do
   #     do_something!
   #   end
   #
-  # Both methods can be restricted to only handle a specific exception class
+  # Both methods can be restricted to handle only a specific error class:
   #
   #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
   #
-  # You can also pass some extra context information that may be used by the error subscribers:
-  #
-  #   Rails.error.handle(context: { section: "admin" }) do
-  #     # ...
-  #   end
-  #
-  # Additionally a +severity+ can be passed along to communicate how important the error report is.
-  # +severity+ can be one of +:error+, +:warning+, or +:info+. Handled errors default to the +:warning+
-  # severity, and unhandled ones to +:error+.
-  #
-  # Both +handle+ and +record+ pass through the return value from the block. In the case of +handle+
-  # rescuing an error, a fallback can be provided. The fallback must be a callable whose result will
-  # be returned when the block raises and is handled:
-  #
-  #   user = Rails.error.handle(fallback: -> { User.anonymous }) do
-  #     User.find_by(params)
-  #   end
   class ErrorReporter
     SEVERITIES = %i(error warning info)
+    DEFAULT_SOURCE = "application"
 
     attr_accessor :logger
 
@@ -48,31 +34,92 @@ module ActiveSupport
       @logger = logger
     end
 
-    # Report any unhandled exception, and swallow it.
+    # Evaluates the given block, reporting and swallowing any unhandled error.
+    # If no error is raised, returns the return value of the block. Otherwise,
+    # returns the result of +fallback.call+, or +nil+ if +fallback+ is not
+    # specified.
     #
+    #   # Will report a TypeError to all subscribers and return nil.
     #   Rails.error.handle do
     #     1 + '1'
     #   end
     #
-    def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)
+    # Can be restricted to handle only specific error classes:
+    #
+    #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:warning+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.handle(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:fallback+ - A callable that provides +handle+'s return value when an
+    #   unhandled error is raised. For example:
+    #
+    #     user = Rails.error.handle(fallback: -> { User.anonymous }) do
+    #       User.find_by(params)
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)
+      error_classes = [StandardError] if error_classes.blank?
       yield
-    rescue error_class => error
-      report(error, handled: true, severity: severity, context: context)
+    rescue *error_classes => error
+      report(error, handled: true, severity: severity, context: context, source: source)
       fallback.call if fallback
     end
 
-    def record(error_class = StandardError, severity: :error, context: {})
+    # Evaluates the given block, reporting and re-raising any unhandled error.
+    # If no error is raised, returns the return value of the block.
+    #
+    #   # Will report a TypeError to all subscribers and re-raise it.
+    #   Rails.error.record do
+    #     1 + '1'
+    #   end
+    #
+    # Can be restricted to handle only specific error classes:
+    #
+    #   tags = Rails.error.record(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:error+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.record(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)
+      error_classes = [StandardError] if error_classes.blank?
       yield
-    rescue error_class => error
-      report(error, handled: false, severity: severity, context: context)
+    rescue *error_classes => error
+      report(error, handled: false, severity: severity, context: context, source: source)
       raise
     end
 
     # Register a new error subscriber. The subscriber must respond to
     #
-    #   report(Exception, handled: Boolean, context: Hash)
+    #   report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)
     #
-    # The +report+ method +should+ never raise an error.
+    # The +report+ method <b>should never</b> raise an error.
     def subscribe(subscriber)
       unless subscriber.respond_to?(:report)
         raise ArgumentError, "Error subscribers must respond to #report"
@@ -80,26 +127,61 @@ module ActiveSupport
       @subscribers << subscriber
     end
 
-    # Update the execution context that is accessible to error subscribers
+    # Unregister an error subscriber. Accepts either a subscriber or a class.
+    #
+    #   subscriber = MyErrorSubscriber.new
+    #   Rails.error.subscribe(subscriber)
+    #
+    #   Rails.error.unsubscribe(subscriber)
+    #   # or
+    #   Rails.error.unsubscribe(MyErrorSubscriber)
+    def unsubscribe(subscriber)
+      @subscribers.delete_if { |s| subscriber === s }
+    end
+
+    # Prevent a subscriber from being notified of errors for the
+    # duration of the block. You may pass in the subscriber itself, or its class.
+    #
+    # This can be helpful for error reporting service integrations, when they wish
+    # to handle any errors higher in the stack.
+    def disable(subscriber)
+      disabled_subscribers = (ActiveSupport::IsolatedExecutionState[self] ||= [])
+      disabled_subscribers << subscriber
+      begin
+        yield
+      ensure
+        disabled_subscribers.delete(subscriber)
+      end
+    end
+
+    # Update the execution context that is accessible to error subscribers. Any
+    # context passed to #handle, #record, or #report will be merged with the
+    # context set here.
     #
     #   Rails.error.set_context(section: "checkout", user_id: @user.id)
     #
-    # See +ActiveSupport::ExecutionContext.set+
     def set_context(...)
       ActiveSupport::ExecutionContext.set(...)
     end
 
-    # When the block based +handle+ and +record+ methods are not suitable, you can directly use +report+
+    # Report an error directly to subscribers. You can use this method when the
+    # block-based #handle and #record methods are not suitable.
+    #
+    #   Rails.error.report(error)
     #
-    #   Rails.error.report(error, handled: true)
-    def report(error, handled:, severity: handled ? :warning : :error, context: {})
+    def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
+      return if error.instance_variable_defined?(:@__rails_error_reported)
+
       unless SEVERITIES.include?(severity)
         raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
       end
 
       full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
+      disabled_subscribers = ActiveSupport::IsolatedExecutionState[self]
       @subscribers.each do |subscriber|
-        subscriber.report(error, handled: handled, severity: severity, context: full_context)
+        unless disabled_subscribers&.any? { |s| s === subscriber }
+          subscriber.report(error, handled: handled, severity: severity, context: full_context, source: source)
+        end
       rescue => subscriber_error
         if logger
           logger.fatal(
@@ -111,6 +193,10 @@ module ActiveSupport
         end
       end
 
+      unless error.frozen?
+        error.instance_variable_set(:@__rails_error_reported, true)
+      end
+
       nil
     end
   end

data/lib/active_support/execution_wrapper.rb

@@ -84,14 +84,14 @@ module ActiveSupport
     end
 
     # Perform the work in the supplied block as an execution.
-    def self.wrap
+    def self.wrap(source: "application.active_support")
       return yield if active?
 
       instance = run!
       begin
         yield
       rescue => error
-        error_reporter.report(error, handled: false)
+        error_reporter&.report(error, handled: false, source: source)
         raise
       ensure
         instance.complete!
@@ -108,8 +108,8 @@ module ActiveSupport
       end
     end
 
-    def self.error_reporter
-      @error_reporter ||= ActiveSupport::ErrorReporter.new
+    def self.error_reporter # :nodoc:
+      ActiveSupport.error_reporter
     end
 
     def self.active_key # :nodoc:

data/lib/active_support/file_update_checker.rb

@@ -3,7 +3,9 @@
 require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
-  # FileUpdateChecker specifies the API used by Rails to watch files
+  # = \File Update Checker
+  #
+  # FileUpdateChecker specifies the API used by \Rails to watch files
   # and control reloading. The API depends on four methods:
   #
   # * +initialize+ which expects two parameters and one block as
@@ -20,7 +22,7 @@ module ActiveSupport
   # After initialization, a call to +execute_if_updated+ must execute
   # the block only if there was really a change in the filesystem.
   #
-  # This class is used by Rails to reload the I18n framework whenever
+  # This class is used by \Rails to reload the I18n framework whenever
   # they are changed upon a new request.
   #
   #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do

data/lib/active_support/fork_tracker.rb

@@ -6,7 +6,7 @@ module ActiveSupport
       def _fork
         pid = super
         if pid == 0
-          ForkTracker.check!
+          ForkTracker.after_fork_callback
         end
         pid
       end
@@ -37,7 +37,7 @@ module ActiveSupport
     @callbacks = []
 
     class << self
-      def check!
+      def after_fork_callback
         new_pid = Process.pid
         if @pid != new_pid
           @callbacks.each(&:call)
@@ -45,6 +45,14 @@ module ActiveSupport
         end
       end
 
+      if Process.respond_to?(:_fork) # Ruby 3.1+
+        def check!
+          # We trust the `_fork` callback
+        end
+      else
+        alias_method :check!, :after_fork_callback
+      end
+
       def hook!
         if Process.respond_to?(:_fork) # Ruby 3.1+
           ::Process.singleton_class.prepend(ModernCoreExt)

data/lib/active_support/gem_version.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  # Returns the currently loaded version of Active Support as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Support as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 7
-    MINOR = 0
-    TINY  = 8
-    PRE   = "6"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/gzip.rb

@@ -4,6 +4,8 @@ require "zlib"
 require "stringio"
 
 module ActiveSupport
+  # = Active Support \Gzip
+  #
   # A convenient wrapper for the zlib standard library that allows
   # compression/decompression of strings with gzip.
   #

data/lib/active_support/hash_with_indifferent_access.rb

@@ -6,6 +6,8 @@ require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/slice"
 
 module ActiveSupport
+  # = \Hash With Indifferent Access
+  #
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
   # to be the same.
   #
@@ -37,7 +39,7 @@ module ActiveSupport
   #
   # but this class is intended for use cases where strings or symbols are the
   # expected keys and it is convenient to understand both as the same. For
-  # example the +params+ hash in Ruby on Rails.
+  # example the +params+ hash in Ruby on \Rails.
   #
   # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
   #
@@ -45,7 +47,7 @@ module ActiveSupport
   #
   # which may be handy.
   #
-  # To access this class outside of Rails, require the core extension with:
+  # To access this class outside of \Rails, require the core extension with:
   #
   #   require "active_support/core_ext/hash/indifferent_access"
   #
@@ -113,7 +115,7 @@ module ActiveSupport
     #   hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
     #
     # The arguments can be either an
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
+    # +ActiveSupport::HashWithIndifferentAccess+ or a regular +Hash+.
     # In either case the merge respects the semantics of indifferent access.
     #
     # If the argument is a regular hash with keys +:key+ and <tt>"key"</tt> only one
@@ -218,8 +220,12 @@ module ActiveSupport
     #   hash.default                   # => nil
     #   hash.default('foo')            # => 'foo'
     #   hash.default(:foo)             # => 'foo'
-    def default(*args)
-      super(*args.map { |arg| convert_key(arg) })
+    def default(key = (no_key = true))
+      if no_key
+        super()
+      else
+        super(convert_key(key))
+      end
     end
 
     # Returns an array of the values at the specified indices:
@@ -229,7 +235,8 @@ module ActiveSupport
     #   hash[:b] = 'y'
     #   hash.values_at('a', 'b') # => ["x", "y"]
     def values_at(*keys)
-      super(*keys.map { |key| convert_key(key) })
+      keys.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns an array of the values at the specified indices, but also
@@ -242,7 +249,8 @@ module ActiveSupport
     #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
     #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
     def fetch_values(*indices, &block)
-      super(*indices.map { |key| convert_key(key) }, &block)
+      indices.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns a shallow copy of the hash.
@@ -301,7 +309,7 @@ module ActiveSupport
     #   hash.except(:a, "b") # => {c: 10}.with_indifferent_access
     #   hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access
     def except(*keys)
-      slice(*self.keys - keys.map { |key| convert_key(key) })
+      dup.except!(*keys)
     end
     alias_method :without, :except
 
@@ -326,21 +334,31 @@ module ActiveSupport
       dup.tap { |hash| hash.reject!(*args, &block) }
     end
 
-    def transform_values(*args, &block)
+    def transform_values(&block)
       return to_enum(:transform_values) unless block_given?
-      dup.tap { |hash| hash.transform_values!(*args, &block) }
+      dup.tap { |hash| hash.transform_values!(&block) }
     end
 
-    def transform_keys(*args, &block)
-      return to_enum(:transform_keys) unless block_given?
-      dup.tap { |hash| hash.transform_keys!(*args, &block) }
+    NOT_GIVEN = Object.new # :nodoc:
+
+    def transform_keys(hash = NOT_GIVEN, &block)
+      return to_enum(:transform_keys) if NOT_GIVEN.equal?(hash) && !block_given?
+      dup.tap { |h| h.transform_keys!(hash, &block) }
     end
 
-    def transform_keys!
-      return enum_for(:transform_keys!) { size } unless block_given?
-      keys.each do |key|
-        self[yield(key)] = delete(key)
+    def transform_keys!(hash = NOT_GIVEN, &block)
+      return to_enum(:transform_keys!) if NOT_GIVEN.equal?(hash) && !block_given?
+
+      if hash.nil?
+        super
+      elsif NOT_GIVEN.equal?(hash)
+        keys.each { |key| self[yield(key)] = delete(key) }
+      elsif block_given?
+        keys.each { |key| self[hash[key] || yield(key)] = delete(key) }
+      else
+        keys.each { |key| self[hash[key] || key] = delete(key) }
       end
+
       self
     end
 

data/lib/active_support/i18n.rb

@@ -7,7 +7,7 @@ begin
   require "i18n"
   require "i18n/backend/fallbacks"
 rescue LoadError => e
-  $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
+  warn "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
   raise e
 end
 require "active_support/lazy_load_hooks"

data/lib/active_support/i18n_railtie.rb

@@ -49,7 +49,7 @@ module I18n
         when :load_path
           I18n.load_path += value
         when :raise_on_missing_translations
-          forward_raise_on_missing_translations_config(app)
+          setup_raise_on_missing_translations_config(app)
         else
           I18n.public_send("#{setting}=", value)
         end
@@ -60,28 +60,35 @@ module I18n
       # Restore available locales check so it will take place from now on.
       I18n.enforce_available_locales = enforce_available_locales
 
-      directories = watched_dirs_with_extensions(reloadable_paths)
-      reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
-        I18n.load_path.keep_if { |p| File.exist?(p) }
-        I18n.load_path |= reloadable_paths.flat_map(&:existent)
-      end
+      if app.config.reloading_enabled?
+        directories = watched_dirs_with_extensions(reloadable_paths)
+        reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
+          I18n.load_path.keep_if { |p| File.exist?(p) }
+          I18n.load_path |= reloadable_paths.flat_map(&:existent)
+        end
 
-      app.reloaders << reloader
-      app.reloader.to_run do
-        reloader.execute_if_updated { require_unload_lock! }
+        app.reloaders << reloader
+        app.reloader.to_run do
+          reloader.execute_if_updated { require_unload_lock! }
+        end
+        reloader.execute
       end
-      reloader.execute
 
       @i18n_inited = true
     end
 
-    def self.forward_raise_on_missing_translations_config(app)
+    def self.setup_raise_on_missing_translations_config(app)
       ActiveSupport.on_load(:action_view) do
         ActionView::Helpers::TranslationHelper.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
       end
 
-      ActiveSupport.on_load(:action_controller) do
-        AbstractController::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
+      if app.config.i18n.raise_on_missing_translations &&
+          I18n.exception_handler.is_a?(I18n::ExceptionHandler) # Only override the i18n gem's default exception handler.
+
+        I18n.exception_handler = ->(exception, *) {
+          exception = exception.to_exception if exception.is_a?(I18n::MissingTranslation)
+          raise exception
+        }
       end
     end
 

data/lib/active_support/inflector/inflections.rb

@@ -7,6 +7,8 @@ module ActiveSupport
   module Inflector
     extend self
 
+    # = Active Support \Inflections
+    #
     # A singleton instance of this class is yielded by Inflector.inflections,
     # which can then be used to specify additional inflection rules. If passed
     # an optional locale, rules for other languages can be specified. The

data/lib/active_support/inflector/methods.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
 require "active_support/inflections"
-require "active_support/core_ext/object/blank"
 
 module ActiveSupport
+  # = Active Support \Inflector
+  #
   # The Inflector transforms words from singular to plural, class names to table
   # names, modularized class names to ones without, and class names to foreign
   # keys. The default inflections for pluralization, singularization, and
   # uncountable words are kept in inflections.rb.
   #
-  # The Rails core team has stated patches for the inflections library will not
+  # The \Rails core team has stated patches for the inflections library will not
   # be accepted in order to avoid breaking legacy applications which may be
   # relying on errant inflections. If you discover an incorrect inflection and
   # require it for your application or wish to define rules for languages other
@@ -71,6 +72,8 @@ module ActiveSupport
       # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
       if !uppercase_first_letter || uppercase_first_letter == :lower
         string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+      elsif string.match?(/\A[a-z\d]*\z/)
+        return inflections.acronyms[string]&.dup || string.capitalize
       else
         string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
       end
@@ -94,10 +97,10 @@ module ActiveSupport
     #
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
-      return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+      return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
       word = camel_cased_word.to_s.gsub("::", "/")
       word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
-      word.gsub!(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
+      word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
       word.tr!("-", "_")
       word.downcase!
       word
@@ -155,7 +158,7 @@ module ActiveSupport
       result
     end
 
-    # Converts just the first character to uppercase.
+    # Converts the first character in the string to uppercase.
     #
     #   upcase_first('what a Lovely Day') # => "What a Lovely Day"
     #   upcase_first('w')                 # => "W"
@@ -164,9 +167,18 @@ module ActiveSupport
       string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
     end
 
+    # Converts the first character in the string to lowercase.
+    #
+    #   downcase_first('If they enjoyed The Matrix') # => "if they enjoyed The Matrix"
+    #   downcase_first('I')                          # => "i"
+    #   downcase_first('')                           # => ""
+    def downcase_first(string)
+      string.length > 0 ? string[0].downcase.concat(string[1..-1]) : ""
+    end
+
     # 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.
+    # output. It is not used in the \Rails internals.
     #
     # The trailing '_id','Id'.. can be kept and capitalized by setting the
     # optional parameter +keep_id_suffix+ to true.
@@ -183,7 +195,7 @@ module ActiveSupport
       end
     end
 
-    # Creates the name of a table like Rails does for models to table names.
+    # 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.
     #
     #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
@@ -193,7 +205,7 @@ module ActiveSupport
       pluralize(underscore(class_name))
     end
 
-    # Creates a class name from a plural table name like Rails does for table
+    # 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.)
     #
@@ -226,7 +238,7 @@ module ActiveSupport
     def demodulize(path)
       path = path.to_s
       if i = path.rindex("::")
-        path[(i + 2)..-1]
+        path[(i + 2), path.length]
       else
         path
       end
@@ -345,7 +357,7 @@ module ActiveSupport
       def const_regexp(camel_cased_word)
         parts = camel_cased_word.split("::")
 
-        return Regexp.escape(camel_cased_word) if parts.blank?
+        return Regexp.escape(camel_cased_word) if parts.empty?
 
         last = parts.pop
 

data/lib/active_support/inflector/transliterate.rb

@@ -62,10 +62,12 @@ module ActiveSupport
     # Transliteration is restricted to UTF-8, US-ASCII, and GB18030 strings.
     # Other encodings will raise an ArgumentError.
     def transliterate(string, replacement = "?", locale: nil)
-      string = string.dup if string.frozen?
       raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
       raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
 
+      return string.dup if string.ascii_only?
+      string = string.dup if string.frozen?
+
       input_encoding = string.encoding
 
       # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if