activesupport 7.0.0 → 7.2.2.1

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,221 +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)
-            remove_method(:descendants)
-            @@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
-        descendants = super
-        descendants.reject! { |d| @@excluded_descendants[d] }
-        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
 

data/lib/active_support/duration/iso8601_serializer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/blank"
-
 module ActiveSupport
   class Duration
     # Serializes duration to string according to ISO 8601 Duration format.
@@ -37,7 +35,6 @@ module ActiveSupport
         # Return pair of duration's parts and whole duration sign.
         # Parts are summarized (as they can become repetitive due to addition, etc).
         # Zero parts are removed as not significant.
-        # If all parts are negative it will negate all of them and return minus as a sign.
         def normalize
           parts = @duration.parts.each_with_object(Hash.new(0)) do |(k, v), p|
             p[k] += v  unless v.zero?
@@ -52,7 +49,7 @@ module ActiveSupport
         end
 
         def week_mixed_with_date?(parts)
-          parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
         end
 
         def format_seconds(seconds)

data/lib/active_support/duration.rb

@@ -3,9 +3,10 @@
 require "active_support/core_ext/array/conversions"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/string/filters"
 
 module ActiveSupport
+  # = Active Support \Duration
+  #
   # Provides accurate date and time measurements using Date#advance and
   # Time#advance, respectively. It mainly supports the methods on Numeric.
   #
@@ -13,7 +14,7 @@ module ActiveSupport
   class Duration
     class Scalar < Numeric # :nodoc:
       attr_reader :value
-      delegate :to_i, :to_f, :to_s, to: :value
+      delegate :to_i, :to_f, :to_s, to: :@value
 
       def initialize(value)
         @value = value
@@ -220,6 +221,8 @@ module ActiveSupport
         end
     end
 
+    Delegation.generate(self, [:to_f, :positive?, :negative?, :zero?, :abs], to: :@value, as: Integer, nilable: false)
+
     def initialize(value, parts, variable = nil) # :nodoc:
       @value, @parts = value, parts
       @parts.reject! { |k, v| v.zero? } unless value == 0
@@ -231,7 +234,10 @@ module ActiveSupport
       end
     end
 
-    # Returns a copy of the parts hash that defines the duration
+    # Returns a copy of the parts hash that defines the duration.
+    #
+    #   5.minutes.parts # => {:minutes=>5}
+    #   3.years.parts # => {:years=>3}
     def parts
       @parts.dup
     end
@@ -365,8 +371,8 @@ module ActiveSupport
     #   1.year.to_i     # => 31556952
     #
     # In such cases, Ruby's core
-    # Date[https://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
-    # Time[https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # Date[https://docs.ruby-lang.org/en/master/Date.html] and
+    # Time[https://docs.ruby-lang.org/en/master/Time.html] should be used for precision
     # date and time arithmetic.
     def to_i
       @value.to_i
@@ -503,8 +509,8 @@ module ActiveSupport
         value.respond_to?(method)
       end
 
-      def method_missing(method, *args, &block)
-        value.public_send(method, *args, &block)
+      def method_missing(...)
+        value.public_send(...)
       end
 
       def raise_type_error(other)