activesupport 6.1.4.1 → 7.0.8.3

data/lib/active_support/deprecation/behaviors.rb

@@ -3,7 +3,7 @@
 require "active_support/notifications"
 
 module ActiveSupport
-  # Raised when <tt>ActiveSupport::Deprecation::Behavior#behavior</tt> is set with <tt>:raise</tt>.
+  # Raised when ActiveSupport::Deprecation::Behavior#behavior is set with <tt>:raise</tt>.
   # You would set <tt>:raise</tt>, as a behavior to raise errors and proactively report exceptions from deprecations.
   class DeprecationException < StandardError
   end
@@ -54,7 +54,7 @@ module ActiveSupport
     # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
     # [+log+]     Log all deprecation warnings to +Rails.logger+.
     # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-    # [+silence+] Do nothing.
+    # [+silence+] Do nothing. On Rails, set <tt>config.active_support.report_deprecations = false</tt> to disable all behaviors.
     #
     # Setting behaviors only affects deprecations that happen after boot time.
     # For more information you can read the documentation of the +behavior=+ method.
@@ -93,6 +93,9 @@ module ActiveSupport
       #   ActiveSupport::Deprecation.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
       #     # custom stuff
       #   }
+      #
+      # If you are using Rails, you can set <tt>config.active_support.report_deprecations = false</tt> to disable
+      # all deprecation behaviors. This is similar to the +silence+ option but more performant.
       def behavior=(behavior)
         @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
       end
@@ -111,10 +114,10 @@ module ActiveSupport
             raise ArgumentError, "#{behavior.inspect} is not a valid deprecation behavior."
           end
 
-          if behavior.arity == 4 || behavior.arity == -1
-            behavior
-          else
+          if behavior.respond_to?(:arity) && behavior.arity == 2
             -> message, callstack, _, _ { behavior.call(message, callstack) }
+          else
+            behavior
           end
         end
     end

data/lib/active_support/deprecation/disallowed.rb

@@ -5,15 +5,15 @@ module ActiveSupport
     module Disallowed
       # Sets the criteria used to identify deprecation messages which should be
       # disallowed. Can be an array containing strings, symbols, or regular
-      # expressions. (Symbols are treated as strings). These are compared against
+      # expressions. (Symbols are treated as strings.) These are compared against
       # the text of the generated deprecation warning.
       #
       # Additionally the scalar symbol +:all+ may be used to treat all
       # deprecations as disallowed.
       #
       # Deprecations matching a substring or regular expression will be handled
-      # using the configured +ActiveSupport::Deprecation.disallowed_behavior+
-      # rather than +ActiveSupport::Deprecation.behavior+
+      # using the configured Behavior#disallowed_behavior rather than
+      # Behavior#behavior.
       attr_writer :disallowed_warnings
 
       # Returns the configured criteria used to identify deprecation messages

data/lib/active_support/deprecation/method_wrappers.rb

@@ -62,9 +62,9 @@ module ActiveSupport
             target_module.module_eval do
               redefine_method(method_name) do |*args, &block|
                 deprecator.deprecation_warning(method_name, message)
-                method.bind(self).call(*args, &block)
+                method.bind_call(self, *args, &block)
               end
-              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
+              ruby2_keywords(method_name)
             end
           else
             mod ||= Module.new
@@ -73,7 +73,7 @@ module ActiveSupport
                 deprecator.deprecation_warning(method_name, message)
                 super(*args, &block)
               end
-              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
+              ruby2_keywords(method_name)
             end
           end
         end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -2,7 +2,7 @@
 
 module ActiveSupport
   class Deprecation
-    class DeprecationProxy #:nodoc:
+    class DeprecationProxy # :nodoc:
       def self.new(*args, &block)
         object = args.first
 
@@ -26,7 +26,7 @@ module ActiveSupport
     end
 
     # DeprecatedObjectProxy transforms an object into a deprecated one. It
-    # takes an object, a deprecation message and optionally a deprecator. The
+    # takes an object, a deprecation message, and optionally a deprecator. The
     # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
     #
     #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")

data/lib/active_support/deprecation.rb

@@ -4,7 +4,7 @@ require "singleton"
 
 module ActiveSupport
   # \Deprecation specifies the API used by Rails to deprecate methods, instance
-  # variables, objects and constants.
+  # variables, objects, and constants.
   class Deprecation
     # active_support.rb sets an autoload for ActiveSupport::Deprecation.
     #
@@ -38,7 +38,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "6.2", gem_name = "Rails")
+    def initialize(deprecation_horizon = "7.1", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/descendants_tracker.rb

@@ -1,110 +1,216 @@
 # frozen_string_literal: true
 
 require "weakref"
+require "active_support/ruby_features"
 
 module ActiveSupport
   # This module provides an internal implementation to track descendants
   # which is faster than iterating through ObjectSpace.
   module DescendantsTracker
-    @@direct_descendants = {}
-
     class << self
       def direct_descendants(klass)
-        descendants = @@direct_descendants[klass]
-        descendants ? descendants.to_a : []
+        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
-      alias_method :subclasses, :direct_descendants
+    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 descendants(klass)
-        arr = []
-        accumulate_descendants(klass, arr)
-        arr
+          def [](object)
+            @map.key?(object.object_id)
+          end
+
+          def []=(object, _present)
+            @map[object.object_id] = object
+          end
+        end
+        WeakSet.new
       end
 
-      def clear
-        if defined? ActiveSupport::Dependencies
-          @@direct_descendants.each do |klass, descendants|
-            if Dependencies.autoloaded?(klass)
-              @@direct_descendants.delete(klass)
-            else
-              descendants.reject! { |v| Dependencies.autoloaded?(v) }
+      class << self
+        def disable_clear! # :nodoc:
+          unless @clear_disabled
+            @clear_disabled = true
+            remove_method(:subclasses)
+            @@excluded_descendants = nil
+          end
+        end
+
+        def subclasses(klass)
+          klass.subclasses
+        end
+
+        def descendants(klass)
+          klass.descendants
+        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
-        else
-          @@direct_descendants.clear
         end
+
+        def native? # :nodoc:
+          true
+        end
+      end
+
+      def subclasses
+        subclasses = super
+        subclasses.reject! { |d| @@excluded_descendants[d] }
+        subclasses
       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
+      def descendants
+        subclasses.concat(subclasses.flat_map(&:descendants))
       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)
+      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
+      end
+    else
+      @@direct_descendants = {}
+
+      class << self
+        def disable_clear! # :nodoc:
+          @clear_disabled = true
+        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.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
           end
         end
-    end
 
-    def inherited(base)
-      DescendantsTracker.store_inherited(self, base)
-      super
-    end
+        def native? # :nodoc:
+          false
+        end
 
-    def direct_descendants
-      DescendantsTracker.direct_descendants(self)
-    end
-    alias_method :subclasses, :direct_descendants
+        # 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
 
-    def descendants
-      DescendantsTracker.descendants(self)
-    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
 
-    # DescendantsArray is an array that contains weak references to classes.
-    class DescendantsArray # :nodoc:
-      include Enumerable
+      def inherited(base)
+        DescendantsTracker.store_inherited(self, base)
+        super
+      end
 
-      def initialize
-        @refs = []
+      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)
       end
 
-      def initialize_copy(orig)
-        @refs = @refs.dup
+      def subclasses
+        DescendantsTracker.subclasses(self)
       end
 
-      def <<(klass)
-        @refs << WeakRef.new(klass)
+      def descendants
+        DescendantsTracker.descendants(self)
       end
 
-      def each
-        @refs.reject! do |ref|
-          yield ref.__getobj__
-          false
-        rescue WeakRef::RefError
-          true
+      # DescendantsArray is an array that contains weak references to classes.
+      class DescendantsArray # :nodoc:
+        include Enumerable
+
+        def initialize
+          @refs = []
         end
-        self
-      end
 
-      def refs_size
-        @refs.size
-      end
+        def initialize_copy(orig)
+          @refs = @refs.dup
+        end
 
-      def cleanup!
-        @refs.delete_if { |ref| !ref.weakref_alive? }
-      end
+        def <<(klass)
+          @refs << WeakRef.new(klass)
+        end
 
-      def reject!
-        @refs.reject! do |ref|
-          yield ref.__getobj__
-        rescue WeakRef::RefError
-          true
+        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
     end

data/lib/active_support/digest.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "openssl"
+
 module ActiveSupport
-  class Digest #:nodoc:
-    class <<self
+  class Digest # :nodoc:
+    class << self
       def hash_digest_class
-        @hash_digest_class ||= ::Digest::MD5
+        @hash_digest_class ||= OpenSSL::Digest::MD5
       end
 
       def hash_digest_class=(klass)

data/lib/active_support/duration/iso8601_parser.rb

@@ -16,11 +16,11 @@ module ActiveSupport
       PERIOD = "."
       COMMA = ","
 
-      SIGN_MARKER = /\A\-|\+|/
+      SIGN_MARKER = /\A-|\+|/
       DATE_MARKER = /P/
       TIME_MARKER = /T/
-      DATE_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
-      TIME_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(H|M|S)/
+      DATE_COMPONENT = /(-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
+      TIME_COMPONENT = /(-?\d+(?:[.,]\d+)?)(H|M|S)/
 
       DATE_TO_PART = { "Y" => :years, "M" => :months, "W" => :weeks, "D" => :days }
       TIME_TO_PART = { "H" => :hours, "M" => :minutes, "S" => :seconds }

data/lib/active_support/duration/iso8601_serializer.rb

@@ -27,7 +27,7 @@ module ActiveSupport
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
         if parts.key?(:seconds)
-          time << "#{sprintf(@precision ? "%0.0#{@precision}f" : '%g', parts[:seconds])}S"
+          time << "#{format_seconds(parts[:seconds])}S"
         end
         output << "T#{time}" unless time.empty?
         output
@@ -54,6 +54,14 @@ module ActiveSupport
         def week_mixed_with_date?(parts)
           parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
         end
+
+        def format_seconds(seconds)
+          if @precision
+            sprintf("%0.0#{@precision}f", seconds)
+          else
+            seconds.to_s
+          end
+        end
     end
   end
 end