activesupport 7.0.0.alpha2 → 7.0.0.rc1

data/lib/active_support/core_ext/range/include_time_with_zone.rb

@@ -1,28 +1,7 @@
 # frozen_string_literal: true
 
-require "active_support/time_with_zone"
-require "active_support/deprecation"
-
-module ActiveSupport
-  module IncludeTimeWithZone # :nodoc:
-    # Extends the default Range#include? to support ActiveSupport::TimeWithZone.
-    #
-    #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
-    #
-    def include?(value)
-      if self.begin.is_a?(TimeWithZone) || self.end.is_a?(TimeWithZone)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Using `Range#include?` to check the inclusion of a value in
-          a date time range is deprecated.
-          It is recommended to use `Range#cover?` instead of `Range#include?` to
-          check the inclusion of a value in a date time range.
-        MSG
-        cover?(value)
-      else
-        super
-      end
-    end
-  end
-end
+# frozen_string_literal: true
 
-Range.prepend(ActiveSupport::IncludeTimeWithZone)
+ActiveSupport::Deprecation.warn(<<-MSG.squish)
+  `active_support/core_ext/range/include_time_with_zone` is deprecated and will be removed in Rails 7.1.
+MSG

data/lib/active_support/core_ext/range.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/range/conversions"
+require "active_support/core_ext/range/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/range/compare_range"
-require "active_support/core_ext/range/include_time_with_zone"
 require "active_support/core_ext/range/overlaps"
 require "active_support/core_ext/range/each"

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

@@ -305,7 +305,7 @@ class Time
     other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
   end
   alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion
+  alias_method :-, :minus_with_coercion # rubocop:disable Lint/DuplicateMethods
 
   # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
   # can be chronologically compared with a Time

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

@@ -27,12 +27,12 @@ class Time
 
   # Converts to a formatted string. See DATE_FORMATS for built-in formats.
   #
-  # This method is aliased to <tt>to_s</tt>.
+  # This method is aliased to <tt>to_fs</tt>.
   #
   #   time = Time.now                    # => 2007-01-18 06:10:17 -06:00
   #
   #   time.to_formatted_s(:time)         # => "06:10"
-  #   time.to_s(:time)                   # => "06:10"
+  #   time.to_formatted_s(:time)         # => "06:10"
   #
   #   time.to_formatted_s(:db)           # => "2007-01-18 06:10:17"
   #   time.to_formatted_s(:number)       # => "20070118061017"
@@ -54,11 +54,12 @@ class Time
     if formatter = DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
+      # Change to `to_s` when deprecation is gone. Also deprecate `to_default_s`.
       to_default_s
     end
   end
+  alias_method :to_fs, :to_formatted_s
   alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "time"
+
+class Time
+  NOT_SET = Object.new # :nodoc:
+  def to_s(format = NOT_SET) # :nodoc:
+    if formatter = DATE_FORMATS[format]
+      ActiveSupport::Deprecation.warn(
+        "Time#to_s(#{format.inspect}) is deprecated. Please use Time#to_formatted_s(#{format.inspect}) instead."
+      )
+      formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+    elsif format == NOT_SET
+      to_default_s
+    else
+      ActiveSupport::Deprecation.warn(
+        "Time#to_s(#{format.inspect}) is deprecated. Please use Time#to_formatted_s(#{format.inspect}) instead."
+      )
+      to_default_s
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ class Time
     # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
     # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
     def zone
-      Thread.current[:time_zone] || zone_default
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] || zone_default
     end
 
     # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread.
@@ -39,7 +39,7 @@ class Time
     #     end
     #   end
     def zone=(time_zone)
-      Thread.current[:time_zone] = find_zone!(time_zone)
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] = find_zone!(time_zone)
     end
 
     # Allows override of <tt>Time.zone</tt> locally inside supplied block;

data/lib/active_support/core_ext/time.rb

@@ -4,4 +4,5 @@ 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/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/time/zones"

data/lib/active_support/core_ext/uri.rb

@@ -1,15 +1,5 @@
 # frozen_string_literal: true
 
-require "uri"
-
-module URI
-  class << self
-    def parser
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        URI.parser is deprecated and will be removed in Rails 7.0.
-        Use `URI::DEFAULT_PARSER` instead.
-      MSG
-      URI::DEFAULT_PARSER
-    end
-  end
-end
+ActiveSupport::Deprecation.warn(<<-MSG.squish)
+  `active_support/core_ext/uri` is deprecated and will be removed in Rails 7.1.
+MSG

data/lib/active_support/core_ext.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
+  next if path.end_with?("core_ext/uri.rb")
   require path
 end

data/lib/active_support/current_attributes.rb

@@ -98,25 +98,37 @@ module ActiveSupport
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
       def attribute(*names)
-        generated_attribute_methods.module_eval do
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
-            define_method(name) do
-              attributes[name.to_sym]
+            owner.define_cached_method(name, namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}" <<
+                "attributes[:#{name}]" <<
+                "end"
             end
-
-            define_method("#{name}=") do |attribute|
-              attributes[name.to_sym] = attribute
+            owner.define_cached_method("#{name}=", namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "attributes[:#{name}] = value" <<
+                "end"
             end
           end
         end
 
-        names.each do |name|
-          define_singleton_method(name) do
-            instance.public_send(name)
-          end
-
-          define_singleton_method("#{name}=") do |attribute|
-            instance.public_send("#{name}=", attribute)
+        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
+          names.each do |name|
+            owner.define_cached_method(name, namespace: :current_attributes_delegation) do |batch|
+              batch <<
+                "def #{name}" <<
+                "instance.#{name}" <<
+                "end"
+            end
+            owner.define_cached_method("#{name}=", namespace: :current_attributes_delegation) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "instance.#{name} = value" <<
+                "end"
+            end
           end
         end
       end
@@ -143,24 +155,13 @@ module ActiveSupport
         current_instances.clear
       end
 
-      def _use_thread_variables=(value) # :nodoc:
-        clear_all
-        @@use_thread_variables = value
-      end
-      @@use_thread_variables = false
-
       private
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
 
         def current_instances
-          if @@use_thread_variables
-            Thread.current.thread_variable_get(:current_attributes_instances) ||
-              Thread.current.thread_variable_set(:current_attributes_instances, {})
-          else
-            Thread.current[:current_attributes_instances] ||= {}
-          end
+          IsolatedExecutionState[:current_attributes_instances] ||= {}
         end
 
         def current_instances_key

data/lib/active_support/descendants_tracker.rb

@@ -1,113 +1,219 @@
 # frozen_string_literal: true
 
 require "weakref"
+require "active_support/ruby_features"
 
 module ActiveSupport
   # This module provides an internal implementation to track descendants
   # which is faster than iterating through ObjectSpace.
   module DescendantsTracker
-    @@direct_descendants = {}
-
     class << self
       def direct_descendants(klass)
-        descendants = @@direct_descendants[klass]
-        descendants ? descendants.to_a : []
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          ActiveSupport::DescendantsTracker.direct_descendants is deprecated and will be removed in Rails 7.1.
+          Use ActiveSupport::DescendantsTracker.subclasses instead.
+        MSG
+        subclasses(klass)
       end
-      alias_method :subclasses, :direct_descendants
+    end
+
+    @clear_disabled = false
+
+    if RubyFeatures::CLASS_SUBCLASSES
+      @@excluded_descendants = if RUBY_ENGINE == "ruby"
+        # On MRI `ObjectSpace::WeakMap` keys are weak references.
+        # So we can simply use WeakMap as a `Set`.
+        ObjectSpace::WeakMap.new
+      else
+        # On TruffleRuby `ObjectSpace::WeakMap` keys are strong references.
+        # So we use `object_id` as a key and the actual object as a value.
+        #
+        # JRuby for now doesn't have Class#descendant, but when it will, it will likely
+        # have the same WeakMap semantic than Truffle so we future proof this as much as possible.
+        class WeakSet # :nodoc:
+          def initialize
+            @map = ObjectSpace::WeakMap.new
+          end
 
-      def descendants(klass)
-        arr = []
-        accumulate_descendants(klass, arr)
-        arr
+          def [](object)
+            @map.key?(object.object_id)
+          end
+
+          def []=(object, _present)
+            @map[object_id] = object
+          end
+        end
+        WeakSet.new
       end
 
-      def clear(only: nil)
-        if only.nil?
-          @@direct_descendants.clear
-          return
+      class << self
+        def disable_clear! # :nodoc:
+          unless @clear_disabled
+            @clear_disabled = true
+            remove_method(:subclasses)
+            remove_method(:descendants)
+            @@excluded_descendants = nil
+          end
+        end
+
+        def subclasses(klass)
+          klass.subclasses
         end
 
-        @@direct_descendants.each do |klass, direct_descendants_of_klass|
-          if only.member?(klass)
-            @@direct_descendants.delete(klass)
-          else
-            direct_descendants_of_klass.reject! do |direct_descendant_of_class|
-              only.member?(direct_descendant_of_class)
+        def descendants(klass)
+          klass.descendants
+        end
+
+        def clear(classes) # :nodoc:
+          raise "DescendantsTracker.clear was disabled because config.cache_classes = true" if @clear_disabled
+
+          classes.each do |klass|
+            @@excluded_descendants[klass] = true
+            klass.descendants.each do |descendant|
+              @@excluded_descendants[descendant] = true
             end
           end
         end
+
+        def native? # :nodoc:
+          true
+        end
+      end
+
+      def subclasses
+        subclasses = super
+        subclasses.reject! { |d| @@excluded_descendants[d] }
+        subclasses
+      end
+
+      def descendants
+        descendants = super
+        descendants.reject! { |d| @@excluded_descendants[d] }
+        descendants
       end
 
-      # This is the only method that is not thread safe, but is only ever called
-      # during the eager loading phase.
-      def store_inherited(klass, descendant)
-        (@@direct_descendants[klass] ||= DescendantsArray.new) << descendant
+      def direct_descendants
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          ActiveSupport::DescendantsTracker#direct_descendants is deprecated and will be removed in Rails 7.1.
+          Use #subclasses instead.
+        MSG
+        subclasses
       end
+    else
+      @@direct_descendants = {}
+
+      class << self
+        def disable_clear! # :nodoc:
+          @clear_disabled = true
+        end
+
+        def subclasses(klass)
+          descendants = @@direct_descendants[klass]
+          descendants ? descendants.to_a : []
+        end
+
+        def descendants(klass)
+          arr = []
+          accumulate_descendants(klass, arr)
+          arr
+        end
+
+        def clear(classes) # :nodoc:
+          raise "DescendantsTracker.clear was disabled because config.cache_classes = true" if @clear_disabled
 
-      private
-        def accumulate_descendants(klass, acc)
-          if direct_descendants = @@direct_descendants[klass]
-            direct_descendants.each do |direct_descendant|
-              acc << direct_descendant
-              accumulate_descendants(direct_descendant, acc)
+          @@direct_descendants.each do |klass, direct_descendants_of_klass|
+            if classes.member?(klass)
+              @@direct_descendants.delete(klass)
+            else
+              direct_descendants_of_klass.reject! do |direct_descendant_of_class|
+                classes.member?(direct_descendant_of_class)
+              end
             end
           end
         end
-    end
 
-    def inherited(base)
-      DescendantsTracker.store_inherited(self, base)
-      super
-    end
+        def native? # :nodoc:
+          false
+        end
 
-    def direct_descendants
-      DescendantsTracker.direct_descendants(self)
-    end
-    alias_method :subclasses, :direct_descendants
+        # This is the only method that is not thread safe, but is only ever called
+        # during the eager loading phase.
+        def store_inherited(klass, descendant)
+          (@@direct_descendants[klass] ||= DescendantsArray.new) << descendant
+        end
 
-    def descendants
-      DescendantsTracker.descendants(self)
-    end
+        private
+          def accumulate_descendants(klass, acc)
+            if direct_descendants = @@direct_descendants[klass]
+              direct_descendants.each do |direct_descendant|
+                acc << direct_descendant
+                accumulate_descendants(direct_descendant, acc)
+              end
+            end
+          end
+      end
 
-    # DescendantsArray is an array that contains weak references to classes.
-    class DescendantsArray # :nodoc:
-      include Enumerable
+      def inherited(base)
+        DescendantsTracker.store_inherited(self, base)
+        super
+      end
 
-      def initialize
-        @refs = []
+      def direct_descendants
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          ActiveSupport::DescendantsTracker#direct_descendants is deprecated and will be removed in Rails 7.1.
+          Use #subclasses instead.
+        MSG
+        DescendantsTracker.subclasses(self)
       end
 
-      def initialize_copy(orig)
-        @refs = @refs.dup
+      def subclasses
+        DescendantsTracker.subclasses(self)
       end
 
-      def <<(klass)
-        @refs << WeakRef.new(klass)
+      def descendants
+        DescendantsTracker.descendants(self)
       end
 
-      def each
-        @refs.reject! do |ref|
-          yield ref.__getobj__
-          false
-        rescue WeakRef::RefError
-          true
+      # DescendantsArray is an array that contains weak references to classes.
+      class DescendantsArray # :nodoc:
+        include Enumerable
+
+        def initialize
+          @refs = []
         end
-        self
-      end
 
-      def refs_size
-        @refs.size
-      end
+        def initialize_copy(orig)
+          @refs = @refs.dup
+        end
 
-      def cleanup!
-        @refs.delete_if { |ref| !ref.weakref_alive? }
-      end
+        def <<(klass)
+          @refs << WeakRef.new(klass)
+        end
 
-      def reject!
-        @refs.reject! do |ref|
-          yield ref.__getobj__
-        rescue WeakRef::RefError
-          true
+        def each
+          @refs.reject! do |ref|
+            yield ref.__getobj__
+            false
+          rescue WeakRef::RefError
+            true
+          end
+          self
+        end
+
+        def refs_size
+          @refs.size
+        end
+
+        def cleanup!
+          @refs.delete_if { |ref| !ref.weakref_alive? }
+        end
+
+        def reject!
+          @refs.reject! do |ref|
+            yield ref.__getobj__
+          rescue WeakRef::RefError
+            true
+          end
         end
       end
     end

data/lib/active_support/error_reporter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
+  #
+  # To rescue and report any unhandled error, you can use the +handle+ method:
+  #
+  #   Rails.error.handle do
+  #     do_something!
+  #   end
+  #
+  # If an error is raised, it will be reported and swallowed.
+  #
+  # Alternatively if you want to report the error but not swallow it, you can use +record+
+  #
+  #   Rails.error.record do
+  #     do_something!
+  #   end
+  #
+  # Both methods can be restricted to only handle a specific exception class
+  #
+  #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+  #
+  # You can also pass some extra context information that may be used by the error subscribers:
+  #
+  #   Rails.error.handle(context: { section: "admin" }) do
+  #     # ...
+  #   end
+  #
+  # Additionally a +severity+ can be passed along to communicate how important the error report is.
+  # +severity+ can be one of +:error+, +:warning+ or +:info+. Handled errors default to the +:warning+
+  # severity, and unhandled ones to +error+.
+  #
+  # Both +handle+ and +record+ pass through the return value from the block. In the case of +handle+
+  # rescuing an error, a fallback can be provided. The fallback must be a callable whose result will
+  # be returned when the block raises and is handled:
+  #
+  #   user = Rails.error.handle(fallback: -> { User.anonymous }) do
+  #     User.find_by(params)
+  #   end
+  class ErrorReporter
+    SEVERITIES = %i(error warning info)
+
+    attr_accessor :logger
+
+    def initialize(*subscribers, logger: nil)
+      @subscribers = subscribers.flatten
+      @logger = logger
+    end
+
+    # Report any unhandled exception, and swallow it.
+    #
+    #   Rails.error.handle do
+    #     1 + '1'
+    #   end
+    #
+    def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)
+      yield
+    rescue error_class => error
+      report(error, handled: true, severity: severity, context: context)
+      fallback.call if fallback
+    end
+
+    def record(error_class = StandardError, severity: :error, context: {})
+      yield
+    rescue error_class => error
+      report(error, handled: false, severity: severity, context: context)
+      raise
+    end
+
+    # Register a new error subscriber. The subscriber must respond to
+    #
+    #   report(Exception, handled: Boolean, context: Hash)
+    #
+    # The +report+ method +should+ never raise an error.
+    def subscribe(subscriber)
+      unless subscriber.respond_to?(:report)
+        raise ArgumentError, "Error subscribers must respond to #report"
+      end
+      @subscribers << subscriber
+    end
+
+    # Update the execution context that is accessible to error subscribers
+    #
+    #   Rails.error.set_context(section: "checkout", user_id: @user.id)
+    #
+    # See +ActiveSupport::ExecutionContext.set+
+    def set_context(...)
+      ActiveSupport::ExecutionContext.set(...)
+    end
+
+    # When the block based +handle+ and +record+ methods are not suitable, you can directly use +report+
+    #
+    #   Rails.error.report(error, handled: true)
+    def report(error, handled:, severity: handled ? :warning : :error, context: {})
+      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)
+      @subscribers.each do |subscriber|
+        subscriber.report(error, handled: handled, severity: severity, context: full_context)
+      rescue => subscriber_error
+        if logger
+          logger.fatal(
+            "Error subscriber raised an error: #{subscriber_error.message} (#{subscriber_error.class})\n" +
+            subscriber_error.backtrace.join("\n")
+          )
+        else
+          raise
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/active_support/execution_context/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ExecutionContext::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::ExecutionContext.clear
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::ExecutionContext.clear
+  end
+end