activesupport 6.0.6 → 7.0.1

data/lib/active_support/deprecation/behaviors.rb

@@ -51,10 +51,10 @@ module ActiveSupport
     # constant. Available behaviors are:
     #
     # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-    # [+stderr+]  Log all deprecation warnings to +$stderr+.
+    # [+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.
@@ -67,13 +67,18 @@ module ActiveSupport
         @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
       end
 
+      # Returns the current behavior for disallowed deprecations or if one isn't set, defaults to +:raise+.
+      def disallowed_behavior
+        @disallowed_behavior ||= [DEFAULT_BEHAVIORS[:raise]]
+      end
+
       # Sets the behavior to the specified value. Can be a single value, array,
       # or an object that responds to +call+.
       #
       # Available behaviors:
       #
       # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-      # [+stderr+]  Log all deprecation warnings to +$stderr+.
+      # [+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.
@@ -88,10 +93,21 @@ 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
 
+      # Sets the behavior for disallowed deprecations (those configured by
+      # ActiveSupport::Deprecation.disallowed_warnings=) to the specified
+      # value. As with +behavior=+, this can be a single value, array, or an
+      # object that responds to +call+.
+      def disallowed_behavior=(behavior)
+        @disallowed_behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
+      end
+
       private
         def arity_coerce(behavior)
           unless behavior.respond_to?(:call)

data/lib/active_support/deprecation/disallowed.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    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
+      # 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+
+      attr_writer :disallowed_warnings
+
+      # Returns the configured criteria used to identify deprecation messages
+      # which should be treated as disallowed.
+      def disallowed_warnings
+        @disallowed_warnings ||= []
+      end
+
+      private
+        def deprecation_disallowed?(message)
+          disallowed = ActiveSupport::Deprecation.disallowed_warnings
+          return false if explicitly_allowed?(message)
+          return true if disallowed == :all
+          disallowed.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+
+        def explicitly_allowed?(message)
+          allowances = @explicitly_allowed_warnings.value
+          return false unless allowances
+          return true if allowances == :all
+          allowances = [allowances] unless allowances.kind_of?(Array)
+          allowances.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_support/deprecation/instance_delegator.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/module/delegation"
 
 module ActiveSupport

data/lib/active_support/deprecation/method_wrappers.rb

@@ -56,23 +56,24 @@ module ActiveSupport
         mod = nil
 
         method_names.each do |method_name|
+          message = options[method_name]
           if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
             method = target_module.instance_method(method_name)
             target_module.module_eval do
               redefine_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, options[method_name])
-                method.bind(self).call(*args, &block)
+                deprecator.deprecation_warning(method_name, message)
+                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
             mod.module_eval do
               define_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, options[method_name])
+                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
 
@@ -121,7 +121,7 @@ module ActiveSupport
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < Module
-      def self.new(*args, **kwargs, &block)
+      def self.new(*args, **options, &block)
         object = args.first
 
         return object unless object
@@ -129,7 +129,7 @@ module ActiveSupport
       end
 
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
-        require "active_support/inflector/methods"
+        Kernel.require "active_support/inflector/methods"
 
         @old_const = old_const
         @new_const = new_const

data/lib/active_support/deprecation/reporting.rb

@@ -6,7 +6,7 @@ module ActiveSupport
   class Deprecation
     module Reporting
       # Whether to print a message (silent mode)
-      attr_accessor :silenced
+      attr_writer :silenced
       # Name of gem where method is deprecated
       attr_accessor :gem_name
 
@@ -20,7 +20,11 @@ module ActiveSupport
 
         callstack ||= caller_locations(2)
         deprecation_message(callstack, message).tap do |m|
-          behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          if deprecation_disallowed?(message)
+            disallowed_behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          else
+            behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          end
         end
       end
 
@@ -33,11 +37,50 @@ module ActiveSupport
       #     ActiveSupport::Deprecation.warn('something broke!')
       #   end
       #   # => nil
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
-      ensure
-        @silenced = old_silenced
+      def silence(&block)
+        @silenced_thread.bind(true, &block)
+      end
+
+      # Allow previously disallowed deprecation warnings within the block.
+      # <tt>allowed_warnings</tt> can be an array containing strings, symbols, or regular
+      # 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+
+      #
+      # 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 = [
+      #     "something broke"
+      #   ]
+      #
+      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   # => ActiveSupport::DeprecationException
+      #
+      #   ActiveSupport::Deprecation.allow ['something broke'] do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => nil
+      #
+      #   ActiveSupport::Deprecation.allow ['something broke'], if: Rails.env.production? do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => ActiveSupport::DeprecationException for dev/test, nil for production
+      def allow(allowed_warnings = :all, if: true, &block)
+        conditional = binding.local_variable_get(:if)
+        conditional = conditional.call if conditional.respond_to?(:call)
+        if conditional
+          @explicitly_allowed_warnings.bind(allowed_warnings, &block)
+        else
+          yield
+        end
+      end
+
+      def silenced
+        @silenced || @silenced_thread.value
       end
 
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)

data/lib/active_support/deprecation.rb

@@ -17,15 +17,18 @@ module ActiveSupport
     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/core_ext/module/deprecation"
+    require "concurrent/atomic/thread_local_var"
 
     include Singleton
     include InstanceDelegator
     include Behavior
     include Reporting
+    include Disallowed
     include MethodWrapper
 
     # The version number in which the deprecated behavior will be removed, by default.
@@ -35,12 +38,14 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "6.1", 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.
       self.silenced = false
       self.debug = false
+      @silenced_thread = Concurrent::ThreadLocalVar.new(false)
+      @explicitly_allowed_warnings = Concurrent::ThreadLocalVar.new(nil)
     end
   end
 end

data/lib/active_support/descendants_tracker.rb

@@ -1,106 +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
+    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
+        # 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)
-        cleanup!
-        @refs << WeakRef.new(klass)
+      def descendants
+        DescendantsTracker.descendants(self)
       end
 
-      def each
-        @refs.each do |ref|
-          yield ref.__getobj__
-        rescue WeakRef::RefError
+      # DescendantsArray is an array that contains weak references to classes.
+      class DescendantsArray # :nodoc:
+        include Enumerable
+
+        def initialize
+          @refs = []
         end
-      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

@@ -6,6 +6,8 @@ module ActiveSupport
   class Duration
     # Serializes duration to string according to ISO 8601 Duration format.
     class ISO8601Serializer # :nodoc:
+      DATE_COMPONENTS = %i(years months days)
+
       def initialize(duration, precision: nil)
         @duration = duration
         @precision = precision
@@ -13,22 +15,22 @@ module ActiveSupport
 
       # Builds and returns output string.
       def serialize
-        parts, sign = normalize
+        parts = normalize
         return "PT0S" if parts.empty?
 
         output = +"P"
         output << "#{parts[:years]}Y"   if parts.key?(:years)
         output << "#{parts[:months]}M"  if parts.key?(:months)
-        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         output << "#{parts[:days]}D"    if parts.key?(:days)
+        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         time = +""
         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?
-        "#{sign}#{output}"
+        output
       end
 
       private
@@ -40,13 +42,25 @@ module ActiveSupport
           parts = @duration.parts.each_with_object(Hash.new(0)) do |(k, v), p|
             p[k] += v  unless v.zero?
           end
-          # If all parts are negative - let's make a negative duration
-          sign = ""
-          if parts.values.all? { |v| v < 0 }
-            sign = "-"
-            parts.transform_values!(&:-@)
+
+          # Convert weeks to days and remove weeks if mixed with date parts
+          if week_mixed_with_date?(parts)
+            parts[:days] += parts.delete(:weeks) * SECONDS_PER_WEEK / SECONDS_PER_DAY
+          end
+
+          parts
+        end
+
+        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
-          [parts, sign]
         end
     end
   end