activesupport 7.2.2.2 → 7.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 750ecfba98f84e525b7c36607c041c383a1a549a4066b99eff3b54cb7f6aea17
-  data.tar.gz: 541657fdd905365f97f377d67b2cbd3f0849e6d94281bfe6da4625a09226167d
+  metadata.gz: d12b3bc49972cf65396ee7cb16b370f76853dde525bf3d111e6da8a5936ab441
+  data.tar.gz: a97522d2f10dc74dc7d3bc922eb37b3b6c369bd729e26a22e97d250602d6c544
 SHA512:
-  metadata.gz: c3af2c496e771d723aca4f73c5d11fde1b163a975fd0652de23ef91896615af158b804e8754bf5483b2946333051c8fb0a31aacf6f13d5a314b9a8815e1cdb3c
-  data.tar.gz: 3242b4bc37eb068eb09c191d5f4feec156dc21e565b4a9372068c22828e1c84e80fb847e04b85a7521af018ba543ba9a20e0fae25bcb9e03e83b123ec9ecd8c0
+  metadata.gz: 2a89e3f270073d83270087ad960f1236ee794fb833303b1e97121a1f52b20f07ca79d22c879b474d33d9180b2fbc90359619bd20886a8ab978dabcd7df3df4e2
+  data.tar.gz: 0576fb7d4a4bef1d8e9e8a0bbce32f0fbb74ba626e7bbcacabcf50352aaf3c2f6567e4989debe83095164b1f9a16a31ea9c0a9afe55cd4327ffc645f5acbef2d

data/CHANGELOG.md

@@ -1,3 +1,146 @@
+## Rails 7.2.3 (October 28, 2025) ##
+
+*   Fix `Enumerable#sole` to return the full tuple instead of just the first element of the tuple.
+
+    *Olivier Bellone*
+
+*   Fix parallel tests hanging when worker processes die abruptly.
+
+    Previously, if a worker process was killed (e.g., OOM killed, `kill -9`) during parallel
+    test execution, the test suite would hang forever waiting for the dead worker.
+
+    *Joshua Young*
+
+*   `ActiveSupport::FileUpdateChecker` does not depend on `Time.now` to prevent unnecessary reloads with time travel test helpers
+
+    *Jan Grodowski*
+
+*   Fix `ActiveSupport::BroadcastLogger` from executing a block argument for each logger (tagged, info, etc.).
+
+    *Jared Armstrong*
+
+*   Fix `ActiveSupport::HashWithIndifferentAccess#transform_keys!` removing defaults.
+
+    *Hartley McGuire*
+
+*   Fix `ActiveSupport::HashWithIndifferentAccess#tranform_keys!` to handle collisions.
+
+    If the transformation would result in a key equal to another not yet transformed one,
+    it would result in keys being lost.
+
+    Before:
+
+    ```ruby
+    >> {a: 1, b: 2}.with_indifferent_access.transform_keys!(&:succ)
+    => {"c" => 1}
+    ```
+
+    After:
+
+    ```ruby
+    >> {a: 1, b: 2}.with_indifferent_access.transform_keys!(&:succ)
+    => {"c" => 1, "d" => 2}
+    ```
+
+    *Jason T Johnson*, *Jean Boussier*
+
+*   Fix `ActiveSupport::Cache::MemCacheStore#read_multi` to handle network errors.
+
+    This method specifically wasn't handling network errors like other codepaths.
+
+    *Alessandro Dal Grande*
+
+*   Fix Active Support Cache `fetch_multi` when local store is active.
+
+    `fetch_multi` now properly yield to the provided block for missing entries
+    that have been recorded as such in the local store.
+
+    *Jean Boussier*
+
+*   Fix execution wrapping to report all exceptions, including `Exception`.
+
+    If a more serious error like `SystemStackError` or `NoMemoryError` happens,
+    the error reporter should be able to report these kinds of exceptions.
+
+    *Gannon McGibbon*
+
+*   Fix `RedisCacheStore` and `MemCacheStore` to also handle connection pool related errors.
+
+    These errors are rescued and reported to `Rails.error`.
+
+    *Jean Boussier*
+
+*   Fix `ActiveSupport::Cache#read_multi` to respect version expiry when using local cache.
+
+    *zzak*
+
+*   Fix `ActiveSupport::MessageVerifier` and `ActiveSupport::MessageEncryptor` configuration of `on_rotation` callback.
+
+    ```ruby
+    verifier.rotate(old_secret).on_rotation { ... }
+    ```
+
+    Now both work as documented.
+
+    *Jean Boussier*
+
+*   Fix `ActiveSupport::MessageVerifier` to always be able to verify both URL-safe and URL-unsafe payloads.
+
+    This is to allow transitioning seemlessly from either configuration without immediately invalidating
+    all previously generated signed messages.
+
+    *Jean Boussier*, *Florent Beaurain*, *Ali Sepehri*
+
+*   Fix `cache.fetch` to honor the provided expiry when `:race_condition_ttl` is used.
+
+    ```ruby
+    cache.fetch("key", expires_in: 1.hour, race_condition_ttl: 5.second) do
+      "something"
+    end
+    ```
+
+    In the above example, the final cache entry would have a 10 seconds TTL instead
+    of the requested 1 hour.
+
+    *Dhia*
+
+*   Better handle procs with splat arguments in `set_callback`.
+
+    *Radamés Roriz*
+
+*   Fix `String#mb_chars` to not mutate the receiver.
+
+    Previously it would call `force_encoding` on the receiver,
+    now it dups the receiver first.
+
+    *Jean Boussier*
+
+*   Improve `ErrorSubscriber` to also mark error causes as reported.
+
+    This avoid some cases of errors being reported twice, notably in views because of how
+    errors are wrapped in `ActionView::Template::Error`.
+
+    *Jean Boussier*
+
+*   Fix `Module#module_parent_name` to return the correct name after the module has been named.
+
+    When called on an anonymous module, the return value wouldn't change after the module was given a name
+    later by being assigned to a constant.
+
+    ```ruby
+    mod = Module.new
+    mod.module_parent_name # => "Object"
+    MyModule::Something = mod
+    mod.module_parent_name # => "MyModule"
+    ```
+
+    *Jean Boussier*
+
+*   Fix a bug in `ERB::Util.tokenize` that causes incorrect tokenization when ERB tags are preceeded by multibyte characters.
+
+    *Martin Emde*
+
+
 ## Rails 7.2.2.2 (August 13, 2025) ##
 
 *   No changes.

data/README.rdoc

@@ -35,6 +35,6 @@ Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
 * https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_support/backtrace_cleaner.rb

@@ -79,7 +79,7 @@ module ActiveSupport
     #
     #   # Will turn "/my/rails/root/app/models/person.rb" into "app/models/person.rb"
     #   root = "#{Rails.root}/"
-    #   backtrace_cleaner.add_filter { |line| line.start_with?(root) ? line.from(root.size) : line }
+    #   backtrace_cleaner.add_filter { |line| line.delete_prefix(root) }
     def add_filter(&block)
       @filters << block
     end

data/lib/active_support/broadcast_logger.rb

@@ -76,7 +76,6 @@ module ActiveSupport
 
     # Returns all the logger that are part of this broadcast.
     attr_reader :broadcasts
-    attr_reader :formatter
     attr_accessor :progname
 
     def initialize(*loggers)
@@ -105,131 +104,119 @@ module ActiveSupport
       @broadcasts.delete(logger)
     end
 
-    def level
-      @broadcasts.map(&:level).min
-    end
-
-    def <<(message)
-      dispatch { |logger| logger.<<(message) }
-    end
-
-    def add(...)
-      dispatch { |logger| logger.add(...) }
-    end
-    alias_method :log, :add
-
-    def debug(...)
-      dispatch { |logger| logger.debug(...) }
-    end
-
-    def info(...)
-      dispatch { |logger| logger.info(...) }
-    end
-
-    def warn(...)
-      dispatch { |logger| logger.warn(...) }
-    end
-
-    def error(...)
-      dispatch { |logger| logger.error(...) }
-    end
-
-    def fatal(...)
-      dispatch { |logger| logger.fatal(...) }
-    end
-
-    def unknown(...)
-      dispatch { |logger| logger.unknown(...) }
+    def local_level=(level)
+      @broadcasts.each do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
     end
 
-    def formatter=(formatter)
-      dispatch { |logger| logger.formatter = formatter }
-
-      @formatter = formatter
-    end
+    def local_level
+      loggers = @broadcasts.select { |logger| logger.respond_to?(:local_level) }
 
-    def level=(level)
-      dispatch { |logger| logger.level = level }
+      loggers.map do |logger|
+        logger.local_level
+      end.first
     end
-    alias_method :sev_threshold=, :level=
 
-    def local_level=(level)
-      dispatch do |logger|
-        logger.local_level = level if logger.respond_to?(:local_level=)
-      end
+    LOGGER_METHODS = %w[
+      << log add debug info warn error fatal unknown
+      level= sev_threshold= close
+      formatter formatter=
+    ] # :nodoc:
+    LOGGER_METHODS.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(...)
+          dispatch(:#{method}, ...)
+        end
+      RUBY
     end
 
-    def close
-      dispatch { |logger| logger.close }
+    # Returns the lowest level of all the loggers in the broadcast.
+    def level
+      @broadcasts.map(&:level).min
     end
 
-    # +True+ if the log level allows entries with severity Logger::DEBUG to be written
-    # to at least one broadcast. +False+ otherwise.
+    # True if the log level allows entries with severity +Logger::DEBUG+ to be written
+    # to at least one broadcast. False otherwise.
     def debug?
       @broadcasts.any? { |logger| logger.debug? }
     end
 
-    # Sets the log level to Logger::DEBUG for the whole broadcast.
+    # Sets the log level to +Logger::DEBUG+ for the whole broadcast.
     def debug!
-      dispatch { |logger| logger.debug! }
+      dispatch(:debug!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::INFO to be written
-    # to at least one broadcast. +False+ otherwise.
+    # True if the log level allows entries with severity +Logger::INFO+ to be written
+    # to at least one broadcast. False otherwise.
     def info?
       @broadcasts.any? { |logger| logger.info? }
     end
 
-    # Sets the log level to Logger::INFO for the whole broadcast.
+    # Sets the log level to +Logger::INFO+ for the whole broadcast.
     def info!
-      dispatch { |logger| logger.info! }
+      dispatch(:info!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::WARN to be written
-    # to at least one broadcast. +False+ otherwise.
+    # True if the log level allows entries with severity +Logger::WARN+ to be written
+    # to at least one broadcast. False otherwise.
     def warn?
       @broadcasts.any? { |logger| logger.warn? }
     end
 
-    # Sets the log level to Logger::WARN for the whole broadcast.
+    # Sets the log level to +Logger::WARN+ for the whole broadcast.
     def warn!
-      dispatch { |logger| logger.warn! }
+      dispatch(:warn!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::ERROR to be written
-    # to at least one broadcast. +False+ otherwise.
+    # True if the log level allows entries with severity +Logger::ERROR+ to be written
+    # to at least one broadcast. False otherwise.
     def error?
       @broadcasts.any? { |logger| logger.error? }
     end
 
-    # Sets the log level to Logger::ERROR for the whole broadcast.
+    # Sets the log level to +Logger::ERROR+ for the whole broadcast.
     def error!
-      dispatch { |logger| logger.error! }
+      dispatch(:error!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::FATAL to be written
-    # to at least one broadcast. +False+ otherwise.
+    # True if the log level allows entries with severity +Logger::FATAL+ to be written
+    # to at least one broadcast. False otherwise.
     def fatal?
       @broadcasts.any? { |logger| logger.fatal? }
     end
 
-    # Sets the log level to Logger::FATAL for the whole broadcast.
+    # Sets the log level to +Logger::FATAL+ for the whole broadcast.
     def fatal!
-      dispatch { |logger| logger.fatal! }
+      dispatch(:fatal!)
     end
 
     def initialize_copy(other)
       @broadcasts = []
       @progname = other.progname.dup
-      @formatter = other.formatter.dup
 
       broadcast_to(*other.broadcasts.map(&:dup))
     end
 
     private
-      def dispatch(&block)
-        @broadcasts.each { |logger| block.call(logger) }
-        true
+      def dispatch(method, *args, **kwargs, &block)
+        if block_given?
+          # Maintain semantics that the first logger yields the block
+          # as normal, but subsequent loggers won't re-execute the block.
+          # Instead, the initial result is immediately returned.
+          called, result = false, nil
+          block = proc { |*args, **kwargs|
+            if called then result
+            else
+              called = true
+              result = yield(*args, **kwargs)
+            end
+          }
+        end
+
+        @broadcasts.map { |logger|
+          logger.send(method, *args, **kwargs, &block)
+        }.first
       end
 
       def method_missing(name, ...)

data/lib/active_support/cache/file_store.rb

@@ -57,7 +57,7 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.increment("baz") # => 6
       #
-      def increment(name, amount = 1, options = nil)
+      def increment(name, amount = 1, **options)
         modify_value(name, amount, options)
       end
 
@@ -72,7 +72,7 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.decrement("baz") # => 4
       #
-      def decrement(name, amount = 1, options = nil)
+      def decrement(name, amount = 1, **options)
         modify_value(name, -amount, options)
       end
 

data/lib/active_support/cache/mem_cache_store.rb

@@ -212,26 +212,24 @@ module ActiveSupport
         def read_multi_entries(names, **options)
           keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
-          raw_values = begin
-            @data.with { |c| c.get_multi(keys_to_names.keys) }
-          rescue Dalli::UnmarshalError
-            {}
-          end
+          rescue_error_with({}) do
+            raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
 
-          values = {}
+            values = {}
 
-          raw_values.each do |key, value|
-            entry = deserialize_entry(value, raw: options[:raw])
+            raw_values.each do |key, value|
+              entry = deserialize_entry(value, raw: options[:raw])
 
-            unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
-              begin
-                values[keys_to_names[key]] = entry.value
-              rescue DeserializationError
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+                begin
+                  values[keys_to_names[key]] = entry.value
+                rescue DeserializationError
+                end
               end
             end
-          end
 
-          values
+            values
+          end
         end
 
         # Delete an entry from the cache.
@@ -276,7 +274,7 @@ module ActiveSupport
 
         def rescue_error_with(fallback)
           yield
-        rescue Dalli::DalliError => error
+        rescue Dalli::DalliError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
           logger.error("DalliError (#{error}): #{error.message}") if logger
           ActiveSupport.error_reporter&.report(
             error,

data/lib/active_support/cache/memory_store.rb

@@ -146,8 +146,8 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.increment("baz") # => 6
       #
-      def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+      def increment(name, amount = 1, **options)
+        modify_value(name, amount, **options)
       end
 
       # Decrement a cached integer value. Returns the updated value.
@@ -161,8 +161,8 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.decrement("baz") # => 4
       #
-      def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+      def decrement(name, amount = 1, **options)
+        modify_value(name, -amount, **options)
       end
 
       # Deletes cache entries if the cache key matches a given pattern.
@@ -234,7 +234,7 @@ module ActiveSupport
 
         # Modifies the amount of an integer value that is stored in the cache.
         # If the key is not found it is created and set to +amount+.
-        def modify_value(name, amount, options)
+        def modify_value(name, amount, **options)
           options = merged_options(options)
           key     = normalize_key(name, options)
           version = normalize_version(name, options)

data/lib/active_support/cache/null_store.rb

@@ -25,10 +25,10 @@ module ActiveSupport
       def cleanup(options = nil)
       end
 
-      def increment(name, amount = 1, options = nil)
+      def increment(name, amount = 1, **options)
       end
 
-      def decrement(name, amount = 1, options = nil)
+      def decrement(name, amount = 1, **options)
       end
 
       def delete_matched(matcher, options = nil)

data/lib/active_support/cache/redis_cache_store.rb

@@ -480,7 +480,7 @@ module ActiveSupport
 
         def failsafe(method, returning: nil)
           yield
-        rescue ::Redis::BaseError => error
+        rescue ::Redis::BaseError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
           @error_handler&.call(method: method, exception: error, returning: returning)
           returning
         end

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

@@ -94,28 +94,54 @@ module ActiveSupport
           super
         end
 
-        def increment(name, amount = 1, options = nil) # :nodoc:
+        def increment(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          if options
-            write_cache_value(name, value, raw: true, **options)
-          else
-            write_cache_value(name, value, raw: true)
-          end
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
-        def decrement(name, amount = 1, options = nil) # :nodoc:
+        def decrement(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          if options
-            write_cache_value(name, value, raw: true, **options)
-          else
-            write_cache_value(name, value, raw: true)
-          end
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
+        def fetch_multi(*names, &block) # :nodoc:
+          return super if local_cache.nil? || names.empty?
+
+          options = names.extract_options!
+          options = merged_options(options)
+
+          keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+          local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+          results = local_entries.each_with_object({}) do |(key, value), result|
+            # If we recorded a miss in the local cache, `#fetch_multi` will forward
+            # that key to the real store, and the entry will be replaced
+            # local_cache.delete_entry(key)
+            next if value.nil?
+
+            entry = deserialize_entry(value, **options)
+
+            normalized_key = keys_to_names[key]
+            if entry.nil?
+              result[normalized_key] = nil
+            elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
+              local_cache.delete_entry(key)
+            else
+              result[normalized_key] = entry.value
+            end
+          end
+
+          if results.size < names.size
+            results.merge!(super(*(names - results.keys), options, &block))
+          end
+
+          results
+        end
+
         private
           def read_serialized_entry(key, raw: false, **options)
             if cache = local_cache
@@ -137,17 +163,27 @@ module ActiveSupport
             keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
             local_entries = local_cache.read_multi_entries(keys_to_names.keys)
-            local_entries.transform_keys! { |key| keys_to_names[key] }
-            local_entries.transform_values! do |payload|
-              deserialize_entry(payload, **options)&.value
+
+            results = local_entries.each_with_object({}) do |(key, value), result|
+              next if value.nil? # recorded cache miss
+
+              entry = deserialize_entry(value, **options)
+
+              normalized_key = keys_to_names[key]
+              if entry.nil?
+                result[normalized_key] = nil
+              elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
+                local_cache.delete_entry(key)
+              else
+                result[normalized_key] = entry.value
+              end
             end
-            missed_names = names - local_entries.keys
 
-            if missed_names.any?
-              local_entries.merge!(super(missed_names, **options))
-            else
-              local_entries
+            if results.size < names.size
+              results.merge!(super(names - results.keys, **options))
             end
+
+            results
           end
 
           def write_serialized_entry(key, payload, **)

data/lib/active_support/cache.rb

@@ -35,6 +35,7 @@ module ActiveSupport
       :race_condition_ttl,
       :serializer,
       :skip_nil,
+      :raw,
     ]
 
     # Mapping of canonical option names to aliases that a store will recognize.
@@ -386,7 +387,7 @@ module ActiveSupport
       #   process can try to generate a new value after the extended time window
       #   has elapsed.
       #
-      #     # Set all values to expire after one minute.
+      #     # Set all values to expire after one second.
       #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
       #
       #     cache.write("foo", "original value")
@@ -1030,8 +1031,7 @@ module ActiveSupport
               # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is being recalculated.
               entry.expires_at = Time.now.to_f + race_ttl
-              options[:expires_in] = race_ttl * 2
-              write_entry(key, entry, **options)
+              write_entry(key, entry, **options, expires_in: race_ttl * 2)
             else
               delete_entry(key, **options)
             end

data/lib/active_support/callbacks.rb

@@ -499,9 +499,10 @@ module ActiveSupport
           when Conditionals::Value
             ProcCall.new(filter)
           when ::Proc
-            if filter.arity > 1
+            case filter.arity
+            when 2
               InstanceExec2.new(filter)
-            elsif filter.arity > 0
+            when 1, -2
               InstanceExec1.new(filter)
             else
               InstanceExec0.new(filter)

data/lib/active_support/core_ext/benchmark.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "benchmark"
+return if Benchmark.respond_to?(:ms)
 
 class << Benchmark
   # Benchmark realtime in milliseconds.

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

@@ -83,8 +83,8 @@ class Class
   #
   #   class_attribute :settings, default: {}
   def class_attribute(*attrs, instance_accessor: true,
-    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
-
+    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil
+  )
     class_methods, methods = [], []
     attrs.each do |name|
       unless name.is_a?(Symbol) || name.is_a?(String)