activesupport 7.0.0.alpha2 → 7.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5519479cbadbd2a19e3eaf56b8f1446903f303901f28fcf3b0d7b54f65105b00
-  data.tar.gz: 3a69b60b6b587c44b8dfd6988bf0582a8bb872c888aa06dd318b63aba4532a62
+  metadata.gz: fc2a50831138a53abf91816c46a1ada54c6457c2a6be685e46c32fdacae8706d
+  data.tar.gz: 805b7df2562018d4991b711eda5badd29778b262cf82467f2d18c57bd69f8d2c
 SHA512:
-  metadata.gz: ee3c9d43bd65e15a1b828ed60e2a6f4dd5734a2aad2d3aa7023def780f5148f6060d8ea4fff238f63a71b69c04b9b3ee6e5ba0671561c40118883b9ac7f2745d
-  data.tar.gz: 2254965d4be1e85d7c37bb907e2f68e0323efbdb3ccac496eaec3d07d4f94cfc54dd1e090b2d7d6fd4a32e468bfdbb4c6dbe431d6b04959cb7efd7071a565cc6
+  metadata.gz: fc5e281a4b9549b92170e17056b0bb12911327b839d7af8d021ef8173e7432deceea44a1444a2c954f489ce534ea0bce527add775be03298d3d3f8224ba0e2af
+  data.tar.gz: fa401cf383e3bb17d03ae007d972b8f3b15f5b4565c05af3ee48895e60154a8c58e010096bfc50eb11a658102d1afbbad0d80b90744424783614d9146780b46b

data/CHANGELOG.md

@@ -1,3 +1,83 @@
+*   Deprecate passing a format to `#to_s` in favor of `#to_formatted_s` in `Array`, `Range`, `Date`, `DateTime`, `Time`,
+    `BigDecimal`, `Float` and, `Integer`.
+
+    *Rafael Mendonça França*
+
+*   Document `ActiveSupport::Testing::Deprecation`.
+
+    *Sam Bostock & Sam Jordan*
+
+*   Add `Pathname#existence`.
+
+    ```ruby
+    Pathname.new("file").existence&.read
+    ```
+
+    *Timo Schilling*
+
+*   Remove deprecate `ActiveSupport::Multibyte::Unicode.default_normalization_form`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated support to use `Range#include?` to check the inclusion of a value in
+    a date time range is deprecated.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `URI.parser`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated `config.active_support.use_sha1_digests`.
+
+    *Rafael Mendonça França*
+
+*   Invoking `Object#with_options` without a `&block` argument returns the
+    `ActiveSupport::OptionMerger` instance.
+
+    *Sean Doyle*
+
+*   `Rails.application.executor` hooks can now be called around every test
+
+    This helps to better simulate request or job local state being reset around tests and prevents state
+    leaking from one test to another.
+
+    However it requires the executor hooks executed in the test environment to be re-entrant.
+
+    To enable this, set `config.active_support.executor_around_test_case = true` (this is the default in Rails 7).
+
+    *Jean Boussier*
+
+*   `ActiveSupport::DescendantsTracker` now mostly delegate to `Class#descendants` on Ruby 3.1
+
+    Ruby now provides a fast `Class#descendants` making `ActiveSupport::DescendantsTracker` mostly useless.
+
+    As a result the following methods are deprecated:
+
+      - `ActiveSupport::DescendantsTracker.direct_descendants`
+      - `ActiveSupport::DescendantsTracker#direct_descendants`
+
+    *Jean Boussier*
+
+*   Fix the `Digest::UUID.uuid_from_hash` behavior for namespace IDs that are different from the ones defined on `Digest::UUID`.
+
+    The new behavior will be enabled by setting the
+    `config.active_support.use_rfc4122_namespaced_uuids` option to `true`
+    and is the default for new apps.
+
+    The old behavior is the default for upgraded apps and will output a
+    deprecation warning every time a value that is different than one of
+    the constants defined on the `Digest::UUID` extension is used as the
+    namespace ID.
+
+    *Alex Robbin*, *Erich Soares Machado*, *Eugene Kenny*
+
+*   `ActiveSupport::Inflector::Inflections#clear(:acronyms)` is now supported,
+    and `inflector.clear` / `inflector.clear(:all)` also clears acronyms.
+
+    *Alex Ghiculescu*, *Oliver Peate*
+
+
 ## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
 *   No changes.

data/lib/active_support/cache/mem_cache_store.rb

@@ -121,7 +121,9 @@ module ActiveSupport
           @data = addresses.first
         else
           mem_cache_options = options.dup
-          UNIVERSAL_OPTIONS.each { |name| mem_cache_options.delete(name) }
+          # The value "compress: false" prevents duplicate compression within Dalli.
+          mem_cache_options[:compress] = false
+          (UNIVERSAL_OPTIONS - %i(compress)).each { |name| mem_cache_options.delete(name) }
           @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
         end
       end
@@ -236,8 +238,9 @@ module ActiveSupport
             expires_in += 5.minutes
           end
           rescue_error_with false do
-            # The value "compress: false" prevents duplicate compression within Dalli.
-            @data.with { |c| c.send(method, key, payload, expires_in, **options, compress: false) }
+            # Don't pass compress option to Dalli since we are already dealing with compression.
+            options.delete(:compress)
+            @data.with { |c| c.send(method, key, payload, expires_in, **options) }
           end
         end
 
@@ -295,8 +298,9 @@ module ActiveSupport
 
         def rescue_error_with(fallback)
           yield
-        rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
+        rescue Dalli::DalliError => error
+          ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
+          logger.error("DalliError (#{error}): #{error.message}") if logger
           fallback
         end
     end

data/lib/active_support/cache/memory_store.rb

@@ -89,13 +89,13 @@ module ActiveSupport
         return if pruning?
         @pruning = true
         begin
-          start_time = Concurrent.monotonic_time
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           cleanup
           instrument(:prune, target_size, from: @cache_size) do
             keys = synchronize { @data.keys }
             keys.each do |key|
               delete_entry(key, **options)
-              return if @cache_size <= target_size || (max_time && Concurrent.monotonic_time - start_time > max_time)
+              return if @cache_size <= target_size || (max_time && Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time > max_time)
             end
           end
         ensure

data/lib/active_support/cache/redis_cache_store.rb

@@ -458,16 +458,11 @@ module ActiveSupport
 
         def failsafe(method, returning: nil)
           yield
-        rescue ::Redis::BaseError => e
-          handle_exception exception: e, method: method, returning: returning
+        rescue ::Redis::BaseError => error
+          ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
+          @error_handler&.call(method: method, exception: error, returning: returning)
           returning
         end
-
-        def handle_exception(exception:, method:, returning:)
-          if @error_handler
-            @error_handler.(method: method, exception: exception, returning: returning)
-          end
-        end
     end
   end
 end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/inflections"
-require "active_support/per_thread_registry"
 
 module ActiveSupport
   module Cache
@@ -13,23 +12,18 @@ module ActiveSupport
         autoload :Middleware, "active_support/cache/strategy/local_cache_middleware"
 
         # Class for storing and registering the local caches.
-        class LocalCacheRegistry # :nodoc:
-          extend ActiveSupport::PerThreadRegistry
-
-          def initialize
-            @registry = {}
-          end
+        module LocalCacheRegistry # :nodoc:
+          extend self
 
           def cache_for(local_cache_key)
-            @registry[local_cache_key]
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key]
           end
 
           def set_cache_for(local_cache_key, value)
-            @registry[local_cache_key] = value
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key] = value
           end
-
-          def self.set_cache_for(l, v); instance.set_cache_for l, v; end
-          def self.cache_for(l); instance.cache_for l; end
         end
 
         # Simple memory backed cache. This cache is not thread safe and is intended only

data/lib/active_support/callbacks.rb

@@ -372,56 +372,153 @@ module ActiveSupport
 
       # A future invocation of user-supplied code (either as a callback,
       # or a condition filter).
-      class CallTemplate # :nodoc:
-        def initialize(target, method, arguments, block)
-          @override_target = target
-          @method_name = method
-          @arguments = arguments
-          @override_block = block
+      module CallTemplate # :nodoc:
+        class MethodCall
+          def initialize(method)
+            @method_name = method
+          end
+
+          # Return the parts needed to make this call, with the given
+          # input values.
+          #
+          # Returns an array of the form:
+          #
+          #   [target, block, method, *arguments]
+          #
+          # This array can be used as such:
+          #
+          #   target.send(method, *arguments, &block)
+          #
+          # The actual invocation is left up to the caller to minimize
+          # call stack pollution.
+          def expand(target, value, block)
+            [target, block, @method_name]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              target.send(@method_name, &block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !target.send(@method_name, &block)
+            end
+          end
         end
 
-        # Return the parts needed to make this call, with the given
-        # input values.
-        #
-        # Returns an array of the form:
-        #
-        #   [target, block, method, *arguments]
-        #
-        # This array can be used as such:
-        #
-        #   target.send(method, *arguments, &block)
-        #
-        # The actual invocation is left up to the caller to minimize
-        # call stack pollution.
-        def expand(target, value, block)
-          expanded = [@override_target || target, @override_block || block, @method_name]
+        class ObjectCall
+          def initialize(target, method)
+            @override_target = target
+            @method_name = method
+          end
+
+          def expand(target, value, block)
+            [@override_target || target, block, @method_name, target]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              (@override_target || target).send(@method_name, target, &block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !(@override_target || target).send(@method_name, target, &block)
+            end
+          end
+        end
+
+        class InstanceExec0
+          def initialize(block)
+            @override_block = block
+          end
+
+          def expand(target, value, block)
+            [target, @override_block, :instance_exec]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              target.instance_exec(&@override_block)
+            end
+          end
 
-          @arguments.each do |arg|
-            case arg
-            when :value then expanded << value
-            when :target then expanded << target
-            when :block then expanded << (block || raise(ArgumentError))
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !target.instance_exec(&@override_block)
+            end
+          end
+        end
+
+        class InstanceExec1
+          def initialize(block)
+            @override_block = block
+          end
+
+          def expand(target, value, block)
+            [target, @override_block, :instance_exec, target]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              target.instance_exec(target, &@override_block)
             end
           end
 
-          expanded
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !target.instance_exec(target, &@override_block)
+            end
+          end
         end
 
-        # Return a lambda that will make this call when given the input
-        # values.
-        def make_lambda
-          lambda do |target, value, &block|
-            target, block, method, *arguments = expand(target, value, block)
-            target.send(method, *arguments, &block)
+        class InstanceExec2
+          def initialize(block)
+            @override_block = block
+          end
+
+          def expand(target, value, block)
+            raise ArgumentError unless block
+            [target, @override_block || block, :instance_exec, target, block]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              raise ArgumentError unless block
+              target.instance_exec(target, block, &@override_block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              raise ArgumentError unless block
+              !target.instance_exec(target, block, &@override_block)
+            end
           end
         end
 
-        # Return a lambda that will make this call when given the input
-        # values, but then return the boolean inverse of that result.
-        def inverted_lambda
-          lambda do |target, value, &block|
-            target, block, method, *arguments = expand(target, value, block)
-            ! target.send(method, *arguments, &block)
+        class ProcCall
+          def initialize(target)
+            @override_target = target
+          end
+
+          def expand(target, value, block)
+            [@override_target || target, block, :call, target, value]
+          end
+
+          def make_lambda
+            lambda do |target, value, &block|
+              (@override_target || target).call(target, value, &block)
+            end
+          end
+
+          def inverted_lambda
+            lambda do |target, value, &block|
+              !(@override_target || target).call(target, value, &block)
+            end
           end
         end
 
@@ -436,21 +533,19 @@ module ActiveSupport
         def self.build(filter, callback)
           case filter
           when Symbol
-            new(nil, filter, [], nil)
+            MethodCall.new(filter)
           when Conditionals::Value
-            new(filter, :call, [:target, :value], nil)
+            ProcCall.new(filter)
           when ::Proc
             if filter.arity > 1
-              new(nil, :instance_exec, [:target, :block], filter)
+              InstanceExec2.new(filter)
             elsif filter.arity > 0
-              new(nil, :instance_exec, [:target], filter)
+              InstanceExec1.new(filter)
             else
-              new(nil, :instance_exec, [], filter)
+              InstanceExec0.new(filter)
             end
           else
-            method_to_call = callback.current_scopes.join("_")
-
-            new(filter, method_to_call, [:target], nil)
+            ObjectCall.new(filter, callback.current_scopes.join("_").to_sym)
           end
         end
       end
@@ -608,7 +703,7 @@ module ActiveSupport
         # This is used internally to append, prepend and skip callbacks to the
         # CallbackChain.
         def __update_callbacks(name) # :nodoc:
-          ([self] + ActiveSupport::DescendantsTracker.descendants(self)).reverse_each do |target|
+          ([self] + self.descendants).reverse_each do |target|
             chain = target.get_callbacks name
             yield target, chain.dup
           end
@@ -732,7 +827,7 @@ module ActiveSupport
         def reset_callbacks(name)
           callbacks = get_callbacks name
 
-          ActiveSupport::DescendantsTracker.descendants(self).each do |target|
+          self.descendants.each do |target|
             chain = target.get_callbacks(name).dup
             callbacks.each { |c| chain.delete(c) }
             target.set_callbacks name, chain
@@ -825,7 +920,7 @@ module ActiveSupport
           names.each do |name|
             name = name.to_sym
 
-            ([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |target|
+            ([self] + self.descendants).each do |target|
               target.set_callbacks name, CallbackChain.new(name, options)
             end
 

data/lib/active_support/code_generator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class CodeGenerator # :nodoc:
+    class MethodSet
+      METHOD_CACHES = Hash.new { |h, k| h[k] = Module.new }
+
+      def initialize(namespace)
+        @cache = METHOD_CACHES[namespace]
+        @sources = []
+        @methods = {}
+      end
+
+      def define_cached_method(name, as: name)
+        name = name.to_sym
+        as = as.to_sym
+        @methods.fetch(name) do
+          unless @cache.method_defined?(as)
+            yield @sources
+          end
+          @methods[name] = as
+        end
+      end
+
+      def apply(owner, path, line)
+        unless @sources.empty?
+          @cache.module_eval("# frozen_string_literal: true\n" + @sources.join(";"), path, line)
+        end
+        @methods.each do |name, as|
+          owner.define_method(name, @cache.instance_method(as))
+        end
+      end
+    end
+
+    class << self
+      def batch(owner, path, line)
+        if owner.is_a?(CodeGenerator)
+          yield owner
+        else
+          instance = new(owner, path, line)
+          result = yield instance
+          instance.execute
+          result
+        end
+      end
+    end
+
+    def initialize(owner, path, line)
+      @owner = owner
+      @path = path
+      @line = line
+      @namespaces = Hash.new { |h, k| h[k] = MethodSet.new(k) }
+    end
+
+    def define_cached_method(name, namespace:, as: name, &block)
+      @namespaces[namespace].define_cached_method(name, as: as, &block)
+    end
+
+    def execute
+      @namespaces.each_value do |method_set|
+        method_set.apply(@owner, @path, @line - 1)
+      end
+    end
+  end
+end

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

@@ -87,6 +87,8 @@ class Array
   # Extends <tt>Array#to_s</tt> to convert a collection of elements into a
   # comma separated id list if <tt>:db</tt> argument is given as the format.
   #
+  # This method is aliased to <tt>to_fs</tt>.
+  #
   #   Blog.all.to_formatted_s(:db)  # => "1,2,3"
   #   Blog.none.to_formatted_s(:db) # => "null"
   #   [1,2].to_formatted_s          # => "[1, 2]"
@@ -102,8 +104,8 @@ class Array
       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 string that represents the array in XML by invoking +to_xml+
   # on each element. Active Record collections delegate their representation

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Array
+  NOT_SET = Object.new # :nodoc:
+  def to_s(format = NOT_SET) # :nodoc:
+    case format
+    when :db
+      ActiveSupport::Deprecation.warn(
+        "Array#to_s(#{format.inspect}) is deprecated. Please use Array#to_formatted_s(#{format.inspect}) instead."
+      )
+      if empty?
+        "null"
+      else
+        collect(&:id).join(",")
+      end
+    when NOT_SET
+      to_default_s
+    else
+      ActiveSupport::Deprecation.warn(
+        "Array#to_s(#{format.inspect}) is deprecated. Please use Array#to_formatted_s(#{format.inspect}) instead."
+      )
+      to_default_s
+    end
+  end
+end

data/lib/active_support/core_ext/array.rb

@@ -3,6 +3,7 @@
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/array/access"
 require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/array/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/array/extract"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/array/grouping"

data/lib/active_support/core_ext/class/subclasses.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/ruby_features"
+
 class Class
   # Returns an array with all classes that are < than its receiver.
   #
@@ -18,7 +20,7 @@ class Class
     ObjectSpace.each_object(singleton_class).reject do |k|
       k.singleton_class? || k == self
     end
-  end
+  end unless ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
 
   # Returns an array with the direct children of +self+.
   #
@@ -29,5 +31,5 @@ class Class
   #   Foo.subclasses # => [Bar]
   def subclasses
     descendants.select { |descendant| descendant.superclass == self }
-  end
+  end unless ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
 end

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

@@ -17,7 +17,7 @@ class Date
     # If <tt>Date.beginning_of_week</tt> has not been set for the current request, returns the week start specified in <tt>config.beginning_of_week</tt>.
     # If no config.beginning_of_week was specified, returns :monday.
     def beginning_of_week
-      Thread.current[:beginning_of_week] || beginning_of_week_default || :monday
+      ::ActiveSupport::IsolatedExecutionState[:beginning_of_week] || beginning_of_week_default || :monday
     end
 
     # Sets <tt>Date.beginning_of_week</tt> to a week start (e.g. :monday) for current request/thread.
@@ -25,7 +25,7 @@ class Date
     # This method accepts any of the following day symbols:
     # :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday
     def beginning_of_week=(week_start)
-      Thread.current[:beginning_of_week] = find_beginning_of_week!(week_start)
+      ::ActiveSupport::IsolatedExecutionState[:beginning_of_week] = find_beginning_of_week!(week_start)
     end
 
     # Returns week start day symbol (e.g. :monday), or raises an +ArgumentError+ for invalid day symbol.

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

@@ -22,12 +22,12 @@ class Date
 
   # Convert to a formatted string. See DATE_FORMATS for predefined formats.
   #
-  # This method is aliased to <tt>to_s</tt>.
+  # This method is aliased to <tt>to_fs</tt>.
   #
   #   date = Date.new(2007, 11, 10)       # => Sat, 10 Nov 2007
   #
   #   date.to_formatted_s(:db)            # => "2007-11-10"
-  #   date.to_s(:db)                      # => "2007-11-10"
+  #   date.to_formatted_s(:db)            # => "2007-11-10"
   #
   #   date.to_formatted_s(:short)         # => "10 Nov"
   #   date.to_formatted_s(:number)        # => "20071110"
@@ -55,8 +55,8 @@ class Date
       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
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
   def readable_inspect

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

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