activesupport 8.0.2 → 8.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f094945c33f1c6e036f987c0cc7405a0146f0c800635e1fc16d8a1c34910cb7
-  data.tar.gz: 9ffe8729fffcae283965435a590eb7db596a43fa39c8565e814abab6e16e0444
+  metadata.gz: 961314ec0e1413ca082492acda67d57e19e5011d13725707c3b3d83cb3e88b6c
+  data.tar.gz: '0918a0dcb857f0621acf8c0034cc568efceddbaf92991da1d73ea1a3ae892f40'
 SHA512:
-  metadata.gz: a391e85fc1235084e201abc2736139578767397fa4a503573e82c5f7f339e13d13b5702302ff37176a26a8d80203fc914682e40c570d933aa282e2fb92f26e76
-  data.tar.gz: 6adf2e0b528f17bcd51373d8e627c4ec77de8967c968fdab89fb2bac11952bf98f5ffb6910cdf372cf57bd7929f539808dc783160b0456a803783264421016ce
+  metadata.gz: d167935a467f95a7dd138a7498328e7f8bb5970ad79e33ea43267fe79d6a40f5515abc768f9aa995d15e8678638e34a4b1ce925797a216bc7b5b26ab8ea97be7
+  data.tar.gz: 01edbccd59380207d979f9a504619a862c475217eecd9c8972af5868e4f870e405a511babb6925a7723038c7da395a94ecbaf1a3e3e8fb1f4f07dd7300d0321a

data/CHANGELOG.md

@@ -1,255 +1,371 @@
-## Rails 8.0.2 (March 12, 2025) ##
+## Rails 8.1.0.beta1 (September 04, 2025) ##
 
-*   No changes.
+*   Add `ActiveSupport::Cache::Store#namespace=` and `#namespace`.
 
+    Can be used as an alternative to `Store#clear` in some situations such as parallel
+    testing.
 
-## Rails 8.0.2 (March 12, 2025) ##
+    *Nick Schwaderer*
 
-*   Fix setting `to_time_preserves_timezone` from `new_framework_defaults_8_0.rb`.
+*   Create `parallel_worker_id` helper for running parallel tests. This allows users to
+    know which worker they are currently running in.
 
-    *fatkodima*
+    *Nick Schwaderer*
 
-*   Fix Active Support Cache `fetch_multi` when local store is active.
+*   Make the cache of `ActiveSupport::Cache::Strategy::LocalCache::Middleware` updatable.
 
-    `fetch_multi` now properly yield to the provided block for missing entries
-    that have been recorded as such in the local store.
+    If the cache client at `Rails.cache` of a booted application changes, the corresponding
+    mounted middleware needs to update in order for request-local caches to be setup properly.
+    Otherwise, redundant cache operations will erroneously hit the datastore.
 
-    *Jean Boussier*
+    *Gannon McGibbon*
 
-*   Fix execution wrapping to report all exceptions, including `Exception`.
+*   Add `assert_events_reported` test helper for `ActiveSupport::EventReporter`.
 
-    If a more serious error like `SystemStackError` or `NoMemoryError` happens,
-    the error reporter should be able to report these kinds of exceptions.
+    This new assertion allows testing multiple events in a single block, regardless of order:
 
-    *Gannon McGibbon*
+    ```ruby
+    assert_events_reported([
+      { name: "user.created", payload: { id: 123 } },
+      { name: "email.sent", payload: { to: "user@example.com" } }
+    ]) do
+      create_user_and_send_welcome_email
+    end
+    ```
 
-*   Fix `RedisCacheStore` and `MemCacheStore` to also handle connection pool related errors.
+    *George Ma*
 
-    These errors are rescued and reported to `Rails.error`.
+*   Add `ActiveSupport::TimeZone#standard_name` method.
 
-    *Jean Boussier*
+    ``` ruby
+    zone = ActiveSupport::TimeZone['Hawaii']
+    # Old way
+    ActiveSupport::TimeZone::MAPPING[zone.name]
+    # New way
+    zone.standard_name # => 'Pacific/Honolulu'
+    ```
 
-*   Fix `ActiveSupport::Cache#read_multi` to respect version expiry when using local cache.
+    *Bogdan Gusiev*
 
-    *zzak*
+*   Add Structured Event Reporter, accessible via `Rails.event`.
 
-*   Fix `ActiveSupport::MessageVerifier` and `ActiveSupport::MessageEncryptor` configuration of `on_rotation` callback.
+    The Event Reporter provides a unified interface for producing structured events in Rails
+    applications:
 
     ```ruby
-    verifier.rotate(old_secret).on_rotation { ... }
+    Rails.event.notify("user.signup", user_id: 123, email: "user@example.com")
     ```
 
-    Now both work as documented.
-
-    *Jean Boussier*
-
-*   Fix `ActiveSupport::MessageVerifier` to always be able to verify both URL-safe and URL-unsafe payloads.
+    It supports adding tags to events:
 
-    This is to allow transitioning seemlessly from either configuration without immediately invalidating
-    all previously generated signed messages.
+    ```ruby
+    Rails.event.tagged("graphql") do
+      # Event includes tags: { graphql: true }
+      Rails.event.notify("user.signup", user_id: 123, email: "user@example.com")
+    end
+    ```
 
-    *Jean Boussier*, *Florent Beaurain*, *Ali Sepehri*
+    As well as context:
+    ```ruby
+    # All events will contain context: {request_id: "abc123", shop_id: 456}
+    Rails.event.set_context(request_id: "abc123", shop_id: 456)
+    ```
 
-*   Fix `cache.fetch` to honor the provided expiry when `:race_condition_ttl` is used.
+    Events are emitted to subscribers. Applications register subscribers to
+    control how events are serialized and emitted. Subscribers must implement
+    an `#emit` method, which receives the event hash:
 
     ```ruby
-    cache.fetch("key", expires_in: 1.hour, race_condition_ttl: 5.second) do
-      "something"
+    class LogSubscriber
+      def emit(event)
+        payload = event[:payload].map { |key, value| "#{key}=#{value}" }.join(" ")
+        source_location = event[:source_location]
+        log = "[#{event[:name]}] #{payload} at #{source_location[:filepath]}:#{source_location[:lineno]}"
+        Rails.logger.info(log)
+      end
     end
     ```
 
-    In the above example, the final cache entry would have a 10 seconds TTL instead
-    of the requested 1 hour.
+    *Adrianna Chang*
 
-    *Dhia*
+*   Make `ActiveSupport::Logger` `#freeze`-friendly.
 
-*   Better handle procs with splat arguments in `set_callback`.
+    *Joshua Young*
 
-    *Radamés Roriz*
+*   Make `ActiveSupport::Gzip.compress` deterministic based on input.
 
-*   Fix `String#mb_chars` to not mutate the receiver.
+    `ActiveSupport::Gzip.compress` used to include a timestamp in the output,
+    causing consecutive calls with the same input data to have different output
+    if called during different seconds. It now always sets the timestamp to `0`
+    so that the output is identical for any given input.
 
-    Previously it would call `force_encoding` on the receiver,
-    now it dups the receiver first.
+    *Rob Brackett*
 
-    *Jean Boussier*
+*   Given an array of `Thread::Backtrace::Location` objects, the new method
+    `ActiveSupport::BacktraceCleaner#clean_locations` returns an array with the
+    clean ones:
 
-*   Improve `ErrorSubscriber` to also mark error causes as reported.
+    ```ruby
+    clean_locations = backtrace_cleaner.clean_locations(caller_locations)
+    ```
 
-    This avoid some cases of errors being reported twice, notably in views because of how
-    errors are wrapped in `ActionView::Template::Error`.
+    Filters and silencers receive strings as usual. However, the `path`
+    attributes of the locations in the returned array are the original,
+    unfiltered ones, since locations are immutable.
 
-    *Jean Boussier*
+    *Xavier Noria*
 
-*   Fix `Module#module_parent_name` to return the correct name after the module has been named.
+*   Improve `CurrentAttributes` and `ExecutionContext` state managment in test cases.
 
-    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.
+    Previously these two global state would be entirely cleared out whenever calling
+    into code that is wrapped by the Rails executor, typically Action Controller or
+    Active Job helpers:
 
     ```ruby
-    mod = Module.new
-    mod.module_parent_name # => "Object"
-    MyModule::Something = mod
-    mod.module_parent_name # => "MyModule"
+    test "#index works" do
+      CurrentUser.id = 42
+      get :index
+      CurrentUser.id == nil
+    end
     ```
 
+    Now re-entering the executor properly save and restore that state.
+
     *Jean Boussier*
 
+*   The new method `ActiveSupport::BacktraceCleaner#first_clean_location`
+    returns the first clean location of the caller's call stack, or `nil`.
+    Locations are `Thread::Backtrace::Location` objects. Useful when you want to
+    report the application-level location where something happened as an object.
 
-## Rails 8.0.1 (December 13, 2024) ##
+    *Xavier Noria*
 
-*   Fix a bug in `ERB::Util.tokenize` that causes incorrect tokenization when ERB tags are preceeded by multibyte characters.
+*   FileUpdateChecker and EventedFileUpdateChecker ignore changes in Gem.path now.
 
-    *Martin Emde*
+    *Ermolaev Andrey*, *zzak*
 
-*   Restore the ability to decorate methods generated by `class_attribute`.
+*   The new method `ActiveSupport::BacktraceCleaner#first_clean_frame` returns
+    the first clean frame of the caller's backtrace, or `nil`. Useful when you
+    want to report the application-level frame where something happened as a
+    string.
 
-    It always has been complicated to use Module#prepend or an alias method chain
-    to decorate methods defined by `class_attribute`, but became even harder in 8.0.
+    *Xavier Noria*
 
-    This capability is now supported for both reader and writer methods.
+*   Always clear `CurrentAttributes` instances.
 
-    *Jean Boussier*
+    Previously `CurrentAttributes` instance would be reset at the end of requests.
+    Meaning its attributes would be re-initialized.
 
+    This is problematic because it assume these objects don't hold any state
+    other than their declared attribute, which isn't always the case, and
+    can lead to state leak across request.
 
-## Rails 8.0.0.1 (December 10, 2024) ##
+    Now `CurrentAttributes` instances are abandoned at the end of a request,
+    and a new instance is created at the start of the next request.
 
-*   No changes.
+    *Jean Boussier*, *Janko Marohnić*
 
+*   Add public API for `before_fork_hook` in parallel testing.
 
-## Rails 8.0.0 (November 07, 2024) ##
+    Introduces a public API for calling the before fork hooks implemented by parallel testing.
 
-*   No changes.
+    ```ruby
+    parallelize_before_fork do
+        # perform an action before test processes are forked
+    end
+    ```
 
+    *Eileen M. Uchitelle*
 
-## Rails 8.0.0.rc2 (October 30, 2024) ##
+*   Implement ability to skip creating parallel testing databases.
 
-*   No changes.
+    With parallel testing, Rails will create a database per process. If this isn't
+    desirable or you would like to implement databases handling on your own, you can
+    now turn off this default behavior.
 
+    To skip creating a database per process, you can change it via the
+    `parallelize` method:
 
-## Rails 8.0.0.rc1 (October 19, 2024) ##
+    ```ruby
+    parallelize(workers: 10, parallelize_databases: false)
+    ```
 
-*   Remove deprecated support to passing an array of strings to `ActiveSupport::Deprecation#warn`.
+    or via the application configuration:
 
-    *Rafael Mendonça França*
+    ```ruby
+    config.active_support.parallelize_databases = false
+    ```
 
-*   Remove deprecated support to setting `attr_internal_naming_format` with a `@` prefix.
+    *Eileen M. Uchitelle*
 
-    *Rafael Mendonça França*
+*   Allow to configure maximum cache key sizes
 
-*   Remove deprecated `ActiveSupport::ProxyObject`.
+    When the key exceeds the configured limit (250 bytes by default), it will be truncated and
+    the digest of the rest of the key appended to it.
 
-    *Rafael Mendonça França*
+    Note that previously `ActiveSupport::Cache::RedisCacheStore` allowed up to 1kb cache keys before
+    truncation, which is now reduced to 250 bytes.
 
-*   Don't execute i18n watcher on boot. It shouldn't catch any file changes initially,
-    and unnecessarily slows down boot of applications with lots of translations.
+    ```ruby
+    config.cache_store = :redis_cache_store, { max_key_size: 64 }
+    ```
 
-    *Gannon McGibbon*, *David Stosik*
+    *fatkodima*
 
-*   Fix `ActiveSupport::HashWithIndifferentAccess#stringify_keys` to stringify all keys not just symbols.
+*   Use `UNLINK` command instead of `DEL` in `ActiveSupport::Cache::RedisCacheStore` for non-blocking deletion.
 
-    Previously:
+    *Aron Roh*
+
+*   Add `Cache#read_counter` and `Cache#write_counter`
 
     ```ruby
-    { 1 => 2 }.with_indifferent_access.stringify_keys[1] # => 2
+    Rails.cache.write_counter("foo", 1)
+    Rails.cache.read_counter("foo") # => 1
+    Rails.cache.increment("foo")
+    Rails.cache.read_counter("foo") # => 2
     ```
 
-    After this change:
+    *Alex Ghiculescu*
+
+*   Introduce ActiveSupport::Testing::ErrorReporterAssertions#capture_error_reports
+
+    Captures all reported errors from within the block that match the given
+    error class.
 
     ```ruby
-    { 1 => 2 }.with_indifferent_access.stringify_keys["1"] # => 2
+    reports = capture_error_reports(IOError) do
+      Rails.error.report(IOError.new("Oops"))
+      Rails.error.report(IOError.new("Oh no"))
+      Rails.error.report(StandardError.new)
+    end
+
+    assert_equal 2, reports.size
+    assert_equal "Oops", reports.first.error.message
+    assert_equal "Oh no", reports.last.error.message
     ```
 
-    This change can be seen as a bug fix, but since it behaved like this for a very long time, we're deciding
-    to not backport the fix and to make the change in a major release.
+    *Andrew Novoselac*
 
-    *Jean Boussier*
+*   Introduce ActiveSupport::ErrorReporter#add_middleware
 
-## Rails 8.0.0.beta1 (September 26, 2024) ##
+    When reporting an error, the error context middleware will be called with the reported error
+    and base execution context. The stack may mutate the context hash. The mutated context will
+    then be passed to error subscribers. Middleware receives the same parameters as `ErrorReporter#report`.
 
-*   Include options when instrumenting `ActiveSupport::Cache::Store#delete` and `ActiveSupport::Cache::Store#delete_multi`.
+    *Andrew Novoselac*, *Sam Schmidt*
 
-    *Adam Renberg Tamm*
+*   Change execution wrapping to report all exceptions, including `Exception`.
 
-*   Print test names when running `rails test -v` for parallel tests.
+    If a more serious error like `SystemStackError` or `NoMemoryError` happens,
+    the error reporter should be able to report these kinds of exceptions.
 
-    *John Hawthorn*, *Abeid Ahmed*
+    *Gannon McGibbon*
 
-*   Deprecate `Benchmark.ms` core extension.
+*   `ActiveSupport::Testing::Parallelization.before_fork_hook` allows declaration of callbacks that
+    are invoked immediately before forking test workers.
 
-    The `benchmark` gem will become bundled in Ruby 3.5
+    *Mike Dalessio*
 
-    *Earlopain*
+*   Allow the `#freeze_time` testing helper to accept a date or time argument.
 
-*   `ActiveSupport::TimeWithZone#inspect` now uses ISO 8601 style time like `Time#inspect`
+    ```ruby
+    Time.current # => Sun, 09 Jul 2024 15:34:49 EST -05:00
+    freeze_time Time.current + 1.day
+    sleep 1
+    Time.current # => Mon, 10 Jul 2024 15:34:49 EST -05:00
+    ```
 
-    *John Hawthorn*
+    *Joshua Young*
 
-*   `ActiveSupport::ErrorReporter#report` now assigns a backtrace to unraised exceptions.
+*   `ActiveSupport::JSON` now accepts options
 
-    Previously reporting an un-raised exception would result in an error report without
-    a backtrace. Now it automatically generates one.
+    It is now possible to pass options to `ActiveSupport::JSON`:
+    ```ruby
+    ActiveSupport::JSON.decode('{"key": "value"}', symbolize_names: true) # => { key: "value" }
+    ```
 
-    *Jean Boussier*
+    *matthaigh27*
 
-*   Add `escape_html_entities` option to `ActiveSupport::JSON.encode`.
+*   `ActiveSupport::Testing::NotificationAssertions`'s `assert_notification` now matches against payload subsets by default.
 
-    This allows for overriding the global configuration found at
-    `ActiveSupport.escape_html_entities_in_json` for specific calls to `to_json`.
+    Previously the following assertion would fail due to excess key vals in the notification payload. Now with payload subset matching, it will pass.
 
-    This should be usable from controllers in the following manner:
     ```ruby
-    class MyController < ApplicationController
-      def index
-        render json: { hello: "world" }, escape_html_entities: false
-      end
+    assert_notification("post.submitted", title: "Cool Post") do
+      ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post", body: "Cool Body")
     end
     ```
 
-    *Nigel Baillie*
+    Additionally, you can now persist a matched notification for more customized assertions.
 
-*   Raise when using key which can't respond to `#to_sym` in `EncryptedConfiguration`.
+    ```ruby
+    notification = assert_notification("post.submitted", title: "Cool Post") do
+      ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post", body: Body.new("Cool Body"))
+    end
 
-    As is the case when trying to use an Integer or Float as a key, which is unsupported.
+    assert_instance_of(Body, notification.payload[:body])
+    ```
 
-    *zzak*
+    *Nicholas La Roux*
 
-*   Deprecate addition and since between two `Time` and `ActiveSupport::TimeWithZone`.
+*   Deprecate `String#mb_chars` and `ActiveSupport::Multibyte::Chars`.
 
-    Previously adding time instances together such as `10.days.ago + 10.days.ago` or `10.days.ago.since(10.days.ago)` produced a nonsensical future date. This behavior is deprecated and will be removed in Rails 8.1.
+    These APIs are a relic of the Ruby 1.8 days when Ruby strings weren't encoding
+    aware. There is no legitimate reasons to need these APIs today.
 
-    *Nick Schwaderer*
+    *Jean Boussier*
 
-*   Support rfc2822 format for Time#to_fs & Date#to_fs.
+*   Deprecate `ActiveSupport::Configurable`
 
-    *Akshay Birajdar*
+    *Sean Doyle*
 
-*   Optimize load time for `Railtie#initialize_i18n`. Filter `I18n.load_path`s passed to the file watcher to only those
-    under `Rails.root`. Previously the watcher would grab all available locales, including those in gems
-    which do not require a watcher because they won't change.
+*   `nil.to_query("key")` now returns `key`.
 
-    *Nick Schwaderer*
+    Previously it would return `key=`, preventing round tripping with `Rack::Utils.parse_nested_query`.
+
+    *Erol Fornoles*
+
+*   Avoid wrapping redis in a `ConnectionPool` when using `ActiveSupport::Cache::RedisCacheStore` if the `:redis`
+    option is already a `ConnectionPool`.
+
+    *Joshua Young*
+
+*   Alter `ERB::Util.tokenize` to return :PLAIN token with full input string when string doesn't contain ERB tags.
+
+    *Martin Emde*
+
+*   Fix a bug in `ERB::Util.tokenize` that causes incorrect tokenization when ERB tags are preceded by multibyte characters.
+
+    *Martin Emde*
 
-*   Add a `filter` option to `in_order_of` to prioritize certain values in the sorting without filtering the results
-    by these values.
+*   Add `ActiveSupport::Testing::NotificationAssertions` module to help with testing `ActiveSupport::Notifications`.
 
-    *Igor Depolli*
+    *Nicholas La Roux*, *Yishu See*, *Sean Doyle*
 
-*   Improve error message when using `assert_difference` or `assert_changes` with a
-    proc by printing the proc's source code (MRI only).
+*   `ActiveSupport::CurrentAttributes#attributes` now will return a new hash object on each call.
 
-    *Richard Böhme*, *Jean Boussier*
+    Previously, the same hash object was returned each time that method was called.
 
-*   Add a new configuration value `:zone` for `ActiveSupport.to_time_preserves_timezone` and rename the previous `true` value to `:offset`. The new default value is `:zone`.
+    *fatkodima*
+
+*   `ActiveSupport::JSON.encode` supports CIDR notation.
+
+    Previously:
+
+    ```ruby
+    ActiveSupport::JSON.encode(IPAddr.new("172.16.0.0/24")) # => "\"172.16.0.0\""
+    ```
 
-    *Jason Kim*, *John Hawthorn*
+    After this change:
 
-*   Align instrumentation `payload[:key]` in ActiveSupport::Cache to follow the same pattern, with namespaced and normalized keys.
+    ```ruby
+    ActiveSupport::JSON.encode(IPAddr.new("172.16.0.0/24")) # => "\"172.16.0.0/24\""
+    ```
 
-    *Frederik Erbs Spang Thomsen*
+    *Taketo Takashima*
 
-*   Fix `travel_to` to set usec 0 when `with_usec` is `false` and the given argument String or DateTime.
+*   Make `ActiveSupport::FileUpdateChecker` faster when checking many file-extensions.
 
-    *mopp*
+    *Jonathan del Strother*
 
-Please check [7-2-stable](https://github.com/rails/rails/blob/7-2-stable/activesupport/CHANGELOG.md) for previous changes.
+Please check [8-0-stable](https://github.com/rails/rails/blob/8-0-stable/activesupport/CHANGELOG.md) for previous 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

@@ -56,6 +56,18 @@ module ActiveSupport
     end
     alias :filter :clean
 
+    # Given an array of Thread::Backtrace::Location objects, returns an array
+    # with the clean ones:
+    #
+    #     clean_locations = backtrace_cleaner.clean_locations(caller_locations)
+    #
+    # Filters and silencers receive strings as usual. However, the +path+
+    # attributes of the locations in the returned array are the original,
+    # unfiltered ones, since locations are immutable.
+    def clean_locations(locations, kind = :silent)
+      locations.select { |location| clean_frame(location, kind) }
+    end
+
     # Returns the frame with all filters applied.
     # returns +nil+ if the frame was silenced.
     def clean_frame(frame, kind = :silent)
@@ -74,6 +86,65 @@ module ActiveSupport
       end
     end
 
+    # Thread.each_caller_location does not accept a start in Ruby < 3.4.
+    if Thread.method(:each_caller_location).arity == 0
+      # Returns the first clean frame of the caller's backtrace, or +nil+.
+      #
+      # Frames are strings.
+      def first_clean_frame(kind = :silent)
+        caller_location_skipped = false
+
+        Thread.each_caller_location do |location|
+          unless caller_location_skipped
+            caller_location_skipped = true
+            next
+          end
+
+          frame = clean_frame(location, kind)
+          return frame if frame
+        end
+      end
+
+      # Returns the first clean location of the caller's call stack, or +nil+.
+      #
+      # Locations are Thread::Backtrace::Location objects. Since they are
+      # immutable, their +path+ attributes are the original ones, but filters
+      # are applied internally so silencers can still rely on them.
+      def first_clean_location(kind = :silent)
+        caller_location_skipped = false
+
+        Thread.each_caller_location do |location|
+          unless caller_location_skipped
+            caller_location_skipped = true
+            next
+          end
+
+          return location if clean_frame(location, kind)
+        end
+      end
+    else
+      # Returns the first clean frame of the caller's backtrace, or +nil+.
+      #
+      # Frames are strings.
+      def first_clean_frame(kind = :silent)
+        Thread.each_caller_location(2) do |location|
+          frame = clean_frame(location, kind)
+          return frame if frame
+        end
+      end
+
+      # Returns the first clean location of the caller's call stack, or +nil+.
+      #
+      # Locations are Thread::Backtrace::Location objects. Since they are
+      # immutable, their +path+ attributes are the original ones, but filters
+      # are applied internally so silencers can still rely on them.
+      def first_clean_location(kind = :silent)
+        Thread.each_caller_location(2) do |location|
+          return location if clean_frame(location, kind)
+        end
+      end
+    end
+
     # Adds a filter from the block provided. Each line in the backtrace will be
     # mapped against this filter.
     #