activesupport 7.1.3.2 → 7.2.2.2

data/lib/active_support/deprecation/constant_accessor.rb

@@ -2,28 +2,6 @@
 
 module ActiveSupport
   class Deprecation
-    # DeprecatedConstantAccessor transforms a constant into a deprecated one by
-    # hooking +const_missing+.
-    #
-    # It takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and a deprecator.
-    #
-    # The deprecated constant now returns the same object as the new one rather
-    # than a proxy object, so it can be used transparently in +rescue+ blocks
-    # etc.
-    #
-    #   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)
-    #   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-    #   deprecate_constant 'PLANETS', 'PLANETS_POST_2006', deprecator: ActiveSupport::Deprecation.new
-    #
-    #   PLANETS.map { |planet| planet.capitalize }
-    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
-    #        (Backtrace information…)
-    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     module DeprecatedConstantAccessor
       def self.included(base)
         require "active_support/inflector/methods"
@@ -39,11 +17,54 @@ module ActiveSupport
             super
           end
 
-          def deprecate_constant(const_name, new_constant, message: nil, deprecator: nil)
-            ActiveSupport.deprecator.warn("DeprecatedConstantAccessor.deprecate_constant without a deprecator is deprecated") unless deprecator
-            deprecator ||= ActiveSupport::Deprecation._instance
+          # Provides a way to rename constants with a deprecation cycle in which
+          # both the old and new names work, but using the old one prints a
+          # deprecation message.
+          #
+          # In order to rename <tt>A::B</tt> to <tt>C::D</tt>, you need to delete the
+          # definition of <tt>A::B</tt> and declare the deprecation in +A+:
+          #
+          #   require "active_support/deprecation"
+          #
+          #   module A
+          #     include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+          #
+          #     deprecate_constant "B", "C::D", deprecator: ActiveSupport::Deprecation.new
+          #   end
+          #
+          # The first argument is a constant name (no colons). It is the name of
+          # the constant you want to deprecate in the enclosing class or module.
+          #
+          # The second argument is the constant path of the replacement. That
+          # has to be a full path even if the replacement is defined in the same
+          # namespace as the deprecated one was.
+          #
+          # In both cases, strings and symbols are supported.
+          #
+          # The +deprecator+ keyword argument is the object that will print the
+          # deprecation message, an instance of ActiveSupport::Deprecation.
+          #
+          # With that in place, references to <tt>A::B</tt> still work, they
+          # evaluate to <tt>C::D</tt> now, and trigger a deprecation warning:
+          #
+          #   DEPRECATION WARNING: A::B is deprecated! Use C::D instead.
+          #   (called from ...)
+          #
+          # The message can be customized with the optional +message+ keyword
+          # argument.
+          #
+          # For this to work, a +const_missing+ hook is installed. When client
+          # code references the deprecated constant, the callback prints the
+          # message and constantizes the replacement.
+          #
+          # Caveat: If the deprecated constant name is reachable in a different
+          # namespace and Ruby constant lookup finds it, the hook won't be
+          # called and the deprecation won't work as intended. This may happen,
+          # for example, if an ancestor of the enclosing namespace has a
+          # constant with the same name. This is an unsupported edge case.
+          def deprecate_constant(old_constant_name, new_constant_path, deprecator:, message: nil)
             class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
-            class_variable_get(:@@_deprecated_constants)[const_name.to_s] = { new: new_constant, message: message, deprecator: deprecator }
+            class_variable_get(:@@_deprecated_constants)[old_constant_name.to_s] = { new: new_constant_path, message: message, deprecator: deprecator }
           end
         end
         base.singleton_class.prepend extension

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
@@ -36,11 +36,10 @@ module ActiveSupport
     #   (Backtrace)
     #   # => "#<Object:0x007fb9b34c34b0>"
     class DeprecatedObjectProxy < DeprecationProxy
-      def initialize(object, message, deprecator = nil)
+      def initialize(object, message, deprecator)
         @object = object
         @message = message
-        ActiveSupport.deprecator.warn("DeprecatedObjectProxy without a deprecator is deprecated") unless deprecator
-        @deprecator = deprecator || ActiveSupport::Deprecation._instance
+        @deprecator = deprecator
       end
 
       private
@@ -86,12 +85,11 @@ module ActiveSupport
     #   example.request.to_s
     #   # => "special_request"
     class DeprecatedInstanceVariableProxy < DeprecationProxy
-      def initialize(instance, method, var = "@#{method}", deprecator = nil)
+      def initialize(instance, method, var = "@#{method}", deprecator:)
         @instance = instance
         @method = method
         @var = var
-        ActiveSupport.deprecator.warn("DeprecatedInstanceVariableProxy without a deprecator is deprecated") unless deprecator
-        @deprecator = deprecator || ActiveSupport::Deprecation._instance
+        @deprecator = deprecator
       end
 
       private
@@ -127,13 +125,12 @@ module ActiveSupport
         super
       end
 
-      def initialize(old_const, new_const, deprecator = nil, 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
         @new_const = new_const
-        ActiveSupport.deprecator.warn("DeprecatedConstantProxy without a deprecator is deprecated") unless deprecator
-        @deprecator = deprecator || ActiveSupport::Deprecation._instance
+        @deprecator = deprecator
         @message = message
       end
 
@@ -183,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

@@ -151,7 +151,12 @@ module ActiveSupport
         end
 
         def _extract_callstack(callstack)
-          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
+          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
@@ -163,11 +168,11 @@ module ActiveSupport
           end
         end
 
-        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/"
-        LIB_DIR = RbConfig::CONFIG["libdir"]
+        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/" # :nodoc:
+        LIB_DIR = RbConfig::CONFIG["libdir"] # :nodoc:
 
         def ignored_callstack?(path)
-          path.start_with?(RAILS_GEM_ROOT, LIB_DIR)
+          path.start_with?(RAILS_GEM_ROOT, LIB_DIR) || path.include?("<internal:")
         end
     end
   end

data/lib/active_support/deprecation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "singleton"
-
 module ActiveSupport
   # = Active Support \Deprecation
   #
@@ -41,7 +39,6 @@ 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"
@@ -52,12 +49,18 @@ module ActiveSupport
     require "active_support/core_ext/module/deprecation"
     require "concurrent/atomic/thread_local_var"
 
-    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
 
@@ -65,7 +68,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "7.2", 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.

data/lib/active_support/descendants_tracker.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "weakref"
-require "active_support/ruby_features"
 
 module ActiveSupport
   # = Active Support Descendants Tracker
@@ -95,96 +94,19 @@ module ActiveSupport
       end
     end
 
-    if RubyFeatures::CLASS_SUBCLASSES
-      class << self
-        def subclasses(klass)
-          klass.subclasses
-        end
-
-        def descendants(klass)
-          klass.descendants
-        end
-      end
-
-      def descendants
-        subclasses = DescendantsTracker.reject!(self.subclasses)
-        subclasses.concat(subclasses.flat_map(&:descendants))
-      end
-    else
-      # DescendantsArray is an array that contains weak references to classes.
-      # Note: DescendantsArray is redundant with WeakSet, however WeakSet when used
-      # on Ruby 2.7 or 3.0 can trigger a Ruby crash: https://bugs.ruby-lang.org/issues/18928
-      class DescendantsArray # :nodoc:
-        include Enumerable
-
-        def initialize
-          @refs = []
-        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
-
-      @direct_descendants = {}
-
-      class << self
-        def subclasses(klass)
-          descendants = @direct_descendants[klass]
-          descendants ? DescendantsTracker.reject!(descendants.to_a) : []
-        end
-
-        def descendants(klass)
-          subclasses = self.subclasses(klass)
-          subclasses.concat(subclasses.flat_map { |k| descendants(k) })
-        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) # :nodoc:
-          (@direct_descendants[klass] ||= DescendantsArray.new) << descendant
-        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
 
-      private
-        def inherited(base) # :nodoc:
-          DescendantsTracker.store_inherited(self, base)
-          super
-        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

@@ -35,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?
@@ -50,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

@@ -14,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
@@ -221,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
@@ -232,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
@@ -366,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
@@ -504,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)

data/lib/active_support/encrypted_file.rb

@@ -69,7 +69,7 @@ module ActiveSupport
     #   decrypted or verified.
     def read
       if !key.nil? && content_path.exist?
-        decrypt content_path.binread
+        decrypt content_path.binread.strip
       else
         raise MissingContentError, content_path
       end

data/lib/active_support/error_reporter.rb

@@ -26,12 +26,16 @@ module ActiveSupport
   class ErrorReporter
     SEVERITIES = %i(error warning info)
     DEFAULT_SOURCE = "application"
+    DEFAULT_RESCUE = [StandardError].freeze
 
-    attr_accessor :logger
+    attr_accessor :logger, :debug_mode
+
+    UnexpectedError = Class.new(Exception)
 
     def initialize(*subscribers, logger: nil)
       @subscribers = subscribers.flatten
       @logger = logger
+      @debug_mode = false
     end
 
     # Evaluates the given block, reporting and swallowing any unhandled error.
@@ -72,7 +76,7 @@ module ActiveSupport
     #   source of the error. Subscribers can use this value to ignore certain
     #   errors. Defaults to <tt>"application"</tt>.
     def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)
-      error_classes = [StandardError] if error_classes.blank?
+      error_classes = DEFAULT_RESCUE if error_classes.empty?
       yield
     rescue *error_classes => error
       report(error, handled: true, severity: severity, context: context, source: source)
@@ -108,13 +112,47 @@ module ActiveSupport
     #   source of the error. Subscribers can use this value to ignore certain
     #   errors. Defaults to <tt>"application"</tt>.
     def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)
-      error_classes = [StandardError] if error_classes.blank?
+      error_classes = DEFAULT_RESCUE if error_classes.empty?
       yield
     rescue *error_classes => error
       report(error, handled: false, severity: severity, context: context, source: source)
       raise
     end
 
+    # Either report the given error when in production, or raise it when in development or test.
+    #
+    # When called in production, after the error is reported, this method will return
+    # nil and execution will continue.
+    #
+    # When called in development, the original error is wrapped in a different error class to ensure
+    # it's not being rescued higher in the stack and will be surfaced to the developer.
+    #
+    # This method is intended for reporting violated assertions about preconditions, or similar
+    # cases that can and should be gracefully handled in production, but that aren't supposed to happen.
+    #
+    # The error can be either an exception instance or a String.
+    #
+    #   example:
+    #
+    #     def edit
+    #       if published?
+    #         Rails.error.unexpected("[BUG] Attempting to edit a published article, that shouldn't be possible")
+    #         return false
+    #       end
+    #       # ...
+    #     end
+    #
+    def unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE)
+      error = RuntimeError.new(error) if error.is_a?(String)
+      error.set_backtrace(caller(1)) if error.backtrace.nil?
+
+      if @debug_mode
+        raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error
+      else
+        report(error, handled: true, severity: severity, context: context, source: source)
+      end
+    end
+
     # Register a new error subscriber. The subscriber must respond to
     #
     #   report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)

data/lib/active_support/evented_file_update_checker.rb

@@ -6,7 +6,6 @@ require "listen"
 require "set"
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
-require "active_support/fork_tracker"
 
 module ActiveSupport
   # Allows you to "listen" to changes in a file system.

data/lib/active_support/execution_wrapper.rb

@@ -2,7 +2,6 @@
 
 require "active_support/error_reporter"
 require "active_support/callbacks"
-require "concurrent/hash"
 
 module ActiveSupport
   class ExecutionWrapper

data/lib/active_support/file_update_checker.rb

@@ -104,7 +104,7 @@ module ActiveSupport
         @watched || begin
           all = @files.select { |f| File.exist?(f) }
           all.concat(Dir[@glob]) if @glob
-          all
+          all.tap(&:uniq!)
         end
       end
 

data/lib/active_support/fork_tracker.rb

@@ -2,7 +2,7 @@
 
 module ActiveSupport
   module ForkTracker # :nodoc:
-    module ModernCoreExt
+    module CoreExt
       def _fork
         pid = super
         if pid == 0
@@ -12,27 +12,6 @@ module ActiveSupport
       end
     end
 
-    module CoreExt
-      def fork(...)
-        if block_given?
-          super do
-            ForkTracker.check!
-            yield
-          end
-        else
-          unless pid = super
-            ForkTracker.check!
-          end
-          pid
-        end
-      end
-    end
-
-    module CoreExtPrivate
-      include CoreExt
-      private :fork
-    end
-
     @pid = Process.pid
     @callbacks = []
 
@@ -45,23 +24,8 @@ module ActiveSupport
         end
       end
 
-      if Process.respond_to?(:_fork) # Ruby 3.1+
-        def check!
-          # We trust the `_fork` callback
-        end
-      else
-        alias_method :check!, :after_fork_callback
-      end
-
       def hook!
-        if Process.respond_to?(:_fork) # Ruby 3.1+
-          ::Process.singleton_class.prepend(ModernCoreExt)
-        elsif Process.respond_to?(:fork)
-          ::Object.prepend(CoreExtPrivate) if RUBY_VERSION < "3.0"
-          ::Kernel.prepend(CoreExtPrivate)
-          ::Kernel.singleton_class.prepend(CoreExt)
-          ::Process.singleton_class.prepend(CoreExt)
-        end
+        ::Process.singleton_class.prepend(CoreExt)
       end
 
       def after_fork(&block)

data/lib/active_support/gem_version.rb

@@ -8,8 +8,8 @@ module ActiveSupport
 
   module VERSION
     MAJOR = 7
-    MINOR = 1
-    TINY  = 3
+    MINOR = 2
+    TINY  = 2
     PRE   = "2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_support/hash_with_indifferent_access.rb

@@ -387,15 +387,13 @@ module ActiveSupport
       _new_hash
     end
 
+    def to_proc
+      proc { |key| self[key] }
+    end
+
     private
-      if Symbol.method_defined?(:name)
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.name : key
-        end
-      else
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.to_s : key
-        end
+      def convert_key(key)
+        Symbol === key ? key.name : key
       end
 
       def convert_value(value, conversion: nil)

data/lib/active_support/html_safe_translation.rb

@@ -9,11 +9,14 @@ module ActiveSupport
         html_safe_options = html_escape_translation_options(options)
 
         exception = false
+
         exception_handler = ->(*args) do
           exception = true
           I18n.exception_handler.call(*args)
         end
+
         translation = I18n.translate(key, **html_safe_options, exception_handler: exception_handler)
+
         if exception
           translation
         else
@@ -24,11 +27,11 @@ module ActiveSupport
       end
     end
 
-    private
-      def html_safe_translation_key?(key)
-        /(?:_|\b)html\z/.match?(key)
-      end
+    def html_safe_translation_key?(key)
+      /(?:_|\b)html\z/.match?(key)
+    end
 
+    private
       def html_escape_translation_options(options)
         options.each do |name, value|
           unless i18n_option?(name) || (name == :count && value.is_a?(Numeric))

data/lib/active_support/json/encoding.rb

@@ -76,7 +76,7 @@ module ActiveSupport
             when Hash
               result = {}
               value.each do |k, v|
-                k = k.to_s unless String === k
+                k = k.to_s unless Symbol === k || String === k
                 result[k] = jsonify(v)
               end
               result