activesupport 8.0.0 → 8.1.0

data/lib/active_support/core_ext/string/output_safety.rb

@@ -67,14 +67,13 @@ module ActiveSupport # :nodoc:
       original_concat(value)
     end
 
-    def initialize(str = "")
-      @html_safe = true
+    def initialize(_str = "")
       super
     end
 
     def initialize_copy(other)
       super
-      @html_safe = other.html_safe?
+      @html_unsafe = true unless other.html_safe?
     end
 
     def concat(value)
@@ -116,7 +115,9 @@ module ActiveSupport # :nodoc:
     def *(_)
       new_string = super
       new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
-      new_safe_buffer.instance_variable_set(:@html_safe, @html_safe)
+      if @html_unsafe
+        new_safe_buffer.instance_variable_set(:@html_unsafe, true)
+      end
       new_safe_buffer
     end
 
@@ -131,14 +132,18 @@ module ActiveSupport # :nodoc:
       self.class.new(super(escaped_args))
     end
 
-    attr_reader :html_safe
-    alias_method :html_safe?, :html_safe
-    remove_method :html_safe
+    def html_safe?
+      @html_unsafe.nil?
+    end
 
     def to_s
       self
     end
 
+    def as_json(*)
+      to_str
+    end
+
     def to_param
       to_str
     end
@@ -155,7 +160,7 @@ module ActiveSupport # :nodoc:
           end                                       # end
 
           def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
+            @html_unsafe = true                     #   @html_unsafe = true
             super                                   #   super
           end                                       # end
         EOT
@@ -176,7 +181,7 @@ module ActiveSupport # :nodoc:
         end                                             # end
 
         def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
-          @html_safe = false                            #   @html_safe = false
+          @html_unsafe = true                           #   @html_unsafe = true
           if block                                      #   if block
             super(*args) { |*params|                    #     super(*args) { |*params|
               set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
@@ -191,14 +196,14 @@ module ActiveSupport # :nodoc:
 
     private
       def explicit_html_escape_interpolated_argument(arg)
-        (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
+        (!html_safe? || arg.html_safe?) ? arg : ERB::Util.unwrapped_html_escape(arg)
       end
 
       def implicit_html_escape_interpolated_argument(arg)
         if !html_safe? || arg.html_safe?
           arg
         else
-          CGI.escapeHTML(arg.to_str)
+          ERB::Util.unwrapped_html_escape(arg.to_str)
         end
       end
 
@@ -210,7 +215,9 @@ module ActiveSupport # :nodoc:
 
       def string_into_safe_buffer(new_string, is_html_safe)
         new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
-        new_safe_buffer.instance_variable_set :@html_safe, is_html_safe
+        unless is_html_safe
+          new_safe_buffer.instance_variable_set :@html_unsafe, true
+        end
         new_safe_buffer
       end
   end

data/lib/active_support/core_ext/string.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/conversions"
-require "active_support/core_ext/string/filters"
-require "active_support/core_ext/string/multibyte"
-require "active_support/core_ext/string/starts_ends_with"
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/string/access"
-require "active_support/core_ext/string/behavior"
-require "active_support/core_ext/string/output_safety"
-require "active_support/core_ext/string/exclude"
-require "active_support/core_ext/string/strip"
-require "active_support/core_ext/string/inquiry"
-require "active_support/core_ext/string/indent"
-require "active_support/core_ext/string/zones"
+require_relative "string/conversions"
+require_relative "string/filters"
+require_relative "string/multibyte"
+require_relative "string/starts_ends_with"
+require_relative "string/inflections"
+require_relative "string/access"
+require_relative "string/behavior"
+require_relative "string/output_safety"
+require_relative "string/exclude"
+require_relative "string/strip"
+require_relative "string/inquiry"
+require_relative "string/indent"
+require_relative "string/zones"

data/lib/active_support/core_ext/symbol.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/symbol/starts_ends_with"
+require_relative "symbol/starts_ends_with"

data/lib/active_support/core_ext/time/calculations.rb

@@ -224,13 +224,6 @@ class Time
   # Returns a new Time representing the time a number of seconds since the instance time
   def since(seconds)
     self + seconds
-  rescue TypeError
-    result = to_datetime.since(seconds)
-    ActiveSupport.deprecator.warn(
-      "Passing an instance of #{seconds.class} to #{self.class}#since is deprecated. This behavior will raise " \
-      "a `TypeError` in Rails 8.1."
-    )
-    result
   end
   alias :in :since
 

data/lib/active_support/core_ext/time/compatibility.rb

@@ -8,33 +8,8 @@ class Time
 
   silence_redefinition_of_method :to_time
 
-  # Either return +self+ or the time in the local system timezone depending
-  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  # Return +self+.
   def to_time
-    preserve_timezone ? self : getlocal
+    self
   end
-
-  def preserve_timezone # :nodoc:
-    system_local_time? || super
-  end
-
-  private
-    def system_local_time?
-      if ::Time.equal?(self.class)
-        zone = self.zone
-        String === zone &&
-          (zone != "UTC" || active_support_local_zone == "UTC")
-      end
-    end
-
-    @@active_support_local_tz = nil
-
-    def active_support_local_zone
-      @@active_support_local_zone = nil if @@active_support_local_tz != ENV["TZ"]
-      @@active_support_local_zone ||=
-        begin
-          @@active_support_local_tz = ENV["TZ"]
-          Time.new.zone
-        end
-    end
 end

data/lib/active_support/core_ext/time.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/time/acts_like"
-require "active_support/core_ext/time/calculations"
-require "active_support/core_ext/time/compatibility"
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/time/zones"
+require_relative "time/acts_like"
+require_relative "time/calculations"
+require_relative "time/compatibility"
+require_relative "time/conversions"
+require_relative "time/zones"

data/lib/active_support/core_ext.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
+(Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort - [File.expand_path("core_ext/benchmark.rb", __dir__)]).each do |path|
   require path
 end

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)
-          return if respond_to?(name, true)
+
+          # 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,20 +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 }
@@ -232,8 +264,11 @@ module ActiveSupport
         end
       end
 
-      unless error.frozen?
-        error.instance_variable_set(:@__rails_error_reported, true)
+      while error
+        unless error.frozen?
+          error.instance_variable_set(:@__rails_error_reported, true)
+        end
+        error = error.cause
       end
 
       nil
@@ -241,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
@@ -261,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