activesupport 7.1.6 → 8.1.1

data/lib/active_support/option_merger.rb

@@ -31,8 +31,8 @@ module ActiveSupport
         end
       end
 
-      def respond_to_missing?(*arguments)
-        @context.respond_to?(*arguments)
+      def respond_to_missing?(...)
+        @context.respond_to?(...)
       end
   end
 end

data/lib/active_support/ordered_options.rb

@@ -46,18 +46,14 @@ module ActiveSupport
       super(key.to_sym, *identifiers)
     end
 
-    def method_missing(name, *args)
-      name_string = +name.to_s
-      if name_string.chomp!("=")
-        self[name_string] = args.first
+    def method_missing(method, *args)
+      if method.end_with?("=")
+        self[method.name.chomp("=")] = args.first
+      elsif method.end_with?("!")
+        name_string = method.name.chomp("!")
+        self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
       else
-        bangs = name_string.chomp!("!")
-
-        if bangs
-          self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
-        else
-          self[name_string]
-        end
+        self[method.name]
       end
     end
 
@@ -92,18 +88,60 @@ module ActiveSupport
   #   h.boy  # => 'John'
   class InheritableOptions < OrderedOptions
     def initialize(parent = nil)
-      if parent.kind_of?(OrderedOptions)
+      @parent = parent
+      if @parent.kind_of?(OrderedOptions)
         # use the faster _get when dealing with OrderedOptions
-        super() { |h, k| parent._get(k) }
-      elsif parent
-        super() { |h, k| parent[k] }
+        super() { |h, k| @parent._get(k) }
+      elsif @parent
+        super() { |h, k| @parent[k] }
       else
         super()
+        @parent = {}
       end
     end
 
+    def to_h
+      @parent.merge(self)
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+
+    def to_s
+      to_h.to_s
+    end
+
+    def pretty_print(pp)
+      pp.pp_hash(to_h)
+    end
+
+    alias_method :own_key?, :key?
+    private :own_key?
+
+    def key?(key)
+      super || @parent.key?(key)
+    end
+
+    def overridden?(key)
+      !!(@parent && @parent.key?(key) && own_key?(key.to_sym))
+    end
+
     def inheritable_copy
       self.class.new(self)
     end
+
+    def to_a
+      entries
+    end
+
+    def each(&block)
+      to_h.each(&block)
+      self
+    end
   end
 end

data/lib/active_support/railtie.rb

@@ -15,7 +15,7 @@ module ActiveSupport
 
     initializer "active_support.isolation_level" do |app|
       config.after_initialize do
-        if level = app.config.active_support.delete(:isolation_level)
+        if level = app.config.active_support.isolation_level
           ActiveSupport::IsolatedExecutionState.isolation_level = level
         end
       end
@@ -38,19 +38,35 @@ 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 }
+    initializer "active_support.set_event_reporter_context_store" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.event_reporter_context_store
+          ActiveSupport::EventReporter.context_store = klass
+        end
+      end
     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 }
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.clear
+        ActiveSupport.event_reporter.clear_context
+      end
+
+      app.executor.to_run do
+        ActiveSupport::ExecutionContext.push
+      end
+
+      app.executor.to_complete do
+        ActiveSupport::CurrentAttributes.clear_all
+        ActiveSupport::ExecutionContext.pop
+        ActiveSupport.event_reporter.clear_context
+      end
 
       ActiveSupport.on_load(:active_support_test_case) do
         if app.config.active_support.executor_around_test_case
+          ActiveSupport::ExecutionContext.nestable = true
+
           require "active_support/executor/test_helper"
           include ActiveSupport::Executor::TestHelper
         else
@@ -63,6 +79,13 @@ module ActiveSupport
       end
     end
 
+    initializer "active_support.set_filter_parameters" do |app|
+      config.after_initialize do
+        ActiveSupport.filter_parameters += Rails.application.config.filter_parameters
+        ActiveSupport.event_reporter.reload_payload_filter
+      end
+    end
+
     initializer "active_support.deprecation_behavior" do |app|
       if app.config.active_support.report_deprecations == false
         app.deprecators.silenced = true
@@ -89,10 +112,11 @@ module ActiveSupport
       begin
         TZInfo::DataSource.get
       rescue TZInfo::DataSourceNotFound => e
-        raise e.exception "tzinfo-data is not present. Please add gem 'tzinfo-data' to your Gemfile and run bundle install"
+        raise e.exception('tzinfo-data is not present. Please add gem "tzinfo-data" to your Gemfile and run bundle install')
       end
       require "active_support/core_ext/time/zones"
       Time.zone_default = Time.find_zone!(app.config.time_zone)
+      config.eager_load_namespaces << TZInfo
     end
 
     # Sets the default week start
@@ -117,16 +141,8 @@ module ActiveSupport
 
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
-        if k == :disable_to_s_conversion
-          ActiveSupport.deprecator.warn("config.active_support.disable_to_s_conversion is deprecated and will be removed in Rails 7.2.")
-        elsif k == :remove_deprecated_time_with_zone_name
-          ActiveSupport.deprecator.warn("config.active_support.remove_deprecated_time_with_zone_name is deprecated and will be removed in Rails 7.2.")
-        elsif k == :use_rfc4122_namespaced_uuids
-          ActiveSupport.deprecator.warn("config.active_support.use_rfc4122_namespaced_uuids is deprecated and will be removed in Rails 7.2.")
-        else
-          k = "#{k}="
-          ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
-        end
+        k = "#{k}="
+        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
       end
     end
 

data/lib/active_support/string_inquirer.rb

@@ -24,7 +24,7 @@ module ActiveSupport
         method_name.end_with?("?") || super
       end
 
-      def method_missing(method_name, *arguments)
+      def method_missing(method_name, ...)
         if method_name.end_with?("?")
           self == method_name[0..-2]
         else

data/lib/active_support/structured_event_subscriber.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "active_support/subscriber"
+
+module ActiveSupport
+  # = Active Support Structured Event \Subscriber
+  #
+  # +ActiveSupport::StructuredEventSubscriber+ consumes ActiveSupport::Notifications
+  # in order to emit structured events via +Rails.event+.
+  #
+  # An example would be the Action Controller structured event subscriber, responsible for
+  # emitting request processing events:
+  #
+  #   module ActionController
+  #     class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber
+  #       attach_to :action_controller
+  #
+  #       def start_processing(event)
+  #         emit_event("controller.request_started",
+  #           controller: event.payload[:controller],
+  #           action: event.payload[:action],
+  #           format: event.payload[:format]
+  #         )
+  #       end
+  #     end
+  #   end
+  #
+  # After configured, whenever a <tt>"start_processing.action_controller"</tt> notification is published,
+  # it will properly dispatch the event (+ActiveSupport::Notifications::Event+) to the +start_processing+ method.
+  # The subscriber can then emit a structured event via the +emit_event+ method.
+  class StructuredEventSubscriber < Subscriber
+    class_attribute :debug_methods, instance_accessor: false, default: [] # :nodoc:
+
+    DEBUG_CHECK = proc { !ActiveSupport.event_reporter.debug_mode? }
+
+    class << self
+      def attach_to(...) # :nodoc:
+        result = super
+        set_silenced_events
+        result
+      end
+
+      private
+        def set_silenced_events
+          if subscriber
+            subscriber.silenced_events = debug_methods.to_h { |method| ["#{method}.#{namespace}", DEBUG_CHECK] }
+          end
+        end
+
+        def debug_only(method)
+          self.debug_methods << method
+          set_silenced_events
+        end
+    end
+
+    def initialize
+      super
+      @silenced_events = {}
+    end
+
+    def silenced?(event)
+      ActiveSupport.event_reporter.subscribers.none? || @silenced_events[event]&.call
+    end
+
+    attr_writer :silenced_events # :nodoc:
+
+    # Emit a structured event via Rails.event.notify.
+    #
+    # ==== Arguments
+    #
+    # * +name+ - The event name as a string or symbol
+    # * +payload+ - The event payload as a hash or object
+    # * +caller_depth+ - Stack depth for source location (default: 1)
+    # * +kwargs+ - Additional payload data merged with the payload hash
+    def emit_event(name, payload = nil, caller_depth: 1, **kwargs)
+      ActiveSupport.event_reporter.notify(name, payload, caller_depth: caller_depth + 1, **kwargs)
+    rescue => e
+      handle_event_error(name, e)
+    end
+
+    # Like +emit_event+, but only emits when the event reporter is in debug mode
+    def emit_debug_event(name, payload = nil, caller_depth: 1, **kwargs)
+      ActiveSupport.event_reporter.debug(name, payload, caller_depth: caller_depth + 1, **kwargs)
+    rescue => e
+      handle_event_error(name, e)
+    end
+
+    def call(event)
+      super
+    rescue => e
+      handle_event_error(event.name, e)
+    end
+
+    private
+      def handle_event_error(name, error)
+        ActiveSupport.error_reporter.report(error, source: name)
+      end
+  end
+end

data/lib/active_support/subscriber.rb

@@ -67,6 +67,7 @@ module ActiveSupport
 
       # Adds event subscribers for all new methods added to the class.
       def method_added(event)
+        super
         # Only public methods are added as subscribers, and only if a notifier
         # has been set up. This means that subscribers will only be set up for
         # classes that call #attach_to.
@@ -136,10 +137,5 @@ module ActiveSupport
       method = event.name[0, event.name.index(".")]
       send(method, event)
     end
-
-    def publish_event(event) # :nodoc:
-      method = event.name[0, event.name.index(".")]
-      send(method, event)
-    end
   end
 end

data/lib/active_support/syntax_error_proxy.rb

@@ -18,6 +18,9 @@ module ActiveSupport
 
       def label
       end
+
+      def base_label
+      end
     end
 
     class BacktraceLocationProxy < DelegateClass(Thread::Backtrace::Location) # :nodoc:

data/lib/active_support/tagged_logging.rb

@@ -2,7 +2,6 @@
 
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/blank"
-require "logger"
 require "active_support/logger"
 
 module ActiveSupport
@@ -114,6 +113,11 @@ module ActiveSupport
       end
     end
 
+    # Returns an `ActiveSupport::Logger` that has already been wrapped with tagged logging concern.
+    def self.logger(*args, **kwargs)
+      new ActiveSupport::Logger.new(*args, **kwargs)
+    end
+
     def self.new(logger)
       logger = logger.clone
 

data/lib/active_support/test_case.rb

@@ -3,8 +3,10 @@
 require "minitest"
 require "active_support/testing/tagged_logging"
 require "active_support/testing/setup_and_teardown"
+require "active_support/testing/tests_without_assertions"
 require "active_support/testing/assertions"
 require "active_support/testing/error_reporter_assertions"
+require "active_support/testing/event_reporter_assertions"
 require "active_support/testing/deprecation"
 require "active_support/testing/declarative"
 require "active_support/testing/isolation"
@@ -14,13 +16,29 @@ require "active_support/testing/constant_stubbing"
 require "active_support/testing/file_fixtures"
 require "active_support/testing/parallelization"
 require "active_support/testing/parallelize_executor"
+require "active_support/testing/notification_assertions"
 require "concurrent/utility/processor_counter"
 
 module ActiveSupport
   class TestCase < ::Minitest::Test
     Assertion = Minitest::Assertion
 
+    # Class variable to store the parallel worker ID
+    @@parallel_worker_id = nil
+
     class << self
+      # Returns the current parallel worker ID if tests are running in parallel,
+      # nil otherwise.
+      #
+      #   ActiveSupport::TestCase.parallel_worker_id # => 2
+      def parallel_worker_id
+        @@parallel_worker_id
+      end
+
+      def parallel_worker_id=(value) # :nodoc:
+        @@parallel_worker_id = value
+      end
+
       # Sets the order in which test cases are run.
       #
       #   ActiveSupport::TestCase.test_order = :random # => :random
@@ -50,8 +68,8 @@ module ActiveSupport
       # is forked. For each process a new database will be created suffixed
       # with the worker number.
       #
-      #   test-database-0
-      #   test-database-1
+      #   test-database_0
+      #   test-database_1
       #
       # If <tt>ENV["PARALLEL_WORKERS"]</tt> is set the workers argument will be ignored
       # and the environment variable will be used instead. This is useful for CI
@@ -77,14 +95,45 @@ module ActiveSupport
       # 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"]
+      #
+      # If you want to skip Rails default creation of one database per process in favor of
+      # writing your own implementation, you can set +parallelize_databases+, or configure it
+      # via +config.active_support.parallelize_test_databases+.
+      #
+      #   parallelize(workers: :number_of_processors, parallelize_databases: false)
+      #
+      # Note that your test suite may deadlock if you attempt to use only one database
+      # with multiple processes.
+      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases)
+        case
+        when ENV["PARALLEL_WORKERS"]
+          workers = ENV["PARALLEL_WORKERS"].to_i
+        when workers == :number_of_processors
+          workers = (Concurrent.available_processor_count || Concurrent.processor_count).floor
+        end
+
+        if with == :processes
+          ActiveSupport.parallelize_test_databases = parallelize_databases
+        end
 
         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
+      # Before fork hook for parallel testing. This can be used to run anything
+      # before the processes are forked.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_before_fork do
+      #       # run this before fork
+      #     end
+      #   end
+      def parallelize_before_fork(&block)
+        ActiveSupport::Testing::Parallelization.before_fork_hook(&block)
+      end
+
+      # Setup hook for parallel testing. This can be used if you have multiple
       # databases or any behavior that needs to be run after the process is forked
       # but before the tests run.
       #
@@ -140,10 +189,18 @@ module ActiveSupport
 
     alias_method :method_name, :name
 
+    # Returns the current parallel worker ID if tests are running in parallel
+    def parallel_worker_id
+      self.class.parallel_worker_id
+    end
+
     include ActiveSupport::Testing::TaggedLogging
     prepend ActiveSupport::Testing::SetupAndTeardown
+    prepend ActiveSupport::Testing::TestsWithoutAssertions
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::ErrorReporterAssertions
+    include ActiveSupport::Testing::EventReporterAssertions
+    include ActiveSupport::Testing::NotificationAssertions
     include ActiveSupport::Testing::Deprecation
     include ActiveSupport::Testing::ConstantStubbing
     include ActiveSupport::Testing::TimeHelpers