activesupport 7.0.8.7 → 7.2.2.1

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -3,7 +3,7 @@
 module ActiveSupport
   class Deprecation
     class DeprecationProxy # :nodoc:
-      def self.new(*args, &block)
+      def self.new(*args, **kwargs, &block)
         object = args.first
 
         return object unless object
@@ -25,11 +25,10 @@ module ActiveSupport
         end
     end
 
-    # DeprecatedObjectProxy transforms an object into a deprecated one. It
-    # takes an object, a deprecation message, and optionally a deprecator. The
-    # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It takes an object, a deprecation message, and
+    # a deprecator.
     #
-    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
+    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated", ActiveSupport::Deprecation.new)
     #   # => #<Object:0x007fb9b34c34b0>
     #
     #   deprecated_object.to_s
@@ -37,7 +36,7 @@ module ActiveSupport
     #   (Backtrace)
     #   # => "#<Object:0x007fb9b34c34b0>"
     class DeprecatedObjectProxy < DeprecationProxy
-      def initialize(object, message, deprecator = ActiveSupport::Deprecation.instance)
+      def initialize(object, message, deprecator)
         @object = object
         @message = message
         @deprecator = deprecator
@@ -53,15 +52,15 @@ module ActiveSupport
         end
     end
 
-    # DeprecatedInstanceVariableProxy transforms an instance variable into a
-    # deprecated one. It takes an instance of a class, a method on that class
-    # and an instance variable. It optionally takes a deprecator as the last
-    # argument. The deprecator defaults to +ActiveSupport::Deprecator+ if none
-    # is specified.
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a deprecated one. It takes an instance of a
+    # class, a method on that class, an instance variable, and a deprecator as the last argument.
+    #
+    # Trying to use the deprecated instance variable will result in a deprecation warning, pointing to the method as a
+    # replacement.
     #
     #   class Example
     #     def initialize
-    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
+    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, ActiveSupport::Deprecation.new)
     #       @_request = :special_request
     #     end
     #
@@ -86,7 +85,7 @@ module ActiveSupport
     #   example.request.to_s
     #   # => "special_request"
     class DeprecatedInstanceVariableProxy < DeprecationProxy
-      def initialize(instance, method, var = "@#{method}", deprecator = ActiveSupport::Deprecation.instance)
+      def initialize(instance, method, var = "@#{method}", deprecator:)
         @instance = instance
         @method = method
         @var = var
@@ -103,18 +102,16 @@ module ActiveSupport
         end
     end
 
-    # DeprecatedConstantProxy transforms a constant into a deprecated one. It
-    # takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and optionally a deprecator. The deprecator defaults
-    # to +ActiveSupport::Deprecator+ if none is specified. The deprecated constant
-    # now returns the value of the new one.
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. It takes the full names of an old
+    # (deprecated) constant and of a new constant (both in string form) and a deprecator. The deprecated constant now
+    # returns the value of the new one.
     #
     #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
     #
     #   # (In a later update, the original implementation of `PLANETS` has been removed.)
     #
     #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
-    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("PLANETS", "PLANETS_POST_2006", ActiveSupport::Deprecation.new)
     #
     #   PLANETS.map { |planet| planet.capitalize }
     #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
@@ -128,7 +125,7 @@ module ActiveSupport
         super
       end
 
-      def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+      def initialize(old_const, new_const, deprecator, message: "#{old_const} is deprecated! Use #{new_const} instead.")
         Kernel.require "active_support/inflector/methods"
 
         @old_const = old_const
@@ -158,6 +155,21 @@ module ActiveSupport
         target.class
       end
 
+      def append_features(base)
+        @deprecator.warn(@message, caller_locations)
+        base.include(target)
+      end
+
+      def prepend_features(base)
+        @deprecator.warn(@message, caller_locations)
+        base.prepend(target)
+      end
+
+      def extended(base)
+        @deprecator.warn(@message, caller_locations)
+        base.extend(target)
+      end
+
       private
         def target
           ActiveSupport::Inflector.constantize(@new_const.to_s)
@@ -168,9 +180,9 @@ module ActiveSupport
           target.const_get(name)
         end
 
-        def method_missing(called, *args, &block)
+        def method_missing(...)
           @deprecator.warn(@message, caller_locations)
-          target.__send__(called, *args, &block)
+          target.__send__(...)
         end
     end
   end

data/lib/active_support/deprecation/reporting.rb

@@ -11,34 +11,50 @@ module ActiveSupport
       attr_accessor :gem_name
 
       # Outputs a deprecation warning to the output configured by
-      # <tt>ActiveSupport::Deprecation.behavior</tt>.
+      # ActiveSupport::Deprecation#behavior.
       #
-      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   ActiveSupport::Deprecation.new.warn('something broke!')
       #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
       def warn(message = nil, callstack = nil)
         return if silenced
 
         callstack ||= caller_locations(2)
-        deprecation_message(callstack, message).tap do |m|
+        deprecation_message(callstack, message).tap do |full_message|
           if deprecation_disallowed?(message)
-            disallowed_behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+            disallowed_behavior.each { |b| b.call(full_message, callstack, self) }
           else
-            behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+            behavior.each { |b| b.call(full_message, callstack, self) }
           end
         end
       end
 
       # Silence deprecation warnings within the block.
       #
-      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.warn('something broke!')
       #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
       #
-      #   ActiveSupport::Deprecation.silence do
-      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator.silence do
+      #     deprecator.warn('something broke!')
       #   end
       #   # => nil
       def silence(&block)
-        @silenced_thread.bind(true, &block)
+        begin_silence
+        block.call
+      ensure
+        end_silence
+      end
+
+      def begin_silence # :nodoc:
+        @silence_counter.value += 1
+      end
+
+      def end_silence # :nodoc:
+        @silence_counter.value -= 1
+      end
+
+      def silenced
+        @silenced || @silence_counter.value.nonzero?
       end
 
       # Allow previously disallowed deprecation warnings within the block.
@@ -46,27 +62,28 @@ module ActiveSupport
       # expressions. (Symbols are treated as strings). These are compared against
       # the text of deprecation warning messages generated within the block.
       # Matching warnings will be exempt from the rules set by
-      # +ActiveSupport::Deprecation.disallowed_warnings+
+      # ActiveSupport::Deprecation#disallowed_warnings.
       #
       # The optional <tt>if:</tt> argument accepts a truthy/falsy value or an object that
       # responds to <tt>.call</tt>. If truthy, then matching warnings will be allowed.
       # If falsey then the method yields to the block without allowing the warning.
       #
-      #   ActiveSupport::Deprecation.disallowed_behavior = :raise
-      #   ActiveSupport::Deprecation.disallowed_warnings = [
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.disallowed_behavior = :raise
+      #   deprecator.disallowed_warnings = [
       #     "something broke"
       #   ]
       #
-      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator.warn('something broke!')
       #   # => ActiveSupport::DeprecationException
       #
-      #   ActiveSupport::Deprecation.allow ['something broke'] do
-      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator.allow ['something broke'] do
+      #     deprecator.warn('something broke!')
       #   end
       #   # => nil
       #
-      #   ActiveSupport::Deprecation.allow ['something broke'], if: Rails.env.production? do
-      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   deprecator.allow ['something broke'], if: Rails.env.production? do
+      #     deprecator.warn('something broke!')
       #   end
       #   # => ActiveSupport::DeprecationException for dev/test, nil for production
       def allow(allowed_warnings = :all, if: true, &block)
@@ -79,10 +96,6 @@ module ActiveSupport
         end
       end
 
-      def silenced
-        @silenced || @silenced_thread.value
-      end
-
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
         caller_backtrace ||= caller_locations(2)
         deprecated_method_warning(deprecated_method_name, message).tap do |msg|
@@ -125,18 +138,26 @@ module ActiveSupport
         end
 
         def extract_callstack(callstack)
+          return [] if callstack.empty?
           return _extract_callstack(callstack) if callstack.first.is_a? String
 
           offending_line = callstack.find { |frame|
-            frame.absolute_path && !ignored_callstack(frame.absolute_path)
+            # Code generated with `eval` doesn't have an `absolute_path`, e.g. templates.
+            path = frame.absolute_path || frame.path
+            path && !ignored_callstack?(path)
           } || callstack.first
 
           [offending_line.path, offending_line.lineno, offending_line.label]
         end
 
         def _extract_callstack(callstack)
-          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
-          offending_line = callstack.find { |line| !ignored_callstack(line) } || callstack.first
+          ActiveSupport.deprecator.warn(<<~MESSAGE)
+            Passing the result of `caller` to ActiveSupport::Deprecation#warn is deprecated and will be removed in Rails 8.0.
+
+            Please pass the result of `caller_locations` instead.
+          MESSAGE
+
+          offending_line = callstack.find { |line| !ignored_callstack?(line) } || callstack.first
 
           if offending_line
             if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
@@ -147,10 +168,11 @@ module ActiveSupport
           end
         end
 
-        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/"
+        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/" # :nodoc:
+        LIB_DIR = RbConfig::CONFIG["libdir"] # :nodoc:
 
-        def ignored_callstack(path)
-          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
+        def ignored_callstack?(path)
+          path.start_with?(RAILS_GEM_ROOT, LIB_DIR) || path.include?("<internal:")
         end
     end
   end

data/lib/active_support/deprecation.rb

@@ -1,10 +1,35 @@
 # frozen_string_literal: true
 
-require "singleton"
-
 module ActiveSupport
-  # \Deprecation specifies the API used by Rails to deprecate methods, instance
-  # variables, objects, and constants.
+  # = Active Support \Deprecation
+  #
+  # \Deprecation specifies the API used by \Rails to deprecate methods, instance variables, objects, and constants. It's
+  # also available for gems or applications.
+  #
+  # For a gem, use Deprecation.new to create a Deprecation object and store it in your module or class (in order for
+  # users to be able to configure it).
+  #
+  #   module MyLibrary
+  #     def self.deprecator
+  #       @deprecator ||= ActiveSupport::Deprecation.new("2.0", "MyLibrary")
+  #     end
+  #   end
+  #
+  # For a Railtie or Engine, you may also want to add it to the application's deprecators, so that the application's
+  # configuration can be applied to it.
+  #
+  #   module MyLibrary
+  #     class Railtie < Rails::Railtie
+  #       initializer "my_library.deprecator" do |app|
+  #         app.deprecators[:my_library] = MyLibrary.deprecator
+  #       end
+  #     end
+  #   end
+  #
+  # With the above initializer, configuration settings like the following will affect +MyLibrary.deprecator+:
+  #
+  #   # in config/environments/test.rb
+  #   config.active_support.deprecation = :raise
   class Deprecation
     # active_support.rb sets an autoload for ActiveSupport::Deprecation.
     #
@@ -14,23 +39,28 @@ module ActiveSupport
     # a circular require warning for active_support/deprecation.rb.
     #
     # So, we define the constant first, and load dependencies later.
-    require "active_support/deprecation/instance_delegator"
     require "active_support/deprecation/behaviors"
     require "active_support/deprecation/reporting"
     require "active_support/deprecation/disallowed"
     require "active_support/deprecation/constant_accessor"
     require "active_support/deprecation/method_wrappers"
     require "active_support/deprecation/proxy_wrappers"
+    require "active_support/deprecation/deprecators"
     require "active_support/core_ext/module/deprecation"
     require "concurrent/atomic/thread_local_var"
 
-    include Singleton
-    include InstanceDelegator
     include Behavior
     include Reporting
     include Disallowed
     include MethodWrapper
 
+    MUTEX = Mutex.new # :nodoc:
+    private_constant :MUTEX
+
+    def self._instance # :nodoc:
+      @_instance ||= MUTEX.synchronize { @_instance ||= new }
+    end
+
     # The version number in which the deprecated behavior will be removed, by default.
     attr_accessor :deprecation_horizon
 
@@ -38,13 +68,13 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "7.1", gem_name = "Rails")
+    def initialize(deprecation_horizon = "8.0", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.
       self.silenced = false
       self.debug = false
-      @silenced_thread = Concurrent::ThreadLocalVar.new(false)
+      @silence_counter = Concurrent::ThreadLocalVar.new(0)
       @explicitly_allowed_warnings = Concurrent::ThreadLocalVar.new(nil)
     end
   end

data/lib/active_support/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  def self.deprecator # :nodoc:
+    ActiveSupport::Deprecation._instance
+  end
+end

data/lib/active_support/descendants_tracker.rb

@@ -1,218 +1,112 @@
 # frozen_string_literal: true
 
 require "weakref"
-require "active_support/ruby_features"
 
 module ActiveSupport
+  # = Active Support Descendants Tracker
+  #
   # This module provides an internal implementation to track descendants
-  # which is faster than iterating through ObjectSpace.
+  # which is faster than iterating through +ObjectSpace+.
+  #
+  # However Ruby 3.1 provide a fast native +Class#subclasses+ method,
+  # so if you know your code won't be executed on older rubies, including
+  # +ActiveSupport::DescendantsTracker+ does not provide any benefit.
   module DescendantsTracker
-    class << self
-      def direct_descendants(klass)
-        ActiveSupport::Deprecation.warn(<<~MSG)
-          ActiveSupport::DescendantsTracker.direct_descendants is deprecated and will be removed in Rails 7.1.
-          Use ActiveSupport::DescendantsTracker.subclasses instead.
-        MSG
-        subclasses(klass)
-      end
-    end
-
     @clear_disabled = false
 
-    if RubyFeatures::CLASS_SUBCLASSES
-      @@excluded_descendants = if RUBY_ENGINE == "ruby"
-        # On MRI `ObjectSpace::WeakMap` keys are weak references.
-        # So we can simply use WeakMap as a `Set`.
-        ObjectSpace::WeakMap.new
-      else
-        # On TruffleRuby `ObjectSpace::WeakMap` keys are strong references.
-        # So we use `object_id` as a key and the actual object as a value.
-        #
-        # JRuby for now doesn't have Class#descendant, but when it will, it will likely
-        # have the same WeakMap semantic than Truffle so we future proof this as much as possible.
-        class WeakSet # :nodoc:
-          def initialize
-            @map = ObjectSpace::WeakMap.new
-          end
-
-          def [](object)
-            @map.key?(object.object_id)
-          end
+    if RUBY_ENGINE == "ruby"
+      # On MRI `ObjectSpace::WeakMap` keys are weak references.
+      # So we can simply use WeakMap as a `Set`.
+      class WeakSet < ObjectSpace::WeakMap # :nodoc:
+        alias_method :to_a, :keys
 
-          def []=(object, _present)
-            @map[object.object_id] = object
-          end
+        def <<(object)
+          self[object] = true
         end
-        WeakSet.new
       end
-
-      class << self
-        def disable_clear! # :nodoc:
-          unless @clear_disabled
-            @clear_disabled = true
-            remove_method(:subclasses)
-            @@excluded_descendants = nil
-          end
+    else
+      # On TruffleRuby `ObjectSpace::WeakMap` keys are strong references.
+      # So we use `object_id` as a key and the actual object as a value.
+      #
+      # JRuby for now doesn't have Class#descendant, but when it will, it will likely
+      # have the same WeakMap semantic than Truffle so we future proof this as much as possible.
+      class WeakSet # :nodoc:
+        def initialize
+          @map = ObjectSpace::WeakMap.new
         end
 
-        def subclasses(klass)
-          klass.subclasses
+        def [](object)
+          @map.key?(object.object_id)
         end
+        alias_method :include?, :[]
 
-        def descendants(klass)
-          klass.descendants
+        def []=(object, _present)
+          @map[object.object_id] = object
         end
 
-        def clear(classes) # :nodoc:
-          raise "DescendantsTracker.clear was disabled because config.cache_classes = true" if @clear_disabled
-
-          classes.each do |klass|
-            @@excluded_descendants[klass] = true
-            klass.descendants.each do |descendant|
-              @@excluded_descendants[descendant] = true
-            end
-          end
+        def to_a
+          @map.values
         end
 
-        def native? # :nodoc:
-          true
+        def <<(object)
+          self[object] = true
         end
       end
+    end
+    @excluded_descendants = WeakSet.new
 
+    module ReloadedClassesFiltering # :nodoc:
       def subclasses
-        subclasses = super
-        subclasses.reject! { |d| @@excluded_descendants[d] }
-        subclasses
+        DescendantsTracker.reject!(super)
       end
 
       def descendants
-        subclasses.concat(subclasses.flat_map(&:descendants))
-      end
-
-      def direct_descendants
-        ActiveSupport::Deprecation.warn(<<~MSG)
-          ActiveSupport::DescendantsTracker#direct_descendants is deprecated and will be removed in Rails 7.1.
-          Use #subclasses instead.
-        MSG
-        subclasses
+        DescendantsTracker.reject!(super)
       end
-    else
-      @@direct_descendants = {}
+    end
 
-      class << self
-        def disable_clear! # :nodoc:
+    class << self
+      def disable_clear! # :nodoc:
+        unless @clear_disabled
           @clear_disabled = true
+          ReloadedClassesFiltering.remove_method(:subclasses)
+          ReloadedClassesFiltering.remove_method(:descendants)
+          @excluded_descendants = nil
         end
+      end
 
-        def subclasses(klass)
-          descendants = @@direct_descendants[klass]
-          descendants ? descendants.to_a : []
-        end
-
-        def descendants(klass)
-          arr = []
-          accumulate_descendants(klass, arr)
-          arr
-        end
+      def clear(classes) # :nodoc:
+        raise "DescendantsTracker.clear was disabled because config.enable_reloading is false" if @clear_disabled
 
-        def clear(classes) # :nodoc:
-          raise "DescendantsTracker.clear was disabled because config.cache_classes = true" if @clear_disabled
-
-          @@direct_descendants.each do |klass, direct_descendants_of_klass|
-            if classes.member?(klass)
-              @@direct_descendants.delete(klass)
-            else
-              direct_descendants_of_klass.reject! do |direct_descendant_of_class|
-                classes.member?(direct_descendant_of_class)
-              end
-            end
+        classes.each do |klass|
+          @excluded_descendants << klass
+          klass.descendants.each do |descendant|
+            @excluded_descendants << descendant
           end
         end
-
-        def native? # :nodoc:
-          false
-        end
-
-        # This is the only method that is not thread safe, but is only ever called
-        # during the eager loading phase.
-        def store_inherited(klass, descendant)
-          (@@direct_descendants[klass] ||= DescendantsArray.new) << descendant
-        end
-
-        private
-          def accumulate_descendants(klass, acc)
-            if direct_descendants = @@direct_descendants[klass]
-              direct_descendants.each do |direct_descendant|
-                acc << direct_descendant
-                accumulate_descendants(direct_descendant, acc)
-              end
-            end
-          end
-      end
-
-      def inherited(base)
-        DescendantsTracker.store_inherited(self, base)
-        super
       end
 
-      def direct_descendants
-        ActiveSupport::Deprecation.warn(<<~MSG)
-          ActiveSupport::DescendantsTracker#direct_descendants is deprecated and will be removed in Rails 7.1.
-          Use #subclasses instead.
-        MSG
-        DescendantsTracker.subclasses(self)
+      def reject!(classes) # :nodoc:
+        if @excluded_descendants
+          classes.reject! { |d| @excluded_descendants.include?(d) }
+        end
+        classes
       end
+    end
 
-      def subclasses
-        DescendantsTracker.subclasses(self)
+    class << self
+      def subclasses(klass)
+        klass.subclasses
       end
 
-      def descendants
-        DescendantsTracker.descendants(self)
+      def descendants(klass)
+        klass.descendants
       end
+    end
 
-      # DescendantsArray is an array that contains weak references to classes.
-      class DescendantsArray # :nodoc:
-        include Enumerable
-
-        def initialize
-          @refs = []
-        end
-
-        def initialize_copy(orig)
-          @refs = @refs.dup
-        end
-
-        def <<(klass)
-          @refs << WeakRef.new(klass)
-        end
-
-        def each
-          @refs.reject! do |ref|
-            yield ref.__getobj__
-            false
-          rescue WeakRef::RefError
-            true
-          end
-          self
-        end
-
-        def refs_size
-          @refs.size
-        end
-
-        def cleanup!
-          @refs.delete_if { |ref| !ref.weakref_alive? }
-        end
-
-        def reject!
-          @refs.reject! do |ref|
-            yield ref.__getobj__
-          rescue WeakRef::RefError
-            true
-          end
-        end
-      end
+    def descendants
+      subclasses = DescendantsTracker.reject!(self.subclasses)
+      subclasses.concat(subclasses.flat_map(&:descendants))
     end
   end
 end

data/lib/active_support/duration/iso8601_parser.rb

@@ -102,12 +102,12 @@ module ActiveSupport
           raise_parsing_error("is empty duration") if parts.empty?
 
           # Mixing any of Y, M, D with W is invalid.
-          if parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          if parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
             raise_parsing_error("mixing weeks with other date parts not allowed")
           end
 
           # Specifying an empty T part is invalid.
-          if mode == :time && (parts.keys & TIME_COMPONENTS).empty?
+          if mode == :time && !parts.keys.intersect?(TIME_COMPONENTS)
             raise_parsing_error("time part marker is present but time part is empty")
           end