activesupport 8.0.2.1 → 8.1.1

data/lib/active_support/current_attributes/test_helper.rb

@@ -2,12 +2,12 @@
 
 module ActiveSupport::CurrentAttributes::TestHelper # :nodoc:
   def before_setup
-    ActiveSupport::CurrentAttributes.reset_all
+    ActiveSupport::CurrentAttributes.clear_all
     super
   end
 
   def after_teardown
     super
-    ActiveSupport::CurrentAttributes.reset_all
+    ActiveSupport::CurrentAttributes.clear_all
   end
 end

data/lib/active_support/current_attributes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/callbacks"
+require "active_support/execution_context"
 require "active_support/core_ext/object/with"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/delegation"
@@ -108,35 +109,35 @@ module ActiveSupport
       # ==== Options
       #
       # * <tt>:default</tt> - The default value for the attributes. If the value
-      # is a proc or lambda, it will be called whenever an instance is
-      # constructed. Otherwise, the value will be duplicated with +#dup+.
-      # Default values are re-assigned when the attributes are reset.
+      #   is a proc or lambda, it will be called whenever an instance is
+      #   constructed. Otherwise, the value will be duplicated with +#dup+.
+      #   Default values are re-assigned when the attributes are reset.
       def attribute(*names, default: NOT_SET)
         invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
         if invalid_attribute_names.any?
           raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
         end
 
+        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
+        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
+
         ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
             owner.define_cached_method(name, namespace: :current_attributes) do |batch|
               batch <<
                 "def #{name}" <<
-                "attributes[:#{name}]" <<
+                "@attributes[:#{name}]" <<
                 "end"
             end
             owner.define_cached_method("#{name}=", namespace: :current_attributes) do |batch|
               batch <<
                 "def #{name}=(value)" <<
-                "attributes[:#{name}] = value" <<
+                "@attributes[:#{name}] = value" <<
                 "end"
             end
           end
         end
 
-        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
-        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
-
         self.defaults = defaults.merge(names.index_with { default })
       end
 
@@ -153,13 +154,11 @@ module ActiveSupport
 
       delegate :set, :reset, to: :instance
 
-      def reset_all # :nodoc:
-        current_instances.each_value(&:reset)
-      end
-
       def clear_all # :nodoc:
-        reset_all
-        current_instances.clear
+        if instances = current_instances
+          instances.values.each(&:reset)
+          instances.clear
+        end
       end
 
       private
@@ -168,7 +167,7 @@ module ActiveSupport
         end
 
         def current_instances
-          IsolatedExecutionState[:current_attributes_instances] ||= {}
+          ExecutionContext.current_attributes_instances
         end
 
         def current_instances_key
@@ -185,21 +184,32 @@ module ActiveSupport
 
         def method_added(name)
           super
+
+          # We try to generate instance delegators early to not rely on method_missing.
           return if name == :initialize
+
+          # If the added method isn't public, we don't delegate it.
           return unless public_method_defined?(name)
+
+          # If we already have a class method by that name, we don't override it.
           return if singleton_class.method_defined?(name) || singleton_class.private_method_defined?(name)
+
           Delegation.generate(singleton_class, [name], to: :instance, as: self, nilable: false)
         end
     end
 
     class_attribute :defaults, instance_writer: false, default: {}.freeze
 
-    attr_accessor :attributes
+    attr_writer :attributes
 
     def initialize
       @attributes = resolve_defaults
     end
 
+    def attributes
+      @attributes.dup
+    end
+
     # Expose one or more attributes within a block. Old values are returned after the block concludes.
     # Example demonstrating the common use of needing to set Current attributes outside the request-cycle:
     #

data/lib/active_support/dependencies/interlock.rb

@@ -10,19 +10,24 @@ module ActiveSupport # :nodoc:
       end
 
       def loading(&block)
-        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load], &block)
+        ActiveSupport.deprecator.warn(
+          "ActiveSupport::Dependencies::Interlock#loading is deprecated and " \
+          "will be removed in Rails 9.0. The loading interlock is no longer " \
+          "used since Rails switched to Zeitwerk for autoloading."
+        )
+        yield if block
       end
 
       def unloading(&block)
-        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload], &block)
+        @lock.exclusive(purpose: :unload, compatible: [:unload], after_compatible: [:unload], &block)
       end
 
       def start_unloading
-        @lock.start_exclusive(purpose: :unload, compatible: [:load, :unload])
+        @lock.start_exclusive(purpose: :unload, compatible: [:unload])
       end
 
       def done_unloading
-        @lock.stop_exclusive(compatible: [:load, :unload])
+        @lock.stop_exclusive(compatible: [:unload])
       end
 
       def start_running
@@ -38,7 +43,8 @@ module ActiveSupport # :nodoc:
       end
 
       def permit_concurrent_loads(&block)
-        @lock.yield_shares(compatible: [:load], &block)
+        # Soft deprecated: no deprecation warning for now, but this is a no-op.
+        yield if block
       end
 
       def raw_state(&block) # :nodoc:

data/lib/active_support/dependencies.rb

@@ -21,7 +21,12 @@ module ActiveSupport # :nodoc:
     # preventing any other thread from being inside a #run_interlock
     # block at the same time.
     def self.load_interlock(&block)
-      interlock.loading(&block)
+      ActiveSupport.deprecator.warn(
+        "ActiveSupport::Dependencies.load_interlock is deprecated and " \
+        "will be removed in Rails 9.0. The loading interlock is no longer " \
+        "used since Rails switched to Zeitwerk for autoloading."
+      )
+      yield if block
     end
 
     # Execute the supplied block while holding an exclusive lock,

data/lib/active_support/deprecation/reporting.rb

@@ -149,8 +149,10 @@ module ActiveSupport
           [offending_line.path, offending_line.lineno, offending_line.label]
         end
 
-        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/" # :nodoc:
-        LIB_DIR = RbConfig::CONFIG["libdir"] # :nodoc:
+        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/"
+        private_constant :RAILS_GEM_ROOT
+        LIB_DIR = RbConfig::CONFIG["libdir"]
+        private_constant :LIB_DIR
 
         def ignored_callstack?(path)
           path.start_with?(RAILS_GEM_ROOT, LIB_DIR) || path.include?("<internal:")

data/lib/active_support/deprecation.rb

@@ -68,7 +68,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "8.1", gem_name = "Rails")
+    def initialize(deprecation_horizon = "8.2", 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/editor.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActiveSupport
+  class Editor
+    @editors = {}
+    @current = false
+
+    class << self
+      # Registers a URL pattern for opening file in a given editor.
+      # This allows Rails to generate clickable links to control known editors.
+      #
+      # Example:
+      #
+      #  ActiveSupport::Editor.register("myeditor", "myeditor://%s:%d")
+      def register(name, url_pattern, aliases: [])
+        editor = new(url_pattern)
+        @editors[name] = editor
+        aliases.each do |a|
+          @editors[a] = editor
+        end
+      end
+
+      # Returns the current editor pattern if it is known.
+      # First check for the `RAILS_EDITOR` environment variable, and if it's
+      # missing, check for the `EDITOR` environment variable.
+      def current
+        if @current == false
+          @current = if editor_name = ENV["RAILS_EDITOR"] || ENV["EDITOR"]
+            @editors[editor_name]
+          end
+        end
+        @current
+      end
+
+      # :nodoc:
+
+      def find(name)
+        @editors[name]
+      end
+
+      def reset
+        @current = false
+      end
+    end
+
+    def initialize(url_pattern)
+      @url_pattern = url_pattern
+    end
+
+    def url_for(path, line)
+      sprintf(@url_pattern, path, line)
+    end
+
+    register "atom", "atom://core/open/file?filename=%s&line=%d"
+    register "cursor", "cursor://file/%s:%f"
+    register "emacs", "emacs://open?url=file://%s&line=%d", aliases: ["emacsclient"]
+    register "idea", "idea://open?file=%s&line=%d"
+    register "macvim", "mvim://open?url=file://%s&line=%d", aliases: ["mvim"]
+    register "nova", "nova://open?path=%s&line=%d"
+    register "rubymine", "x-mine://open?file=%s&line=%d"
+    register "sublime", "subl://open?url=file://%s&line=%d", aliases: ["subl"]
+    register "textmate", "txmt://open?url=file://%s&line=%d", aliases: ["mate"]
+    register "vscode", "vscode://file/%s:%d", aliases: ["code"]
+    register "vscodium", "vscodium://file/%s:%d", aliases: ["codium"]
+    register "windsurf", "windsurf://file/%s:%d"
+    register "zed", "zed://file/%s:%d"
+  end
+end

data/lib/active_support/error_reporter.rb

@@ -36,6 +36,7 @@ module ActiveSupport
       @subscribers = subscribers.flatten
       @logger = logger
       @debug_mode = false
+      @context_middlewares = ErrorContextMiddlewareStack.new
     end
 
     # Evaluates the given block, reporting and swallowing any unhandled error.
@@ -202,6 +203,22 @@ module ActiveSupport
       ActiveSupport::ExecutionContext.set(...)
     end
 
+    # Add a middleware to modify the error context before it is sent to subscribers.
+    #
+    # Middleware is added to a stack of callables run on an error's execution context
+    # before passing to subscribers. Allows creation of entries in error context that
+    # are shared by all subscribers.
+    #
+    # A context middleware receives the same parameters as #report.
+    # It must return a hash - the middleware stack returns the hash after it has
+    # run through all middlewares. A middleware can mutate or replace the hash.
+    #
+    #   Rails.error.add_middleware(-> (error, context) { context.merge({ foo: :bar }) })
+    #
+    def add_middleware(middleware)
+      @context_middlewares.use(middleware)
+    end
+
     # Report an error directly to subscribers. You can use this method when the
     # block-based #handle and #record methods are not suitable.
     #
@@ -215,13 +232,22 @@ module ActiveSupport
     # string argument.
     def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
       return if error.instance_variable_defined?(:@__rails_error_reported)
+      raise ArgumentError, "Reported error must be an Exception, got: #{error.inspect}" unless error.is_a?(Exception)
+
       ensure_backtrace(error)
 
       unless SEVERITIES.include?(severity)
         raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
       end
 
-      full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
+      full_context = @context_middlewares.execute(
+        error,
+        context: ActiveSupport::ExecutionContext.to_h.merge(context || {}),
+        handled:,
+        severity:,
+        source:
+      )
+
       disabled_subscribers = ActiveSupport::IsolatedExecutionState[self]
       @subscribers.each do |subscriber|
         unless disabled_subscribers&.any? { |s| s === subscriber }
@@ -250,14 +276,12 @@ module ActiveSupport
 
     private
       def ensure_backtrace(error)
-        return if error.frozen? # re-raising won't add a backtrace
+        return if error.frozen? # re-raising won't add a backtrace or set the cause
         return unless error.backtrace.nil?
 
         begin
-          # We could use Exception#set_backtrace, but until Ruby 3.4
-          # it only support setting `Exception#backtrace` and not
-          # `Exception#backtrace_locations`. So raising the exception
-          # is a good way to build a real backtrace.
+          # As of Ruby 3.4, we could use Exception#set_backtrace to set the backtrace,
+          # but there's nothing like Exception#set_cause. Raising+rescuing is the only way to set the cause.
           raise error
         rescue error.class => error
         end
@@ -270,5 +294,25 @@ module ActiveSupport
 
         error.backtrace.shift(count)
       end
+
+      class ErrorContextMiddlewareStack # :nodoc:
+        def initialize
+          @stack = []
+        end
+
+        # Add a middleware to the error context stack.
+        def use(middleware)
+          unless middleware.respond_to?(:call)
+            raise ArgumentError, "Error context middleware must respond to #call"
+          end
+
+          @stack << middleware
+        end
+
+        # Run all middlewares in the stack
+        def execute(error, handled:, severity:, context:, source:)
+          @stack.inject(context) { |c, middleware| middleware.call(error, context: c, handled:, severity:, source:) }
+        end
+      end
   end
 end

data/lib/active_support/event_reporter/test_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveSupport::EventReporter::TestHelper # :nodoc:
+  class EventSubscriber # :nodoc:
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def emit(event)
+      @events << event
+    end
+  end
+
+  def event_matcher(name:, payload: nil, tags: {}, context: {}, source_location: nil)
+    ->(event) {
+      return false unless event[:name] == name
+      return false unless event[:payload] == payload
+      return false unless event[:tags] == tags
+      return false unless event[:context] == context
+
+      [:filepath, :lineno, :label].each do |key|
+        if source_location && source_location[key]
+          return false unless event[:source_location][key] == source_location[key]
+        end
+      end
+
+      true
+    }
+  end
+end