activesupport 6.0.6.1 → 7.1.3.2

data/CHANGELOG.md

@@ -1,782 +1,1209 @@
-## Rails 6.0.6.1 (January 17, 2023) ##
+## Rails 7.1.3.2 (February 21, 2024) ##
 
 *   No changes.
 
 
-## Rails 6.0.6 (September 09, 2022) ##
+## Rails 7.1.3.1 (February 21, 2024) ##
 
 *   No changes.
 
 
-## Rails 6.0.5.1 (July 12, 2022) ##
+## Rails 7.1.3 (January 16, 2024) ##
 
-*   No changes.
+*   Handle nil `backtrace_locations` in `ActiveSupport::SyntaxErrorProxy`.
 
+    *Eugene Kenny*
 
-## Rails 6.0.5 (May 09, 2022) ##
+*   Fix `ActiveSupport::JSON.encode` to prevent duplicate keys.
 
-*   No changes.
+    If the same key exist in both String and Symbol form it could
+    lead to the same key being emitted twice.
 
+    *Manish Sharma*
 
-## Rails 6.0.4.8 (April 26, 2022) ##
+*   Fix `ActiveSupport::Cache::Store#read_multi` when using a cache namespace
+    and local cache strategy.
 
-*   Fix and add protections for XSS in `ActionView::Helpers` and `ERB::Util`.
+    *Mark Oleson*
 
-    Add the method `ERB::Util.xml_name_escape` to escape dangerous characters
-    in names of tags and names of attributes, following the specification of XML.
+*   Fix `Time.now/DateTime.now/Date.today` to return results in a system timezone after `#travel_to`.
 
-    *Álvaro Martín Fraguas*
+    There is a bug in the current implementation of #travel_to:
+    it remembers a timezone of its argument, and all stubbed methods start
+    returning results in that remembered timezone. However, the expected
+    behaviour is to return results in a system timezone.
 
+    *Aleksei Chernenkov*
 
-## Rails 6.0.4.7 (March 08, 2022) ##
+*   Fix `:unless_exist` option for `MemoryStore#write` (et al) when using a
+    cache namespace.
 
-*   No changes.
+    *S. Brent Faulkner*
 
+*   Fix ActiveSupport::Deprecation to handle blaming generated code.
 
-## Rails 6.0.4.6 (February 11, 2022) ##
+    *Jean Boussier*, *fatkodima*
 
-*   Fix Reloader method signature to work with the new Executor signature
 
+## Rails 7.1.2 (November 10, 2023) ##
 
-## Rails 6.0.4.5 (February 11, 2022) ##
+*   Fix `:expires_in` option for `RedisCacheStore#write_multi`.
 
-*   No changes.
+    *fatkodima*
 
+*   Fix deserialization of non-string "purpose" field in Message serializer
 
-## Rails 6.0.4.4 (December 15, 2021) ##
+    *Jacopo Beschi*
 
-*   No changes.
+*   Prevent global cache options being overwritten when setting dynamic options
+    inside a `ActiveSupport::Cache::Store#fetch` block.
 
+    *Yasha Krasnou*
 
-## Rails 6.0.4.3 (December 14, 2021) ##
+*   Fix missing `require` resulting in `NoMethodError` when running
+    `bin/rails secrets:show` or `bin/rails secrets:edit`.
 
-*   No changes.
+    *Stephen Ierodiaconou*
 
+*   Ensure `{down,up}case_first` returns non-frozen string.
 
-## Rails 6.0.4.2 (December 14, 2021) ##
+    *Jonathan Hefner*
 
-*   No changes.
+*   Fix `#to_fs(:human_size)` to correctly work with negative numbers.
 
+    *Earlopain*
 
-## Rails 6.0.4.1 (August 19, 2021) ##
+*   Fix `BroadcastLogger#dup` so that it duplicates the logger's `broadcasts`.
 
-*   No changes.
+    *Andrew Novoselac*
 
+*   Fix issue where `bootstrap.rb` overwrites the `level` of a `BroadcastLogger`'s `broadcasts`.
 
-## Rails 6.0.4 (June 15, 2021) ##
+    *Andrew Novoselac*
 
-*   Fixed issue in `ActiveSupport::Cache::RedisCacheStore` not passing options
-    to `read_multi` causing `fetch_multi` to not work properly.
+*   Fix `ActiveSupport::Cache` to handle outdated Marshal payload from Rails 6.1 format.
 
-    *Rajesh Sharma*
+    Active Support's Cache is supposed to treat a Marshal payload that can no longer be
+    deserialized as a cache miss. It fail to do so for compressed payload in the Rails 6.1
+    legacy format.
 
-*   `with_options` copies its options hash again to avoid leaking mutations.
+    *Jean Boussier*
 
-    Fixes #39343.
+*   Fix `OrderedOptions#dig` for array indexes.
 
-    *Eugene Kenny*
+    *fatkodima*
 
+*   Fix time travel helpers to work when nested using with separate classes.
 
-## Rails 6.0.3.7 (May 05, 2021) ##
+    *fatkodima*
 
-*   No changes.
+*   Fix `delete_matched` for file cache store to work with keys longer than the
+    max filename size.
 
+    *fatkodima* and *Jonathan Hefner*
 
-## Rails 6.0.3.6 (March 26, 2021) ##
+*   Fix compatibility with the `semantic_logger` gem.
 
-*   No changes.
+    The `semantic_logger` gem doesn't behave exactly like stdlib logger in that
+    `SemanticLogger#level` returns a Symbol while stdlib `Logger#level` returns an Integer.
 
+    This caused the various `LogSubscriber` classes in Rails to break when assigned a
+    `SemanticLogger` instance.
 
-## Rails 6.0.3.5 (February 10, 2021) ##
+    *Jean Boussier*, *ojab*
 
-*   No changes.
+## Rails 7.1.1 (October 11, 2023) ##
 
+*   Add support for keyword arguments when delegating calls to custom loggers from `ActiveSupport::BroadcastLogger`.
 
-## Rails 6.0.3.4 (October 07, 2020) ##
+    *Edouard Chin*
 
-*   No changes.
+*   `NumberHelper`: handle objects responding `to_d`.
 
+    *fatkodima*
 
-## Rails 6.0.3.3 (September 09, 2020) ##
+*   Fix RedisCacheStore to properly set the TTL when incrementing or decrementing.
 
-*   No changes.
+    This bug was only impacting Redis server older than 7.0.
+
+    *Thomas Countz*
 
+*   Fix MemoryStore to prevent race conditions when incrementing or decrementing.
 
-## Rails 6.0.3.2 (June 17, 2020) ##
+    *Pierre Jambet*
+
+
+## Rails 7.1.0 (October 05, 2023) ##
 
 *   No changes.
 
 
-## Rails 6.0.3.1 (May 18, 2020) ##
+## Rails 7.1.0.rc2 (October 01, 2023) ##
 
-*   [CVE-2020-8165] Deprecate Marshal.load on raw cache read in RedisCacheStore
+*   Fix `AS::MessagePack` with `ENV["RAILS_MAX_THREADS"]`.
 
-*   [CVE-2020-8165] Avoid Marshal.load on raw cache value in MemCacheStore
+    *Jonathan Hefner*
 
 
-## Rails 6.0.3 (May 06, 2020) ##
+## Rails 7.1.0.rc1 (September 27, 2023) ##
 
-*   `Array#to_sentence` no longer returns a frozen string.
+*   Add a new public API for broadcasting logs
 
-    Before:
+    This feature existed for a while but was until now a private API.
+    Broadcasting log allows to send log message to difference sinks (STDOUT, a file ...) and
+    is used by default in the development environment to write logs both on STDOUT and in the
+    "development.log" file.
 
-        ['one', 'two'].to_sentence.frozen?
-        # => true
+    Basic usage:
 
-    After:
+    ```ruby
+    stdout_logger = Logger.new(STDOUT)
+    file_logger = Logger.new("development.log")
+    broadcast = ActiveSupport::BroadcastLogger.new(stdout_logger, file_logger)
 
-        ['one', 'two'].to_sentence.frozen?
-        # => false
+    broadcast.info("Hello!") # The "Hello!" message is written on STDOUT and in the log file.
+    ```
 
-    *Nicolas Dular*
+    Adding other sink(s) to the broadcast:
 
-*   Update `ActiveSupport::Messages::Metadata#fresh?` to work for cookies with expiry set when
-    `ActiveSupport.parse_json_times = true`.
+    ```ruby
+    broadcast = ActiveSupport::BroadcastLogger.new
+    broadcast.broadcast_to(Logger.new(STDERR))
+    ```
 
-    *Christian Gregg*
+    Remove a sink from the broadcast:
 
+    ```ruby
+    stdout_logger = Logger.new(STDOUT)
+    broadcast = ActiveSupport::BroadcastLogger.new(stdout_logger)
 
-## Rails 6.0.2.2 (March 19, 2020) ##
+    broadcast.stop_broadcasting_to(stdout_logger)
+    ```
 
-*   No changes.
+    *Edouard Chin*
 
+*   Fix Range#overlap? not taking empty ranges into account on Ruby < 3.3
 
-## Rails 6.0.2.1 (December 18, 2019) ##
+    *Nobuyoshi Nakada*, *Shouichi Kamiya*, *Hartley McGuire*
 
-*   No changes.
+*   Use Ruby 3.3 Range#overlap? if available
+
+    *Yasuo Honda*
 
 
-## Rails 6.0.2 (December 13, 2019) ##
+## Rails 7.1.0.beta1 (September 13, 2023) ##
 
-*   Eager load translations during initialization.
+*   Add `bigdecimal` as Active Support dependency that is a bundled gem candidate for Ruby 3.4.
 
-    *Diego Plentz*
+    `bigdecimal` 3.1.4 or higher version will be installed.
+    Ruby 2.7 and 3.0 users who want `bigdecimal` version 2.0.0 or 3.0.0 behavior as a default gem,
+    pin the `bigdecimal` version in your application Gemfile.
 
-*   Use per-thread CPU time clock on `ActiveSupport::Notifications`.
+    *Koichi ITO*
 
-    *George Claghorn*
+*   Add `drb`, `mutex_m` and `base64` that are bundled gem candidates for Ruby 3.4
 
+    *Yasuo Honda*
 
-## Rails 6.0.1 (November 5, 2019) ##
+*   When using cache format version >= 7.1 or a custom serializer, expired and
+    version-mismatched cache entries can now be detected without deserializing
+    their values.
 
-*   `ActiveSupport::SafeBuffer` supports `Enumerator` methods.
+    *Jonathan Hefner*
 
-    *Shugo Maeda*
+*   Make all cache stores return a boolean for `#delete`
 
-*   The Redis cache store fails gracefully when the server returns a "max number
-    of clients reached" error.
+    Previously the `RedisCacheStore#delete` would return `1` if the entry
+    exists and `0` otherwise. Now it returns true if the entry exists and false
+    otherwise, just like the other stores.
 
-    *Brandon Medenwald*
+    The `FileStore` would return `nil` if the entry doesn't exists and returns
+    `false` now as well.
+
+    *Petrik de Heus*
+
+*   Active Support cache stores now support replacing the default compressor via
+    a `:compressor` option. The specified compressor must respond to `deflate`
+    and `inflate`. For example:
+
+      ```ruby
+      module MyCompressor
+        def self.deflate(string)
+          # compression logic...
+        end
+
+        def self.inflate(compressed)
+          # decompression logic...
+        end
+      end
 
-*   Fixed that mutating a value returned by a memory cache store would
-    unexpectedly change the cached value.
+      config.cache_store = :redis_cache_store, { compressor: MyCompressor }
+      ```
 
-    *Jonathan Hyman*
+    *Jonathan Hefner*
 
-*   The default inflectors in `zeitwerk` mode support overrides:
+*   Active Support cache stores now support a `:serializer` option. Similar to
+    the `:coder` option, serializers must respond to `dump` and `load`. However,
+    serializers are only responsible for serializing a cached value, whereas
+    coders are responsible for serializing the entire `ActiveSupport::Cache::Entry`
+    instance.  Additionally, the output from serializers can be automatically
+    compressed, whereas coders are responsible for their own compression.
+
+    Specifying a serializer instead of a coder also enables performance
+    optimizations, including the bare string optimization introduced by cache
+    format version 7.1.
+
+    The `:serializer` and `:coder` options are mutually exclusive. Specifying
+    both will raise an `ArgumentError`.
+
+    *Jonathan Hefner*
+
+*   Fix `ActiveSupport::Inflector.humanize(nil)` raising ``NoMethodError: undefined method `end_with?' for nil:NilClass``.
+
+    *James Robinson*
+
+*   Don't show secrets for `ActiveSupport::KeyGenerator#inspect`.
+
+    Before:
 
     ```ruby
-    # config/initializers/zeitwerk.rb
-    Rails.autoloaders.each do |autoloader|
-      autoloader.inflector.inflect(
-        "html_parser" => "HTMLParser",
-        "ssl_error"   => "SSLError"
-      )
-    end
+    ActiveSupport::KeyGenerator.new(secret).inspect
+    "#<ActiveSupport::KeyGenerator:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
+    ```
+
+    After:
+
+    ```ruby
+    ActiveSupport::KeyGenerator::Aes256Gcm(secret).inspect
+    "#<ActiveSupport::KeyGenerator:0x0000000104888038>"
     ```
 
-    That way, you can tweak how individual basenames are inflected without touching Active Support inflection rules, which are global. These inflectors fallback to `String#camelize`, so existing inflection rules are still taken into account for non-overridden basenames.
+    *Petrik de Heus*
 
-    Please, check the [autoloading guide for `zeitwerk` mode](https://guides.rubyonrails.org/v6.0/autoloading_and_reloading_constants.html#customizing-inflections) if you prefer not to depend on `String#camelize` at all.
+*   Improve error message when EventedFileUpdateChecker is used without a
+    compatible version of the Listen gem
 
-    *Xavier Noria*
+    *Hartley McGuire*
 
-*   Improve `Range#===`, `Range#include?`, and `Range#cover?` to work with beginless (startless)
-    and endless range targets.
+*   Add `:report` behavior for Deprecation
 
-    *Allen Hsu*, *Andrew Hodgkinson*
+    Setting `config.active_support.deprecation = :report` uses the error
+    reporter to report deprecation warnings to `ActiveSupport::ErrorReporter`.
 
-*   Don't use `Process#clock_gettime(CLOCK_THREAD_CPUTIME_ID)` on Solaris.
+    Deprecations are reported as handled errors, with a severity of `:warning`.
 
-    *Iain Beeston*
+    Useful to report deprecations happening in production to your bug tracker.
 
+    *Étienne Barrié*
 
-## Rails 6.0.0 (August 16, 2019) ##
+*   Rename `Range#overlaps?` to `#overlap?` and add alias for backwards compatibility
 
-*   Let `require_dependency` in `zeitwerk` mode look the autoload paths up for
-    better backwards compatibility.
+    *Christian Schmidt*
 
-    *Xavier Noria*
+*   Fix `EncryptedConfiguration` returning incorrect values for some `Hash`
+    methods
 
-*   Let `require_dependency` in `zeitwerk` mode support arguments that respond
-    to `to_path` for better backwards compatibility.
+    *Hartley McGuire*
 
-    *Xavier Noria*
+*   Don't show secrets for `MessageEncryptor#inspect`.
 
-*   Make ActiveSupport::Logger Fiber-safe. Fixes #36752.
+    Before:
 
-    Use `Fiber.current.__id__` in `ActiveSupport::Logger#local_level=` in order
-    to make log level local to Ruby Fibers in addition to Threads.
+    ```ruby
+    ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm").inspect
+    "#<ActiveSupport::MessageEncryptor:0x0000000104888038 ... @secret=\"\\xAF\\bFh]LV}q\\nl\\xB2U\\xB3 ... >"
+    ```
 
-    Example:
+    After:
 
-        logger = ActiveSupport::Logger.new(STDOUT)
-        logger.level = 1
-        p "Main is debug? #{logger.debug?}"
+    ```ruby
+    ActiveSupport::MessageEncryptor.new(secret, cipher: "aes-256-gcm").inspect
+    "#<ActiveSupport::MessageEncryptor:0x0000000104888038>"
+    ```
 
-        Fiber.new {
-          logger.local_level = 0
-          p "Thread is debug? #{logger.debug?}"
-        }.resume
+    *Petrik de Heus*
 
-        p "Main is debug? #{logger.debug?}"
+*   Don't show contents for `EncryptedConfiguration#inspect`.
 
     Before:
-
-        Main is debug? false
-        Thread is debug? true
-        Main is debug? true
+    ```ruby
+    Rails.application.credentials.inspect
+    "#<ActiveSupport::EncryptedConfiguration:0x000000010d2b38e8 ... @config={:secret=>\"something secret\"} ... @key_file_contents=\"915e4ea054e011022398dc242\" ...>"
+    ```
 
     After:
+    ```ruby
+    Rails.application.credentials.inspect
+    "#<ActiveSupport::EncryptedConfiguration:0x000000010d2b38e8>"
+    ```
 
-        Main is debug? false
-        Thread is debug? true
-        Main is debug? false
+    *Petrik de Heus*
 
-    *Alexander Varnin*
+*   `ERB::Util.html_escape_once` always returns an `html_safe` string.
 
-*   Do not delegate missing `marshal_dump` and `_dump` methods via the
-    `delegate_missing_to` extension. This avoids unintentionally adding instance
-    variables when calling `Marshal.dump(object)`, should the delegation target of
-    `object` be a method which would otherwise add them. Fixes #36522.
+    This method previously maintained the `html_safe?` property of a string on the return
+    value. Because this string has been escaped, however, not marking it as `html_safe` causes
+    entities to be double-escaped.
 
-    *Aaron Lipman*
+    As an example, take this view snippet:
 
+      ```html
+      <p><%= html_escape_once("this & that &amp; the other") %></p>
+      ```
 
-## Rails 6.0.0.rc2 (July 22, 2019) ##
+    Before this change, that would be double-escaped and render as:
 
-*   `truncate` would return the original string if it was too short to be truncated
-    and a frozen string if it were long enough to be truncated. Now truncate will
-    consistently return an unfrozen string regardless. This behavior is consistent
-    with `gsub` and `strip`.
+      ```html
+      <p>this &amp;amp; that &amp;amp; the other</p>
+      ```
 
-    Before:
+    After this change, it renders correctly as:
 
-        'foobar'.truncate(5).frozen?
-        # => true
-        'foobar'.truncate(6).frozen?
-        # => false
+      ```html
+      <p>this &amp; that &amp; the other</p>
+      ```
 
-    After:
+    Fixes #48256
 
-        'foobar'.truncate(5).frozen?
-        # => false
-        'foobar'.truncate(6).frozen?
-        # => false
+    *Mike Dalessio*
 
-    *Jordan Thomas*
+*   Deprecate `SafeBuffer#clone_empty`.
 
+    This method has not been used internally since Rails 4.2.0.
 
-## Rails 6.0.0.rc1 (April 24, 2019) ##
+    *Mike Dalessio*
 
-*   Speed improvements to `Hash.except` and `HashWithIndifferentAccess#except`.
+*   `MessageEncryptor`, `MessageVerifier`, and `config.active_support.message_serializer`
+    now accept `:message_pack` and `:message_pack_allow_marshal` as serializers.
+    These serializers require the [`msgpack` gem](https://rubygems.org/gems/msgpack)
+    (>= 1.7.0).
 
-    These methods now unset the `default`/`default_proc` on the returned Hash, compatible with Ruby 3.0’s native implementation.
+    The Message Pack format can provide improved performance and smaller payload
+    sizes. It also supports round-tripping some Ruby types that are not supported
+    by JSON. For example:
 
-    *Timo Schilling*
+      ```ruby
+      verifier = ActiveSupport::MessageVerifier.new("secret")
+      data = [{ a: 1 }, { b: 2 }.with_indifferent_access, 1.to_d, Time.at(0, 123)]
+      message = verifier.generate(data)
 
-*   Introduce `ActiveSupport::ActionableError`.
+      # BEFORE with config.active_support.message_serializer = :json
+      verifier.verified(message)
+      # => [{"a"=>1}, {"b"=>2}, "1.0", "1969-12-31T18:00:00.000-06:00"]
+      verifier.verified(message).map(&:class)
+      # => [Hash, Hash, String, String]
 
-    Actionable errors let's you dispatch actions from Rails' error pages. This
-    can help you save time if you have a clear action for the resolution of
-    common development errors.
+      # AFTER with config.active_support.message_serializer = :message_pack
+      verifier.verified(message)
+      # => [{:a=>1}, {"b"=>2}, 0.1e1, 1969-12-31 18:00:00.000123 -0600]
+      verifier.verified(message).map(&:class)
+      # => [Hash, ActiveSupport::HashWithIndifferentAccess, BigDecimal, Time]
+      ```
 
-    The de-facto example are pending migrations. Every time pending migrations
-    are found, a middleware raises an error. With actionable errors, you can
-    run the migrations right from the error page. Other examples include Rails
-    plugins that need to run a rake task to setup themselves. They can now
-    raise actionable errors to run the setup straight from the error pages.
+    The `:message_pack` serializer can fall back to deserializing with
+    `ActiveSupport::JSON` when necessary, and the `:message_pack_allow_marshal`
+    serializer can fall back to deserializing with `Marshal` as well as
+    `ActiveSupport::JSON`. Additionally, the `:marshal`, `:json`, and
+    `:json_allow_marshal` serializers can now fall back to deserializing with
+    `ActiveSupport::MessagePack` when necessary. These behaviors ensure old
+    messages can still be read so that migration is easier.
 
-    Here is how to define an actionable error:
+    *Jonathan Hefner*
+
+*   A new `7.1` cache format is available which includes an optimization for
+    bare string values such as view fragments.
+
+    The `7.1` cache format is used by default for new apps, and existing apps
+    can enable the format by setting `config.load_defaults 7.1` or by setting
+    `config.active_support.cache_format_version = 7.1` in `config/application.rb`
+    or a `config/environments/*.rb` file.
+
+    Cache entries written using the `6.1` or `7.0` cache formats can be read
+    when using the `7.1` format. To perform a rolling deploy of a Rails 7.1
+    upgrade, wherein servers that have not yet been upgraded must be able to
+    read caches from upgraded servers, leave the cache format unchanged on the
+    first deploy, then enable the `7.1` cache format on a subsequent deploy.
+
+    *Jonathan Hefner*
+
+*   Active Support cache stores can now use a preconfigured serializer based on
+    `ActiveSupport::MessagePack` via the `:serializer` option:
+
+      ```ruby
+      config.cache_store = :redis_cache_store, { serializer: :message_pack }
+      ```
+
+    The `:message_pack` serializer can reduce cache entry sizes and improve
+    performance, but requires the [`msgpack` gem](https://rubygems.org/gems/msgpack)
+    (>= 1.7.0).
+
+    The `:message_pack` serializer can read cache entries written by the default
+    serializer, and the default serializer can now read entries written by the
+    `:message_pack` serializer. These behaviors make it easy to migrate between
+    serializer without invalidating the entire cache.
+
+    *Jonathan Hefner*
+
+*   `Object#deep_dup` no longer duplicate named classes and modules.
+
+    Before:
 
     ```ruby
-    class PendingMigrationError < MigrationError #:nodoc:
-      include ActiveSupport::ActionableError
+    hash = { class: Object, module: Kernel }
+    hash.deep_dup # => {:class=>#<Class:0x00000001063ffc80>, :module=>#<Module:0x00000001063ffa00>}
+    ```
 
-      action "Run pending migrations" do
-        ActiveRecord::Tasks::DatabaseTasks.migrate
-      end
+    After:
+
+    ```ruby
+    hash = { class: Object, module: Kernel }
+    hash.deep_dup # => {:class=>Object, :module=>Kernel}
+    ```
+
+    *Jean Boussier*
+
+*   Consistently raise an `ArgumentError` if the `ActiveSupport::Cache` key is blank.
+
+    *Joshua Young*
+
+*   Deprecate usage of the singleton `ActiveSupport::Deprecation`.
+
+    All usage of `ActiveSupport::Deprecation` as a singleton is deprecated, the most common one being
+    `ActiveSupport::Deprecation.warn`. Gem authors should now create their own deprecator (`ActiveSupport::Deprecation`
+    object), and use it to emit deprecation warnings.
+
+    Calling any of the following without specifying a deprecator argument is also deprecated:
+      * Module.deprecate
+      * deprecate_constant
+      * DeprecatedObjectProxy
+      * DeprecatedInstanceVariableProxy
+      * DeprecatedConstantProxy
+      * deprecation-related test assertions
+
+    Use of `ActiveSupport::Deprecation.silence` and configuration methods like `behavior=`, `disallowed_behavior=`,
+    `disallowed_warnings=` should now be aimed at the [application's deprecators](https://api.rubyonrails.org/classes/Rails/Application.html#method-i-deprecators).
+
+    ```ruby
+    Rails.application.deprecators.silence do
+      # code that emits deprecation warnings
     end
     ```
 
-    To make an error actionable, include the `ActiveSupport::ActionableError`
-    module and invoke the `action` class macro to define the action. An action
-    needs a name and a procedure to execute. The name is shown as the name of a
-    button on the error pages. Once clicked, it will invoke the given
-    procedure.
+    If your gem has a Railtie or Engine, it's encouraged to add your deprecator to the application's deprecators, that
+    way the deprecation related configuration options will apply to it as well, e.g.
+    `config.active_support.report_deprecations` set to `false` in the production environment will also disable your
+    deprecator.
 
-    *Vipul A M*, *Yao Jie*, *Genadi Samokovarov*
+    ```ruby
+    initializer "my_gem.deprecator" do |app|
+      app.deprecators[:my_gem] = MyGem.deprecator
+    end
+    ```
 
-*   Preserve `html_safe?` status on `ActiveSupport::SafeBuffer#*`.
+    *Étienne Barrié*
 
-    Before:
+*   Add `Object#with` to set and restore public attributes around a block
 
-        ("<br />".html_safe * 2).html_safe? #=> nil
+    ```ruby
+    client.timeout # => 5
+    client.with(timeout: 1) do
+      client.timeout # => 1
+    end
+    client.timeout # => 5
+    ```
 
-    After:
+    *Jean Boussier*
 
-        ("<br />".html_safe * 2).html_safe? #=> true
+*   Remove deprecated support to generate incorrect RFC 4122 UUIDs when providing a namespace ID that is not one of the
+    constants defined on `Digest::UUID`.
 
-    *Ryo Nakamura*
+    *Rafael Mendonça França*
+
+*   Deprecate `config.active_support.use_rfc4122_namespaced_uuids`.
+
+    *Rafael Mendonça França*
+
+*   Remove implicit conversion of objects into `String` by `ActiveSupport::SafeBuffer`.
 
-*   Calling test methods with `with_info_handler` method to allow minitest-hooks
-    plugin to work.
+    *Rafael Mendonça França*
 
-    *Mauri Mustonen*
+*   Remove deprecated `active_support/core_ext/range/include_time_with_zone` file.
 
-*   The Zeitwerk compatibility interface for `ActiveSupport::Dependencies` no
-    longer implements `autoloaded_constants` or `autoloaded?` (undocumented,
-    anyway). Experience shows introspection does not have many use cases, and
-    troubleshooting is done by logging. With this design trade-off we are able
-    to use even less memory in all environments.
+    *Rafael Mendonça França*
 
-    *Xavier Noria*
+*   Deprecate `config.active_support.remove_deprecated_time_with_zone_name`.
 
-*   Depends on Zeitwerk 2, which stores less metadata if reloading is disabled
-    and hence uses less memory when `config.cache_classes` is `true`, a standard
-    setup in production.
+    *Rafael Mendonça França*
 
-    *Xavier Noria*
+*   Remove deprecated override of `ActiveSupport::TimeWithZone.name`.
 
-*   In `:zeitwerk` mode, eager load directories in engines and applications only
-    if present in their respective `config.eager_load_paths`.
+    *Rafael Mendonça França*
 
-    A common use case for this is adding `lib` to `config.autoload_paths`, but
-    not to `config.eager_load_paths`. In that configuration, for example, files
-    in the `lib` directory should not be eager loaded.
+*   Deprecate `config.active_support.disable_to_s_conversion`.
 
-    *Xavier Noria*
+    *Rafael Mendonça França*
 
-*   Fix bug in Range comparisons when comparing to an excluded-end Range
+*   Remove deprecated option to passing a format to `#to_s` in `Array`, `Range`, `Date`, `DateTime`, `Time`,
+    `BigDecimal`, `Float` and, `Integer`.
 
-    Before:
+    *Rafael Mendonça França*
 
-        (1..10).cover?(1...11) # => false
+*   Remove deprecated `ActiveSupport::PerThreadRegistry`.
 
-    After:
+    *Rafael Mendonça França*
 
-        (1..10).cover?(1...11) # => true
+*   Remove deprecated override of `Enumerable#sum`.
 
-    With the same change for `Range#include?` and `Range#===`.
+    *Rafael Mendonça França*
 
-    *Owen Stephens*
+*   Deprecated initializing a `ActiveSupport::Cache::MemCacheStore` with an instance of `Dalli::Client`.
 
-*   Use weak references in descendants tracker to allow anonymous subclasses to
-    be garbage collected.
+    Deprecate the undocumented option of providing an already-initialized instance of `Dalli::Client` to `ActiveSupport::Cache::MemCacheStore`. Such clients could be configured with unrecognized options, which could lead to unexpected behavior. Instead, provide addresses as documented.
 
-    *Edgars Beigarts*
+    *aledustet*
 
-*   Update `ActiveSupport::Notifications::Instrumenter#instrument` to make
-    passing a block optional. This will let users use
-    `ActiveSupport::Notifications` messaging features outside of
-    instrumentation.
+*   Stub `Time.new()` in `TimeHelpers#travel_to`
 
-    *Ali Ibrahim*
+      ```ruby
+      travel_to Time.new(2004, 11, 24) do
+        # Inside the `travel_to` block `Time.new` is stubbed
+        assert_equal 2004, Time.new.year
+      end
+      ```
 
-*   Fix `Time#advance` to work with dates before 1001-03-07
+    *fatkodima*
 
-    Before:
+*   Raise `ActiveSupport::MessageEncryptor::InvalidMessage` from
+    `ActiveSupport::MessageEncryptor#decrypt_and_verify` regardless of cipher.
+    Previously, when a `MessageEncryptor` was using a non-AEAD cipher such as
+    AES-256-CBC, a corrupt or tampered message would raise
+    `ActiveSupport::MessageVerifier::InvalidSignature`.  Now, all ciphers raise
+    the same error:
 
-        Time.utc(1001, 3, 6).advance(years: -1) # => 1000-03-05 00:00:00 UTC
+      ```ruby
+      encryptor = ActiveSupport::MessageEncryptor.new("x" * 32, cipher: "aes-256-gcm")
+      message = encryptor.encrypt_and_sign("message")
+      encryptor.decrypt_and_verify(message.next)
+      # => raises ActiveSupport::MessageEncryptor::InvalidMessage
 
-    After
+      encryptor = ActiveSupport::MessageEncryptor.new("x" * 32, cipher: "aes-256-cbc")
+      message = encryptor.encrypt_and_sign("message")
+      encryptor.decrypt_and_verify(message.next)
+      # BEFORE:
+      # => raises ActiveSupport::MessageVerifier::InvalidSignature
+      # AFTER:
+      # => raises ActiveSupport::MessageEncryptor::InvalidMessage
+      ```
 
-        Time.utc(1001, 3, 6).advance(years: -1) # => 1000-03-06 00:00:00 UTC
+    *Jonathan Hefner*
 
-    Note that this doesn't affect `DateTime#advance` as that doesn't use a proleptic calendar.
+*   Support `nil` original values when using `ActiveSupport::MessageVerifier#verify`.
+    Previously, `MessageVerifier#verify` did not work with `nil` original
+    values, though both `MessageVerifier#verified` and
+    `MessageEncryptor#decrypt_and_verify` do:
 
-    *Andrew White*
+      ```ruby
+      encryptor = ActiveSupport::MessageEncryptor.new(secret)
+      message = encryptor.encrypt_and_sign(nil)
 
-*   In Zeitwerk mode, engines are now managed by the `main` autoloader. Engines may reference application constants, if the application is reloaded and we do not reload engines, they won't use the reloaded application code.
+      encryptor.decrypt_and_verify(message)
+      # => nil
 
-    *Xavier Noria*
+      verifier = ActiveSupport::MessageVerifier.new(secret)
+      message = verifier.generate(nil)
 
-*   Add support for supplying `locale` to `transliterate` and `parameterize`.
+      verifier.verified(message)
+      # => nil
 
-        I18n.backend.store_translations(:de, i18n: { transliterate: { rule: { "ü" => "ue" } } })
+      verifier.verify(message)
+      # BEFORE:
+      # => raises ActiveSupport::MessageVerifier::InvalidSignature
+      # AFTER:
+      # => nil
+      ```
 
-        ActiveSupport::Inflector.transliterate("ü", locale: :de) # => "ue"
-        "Fünf autos".parameterize(locale: :de) # => "fuenf-autos"
-        ActiveSupport::Inflector.parameterize("Fünf autos", locale: :de) # => "fuenf-autos"
+    *Jonathan Hefner*
 
-    *Kaan Ozkan*, *Sharang Dashputre*
+*   Maintain `html_safe?` on html_safe strings when sliced with `slice`, `slice!`, or `chr` method.
 
-*   Allow `Array#excluding` and `Enumerable#excluding` to deal with a passed array gracefully.
+    Previously, `html_safe?` was only maintained when the html_safe strings were sliced
+    with `[]` method. Now, `slice`, `slice!`, and `chr` methods will maintain `html_safe?` like `[]` method.
 
-        [ 1, 2, 3, 4, 5 ].excluding([4, 5]) # => [ 1, 2, 3 ]
+    ```ruby
+    string = "<div>test</div>".html_safe
+    string.slice(0, 1).html_safe? # => true
+    string.slice!(0, 1).html_safe? # => true
+    # maintain html_safe? after the slice!
+    string.html_safe? # => true
+    string.chr.html_safe? # => true
+    ```
 
-    *DHH*
+    *Michael Go*
 
-*   Renamed `Array#without` and `Enumerable#without` to `Array#excluding` and `Enumerable#excluding`, to create parity with
-    `Array#including` and `Enumerable#including`. Retained the old names as aliases.
+*   Add `Object#in?` support for open ranges.
 
-    *DHH*
+    ```ruby
+    assert Date.today.in?(..Date.tomorrow)
+    assert_not Date.today.in?(Date.tomorrow..)
+    ```
 
-*   Added `Array#including` and `Enumerable#including` to conveniently enlarge a collection with more members using a method rather than an operator:
+    *Ignacio Galindo*
 
-        [ 1, 2, 3 ].including(4, 5) # => [ 1, 2, 3, 4, 5 ]
-        post.authors.including(Current.person) # => All the authors plus the current person!
+*   `config.i18n.raise_on_missing_translations = true` now raises on any missing translation.
 
-    *DHH*
+    Previously it would only raise when called in a view or controller. Now it will raise
+    anytime `I18n.t` is provided an unrecognised key.
 
+    If you do not want this behaviour, you can customise the i18n exception handler. See the
+    upgrading guide or i18n guide for more information.
 
-## Rails 6.0.0.beta3 (March 11, 2019) ##
+    *Alex Ghiculescu*
 
-*   No changes.
+*   `ActiveSupport::CurrentAttributes` now raises if a restricted attribute name is used.
 
+    Attributes such as `set` and `reset` cannot be used as they clash with the
+    `CurrentAttributes` public API.
 
-## Rails 6.0.0.beta2 (February 25, 2019) ##
+    *Alex Ghiculescu*
 
-*   New autoloading based on [Zeitwerk](https://github.com/fxn/zeitwerk).
+*   `HashWithIndifferentAccess#transform_keys` now takes a Hash argument, just
+    as Ruby's `Hash#transform_keys` does.
 
-    *Xavier Noria*
+    *Akira Matsuda*
 
-*   Revise `ActiveSupport::Notifications.unsubscribe` to correctly handle Regex or other multiple-pattern subscribers.
+*   `delegate` now defines method with proper arity when delegating to a Class.
+    With this change, it defines faster method (3.5x faster with no argument).
+    However, in order to gain this benefit, the delegation target method has to
+    be defined before declaring the delegation.
 
-    *Zach Kemp*
+    ```ruby
+    # This defines 3.5 times faster method than before
+    class C
+      def self.x() end
+      delegate :x, to: :class
+    end
 
-*   Add `before_reset` callback to `CurrentAttributes` and define `after_reset` as an alias of `resets` for symmetry.
+    class C
+      # This works but silently falls back to old behavior because
+      # `delegate` cannot find the definition of `x`
+      delegate :x, to: :class
+      def self.x() end
+    end
+    ```
 
-    *Rosa Gutierrez*
+    *Akira Matsuda*
 
-*   Remove the `` Kernel#` `` override that suppresses ENOENT and accidentally returns nil on Unix systems.
+*   `assert_difference` message now includes what changed.
 
-    *Akinori Musha*
+    This makes it easier to debug non-obvious failures.
 
-*   Add `ActiveSupport::HashWithIndifferentAccess#assoc`.
+    Before:
 
-    `assoc` can now be called with either a string or a symbol.
+    ```
+    "User.count" didn't change by 32.
+    Expected: 1611
+      Actual: 1579
+    ```
 
-    *Stefan Schüßler*
+    After:
 
-*   Add `Hash#deep_transform_values`, and `Hash#deep_transform_values!`.
+    ```
+    "User.count" didn't change by 32, but by 0.
+    Expected: 1611
+      Actual: 1579
+    ```
 
-    *Guillermo Iguaran*
+    *Alex Ghiculescu*
 
+*   Add ability to match exception messages to `assert_raises` assertion
 
-## Rails 6.0.0.beta1 (January 18, 2019) ##
+    Instead of this
+    ```ruby
+    error = assert_raises(ArgumentError) do
+      perform_service(param: 'exception')
+    end
+    assert_match(/incorrect param/i, error.message)
+    ```
 
-*   Remove deprecated `Module#reachable?` method.
+    you can now write this
+    ```ruby
+    assert_raises(ArgumentError, match: /incorrect param/i) do
+      perform_service(param: 'exception')
+    end
+    ```
 
-    *Rafael Mendonça França*
+    *fatkodima*
 
-*   Remove deprecated `#acronym_regex` method from `Inflections`.
+*   Add `Rails.env.local?` shorthand for `Rails.env.development? || Rails.env.test?`.
 
-    *Rafael Mendonça França*
+    *DHH*
 
-*   Fix `String#safe_constantize` throwing a `LoadError` for incorrectly cased constant references.
+*   `ActiveSupport::Testing::TimeHelpers` now accepts named `with_usec` argument
+    to `freeze_time`, `travel`, and `travel_to` methods. Passing true prevents
+    truncating the destination time with `change(usec: 0)`.
 
-    *Keenan Brock*
+    *KevSlashNull*, and *serprex*
 
-*   Preserve key order passed to `ActiveSupport::CacheStore#fetch_multi`.
+*   `ActiveSupport::CurrentAttributes.resets` now accepts a method name
 
-    `fetch_multi(*names)` now returns its results in the same order as the `*names` requested, rather than returning cache hits followed by cache misses.
+    The block API is still the recommended approach, but now both APIs are supported:
 
-    *Gannon McGibbon*
+    ```ruby
+    class Current < ActiveSupport::CurrentAttributes
+      resets { Time.zone = nil }
+      resets :clear_time_zone
+    end
+    ```
 
-*   If the same block is `included` multiple times for a Concern, an exception is no longer raised.
+    *Alex Ghiculescu*
 
-    *Mark J. Titorenko*, *Vlad Bokov*
+*   Ensure `ActiveSupport::Testing::Isolation::Forking` closes pipes
 
-*   Fix bug where `#to_options` for `ActiveSupport::HashWithIndifferentAccess`
-    would not act as alias for `#symbolize_keys`.
+    Previously, `Forking.run_in_isolation` opened two ends of a pipe. The fork
+    process closed the read end, wrote to it, and then terminated (which
+    presumably closed the file descriptors on its end). The parent process
+    closed the write end, read from it, and returned, never closing the read
+    end.
 
-    *Nick Weiland*
+    This resulted in an accumulation of open file descriptors, which could
+    cause errors if the limit is reached.
 
-*   Improve the logic that detects non-autoloaded constants.
+    *Sam Bostock*
 
-    *Jan Habermann*, *Xavier Noria*
+*   Fix `Time#change` and `Time#advance` for times around the end of Daylight
+    Saving Time.
 
-*   Deprecate `ActiveSupport::Multibyte::Unicode#pack_graphemes(array)` and `ActiveSupport::Multibyte::Unicode#unpack_graphemes(string)`
-    in favor of `array.flatten.pack("U*")` and `string.scan(/\X/).map(&:codepoints)`, respectively.
+    Previously, when `Time#change` or `Time#advance` constructed a time inside
+    the final stretch of Daylight Saving Time (DST), the non-DST offset would
+    always be chosen for local times:
 
-    *Francesco Rodríguez*
+    ```ruby
+    # DST ended just before 2021-11-07 2:00:00 AM in US/Eastern.
+    ENV["TZ"] = "US/Eastern"
+
+    time = Time.local(2021, 11, 07, 00, 59, 59) + 1
+    # => 2021-11-07 01:00:00 -0400
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0500
+    time.advance(seconds: 0)
+    # => 2021-11-07 01:00:00 -0500
+
+    time = Time.local(2021, 11, 06, 01, 00, 00)
+    # => 2021-11-06 01:00:00 -0400
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0500
+    time.advance(days: 1)
+    # => 2021-11-07 01:00:00 -0500
+    ```
 
-*   Deprecate `ActiveSupport::Multibyte::Chars.consumes?` in favor of `String#is_utf8?`.
+    And the DST offset would always be chosen for times with a `TimeZone`
+    object:
+
+    ```ruby
+    Time.zone = "US/Eastern"
+
+    time = Time.new(2021, 11, 07, 02, 00, 00, Time.zone) - 3600
+    # => 2021-11-07 01:00:00 -0500
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0400
+    time.advance(seconds: 0)
+    # => 2021-11-07 01:00:00 -0400
+
+    time = Time.new(2021, 11, 8, 01, 00, 00, Time.zone)
+    # => 2021-11-08 01:00:00 -0500
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0400
+    time.advance(days: -1)
+    # => 2021-11-07 01:00:00 -0400
+    ```
 
-    *Francesco Rodríguez*
+    Now, `Time#change` and `Time#advance` will choose the offset that matches
+    the original time's offset when possible:
 
-*   Fix duration being rounded to a full second.
+    ```ruby
+    ENV["TZ"] = "US/Eastern"
+
+    time = Time.local(2021, 11, 07, 00, 59, 59) + 1
+    # => 2021-11-07 01:00:00 -0400
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0400
+    time.advance(seconds: 0)
+    # => 2021-11-07 01:00:00 -0400
+
+    time = Time.local(2021, 11, 06, 01, 00, 00)
+    # => 2021-11-06 01:00:00 -0400
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0400
+    time.advance(days: 1)
+    # => 2021-11-07 01:00:00 -0400
+
+    Time.zone = "US/Eastern"
+
+    time = Time.new(2021, 11, 07, 02, 00, 00, Time.zone) - 3600
+    # => 2021-11-07 01:00:00 -0500
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0500
+    time.advance(seconds: 0)
+    # => 2021-11-07 01:00:00 -0500
+
+    time = Time.new(2021, 11, 8, 01, 00, 00, Time.zone)
+    # => 2021-11-08 01:00:00 -0500
+    time.change(day: 07)
+    # => 2021-11-07 01:00:00 -0500
+    time.advance(days: -1)
+    # => 2021-11-07 01:00:00 -0500
     ```
-      time = DateTime.parse("2018-1-1")
-      time += 0.51.seconds
+
+    *Kevin Hall*, *Takayoshi Nishida*, and *Jonathan Hefner*
+
+*   Fix MemoryStore to preserve entries TTL when incrementing or decrementing
+
+    This is to be more consistent with how MemCachedStore and RedisCacheStore behaves.
+
+    *Jean Boussier*
+
+*   `Rails.error.handle` and `Rails.error.record` filter now by multiple error classes.
+
+    ```ruby
+    Rails.error.handle(IOError, ArgumentError) do
+      1 + '1' # raises TypeError
+    end
+    1 + 1 # TypeErrors are not IOErrors or ArgumentError, so this will *not* be handled
     ```
-    Will now correctly add 0.51 second and not 1 full second.
 
-    *Edouard Chin*
+    *Martin Spickermann*
 
-*   Deprecate `ActiveSupport::Multibyte::Unicode#normalize` and `ActiveSupport::Multibyte::Chars#normalize`
-    in favor of `String#unicode_normalize`
+*   `Class#subclasses` and `Class#descendants` now automatically filter reloaded classes.
 
-    *Francesco Rodríguez*
+    Previously they could return old implementations of reloadable classes that have been
+    dereferenced but not yet garbage collected.
 
-*   Deprecate `ActiveSupport::Multibyte::Unicode#downcase/upcase/swapcase` in favor of
-    `String#downcase/upcase/swapcase`.
+    They now automatically filter such classes like `DescendantTracker#subclasses` and
+    `DescendantTracker#descendants`.
 
-    *Francesco Rodríguez*
+    *Jean Boussier*
 
-*   Add `ActiveSupport::ParameterFilter`.
+*   `Rails.error.report` now marks errors as reported to avoid reporting them twice.
 
-    *Yoshiyuki Kinjo*
+    In some cases, users might want to report errors explicitly with some extra context
+    before letting it bubble up.
 
-*   Rename `Module#parent`, `Module#parents`, and `Module#parent_name` to
-    `module_parent`, `module_parents`, and `module_parent_name`.
+    This also allows to safely catch and report errors outside of the execution context.
 
-    *Gannon McGibbon*
+    *Jean Boussier*
 
-*   Deprecate the use of `LoggerSilence` in favor of `ActiveSupport::LoggerSilence`
+*   Add `assert_error_reported` and `assert_no_error_reported`
 
-    *Edouard Chin*
+    Allows to easily asserts an error happened but was handled
+
+    ```ruby
+    report = assert_error_reported(IOError) do
+      # ...
+    end
+    assert_equal "Oops", report.error.message
+    assert_equal "admin", report.context[:section]
+    assert_equal :warning, report.severity
+    assert_predicate report, :handled?
+    ```
 
-*   Deprecate using negative limits in `String#first` and `String#last`.
+    *Jean Boussier*
 
-    *Gannon McGibbon*, *Eric Turner*
+*   `ActiveSupport::Deprecation` behavior callbacks can now receive the
+    deprecator instance as an argument.  This makes it easier for such callbacks
+    to change their behavior based on the deprecator's state.  For example,
+    based on the deprecator's `debug` flag.
 
-*   Fix bug where `#without` for `ActiveSupport::HashWithIndifferentAccess` would fail
-    with symbol arguments
+    3-arity and splat-args callbacks such as the following will now be passed
+    the deprecator instance as their third argument:
 
-    *Abraham Chan*
+    * `->(message, callstack, deprecator) { ... }`
+    * `->(*args) { ... }`
+    * `->(message, *other_args) { ... }`
 
-*   Treat `#delete_prefix`, `#delete_suffix` and `#unicode_normalize` results as non-`html_safe`.
-    Ensure safety of arguments for `#insert`, `#[]=` and `#replace` calls on `html_safe` Strings.
+    2-arity and 4-arity callbacks such as the following will continue to behave
+    the same as before:
 
-    *Janosch Müller*
+    * `->(message, callstack) { ... }`
+    * `->(message, callstack, deprecation_horizon, gem_name) { ... }`
+    * `->(message, callstack, *deprecation_details) { ... }`
 
-*   Changed `ActiveSupport::TaggedLogging.new` to return a new logger instance instead
-    of mutating the one received as parameter.
+    *Jonathan Hefner*
 
-    *Thierry Joyal*
+*   `ActiveSupport::Deprecation#disallowed_warnings` now affects the instance on
+    which it is configured.
 
-*   Define `unfreeze_time` as an alias of `travel_back` in `ActiveSupport::Testing::TimeHelpers`.
+    This means that individual `ActiveSupport::Deprecation` instances can be
+    configured with their own disallowed warnings, and the global
+    `ActiveSupport::Deprecation.disallowed_warnings` now only affects the global
+    `ActiveSupport::Deprecation.warn`.
 
-    The alias is provided for symmetry with `freeze_time`.
+    **Before**
 
-    *Ryan Davidson*
+    ```ruby
+    ActiveSupport::Deprecation.disallowed_warnings = ["foo"]
+    deprecator = ActiveSupport::Deprecation.new("2.0", "MyCoolGem")
+    deprecator.disallowed_warnings = ["bar"]
+
+    ActiveSupport::Deprecation.warn("foo") # => raise ActiveSupport::DeprecationException
+    ActiveSupport::Deprecation.warn("bar") # => print "DEPRECATION WARNING: bar"
+    deprecator.warn("foo")                 # => raise ActiveSupport::DeprecationException
+    deprecator.warn("bar")                 # => print "DEPRECATION WARNING: bar"
+    ```
 
-*   Add support for tracing constant autoloads. Just throw
+    **After**
 
-        ActiveSupport::Dependencies.logger = Rails.logger
-        ActiveSupport::Dependencies.verbose = true
+    ```ruby
+    ActiveSupport::Deprecation.disallowed_warnings = ["foo"]
+    deprecator = ActiveSupport::Deprecation.new("2.0", "MyCoolGem")
+    deprecator.disallowed_warnings = ["bar"]
+
+    ActiveSupport::Deprecation.warn("foo") # => raise ActiveSupport::DeprecationException
+    ActiveSupport::Deprecation.warn("bar") # => print "DEPRECATION WARNING: bar"
+    deprecator.warn("foo")                 # => print "DEPRECATION WARNING: foo"
+    deprecator.warn("bar")                 # => raise ActiveSupport::DeprecationException
+    ```
 
-    in an initializer.
+    Note that global `ActiveSupport::Deprecation` methods such as `ActiveSupport::Deprecation.warn`
+    and `ActiveSupport::Deprecation.disallowed_warnings` have been deprecated.
 
-    *Xavier Noria*
+    *Jonathan Hefner*
 
-*   Maintain `html_safe?` on html_safe strings when sliced.
+*   Add italic and underline support to `ActiveSupport::LogSubscriber#color`
 
-        string = "<div>test</div>".html_safe
-        string[-1..1].html_safe? # => true
+    Previously, only bold text was supported via a positional argument.
+    This allows for bold, italic, and underline options to be specified
+    for colored logs.
 
-    *Elom Gomez*, *Yumin Wong*
+    ```ruby
+    info color("Hello world!", :red, bold: true, underline: true)
+    ```
 
-*   Add `Array#extract!`.
+    *Gannon McGibbon*
 
-    The method removes and returns the elements for which the block returns a true value.
-    If no block is given, an Enumerator is returned instead.
+*   Add `String#downcase_first` method.
 
-        numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-        odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
-        numbers # => [0, 2, 4, 6, 8]
+    This method is the corollary of `String#upcase_first`.
 
-    *bogdanvlviv*
+    *Mark Schneider*
 
-*   Support not to cache `nil` for `ActiveSupport::Cache#fetch`.
+*   `thread_mattr_accessor` will call `.dup.freeze` on non-frozen default values.
 
-        cache.fetch('bar', skip_nil: true) { nil }
-        cache.exist?('bar') # => false
+    This provides a basic level of protection against different threads trying
+    to mutate a shared default object.
 
-    *Martin Hong*
+    *Jonathan Hefner*
 
-*   Add "event object" support to the notification system.
-    Before this change, end users were forced to create hand made artisanal
-    event objects on their own, like this:
+*   Add `raise_on_invalid_cache_expiration_time` config to `ActiveSupport::Cache::Store`
 
-        ActiveSupport::Notifications.subscribe('wait') do |*args|
-          @event = ActiveSupport::Notifications::Event.new(*args)
-        end
+    Specifies if an `ArgumentError` should be raised if `Rails.cache` `fetch` or
+    `write` are given an invalid `expires_at` or `expires_in` time.
 
-        ActiveSupport::Notifications.instrument('wait') do
-          sleep 1
-        end
+    Options are `true`, and `false`. If `false`, the exception will be reported
+    as `handled` and logged instead. Defaults to `true` if `config.load_defaults >= 7.1`.
 
-        @event.duration # => 1000.138
+     *Trevor Turk*
 
-    After this change, if the block passed to `subscribe` only takes one
-    parameter, the framework will yield an event object to the block.  Now
-    end users are no longer required to make their own:
+*   `ActiveSupport::Cache::Store#fetch` now passes an options accessor to the block.
 
-        ActiveSupport::Notifications.subscribe('wait') do |event|
-          @event = event
-        end
+    It makes possible to override cache options:
 
-        ActiveSupport::Notifications.instrument('wait') do
-          sleep 1
+        Rails.cache.fetch("3rd-party-token") do |name, options|
+          token = fetch_token_from_remote
+          # set cache's TTL to match token's TTL
+          options.expires_in = token.expires_in
+          token
         end
 
-        p @event.allocations # => 7
-        p @event.cpu_time    # => 0.256
-        p @event.idle_time   # => 1003.2399
+    *Andrii Gladkyi*, *Jean Boussier*
 
-    Now you can enjoy event objects without making them yourself.  Neat!
+*   `default` option of `thread_mattr_accessor` now applies through inheritance and
+    also across new threads.
 
-    *Aaron "t.lo" Patterson*
+    Previously, the `default` value provided was set only at the moment of defining
+    the attribute writer, which would cause the attribute to be uninitialized in
+    descendants and in other threads.
 
-*   Add cpu_time, idle_time, and allocations to Event.
+    Fixes #43312.
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*
+    *Thierry Deo*
 
-*   RedisCacheStore: support key expiry in increment/decrement.
+*   Redis cache store is now compatible with redis-rb 5.0.
 
-    Pass `:expires_in` to `#increment` and `#decrement` to set a Redis EXPIRE on the key.
+    *Jean Boussier*
 
-    If the key is already set to expire, RedisCacheStore won't extend its expiry.
+*   Add `skip_nil:` support to `ActiveSupport::Cache::Store#fetch_multi`.
 
-        Rails.cache.increment("some_key", 1, expires_in: 2.minutes)
+    *Daniel Alfaro*
 
-    *Jason Lee*
+*   Add `quarter` method to date/time
 
-*   Allow `Range#===` and `Range#cover?` on Range.
+    *Matt Swanson*
 
-    `Range#cover?` can now accept a range argument like `Range#include?` and
-    `Range#===`. `Range#===` works correctly on Ruby 2.6. `Range#include?` is moved
-    into a new file, with these two methods.
+*   Fix `NoMethodError` on custom `ActiveSupport::Deprecation` behavior.
 
-    *Requiring active_support/core_ext/range/include_range is now deprecated.*
-    *Use `require "active_support/core_ext/range/compare_range"` instead.*
+    `ActiveSupport::Deprecation.behavior=` was supposed to accept any object
+    that responds to `call`, but in fact its internal implementation assumed that
+    this object could respond to `arity`, so it was restricted to only `Proc` objects.
 
-    *utilum*
+    This change removes this `arity` restriction of custom behaviors.
 
-*   Add `index_with` to Enumerable.
+    *Ryo Nakamura*
 
-    Allows creating a hash from an enumerable with the value from a passed block
-    or a default argument.
+*   Support `:url_safe` option for `MessageEncryptor`.
 
-        %i( title body ).index_with { |attr| post.public_send(attr) }
-        # => { title: "hey", body: "what's up?" }
+    The `MessageEncryptor` constructor now accepts a `:url_safe` option, similar
+    to the `MessageVerifier` constructor.  When enabled, this option ensures
+    that messages use a URL-safe encoding.
 
-        %i( title body ).index_with(nil)
-        # => { title: nil, body: nil }
+    *Jonathan Hefner*
 
-    Closely linked with `index_by`, which creates a hash where the keys are extracted from a block.
+*   Add `url_safe` option to `ActiveSupport::MessageVerifier` initializer
 
-    *Kasper Timm Hansen*
+    `ActiveSupport::MessageVerifier.new` now takes optional `url_safe` argument.
+    It can generate URL-safe strings by passing `url_safe: true`.
 
-*   Fix bug where `ActiveSupport::TimeZone.all` would fail when tzinfo data for
-    any timezone defined in `ActiveSupport::TimeZone::MAPPING` is missing.
+    ```ruby
+    verifier = ActiveSupport::MessageVerifier.new(url_safe: true)
+    message = verifier.generate(data) # => URL-safe string
+    ```
 
-    *Dominik Sander*
+    This option is `false` by default to be backwards compatible.
 
-*   Redis cache store: `delete_matched` no longer blocks the Redis server.
-    (Switches from evaled Lua to a batched SCAN + DEL loop.)
+    *Shouichi Kamiya*
 
-    *Gleb Mazovetskiy*
+*   Enable connection pooling by default for `MemCacheStore` and `RedisCacheStore`.
 
-*   Fix bug where `ActiveSupport::Cache` will massively inflate the storage
-    size when compression is enabled (which is true by default). This patch
-    does not attempt to repair existing data: please manually flush the cache
-    to clear out the problematic entries.
+    If you want to disable connection pooling, set `:pool` option to `false` when configuring the cache store:
 
-    *Godfrey Chan*
+    ```ruby
+    config.cache_store = :mem_cache_store, "cache.example.com", pool: false
+    ```
 
-*   Fix bug where `URI.unescape` would fail with mixed Unicode/escaped character input:
+    *fatkodima*
 
-        URI.unescape("\xe3\x83\x90")  # => "バ"
-        URI.unescape("%E3%83%90")  # => "バ"
-        URI.unescape("\xe3\x83\x90%E3%83%90")  # => Encoding::CompatibilityError
+*   Add `force:` support to `ActiveSupport::Cache::Store#fetch_multi`.
 
-    *Ashe Connor*, *Aaron Patterson*
+    *fatkodima*
 
-*   Add `before?` and `after?` methods to `Date`, `DateTime`,
-    `Time`, and `TimeWithZone`.
+*   Deprecated `:pool_size` and `:pool_timeout` options for configuring connection pooling in cache stores.
 
-    *Nick Holden*
+    Use `pool: true` to enable pooling with default settings:
 
-*   `ActiveSupport::Inflector#ordinal` and `ActiveSupport::Inflector#ordinalize` now support
-    translations through I18n.
+    ```ruby
+    config.cache_store = :redis_cache_store, pool: true
+    ```
 
-        # locale/fr.rb
+    Or pass individual options via `:pool` option:
 
-        {
-          fr: {
-            number: {
-              nth: {
-                ordinals: lambda do |_key, number:, **_options|
-                  if number.to_i.abs == 1
-                    'er'
-                  else
-                    'e'
-                  end
-                end,
+    ```ruby
+    config.cache_store = :redis_cache_store, pool: { size: 10, timeout: 2 }
+    ```
 
-                ordinalized: lambda do |_key, number:, **_options|
-                  "#{number}#{ActiveSupport::Inflector.ordinal(number)}"
-                end
-              }
-            }
-          }
-        }
+    *fatkodima*
 
+*   Allow #increment and #decrement methods of `ActiveSupport::Cache::Store`
+    subclasses to set new values.
 
-    *Christian Blais*
+    Previously incrementing or decrementing an unset key would fail and return
+    nil. A default will now be assumed and the key will be created.
 
-*   Add `:private` option to ActiveSupport's `Module#delegate`
-    in order to delegate methods as private:
+    *Andrej Blagojević*, *Eugene Kenny*
 
-        class User < ActiveRecord::Base
-          has_one :profile
-          delegate :date_of_birth, to: :profile, private: true
+*   Add `skip_nil:` support to `RedisCacheStore`
 
-          def age
-            Date.today.year - date_of_birth.year
-          end
-        end
+    *Joey Paris*
+
+*   `ActiveSupport::Cache::MemoryStore#write(name, val, unless_exist:true)` now
+    correctly writes expired keys.
+
+    *Alan Savage*
+
+*   `ActiveSupport::ErrorReporter` now accepts and forward a `source:` parameter.
+
+    This allow libraries to signal the origin of the errors, and reporters
+    to easily ignore some sources.
+
+    *Jean Boussier*
 
-        # User.new.age  # => 29
-        # User.new.date_of_birth
-        # => NoMethodError: private method `date_of_birth' called for #<User:0x00000008221340>
+*   Fix and add protections for XSS in `ActionView::Helpers` and `ERB::Util`.
 
-    *Tomas Valent*
+    Add the method `ERB::Util.xml_name_escape` to escape dangerous characters
+    in names of tags and names of attributes, following the specification of XML.
 
-*   `String#truncate_bytes` to truncate a string to a maximum bytesize without
-    breaking multibyte characters or grapheme clusters like 👩‍👩‍👦‍👦.
+    *Álvaro Martín Fraguas*
 
-    *Jeremy Daer*
+*   Respect `ActiveSupport::Logger.new`'s `:formatter` keyword argument
 
-*   `String#strip_heredoc` preserves frozenness.
+    The stdlib `Logger::new` allows passing a `:formatter` keyword argument to
+    set the logger's formatter. Previously `ActiveSupport::Logger.new` ignored
+    that argument by always setting the formatter to an instance of
+    `ActiveSupport::Logger::SimpleFormatter`.
 
-        "foo".freeze.strip_heredoc.frozen?  # => true
+    *Steven Harman*
 
-    Fixes that frozen string literals would inadvertently become unfrozen:
+*   Deprecate preserving the pre-Ruby 2.4 behavior of `to_time`
 
-        # frozen_string_literal: true
+    With Ruby 2.4+ the default for +to_time+ changed from converting to the
+    local system time to preserving the offset of the receiver. At the time Rails
+    supported older versions of Ruby so a compatibility layer was added to assist
+    in the migration process. From Rails 5.0 new applications have defaulted to
+    the Ruby 2.4+ behavior and since Rails 7.0 now only supports Ruby 2.7+
+    this compatibility layer can be safely removed.
+
+    To minimize any noise generated the deprecation warning only appears when the
+    setting is configured to `false` as that is the only scenario where the
+    removal of the compatibility layer has any effect.
+
+    *Andrew White*
 
-        foo = <<-MSG.strip_heredoc
-          la la la
-        MSG
+*   `Pathname.blank?` only returns true for `Pathname.new("")`
 
-        foo.frozen?  # => false !??
+    Previously it would end up calling `Pathname#empty?` which returned true
+    if the path existed and was an empty directory or file.
+
+    That behavior was unlikely to be expected.
+
+    *Jean Boussier*
+
+*   Deprecate `Notification::Event`'s `#children` and `#parent_of?`
+
+    *John Hawthorn*
+
+*   Change the default serializer of `ActiveSupport::MessageVerifier` from
+    `Marshal` to `ActiveSupport::JSON` when using `config.load_defaults 7.1`.
+
+    Messages serialized with `Marshal` can still be read, but new messages will
+    be serialized with `ActiveSupport::JSON`. For more information, see
+    https://guides.rubyonrails.org/v7.1/configuring.html#config-active-support-message-serializer.
+
+    *Saba Kiaei*, *David Buckley*, and *Jonathan Hefner*
+
+*   Change the default serializer of `ActiveSupport::MessageEncryptor` from
+    `Marshal` to `ActiveSupport::JSON` when using `config.load_defaults 7.1`.
+
+    Messages serialized with `Marshal` can still be read, but new messages will
+    be serialized with `ActiveSupport::JSON`. For more information, see
+    https://guides.rubyonrails.org/v7.1/configuring.html#config-active-support-message-serializer.
+
+    *Zack Deveau*, *Martin Gingras*, and *Jonathan Hefner*
+
+*   Add `ActiveSupport::TestCase#stub_const` to stub a constant for the duration of a yield.
+
+    *DHH*
 
-    *Jeremy Daer*
+*   Fix `ActiveSupport::EncryptedConfiguration` to be compatible with Psych 4
 
-*   Rails 6 requires Ruby 2.5.0 or newer.
+    *Stephen Sugden*
 
-    *Jeremy Daer*, *Kasper Timm Hansen*
+*   Improve `File.atomic_write` error handling
 
-*   Adds parallel testing to Rails.
+    *Daniel Pepper*
 
-    Parallelize your test suite with forked processes or threads.
+*   Fix `Class#descendants` and `DescendantsTracker#descendants` compatibility with Ruby 3.1.
 
-    *Eileen M. Uchitelle*, *Aaron Patterson*
+    [The native `Class#descendants` was reverted prior to Ruby 3.1 release](https://bugs.ruby-lang.org/issues/14394#note-33),
+    but `Class#subclasses` was kept, breaking the feature detection.
 
+    *Jean Boussier*
 
-Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/activesupport/CHANGELOG.md) for previous changes.
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activesupport/CHANGELOG.md) for previous changes.