activesupport 7.2.2.2 → 8.1.2

data/lib/active_support/notifications/fanout.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
-require "set"
 require "active_support/core_ext/object/try"
 
 module ActiveSupport
@@ -18,24 +17,30 @@ module ActiveSupport
 
     module FanoutIteration # :nodoc:
       private
-        def iterate_guarding_exceptions(collection)
-          exceptions = nil
-
-          collection.each do |s|
-            yield s
-          rescue Exception => e
-            exceptions ||= []
-            exceptions << e
-          end
+        def iterate_guarding_exceptions(collection, &block)
+          case collection.size
+          when 0
+          when 1
+            collection.each(&block)
+          else
+            exceptions = nil
 
-          if exceptions
-            exceptions = exceptions.flat_map do |exception|
-              exception.is_a?(InstrumentationSubscriberError) ? exception.exceptions : [exception]
+            collection.each do |s|
+              yield s
+            rescue Exception => e
+              exceptions ||= []
+              exceptions << e
             end
-            if exceptions.size == 1
-              raise exceptions.first
-            else
-              raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+
+            if exceptions
+              exceptions = exceptions.flat_map do |exception|
+                exception.is_a?(InstrumentationSubscriberError) ? exception.exceptions : [exception]
+              end
+              if exceptions.size == 1
+                raise exceptions.first
+              else
+                raise InstrumentationSubscriberError.new(exceptions), cause: exceptions.first
+              end
             end
           end
 
@@ -54,7 +59,6 @@ module ActiveSupport
         @other_subscribers = []
         @all_listeners_for = Concurrent::Map.new
         @groups_for = Concurrent::Map.new
-        @silenceable_groups_for = Concurrent::Map.new
       end
 
       def inspect # :nodoc:
@@ -103,11 +107,9 @@ module ActiveSupport
         if key
           @all_listeners_for.delete(key)
           @groups_for.delete(key)
-          @silenceable_groups_for.delete(key)
         else
           @all_listeners_for.clear
           @groups_for.clear
-          @silenceable_groups_for.clear
         end
       end
 
@@ -185,25 +187,25 @@ module ActiveSupport
           end
       end
 
-      def groups_for(name) # :nodoc:
-        groups = @groups_for.compute_if_absent(name) do
-          all_listeners_for(name).reject(&:silenceable).group_by(&:group_class).transform_values do |s|
-            s.map(&:delegate)
-          end
-        end
+      def group_listeners(listeners) # :nodoc:
+        listeners.group_by(&:group_class).transform_values do |s|
+          s.map(&:delegate).freeze
+        end.freeze
+      end
 
-        silenceable_groups = @silenceable_groups_for.compute_if_absent(name) do
-          all_listeners_for(name).select(&:silenceable).group_by(&:group_class).transform_values do |s|
-            s.map(&:delegate)
-          end
+      def groups_for(name) # :nodoc:
+        silenceable_groups, groups = @groups_for.compute_if_absent(name) do
+          listeners = all_listeners_for(name)
+          listeners.partition(&:silenceable).map { |l| group_listeners(l) }
         end
 
         unless silenceable_groups.empty?
-          groups = groups.dup
           silenceable_groups.each do |group_class, subscriptions|
             active_subscriptions = subscriptions.reject { |s| s.silenced?(name) }
             unless active_subscriptions.empty?
-              groups[group_class] = (groups[group_class] || []) + active_subscriptions
+              groups = groups.dup if groups.frozen?
+              base_groups = groups[group_class]
+              groups[group_class] = base_groups ? base_groups + active_subscriptions : active_subscriptions
             end
           end
         end
@@ -228,13 +230,11 @@ module ActiveSupport
       class Handle
         include FanoutIteration
 
-        def initialize(notifier, name, id, payload) # :nodoc:
+        def initialize(notifier, name, id, groups, payload) # :nodoc:
           @name = name
           @id = id
           @payload = payload
-          @groups = notifier.groups_for(name).map do |group_klass, grouped_listeners|
-            group_klass.new(grouped_listeners, name, id, payload)
-          end
+          @groups = groups
           @state = :initialized
         end
 
@@ -268,10 +268,31 @@ module ActiveSupport
           end
       end
 
+      module NullHandle # :nodoc:
+        extend self
+
+        def start
+        end
+
+        def finish
+        end
+
+        def finish_with_values(_name, _id, _payload)
+        end
+      end
+
       include FanoutIteration
 
       def build_handle(name, id, payload)
-        Handle.new(self, name, id, payload)
+        groups = groups_for(name).map do |group_klass, grouped_listeners|
+          group_klass.new(grouped_listeners, name, id, payload)
+        end
+
+        if groups.empty?
+          NullHandle
+        else
+          Handle.new(self, name, id, groups, payload)
+        end
       end
 
       def start(name, id, payload)
@@ -287,8 +308,8 @@ module ActiveSupport
         handle.finish_with_values(name, id, payload)
       end
 
-      def publish(name, *args)
-        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, *args) }
+      def publish(name, ...)
+        iterate_guarding_exceptions(listeners_for(name)) { |s| s.publish(name, ...) }
       end
 
       def publish_event(event)
@@ -388,9 +409,9 @@ module ActiveSupport
             EventedGroup
           end
 
-          def publish(name, *args)
+          def publish(...)
             if @can_publish
-              @delegate.publish name, *args
+              @delegate.publish(...)
             end
           end
 
@@ -420,8 +441,8 @@ module ActiveSupport
             TimedGroup
           end
 
-          def publish(name, *args)
-            @delegate.call name, *args
+          def publish(...)
+            @delegate.call(...)
           end
         end
 

data/lib/active_support/notifications/instrumenter.rb

@@ -164,7 +164,7 @@ module ActiveSupport
         @cpu_time_finish - @cpu_time_start
       end
 
-      # Returns the idle time time (in milliseconds) passed between the call to
+      # Returns the idle time (in milliseconds) passed between the call to
       # #start! and the call to #finish!.
       def idle_time
         diff = duration - cpu_time

data/lib/active_support/number_helper.rb

@@ -1,6 +1,28 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Number Helper
+  #
+  # Provides methods for formatting numbers into currencies, percentages,
+  # phone numbers, and more.
+  #
+  # Example usage in a class:
+  #   class Topic
+  #     include ActiveSupport::NumberHelper
+  #
+  #     def price
+  #       number_to_currency(@price)
+  #     end
+  #   end
+  #
+  # Example usage in a module:
+  #   require "active_support/number_helper"
+  #
+  #   module NumberFormatting
+  #     def format_price(price)
+  #       ActiveSupport::NumberHelper.number_to_currency(price)
+  #     end
+  #   end
   module NumberHelper
     extend ActiveSupport::Autoload
 

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

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

@@ -137,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,13 @@ module ActiveSupport
 
       def label
       end
+
+      def base_label
+      end
+
+      def absolute_path
+        path
+      end
     end
 
     class BacktraceLocationProxy < DelegateClass(Thread::Backtrace::Location) # :nodoc:

data/lib/active_support/tagged_logging.rb

@@ -113,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

@@ -6,6 +6,7 @@ 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"
@@ -15,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
@@ -45,14 +62,20 @@ module ActiveSupport
         ActiveSupport.test_order ||= :random
       end
 
+      if Minitest.respond_to? :run_order # MT6 API change
+        def run_order # :nodoc:
+          test_order
+        end
+      end
+
       # Parallelizes the test suite.
       #
       # Takes a +workers+ argument that controls how many times the process
       # 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
@@ -78,14 +101,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.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.
       #
@@ -141,11 +195,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