activesupport 6.0.3.7 → 7.0.0

data/lib/active_support/logger_silence.rb

@@ -4,19 +4,6 @@ require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/logger_thread_safe_level"
 
-module LoggerSilence
-  extend ActiveSupport::Concern
-
-  included do
-    ActiveSupport::Deprecation.warn(
-      "Including LoggerSilence is deprecated and will be removed in Rails 6.1. " \
-      "Please use `ActiveSupport::LoggerSilence` instead"
-    )
-
-    include ActiveSupport::LoggerSilence
-  end
-end
-
 module ActiveSupport
   module LoggerSilence
     extend ActiveSupport::Concern
@@ -27,19 +14,8 @@ module ActiveSupport
     end
 
     # Silences the logger for the duration of the block.
-    def silence(temporary_level = Logger::ERROR)
-      if silencer
-        begin
-          old_local_level            = local_level
-          self.local_level           = temporary_level
-
-          yield self
-        ensure
-          self.local_level = old_local_level
-        end
-      else
-        yield self
-      end
+    def silence(severity = Logger::ERROR)
+      silencer ? log_at(severity) { yield self } : yield(self)
     end
   end
 end

data/lib/active_support/logger_thread_safe_level.rb

@@ -9,10 +9,6 @@ module ActiveSupport
   module LoggerThreadSafeLevel # :nodoc:
     extend ActiveSupport::Concern
 
-    included do
-      cattr_accessor :local_levels, default: Concurrent::Map.new(initial_capacity: 2), instance_accessor: false
-    end
-
     Logger::Severity.constants.each do |severity|
       class_eval(<<-EOT, __FILE__, __LINE__ + 1)
         def #{severity.downcase}?                # def debug?
@@ -21,36 +17,53 @@ module ActiveSupport
       EOT
     end
 
-    def after_initialize
-      ActiveSupport::Deprecation.warn(
-        "Logger don't need to call #after_initialize directly anymore. It will be deprecated without replacement in " \
-        "Rails 6.1."
-      )
-    end
-
-    def local_log_id
-      Fiber.current.__id__
-    end
-
     def local_level
-      self.class.local_levels[local_log_id]
+      IsolatedExecutionState[:logger_thread_safe_level]
     end
 
     def local_level=(level)
-      if level
-        self.class.local_levels[local_log_id] = level
+      case level
+      when Integer
+      when Symbol
+        level = Logger::Severity.const_get(level.to_s.upcase)
+      when nil
       else
-        self.class.local_levels.delete(local_log_id)
+        raise ArgumentError, "Invalid log level: #{level.inspect}"
       end
+      IsolatedExecutionState[:logger_thread_safe_level] = level
     end
 
     def level
       local_level || super
     end
 
+    # Change the thread-local level for the duration of the given block.
+    def log_at(level)
+      old_local_level, self.local_level = local_level, level
+      yield
+    ensure
+      self.local_level = old_local_level
+    end
+
+    # Redefined to check severity against #level, and thus the thread-local level, rather than +@level+.
+    # FIXME: Remove when the minimum Ruby version supports overriding Logger#level.
     def add(severity, message = nil, progname = nil, &block) # :nodoc:
-      return true if @logdev.nil? || (severity || UNKNOWN) < level
-      super
+      severity ||= UNKNOWN
+      progname ||= @progname
+
+      return true if @logdev.nil? || severity < level
+
+      if message.nil?
+        if block_given?
+          message  = yield
+        else
+          message  = progname
+          progname = @progname
+        end
+      end
+
+      @logdev.write \
+        format_message(format_severity(severity), Time.now, progname, message)
     end
   end
 end

data/lib/active_support/message_encryptor.rb

@@ -2,7 +2,6 @@
 
 require "openssl"
 require "base64"
-require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/message_verifier"
 require "active_support/messages/metadata"
@@ -23,6 +22,11 @@ module ActiveSupport
   #   crypt = ActiveSupport::MessageEncryptor.new(key)                            # => #<ActiveSupport::MessageEncryptor ...>
   #   encrypted_data = crypt.encrypt_and_sign('my secret data')                   # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
   #   crypt.decrypt_and_verify(encrypted_data)                                    # => "my secret data"
+  # The +decrypt_and_verify+ method will raise an
+  # <tt>ActiveSupport::MessageEncryptor::InvalidMessage</tt> exception if the data
+  # provided cannot be decrypted or verified.
+  #
+  #   crypt.decrypt_and_verify('not encrypted data') # => ActiveSupport::MessageEncryptor::InvalidMessage
   #
   # === Confining messages to a specific purpose
   #
@@ -85,7 +89,7 @@ module ActiveSupport
     cattr_accessor :use_authenticated_message_encryption, instance_accessor: false, default: false
 
     class << self
-      def default_cipher #:nodoc:
+      def default_cipher # :nodoc:
         if use_authenticated_message_encryption
           "aes-256-gcm"
         else
@@ -94,7 +98,7 @@ module ActiveSupport
       end
     end
 
-    module NullSerializer #:nodoc:
+    module NullSerializer # :nodoc:
       def self.load(value)
         value
       end
@@ -104,7 +108,7 @@ module ActiveSupport
       end
     end
 
-    module NullVerifier #:nodoc:
+    module NullVerifier # :nodoc:
       def self.verify(value)
         value
       end
@@ -134,15 +138,13 @@ module ActiveSupport
     # * <tt>:digest</tt> - String of digest to use for signing. Default is
     #   +SHA1+. Ignored when using an AEAD cipher like 'aes-256-gcm'.
     # * <tt>:serializer</tt> - Object serializer to use. Default is +Marshal+.
-    def initialize(secret, *signature_key_or_options)
-      options = signature_key_or_options.extract_options!
-      sign_secret = signature_key_or_options.first
+    def initialize(secret, sign_secret = nil, cipher: nil, digest: nil, serializer: nil)
       @secret = secret
       @sign_secret = sign_secret
-      @cipher = options[:cipher] || self.class.default_cipher
-      @digest = options[:digest] || "SHA1" unless aead_mode?
+      @cipher = cipher || self.class.default_cipher
+      @digest = digest || "SHA1" unless aead_mode?
       @verifier = resolve_verifier
-      @serializer = options[:serializer] || Marshal
+      @serializer = serializer || Marshal
     end
 
     # Encrypt and sign a message. We need to sign the message in order to avoid

data/lib/active_support/message_verifier.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "openssl"
 require "base64"
 require "active_support/core_ext/object/blank"
 require "active_support/security_utils"
@@ -68,8 +69,8 @@ module ActiveSupport
   # return the original value. But messages can be set to expire at a given
   # time with +:expires_in+ or +:expires_at+.
   #
-  #   @verifier.generate(parcel, expires_in: 1.month)
-  #   @verifier.generate(doowad, expires_at: Time.now.end_of_year)
+  #   @verifier.generate("parcel", expires_in: 1.month)
+  #   @verifier.generate("doowad", expires_at: Time.now.end_of_year)
   #
   # Then the messages can be verified and returned up to the expire time.
   # Thereafter, the +verified+ method returns +nil+ while +verify+ raises
@@ -78,8 +79,8 @@ module ActiveSupport
   # === Rotating keys
   #
   # MessageVerifier also supports rotating out old configurations by falling
-  # back to a stack of verifiers. Call +rotate+ to build and add a verifier to
-  # so either +verified+ or +verify+ will also try verifying with the fallback.
+  # back to a stack of verifiers. Call +rotate+ to build and add a verifier so
+  # either +verified+ or +verify+ will also try verifying with the fallback.
   #
   # By default any rotated verifiers use the values of the primary
   # verifier unless specified otherwise.
@@ -103,11 +104,14 @@ module ActiveSupport
 
     class InvalidSignature < StandardError; end
 
-    def initialize(secret, options = {})
+    SEPARATOR = "--" # :nodoc:
+    SEPARATOR_LENGTH = SEPARATOR.length # :nodoc:
+
+    def initialize(secret, digest: nil, serializer: nil)
       raise ArgumentError, "Secret should not be nil." unless secret
       @secret = secret
-      @digest = options[:digest] || "SHA1"
-      @serializer = options[:serializer] || Marshal
+      @digest = digest&.to_s || "SHA1"
+      @serializer = serializer || Marshal
     end
 
     # Checks if a signed message could have been generated by signing an object
@@ -120,10 +124,8 @@ module ActiveSupport
     #   tampered_message = signed_message.chop # editing the message invalidates the signature
     #   verifier.valid_message?(tampered_message) # => false
     def valid_message?(signed_message)
-      return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
-
-      data, digest = signed_message.split("--")
-      data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
+      data, digest = get_data_and_digest_from(signed_message)
+      digest_matches_data?(digest, data)
     end
 
     # Decodes the signed message using the +MessageVerifier+'s secret.
@@ -148,9 +150,9 @@ module ActiveSupport
     #   incompatible_message = "test--dad7b06c94abba8d46a15fafaef56c327665d5ff"
     #   verifier.verified(incompatible_message) # => TypeError: incompatible marshal file format
     def verified(signed_message, purpose: nil, **)
-      if valid_message?(signed_message)
+      data, digest = get_data_and_digest_from(signed_message)
+      if digest_matches_data?(digest, data)
         begin
-          data = signed_message.split("--")[0]
           message = Messages::Metadata.verify(decode(data), purpose)
           @serializer.load(message) if message
         rescue ArgumentError => argument_error
@@ -178,14 +180,14 @@ module ActiveSupport
 
     # Generates a signed message for the provided value.
     #
-    # The message is signed with the +MessageVerifier+'s secret. Without knowing
-    # the secret, the original value cannot be extracted from the message.
+    # The message is signed with the +MessageVerifier+'s secret.
+    # Returns Base64-encoded message joined with the generated signature.
     #
     #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
     #   verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"
     def generate(value, expires_at: nil, expires_in: nil, purpose: nil)
       data = encode(Messages::Metadata.wrap(@serializer.dump(value), expires_at: expires_at, expires_in: expires_in, purpose: purpose))
-      "#{data}--#{generate_digest(data)}"
+      "#{data}#{SEPARATOR}#{generate_digest(data)}"
     end
 
     private
@@ -198,8 +200,38 @@ module ActiveSupport
       end
 
       def generate_digest(data)
-        require "openssl" unless defined?(OpenSSL)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
+        OpenSSL::HMAC.hexdigest(@digest, @secret, data)
+      end
+
+      def digest_length_in_hex
+        # In hexadecimal (AKA base16) it takes 4 bits to represent a character,
+        # hence we multiply the digest's length (in bytes) by 8 to get it in
+        # bits and divide by 4 to get its number of characters it hex. Well, 8
+        # divided by 4 is 2.
+        @digest_length_in_hex ||= OpenSSL::Digest.new(@digest).digest_length * 2
+      end
+
+      def separator_index_for(signed_message)
+        index = signed_message.length - digest_length_in_hex - SEPARATOR_LENGTH
+        return if index.negative? || signed_message[index, SEPARATOR_LENGTH] != SEPARATOR
+
+        index
+      end
+
+      def get_data_and_digest_from(signed_message)
+        return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.empty?
+
+        separator_index = separator_index_for(signed_message)
+        return if separator_index.nil?
+
+        data = signed_message[0...separator_index]
+        digest = signed_message[separator_index + SEPARATOR_LENGTH..-1]
+
+        [data, digest]
+      end
+
+      def digest_matches_data?(digest, data)
+        data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
       end
   end
 end

data/lib/active_support/messages/metadata.rb

@@ -3,11 +3,11 @@
 require "time"
 
 module ActiveSupport
-  module Messages #:nodoc:
-    class Metadata #:nodoc:
+  module Messages # :nodoc:
+    class Metadata # :nodoc:
       def initialize(message, expires_at = nil, purpose = nil)
         @message, @purpose = message, purpose
-        @expires_at = expires_at.is_a?(String) ? Time.iso8601(expires_at) : expires_at
+        @expires_at = expires_at.is_a?(String) ? parse_expires_at(expires_at) : expires_at
       end
 
       def as_json(options = {})
@@ -67,6 +67,14 @@ module ActiveSupport
         def fresh?
           @expires_at.nil? || Time.now.utc < @expires_at
         end
+
+        def parse_expires_at(expires_at)
+          if ActiveSupport.use_standard_json_time_format
+            Time.iso8601(expires_at)
+          else
+            Time.parse(expires_at)
+          end
+        end
     end
   end
 end

data/lib/active_support/messages/rotation_configuration.rb

@@ -9,7 +9,8 @@ module ActiveSupport
         @signed, @encrypted = [], []
       end
 
-      def rotate(kind, *args)
+      def rotate(kind, *args, **options)
+        args << options unless options.empty?
         case kind
         when :signed
           @signed << args

data/lib/active_support/messages/rotator.rb

@@ -3,11 +3,12 @@
 module ActiveSupport
   module Messages
     module Rotator # :nodoc:
-      def initialize(*, **options)
-        super
+      def initialize(*secrets, on_rotation: nil, **options)
+        super(*secrets, **options)
 
         @options   = options
         @rotations = []
+        @on_rotation = on_rotation
       end
 
       def rotate(*secrets, **options)
@@ -17,7 +18,7 @@ module ActiveSupport
       module Encryptor
         include Rotator
 
-        def decrypt_and_verify(*args, on_rotation: nil, **options)
+        def decrypt_and_verify(*args, on_rotation: @on_rotation, **options)
           super
         rescue MessageEncryptor::InvalidMessage, MessageVerifier::InvalidSignature
           run_rotations(on_rotation) { |encryptor| encryptor.decrypt_and_verify(*args, **options) } || raise
@@ -32,7 +33,7 @@ module ActiveSupport
       module Verifier
         include Rotator
 
-        def verified(*args, on_rotation: nil, **options)
+        def verified(*args, on_rotation: @on_rotation, **options)
           super || run_rotations(on_rotation) { |verifier| verifier.verified(*args, **options) }
         end
 
@@ -46,7 +47,7 @@ module ActiveSupport
         def run_rotations(on_rotation)
           @rotations.find do |rotation|
             if message = yield(rotation) rescue next
-              on_rotation.call if on_rotation
+              on_rotation&.call
               return message
             end
           end

data/lib/active_support/multibyte/chars.rb

@@ -5,8 +5,8 @@ require "active_support/core_ext/string/access"
 require "active_support/core_ext/string/behavior"
 require "active_support/core_ext/module/delegation"
 
-module ActiveSupport #:nodoc:
-  module Multibyte #:nodoc:
+module ActiveSupport # :nodoc:
+  module Multibyte # :nodoc:
     # Chars enables you to work transparently with UTF-8 encoding in the Ruby
     # String class without having extensive knowledge about the encoding. A
     # Chars object accepts a string upon initialization and proxies String
@@ -48,7 +48,7 @@ module ActiveSupport #:nodoc:
       alias to_s wrapped_string
       alias to_str wrapped_string
 
-      delegate :<=>, :=~, :acts_like_string?, to: :wrapped_string
+      delegate :<=>, :=~, :match?, :acts_like_string?, to: :wrapped_string
 
       # Creates a new Chars instance by wrapping _string_.
       def initialize(string)
@@ -59,7 +59,7 @@ module ActiveSupport #:nodoc:
       # Forward all undefined methods to the wrapped string.
       def method_missing(method, *args, &block)
         result = @wrapped_string.__send__(method, *args, &block)
-        if /!$/.match?(method)
+        if method.end_with?("!")
           self if result
         else
           result.kind_of?(String) ? chars(result) : result
@@ -73,17 +73,6 @@ module ActiveSupport #:nodoc:
         @wrapped_string.respond_to?(method, include_private)
       end
 
-      # Returns +true+ when the proxy class can handle the string. Returns
-      # +false+ otherwise.
-      def self.consumes?(string)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Chars.consumes? is deprecated and will be
-          removed from Rails 6.1. Use string.is_utf8? instead.
-        MSG
-
-        string.encoding == Encoding::UTF_8
-      end
-
       # Works just like <tt>String#split</tt>, with the exception that the items
       # in the resulting list are Chars instances instead of String. This makes
       # chaining methods easier.
@@ -113,7 +102,7 @@ module ActiveSupport #:nodoc:
       #
       #   'Café'.mb_chars.reverse.to_s # => 'éfaC'
       def reverse
-        chars(@wrapped_string.scan(/\X/).reverse.join)
+        chars(@wrapped_string.grapheme_clusters.reverse.join)
       end
 
       # Limits the byte size of the string to a number of bytes without breaking
@@ -134,46 +123,18 @@ module ActiveSupport #:nodoc:
       end
       alias_method :titlecase, :titleize
 
-      # Returns the KC normalization of the string by default. NFKC is
-      # considered the best normalization form for passing strings to databases
-      # and validations.
-      #
-      # * <tt>form</tt> - The form you want to normalize in. Should be one of the following:
-      #   <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>. Default is
-      #   ActiveSupport::Multibyte::Unicode.default_normalization_form
-      def normalize(form = nil)
-        form ||= Unicode.default_normalization_form
-
-        # See https://www.unicode.org/reports/tr15, Table 1
-        if alias_form = Unicode::NORMALIZATION_FORM_ALIASES[form]
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveSupport::Multibyte::Chars#normalize is deprecated and will be
-            removed from Rails 6.1. Use #unicode_normalize(:#{alias_form}) instead.
-          MSG
-
-          send(:unicode_normalize, alias_form)
-        else
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveSupport::Multibyte::Chars#normalize is deprecated and will be
-            removed from Rails 6.1. Use #unicode_normalize instead.
-          MSG
-
-          raise ArgumentError, "#{form} is not a valid normalization variant", caller
-        end
-      end
-
       # Performs canonical decomposition on all the characters.
       #
-      #   'é'.length                         # => 2
-      #   'é'.mb_chars.decompose.to_s.length # => 3
+      #   'é'.length                         # => 1
+      #   'é'.mb_chars.decompose.to_s.length # => 2
       def decompose
         chars(Unicode.decompose(:canonical, @wrapped_string.codepoints.to_a).pack("U*"))
       end
 
       # Performs composition on all the characters.
       #
-      #   'é'.length                       # => 3
-      #   'é'.mb_chars.compose.to_s.length # => 2
+      #   'é'.length                       # => 1
+      #   'é'.mb_chars.compose.to_s.length # => 1
       def compose
         chars(Unicode.compose(@wrapped_string.codepoints.to_a).pack("U*"))
       end
@@ -181,9 +142,9 @@ module ActiveSupport #:nodoc:
       # Returns the number of grapheme clusters in the string.
       #
       #   'क्षि'.mb_chars.length   # => 4
-      #   'क्षि'.mb_chars.grapheme_length # => 3
+      #   'क्षि'.mb_chars.grapheme_length # => 2
       def grapheme_length
-        @wrapped_string.scan(/\X/).length
+        @wrapped_string.grapheme_clusters.length
       end
 
       # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
@@ -195,13 +156,13 @@ module ActiveSupport #:nodoc:
         chars(Unicode.tidy_bytes(@wrapped_string, force))
       end
 
-      def as_json(options = nil) #:nodoc:
+      def as_json(options = nil) # :nodoc:
         to_s.as_json(options)
       end
 
       %w(reverse tidy_bytes).each do |method|
         define_method("#{method}!") do |*args|
-          @wrapped_string = send(method, *args).to_s
+          @wrapped_string = public_send(method, *args).to_s
           self
         end
       end

data/lib/active_support/multibyte/unicode.rb

@@ -5,55 +5,9 @@ module ActiveSupport
     module Unicode
       extend self
 
-      # A list of all available normalization forms.
-      # See https://www.unicode.org/reports/tr15/tr15-29.html for more
-      # information about normalization.
-      NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
-
-      NORMALIZATION_FORM_ALIASES = { # :nodoc:
-        c: :nfc,
-        d: :nfd,
-        kc: :nfkc,
-        kd: :nfkd
-      }
-
       # The Unicode version that is supported by the implementation
       UNICODE_VERSION = RbConfig::CONFIG["UNICODE_VERSION"]
 
-      # The default normalization used for operations that require
-      # normalization. It can be set to any of the normalizations
-      # in NORMALIZATION_FORMS.
-      #
-      #   ActiveSupport::Multibyte::Unicode.default_normalization_form = :c
-      attr_accessor :default_normalization_form
-      @default_normalization_form = :kc
-
-      # Unpack the string at grapheme boundaries. Returns a list of character
-      # lists.
-      #
-      #   Unicode.unpack_graphemes('क्षि') # => [[2325, 2381], [2359], [2367]]
-      #   Unicode.unpack_graphemes('Café') # => [[67], [97], [102], [233]]
-      def unpack_graphemes(string)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Unicode#unpack_graphemes is deprecated and will be
-          removed from Rails 6.1. Use string.scan(/\X/).map(&:codepoints) instead.
-        MSG
-
-        string.scan(/\X/).map(&:codepoints)
-      end
-
-      # Reverse operation of unpack_graphemes.
-      #
-      #   Unicode.pack_graphemes(Unicode.unpack_graphemes('क्षि')) # => 'क्षि'
-      def pack_graphemes(unpacked)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Unicode#pack_graphemes is deprecated and will be
-          removed from Rails 6.1. Use array.flatten.pack("U*") instead.
-        MSG
-
-        unpacked.flatten.pack("U*")
-      end
-
       # Decompose composed characters to the decomposed form.
       def decompose(type, codepoints)
         if type == :compatibility
@@ -76,7 +30,7 @@ module ActiveSupport
         # Passing +true+ will forcibly tidy all bytes, assuming that the string's
         # encoding is entirely CP1252 or ISO-8859-1.
         def tidy_bytes(string, force = false)
-          return string if string.empty?
+          return string if string.empty? || string.ascii_only?
           return recode_windows1252_chars(string) if force
           string.scrub { |bad| recode_windows1252_chars(bad) }
         end
@@ -107,46 +61,6 @@ module ActiveSupport
         end
       end
 
-      # Returns the KC normalization of the string by default. NFKC is
-      # considered the best normalization form for passing strings to databases
-      # and validations.
-      #
-      # * <tt>string</tt> - The string to perform normalization on.
-      # * <tt>form</tt> - The form you want to normalize in. Should be one of
-      #   the following: <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>.
-      #   Default is ActiveSupport::Multibyte::Unicode.default_normalization_form.
-      def normalize(string, form = nil)
-        form ||= @default_normalization_form
-
-        # See https://www.unicode.org/reports/tr15, Table 1
-        if alias_form = NORMALIZATION_FORM_ALIASES[form]
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveSupport::Multibyte::Unicode#normalize is deprecated and will be
-            removed from Rails 6.1. Use String#unicode_normalize(:#{alias_form}) instead.
-          MSG
-
-          string.unicode_normalize(alias_form)
-        else
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveSupport::Multibyte::Unicode#normalize is deprecated and will be
-            removed from Rails 6.1. Use String#unicode_normalize instead.
-          MSG
-
-          raise ArgumentError, "#{form} is not a valid normalization variant", caller
-        end
-      end
-
-      %w(downcase upcase swapcase).each do |method|
-        define_method(method) do |string|
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Unicode##{method} is deprecated and
-          will be removed from Rails 6.1. Use String methods directly.
-          MSG
-
-          string.send(method)
-        end
-      end
-
       private
         def recode_windows1252_chars(string)
           string.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)

data/lib/active_support/multibyte.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module ActiveSupport #:nodoc:
+module ActiveSupport # :nodoc:
   module Multibyte
     autoload :Chars, "active_support/multibyte/chars"
     autoload :Unicode, "active_support/multibyte/unicode"