activesupport 6.1.4.1 → 7.0.8.3

data/lib/active_support/parameter_filter.rb

@@ -3,27 +3,36 @@
 require "active_support/core_ext/object/duplicable"
 
 module ActiveSupport
-  # +ParameterFilter+ allows you to specify keys for sensitive data from
-  # hash-like object and replace corresponding value. Filtering only certain
-  # sub-keys from a hash is possible by using the dot notation:
-  # 'credit_card.number'. If a proc is given, each key and value of a hash and
-  # all sub-hashes are passed to it, where the value or the key can be replaced
-  # using String#replace or similar methods.
+  # +ParameterFilter+ replaces values in a <tt>Hash</tt>-like object if their
+  # keys match one of the specified filters.
   #
+  # Matching based on nested keys is possible by using dot notation, e.g.
+  # <tt>"credit_card.number"</tt>.
+  #
+  # If a proc is given as a filter, each key and value of the <tt>Hash</tt>-like
+  # and of any nested <tt>Hash</tt>es will be passed to it. The value or key can
+  # then be mutated as desired using methods such as <tt>String#replace</tt>.
+  #
+  #   # Replaces values with "[FILTERED]" for keys that match /password/i.
   #   ActiveSupport::ParameterFilter.new([:password])
-  #   => replaces the value to all keys matching /password/i with "[FILTERED]"
   #
+  #   # Replaces values with "[FILTERED]" for keys that match /foo|bar/i.
   #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
-  #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
   #
+  #   # Replaces values for the exact key "pin" and for keys that begin with
+  #   # "pin_". Does not match keys that otherwise include "pin" as a
+  #   # substring, such as "shipping_id".
+  #   ActiveSupport::ParameterFilter.new([/\Apin\z/, /\Apin_/])
+  #
+  #   # Replaces the value for :code in `{ credit_card: { code: "xxxx" } }`.
+  #   # Does not change `{ file: { code: "xxxx" } }`.
   #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
-  #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
-  #   change { file: { code: "xxxx"} }
   #
+  #   # Reverses values for keys that match /secret/i.
   #   ActiveSupport::ParameterFilter.new([-> (k, v) do
   #     v.reverse! if /secret/i.match?(k)
   #   end])
-  #   => reverses the value to all keys matching /secret/i
+  #
   class ParameterFilter
     FILTERED = "[FILTERED]" # :nodoc:
 

data/lib/active_support/per_thread_registry.rb

@@ -40,6 +40,10 @@ module ActiveSupport
   # If the class has an initializer, it must accept no arguments.
   module PerThreadRegistry
     def self.extended(object)
+      ActiveSupport::Deprecation.warn(<<~MSG)
+        ActiveSupport::PerThreadRegistry is deprecated and will be removed in Rails 7.1.
+        Use `Module#thread_mattr_accessor` instead.
+      MSG
       object.instance_variable_set :@per_thread_registry_key, object.name.freeze
     end
 
@@ -56,5 +60,6 @@ module ActiveSupport
 
         send(name, *args, &block)
       end
+      ruby2_keywords(:method_missing)
   end
 end

data/lib/active_support/railtie.rb

@@ -6,9 +6,27 @@ require "active_support/i18n_railtie"
 module ActiveSupport
   class Railtie < Rails::Railtie # :nodoc:
     config.active_support = ActiveSupport::OrderedOptions.new
+    config.active_support.disable_to_s_conversion = false
 
     config.eager_load_namespaces << ActiveSupport
 
+    initializer "active_support.isolation_level" do |app|
+      config.after_initialize do
+        if level = app.config.active_support.delete(:isolation_level)
+          ActiveSupport::IsolatedExecutionState.isolation_level = level
+        end
+      end
+    end
+
+    initializer "active_support.remove_deprecated_time_with_zone_name" do |app|
+      config.after_initialize do
+        if app.config.active_support.remove_deprecated_time_with_zone_name
+          require "active_support/time_with_zone"
+          TimeWithZone.singleton_class.remove_method(:name)
+        end
+      end
+    end
+
     initializer "active_support.set_authenticated_message_encryption" do |app|
       config.after_initialize do
         unless app.config.active_support.use_authenticated_message_encryption.nil?
@@ -18,28 +36,48 @@ module ActiveSupport
       end
     end
 
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload { ActiveSupport::ExecutionContext.clear }
+      app.executor.to_run              { ActiveSupport::ExecutionContext.clear }
+      app.executor.to_complete         { ActiveSupport::ExecutionContext.clear }
+    end
+
     initializer "active_support.reset_all_current_attributes_instances" do |app|
       app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
       app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
       app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
 
       ActiveSupport.on_load(:active_support_test_case) do
-        require "active_support/current_attributes/test_helper"
-        include ActiveSupport::CurrentAttributes::TestHelper
+        if app.config.active_support.executor_around_test_case
+          require "active_support/executor/test_helper"
+          include ActiveSupport::Executor::TestHelper
+        else
+          require "active_support/current_attributes/test_helper"
+          include ActiveSupport::CurrentAttributes::TestHelper
+
+          require "active_support/execution_context/test_helper"
+          include ActiveSupport::ExecutionContext::TestHelper
+        end
       end
     end
 
     initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
-      end
+      if app.config.active_support.report_deprecations == false
+        ActiveSupport::Deprecation.silenced = true
+        ActiveSupport::Deprecation.behavior = :silence
+        ActiveSupport::Deprecation.disallowed_behavior = :silence
+      else
+        if deprecation = app.config.active_support.deprecation
+          ActiveSupport::Deprecation.behavior = deprecation
+        end
 
-      if disallowed_deprecation = app.config.active_support.disallowed_deprecation
-        ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
-      end
+        if disallowed_deprecation = app.config.active_support.disallowed_deprecation
+          ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
+        end
 
-      if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
-        ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
+        if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
+          ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
+        end
       end
     end
 
@@ -75,6 +113,10 @@ module ActiveSupport
       end
     end
 
+    initializer "active_support.set_error_reporter" do |app|
+      ActiveSupport.error_reporter = app.executor.error_reporter
+    end
+
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
         k = "#{k}="
@@ -84,19 +126,27 @@ module ActiveSupport
 
     initializer "active_support.set_hash_digest_class" do |app|
       config.after_initialize do
-        if app.config.active_support.use_sha1_digests
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            config.active_support.use_sha1_digests is deprecated and will
-            be removed from Rails 6.2. Use
-            config.active_support.hash_digest_class = ::Digest::SHA1 instead.
-          MSG
-          ActiveSupport::Digest.hash_digest_class = ::Digest::SHA1
-        end
-
         if klass = app.config.active_support.hash_digest_class
           ActiveSupport::Digest.hash_digest_class = klass
         end
       end
     end
+
+    initializer "active_support.set_key_generator_hash_digest_class" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.key_generator_hash_digest_class
+          ActiveSupport::KeyGenerator.hash_digest_class = klass
+        end
+      end
+    end
+
+    initializer "active_support.set_rfc4122_namespaced_uuids" do |app|
+      config.after_initialize do
+        if app.config.active_support.use_rfc4122_namespaced_uuids
+          require "active_support/core_ext/digest"
+          ::Digest::UUID.use_rfc4122_namespaced_uuids = app.config.active_support.use_rfc4122_namespaced_uuids
+        end
+      end
+    end
   end
 end

data/lib/active_support/reloader.rb

@@ -58,7 +58,7 @@ module ActiveSupport
       prepare!
     end
 
-    def self.run! # :nodoc:
+    def self.run!(reset: false) # :nodoc:
       if check!
         super
       else

data/lib/active_support/rescuable.rb

@@ -30,20 +30,20 @@ module ActiveSupport
       # any.
       #
       #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
+      #     rescue_from User::NotAuthorized, with: :deny_access
+      #     rescue_from ActiveRecord::RecordInvalid, with: :show_record_errors
       #
-      #     rescue_from 'MyAppError::Base' do |exception|
-      #       render xml: exception, status: 500
+      #     rescue_from "MyApp::BaseError" do |exception|
+      #       redirect_to root_url, alert: exception.message
       #     end
       #
       #     private
       #       def deny_access
-      #         ...
+      #         head :forbidden
       #       end
       #
-      #       def show_errors(exception)
-      #         exception.record.new_record? ? ...
+      #       def show_record_errors(exception)
+      #         redirect_back_or_to root_url, alert: exception.record.errors.full_messages.to_sentence
       #       end
       #   end
       #
@@ -74,12 +74,12 @@ module ActiveSupport
       # Matches an exception to a handler based on the exception class.
       #
       # If no handler matches the exception, check for a handler matching the
-      # (optional) exception.cause. If no handler matches the exception or its
+      # (optional) +exception.cause+. If no handler matches the exception or its
       # cause, this returns +nil+, so you can deal with unhandled exceptions.
       # Be sure to re-raise unhandled exceptions if this is what you expect.
       #
       #     begin
-      #       …
+      #       # ...
       #     rescue => exception
       #       rescue_with_handler(exception) || raise
       #     end
@@ -100,7 +100,7 @@ module ActiveSupport
         end
       end
 
-      def handler_for_rescue(exception, object: self) #:nodoc:
+      def handler_for_rescue(exception, object: self) # :nodoc:
         case rescuer = find_rescue_handler(exception)
         when Symbol
           method = object.method(rescuer)
@@ -160,14 +160,14 @@ module ActiveSupport
     end
 
     # Delegates to the class method, but uses the instance as the subject for
-    # rescue_from handlers (method calls, instance_exec blocks).
+    # rescue_from handlers (method calls, +instance_exec+ blocks).
     def rescue_with_handler(exception)
       self.class.rescue_with_handler exception, object: self
     end
 
     # Internal handler lookup. Delegates to class method. Some libraries call
     # this directly, so keeping it around for compatibility.
-    def handler_for_rescue(exception) #:nodoc:
+    def handler_for_rescue(exception) # :nodoc:
       self.class.handler_for_rescue exception, object: self
     end
   end

data/lib/active_support/ruby_features.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module RubyFeatures # :nodoc:
+    CLASS_SUBCLASSES = Class.method_defined?(:subclasses) # RUBY_VERSION >= "3.1"
+  end
+end

data/lib/active_support/secure_compare_rotator.rb

@@ -4,7 +4,7 @@ require "active_support/security_utils"
 require "active_support/messages/rotator"
 
 module ActiveSupport
-  # The ActiveSupport::SecureCompareRotator is a wrapper around +ActiveSupport::SecurityUtils.secure_compare+
+  # The ActiveSupport::SecureCompareRotator is a wrapper around ActiveSupport::SecurityUtils.secure_compare
   # and allows you to rotate a previously defined value to a new one.
   #
   # It can be used as follow:
@@ -17,7 +17,7 @@ module ActiveSupport
   #
   #   class MyController < ApplicationController
   #     def authenticate_request
-  #       rotator = ActiveSupport::SecureComparerotator.new('new_password')
+  #       rotator = ActiveSupport::SecureCompareRotator.new('new_password')
   #       rotator.rotate('old_password')
   #
   #       authenticate_or_request_with_http_basic do |username, password|

data/lib/active_support/string_inquirer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/symbol/starts_ends_with"
-
 module ActiveSupport
   # Wrapping a string in this class gives you a prettier way to test
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped

data/lib/active_support/subscriber.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
 require "active_support/notifications"
 
 module ActiveSupport
@@ -150,25 +149,15 @@ module ActiveSupport
       send(method, event)
     end
 
+    def publish_event(event) # :nodoc:
+      method = event.name.split(".").first
+      send(method, event)
+    end
+
     private
       def event_stack
-        SubscriberQueueRegistry.instance.get_queue(@queue_key)
+        registry = ActiveSupport::IsolatedExecutionState[:active_support_subscriber_queue_registry] ||= {}
+        registry[@queue_key] ||= []
       end
   end
-
-  # This is a registry for all the event stacks kept for subscribers.
-  #
-  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
-  # for further details.
-  class SubscriberQueueRegistry # :nodoc:
-    extend PerThreadRegistry
-
-    def initialize
-      @registry = {}
-    end
-
-    def get_queue(queue_key)
-      @registry[queue_key] ||= []
-    end
-  end
 end

data/lib/active_support/tagged_logging.rb

@@ -57,7 +57,7 @@ module ActiveSupport
       def current_tags
         # We use our object ID here to avoid conflicting with other instances
         thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
-        Thread.current[thread_key] ||= []
+        IsolatedExecutionState[thread_key] ||= []
       end
 
       def tags_text
@@ -79,7 +79,7 @@ module ActiveSupport
     end
 
     def self.new(logger)
-      logger = logger.dup
+      logger = logger.clone
 
       if logger.formatter
         logger.formatter = logger.formatter.dup

data/lib/active_support/test_case.rb

@@ -12,6 +12,7 @@ require "active_support/testing/constant_lookup"
 require "active_support/testing/time_helpers"
 require "active_support/testing/file_fixtures"
 require "active_support/testing/parallelization"
+require "active_support/testing/parallelize_executor"
 require "concurrent/utility/processor_counter"
 
 module ActiveSupport
@@ -71,26 +72,17 @@ module ActiveSupport
       #
       # The threaded parallelization uses minitest's parallel executor directly.
       # The processes parallelization uses a Ruby DRb server.
-      def parallelize(workers: :number_of_processors, with: :processes)
+      #
+      # Because parallelization presents an overhead, it is only enabled when the
+      # number of tests to run is above the +threshold+ param. The default value is
+      # 50, and it's configurable via +config.active_support.test_parallelization_threshold+.
+      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold)
         workers = Concurrent.physical_processor_count if workers == :number_of_processors
         workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
 
         return if workers <= 1
 
-        executor = case with
-                   when :processes
-                     Testing::Parallelization.new(workers)
-                   when :threads
-                     Minitest::Parallel::Executor.new(workers)
-                   else
-                     raise ArgumentError, "#{with} is not a supported parallelization executor."
-        end
-
-        self.lock_threads = false if defined?(self.lock_threads) && with == :threads
-
-        Minitest.parallel_executor = executor
-
-        parallelize_me!
+        Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold)
       end
 
       # Set up hook for parallel testing. This can be used if you have multiple
@@ -107,9 +99,7 @@ module ActiveSupport
       #     end
       #   end
       def parallelize_setup(&block)
-        ActiveSupport::Testing::Parallelization.after_fork_hook do |worker|
-          yield worker
-        end
+        ActiveSupport::Testing::Parallelization.after_fork_hook(&block)
       end
 
       # Clean up hook for parallel testing. This can be used to drop databases
@@ -126,9 +116,7 @@ module ActiveSupport
       #     end
       #   end
       def parallelize_teardown(&block)
-        ActiveSupport::Testing::Parallelization.run_cleanup_hook do |worker|
-          yield worker
-        end
+        ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block)
       end
     end
 
@@ -159,5 +147,9 @@ module ActiveSupport
     alias :assert_not_same :refute_same
 
     ActiveSupport.run_load_hooks(:active_support_test_case, self)
+
+    def inspect # :nodoc:
+      Object.instance_method(:to_s).bind_call(self)
+    end
   end
 end

data/lib/active_support/testing/assertions.rb

@@ -99,7 +99,7 @@ module ActiveSupport
         }
         before = exps.map(&:call)
 
-        retval = assert_nothing_raised(&block)
+        retval = _assert_nothing_raised_or_warn("assert_difference", &block)
 
         expressions.zip(exps, before) do |(code, diff), exp, before_value|
           error  = "#{code.inspect} didn't change by #{diff}"
@@ -159,7 +159,7 @@ module ActiveSupport
       #     @object = 42
       #   end
       #
-      # The keyword arguments :from and :to can be given to specify the
+      # The keyword arguments +:from+ and +:to+ can be given to specify the
       # expected initial value and the expected value after the block was
       # executed.
       #
@@ -176,7 +176,7 @@ module ActiveSupport
         exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
 
         before = exp.call
-        retval = assert_nothing_raised(&block)
+        retval = _assert_nothing_raised_or_warn("assert_changes", &block)
 
         unless from == UNTRACKED
           error = "Expected change from #{from.inspect}"
@@ -189,7 +189,7 @@ module ActiveSupport
         error = "#{expression.inspect} didn't change"
         error = "#{error}. It was already #{to}" if before == to
         error = "#{message}.\n#{error}" if message
-        assert_not_equal before, after, error
+        refute_equal before, after, error
 
         unless to == UNTRACKED
           error = "Expected change to #{to}\n"
@@ -207,16 +207,30 @@ module ActiveSupport
       #     post :create, params: { status: { ok: true } }
       #   end
       #
+      # Provide the optional keyword argument :from to specify the expected
+      # initial value.
+      #
+      #   assert_no_changes -> { Status.all_good? }, from: true do
+      #     post :create, params: { status: { ok: true } }
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do
       #     post :create, params: { status: { ok: false } }
       #   end
-      def assert_no_changes(expression, message = nil, &block)
+      def assert_no_changes(expression, message = nil, from: UNTRACKED, &block)
         exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
 
         before = exp.call
-        retval = assert_nothing_raised(&block)
+        retval = _assert_nothing_raised_or_warn("assert_no_changes", &block)
+
+        unless from == UNTRACKED
+          error = "Expected initial value of #{from.inspect}"
+          error = "#{message}.\n#{error}" if message
+          assert from === before, error
+        end
+
         after = exp.call
 
         error = "#{expression.inspect} changed"
@@ -230,6 +244,22 @@ module ActiveSupport
 
         retval
       end
+
+      private
+        def _assert_nothing_raised_or_warn(assertion, &block)
+          assert_nothing_raised(&block)
+        rescue Minitest::UnexpectedError => e
+          if tagged_logger && tagged_logger.warn?
+            warning = <<~MSG
+              #{self.class} - #{name}: #{e.error.class} raised.
+              If you expected this exception, use `assert_raises` as near to the code that raises as possible.
+              Other block based assertions (e.g. `#{assertion}`) can be used, as long as `assert_raises` is inside their block.
+            MSG
+            tagged_logger.warn warning
+          end
+
+          raise
+        end
     end
   end
 end

data/lib/active_support/testing/deprecation.rb

@@ -4,7 +4,30 @@ require "active_support/deprecation"
 
 module ActiveSupport
   module Testing
-    module Deprecation #:nodoc:
+    module Deprecation
+      # Asserts that a matching deprecation warning was emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_deprecated(/foo/, CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # The +match+ object may be a +Regexp+, or +String+ appearing in the message.
+      #
+      #   assert_deprecated('foo', CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # If the +match+ is omitted (or explicitly +nil+), any deprecation warning will match.
+      #
+      #   assert_deprecated(nil, CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
+      #
+      #   assert_deprecated do
+      #     ActiveSupport::Deprecation.warn "foo should no longer be used"
+      #   end
       def assert_deprecated(match = nil, deprecator = nil, &block)
         result, warnings = collect_deprecations(deprecator, &block)
         assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
@@ -15,12 +38,40 @@ module ActiveSupport
         result
       end
 
+      # Asserts that no deprecation warnings are emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_not_deprecated(CustomDeprecator) do
+      #     CustomDeprecator.warn "message" # fails assertion
+      #   end
+      #
+      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
+      #
+      #   assert_not_deprecated do
+      #     ActiveSupport::Deprecation.warn "message" # fails assertion
+      #   end
+      #
+      #   assert_not_deprecated do
+      #     CustomDeprecator.warn "message" # passes assertion
+      #   end
       def assert_not_deprecated(deprecator = nil, &block)
         result, deprecations = collect_deprecations(deprecator, &block)
         assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
         result
       end
 
+      # Returns an array of all the deprecation warnings emitted by the given
+      # +deprecator+ during the execution of the yielded block.
+      #
+      #   collect_deprecations(CustomDeprecator) do
+      #     CustomDeprecator.warn "message"
+      #   end # => ["message"]
+      #
+      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
+      #
+      #   collect_deprecations do
+      #     CustomDeprecator.warn "custom message"
+      #     ActiveSupport::Deprecation.warn "message"
+      #   end # => ["message"]
       def collect_deprecations(deprecator = nil)
         deprecator ||= ActiveSupport::Deprecation
         old_behavior = deprecator.behavior