activesupport 7.2.3.1 → 8.1.4.1

data/lib/active_support/delegation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module ActiveSupport
   # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
   # option is not used.
@@ -136,11 +134,11 @@ module ActiveSupport
               "def #{method_name}(#{definition})" <<
               "  _ = #{receiver}" <<
               "  _.#{method}(#{definition})" <<
-              "rescue NoMethodError => e" <<
+              "rescue ::NoMethodError => e" <<
               "  if _.nil? && e.name == :#{method}" <<
-              "    raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
+              "    ::Kernel.raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
               "  else" <<
-              "    raise" <<
+              "    ::Kernel.raise" <<
               "  end" <<
               "end"
           end
@@ -153,49 +151,32 @@ module ActiveSupport
         target = target.to_s
         target = "self.#{target}" if RESERVED_METHOD_NAMES.include?(target) || target == "__target"
 
-        if allow_nil
-          owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
-            def respond_to_missing?(name, include_private = false)
-              # It may look like an oversight, but we deliberately do not pass
-              # +include_private+, because they do not get delegated.
-
-              return false if name == :marshal_dump || name == :_dump
-              #{target}.respond_to?(name) || super
-            end
-
-            def method_missing(method, ...)
-              __target = #{target}
-              if __target.nil? && !nil.respond_to?(method)
-                nil
-              elsif __target.respond_to?(method)
-                __target.public_send(method, ...)
-              else
-                super
-              end
-            end
-          RUBY
+        nil_behavior = if allow_nil
+          "nil"
         else
-          owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
-            def respond_to_missing?(name, include_private = false)
-              # It may look like an oversight, but we deliberately do not pass
-              # +include_private+, because they do not get delegated.
+          "::Kernel.raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')"
+        end
 
-              return false if name == :marshal_dump || name == :_dump
-              #{target}.respond_to?(name) || super
-            end
+        owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def respond_to_missing?(name, include_private = false)
+            # It may look like an oversight, but we deliberately do not pass
+            # +include_private+, because they do not get delegated.
 
-            def method_missing(method, ...)
-              __target = #{target}
-              if __target.nil? && !nil.respond_to?(method)
-                raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')
-              elsif __target.respond_to?(method)
-                __target.public_send(method, ...)
-              else
-                super
-              end
+            return false if name == :marshal_dump || name == :_dump
+            #{target}.respond_to?(name) || super
+          end
+
+          def method_missing(method, ...)
+            __target = #{target}
+            if __target.nil? && !nil.respond_to?(method)
+              #{nil_behavior}
+            elsif __target.respond_to?(method)
+              __target.public_send(method, ...)
+            else
+              super
             end
-          RUBY
-        end
+          end
+        RUBY
       end
     end
   end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require "active_support/dependencies/interlock"
 
 module ActiveSupport # :nodoc:
@@ -22,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

@@ -139,7 +139,6 @@ module ActiveSupport
 
         def extract_callstack(callstack)
           return [] if callstack.empty?
-          return _extract_callstack(callstack) if callstack.first.is_a? String
 
           offending_line = callstack.find { |frame|
             # Code generated with `eval` doesn't have an `absolute_path`, e.g. templates.
@@ -150,26 +149,10 @@ module ActiveSupport
           [offending_line.path, offending_line.lineno, offending_line.label]
         end
 
-        def _extract_callstack(callstack)
-          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
-            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
-              md.captures
-            else
-              offending_line
-            end
-          end
-        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.0", 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/duration.rb

@@ -383,42 +383,42 @@ module ActiveSupport
     #
     #   1.day.in_minutes # => 1440.0
     def in_minutes
-      in_seconds / SECONDS_PER_MINUTE.to_f
+      value / SECONDS_PER_MINUTE.to_f
     end
 
     # Returns the amount of hours a duration covers as a float
     #
     #   1.day.in_hours # => 24.0
     def in_hours
-      in_seconds / SECONDS_PER_HOUR.to_f
+      value / SECONDS_PER_HOUR.to_f
     end
 
     # Returns the amount of days a duration covers as a float
     #
     #   12.hours.in_days # => 0.5
     def in_days
-      in_seconds / SECONDS_PER_DAY.to_f
+      value / SECONDS_PER_DAY.to_f
     end
 
     # Returns the amount of weeks a duration covers as a float
     #
     #   2.months.in_weeks # => 8.696
     def in_weeks
-      in_seconds / SECONDS_PER_WEEK.to_f
+      value / SECONDS_PER_WEEK.to_f
     end
 
     # Returns the amount of months a duration covers as a float
     #
     #   9.weeks.in_months # => 2.07
     def in_months
-      in_seconds / SECONDS_PER_MONTH.to_f
+      value / SECONDS_PER_MONTH.to_f
     end
 
     # Returns the amount of years a duration covers as a float
     #
     #   30.days.in_years # => 0.082
     def in_years
-      in_seconds / SECONDS_PER_YEAR.to_f
+      value / SECONDS_PER_YEAR.to_f
     end
 
     # Returns +true+ if +other+ is also a Duration instance, which has the
@@ -491,17 +491,21 @@ module ActiveSupport
         if @parts.empty?
           time.since(sign * value)
         else
-          @parts.inject(time) do |t, (type, number)|
-            if type == :seconds
-              t.since(sign * number)
-            elsif type == :minutes
-              t.since(sign * number * 60)
-            elsif type == :hours
-              t.since(sign * number * 3600)
-            else
-              t.advance(type => sign * number)
-            end
+          @parts.each do |type, number|
+            t = time
+            time =
+              if type == :seconds
+                t.since(sign * number)
+              elsif type == :minutes
+                t.since(sign * number * 60)
+              elsif type == :hours
+                t.since(sign * number * 3600)
+              else
+                t.advance(type => sign * number)
+              end
           end
+
+          time
         end
       end
 

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/encrypted_configuration.rb

@@ -43,6 +43,12 @@ module ActiveSupport
       end
     end
 
+    class InvalidKeyError < RuntimeError
+      def initialize(content_path, key)
+        super "Key '#{key}' is invalid, it must respond to '#to_sym' from configuration in '#{content_path}'."
+      end
+    end
+
     delegate_missing_to :options
 
     def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
@@ -61,7 +67,11 @@ module ActiveSupport
     end
 
     def validate! # :nodoc:
-      deserialize(read)
+      deserialize(read).each_key do |key|
+        key.to_sym
+      rescue NoMethodError
+        raise InvalidKeyError.new(content_path, key)
+      end
     end
 
     # Returns the decrypted content as a Hash with symbolized keys.
@@ -73,7 +83,7 @@ module ActiveSupport
     #   # => { some_secret: 123, some_namespace: { another_secret: 789 } }
     #
     def config
-      @config ||= deserialize(read).deep_symbolize_keys
+      @config ||= deep_symbolize_keys(deserialize(read))
     end
 
     def inspect # :nodoc:
@@ -81,6 +91,14 @@ module ActiveSupport
     end
 
     private
+      def deep_symbolize_keys(hash)
+        hash.deep_transform_keys do |key|
+          key.to_sym
+        rescue NoMethodError
+          raise InvalidKeyError.new(content_path, key)
+        end
+      end
+
       def deep_transform(hash)
         return hash unless hash.is_a?(Hash)
 

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.
@@ -144,9 +145,9 @@ module ActiveSupport
     #
     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
+        ensure_backtrace(error)
         raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error
       else
         report(error, handled: true, severity: severity, context: context, source: source)
@@ -202,19 +203,51 @@ 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.
     #
     #   Rails.error.report(error)
     #
+    # The +error+ argument must be an instance of Exception.
+    #
+    #   Rails.error.report(Exception.new("Something went wrong"))
+    #
+    # Otherwise you can use #unexpected to report an error which does accept a
+    # 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 }
@@ -240,5 +273,46 @@ module ActiveSupport
 
       nil
     end
+
+    private
+      def ensure_backtrace(error)
+        return if error.frozen? # re-raising won't add a backtrace or set the cause
+        return unless error.backtrace.nil?
+
+        begin
+          # 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
+
+        count = 0
+        while error.backtrace_locations.first&.path == __FILE__
+          count += 1
+          error.backtrace_locations.shift
+        end
+
+        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