activesupport 5.2.1.1 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 012f11c548ca33d5985eb783e46a9d962b5cf3c22f007f74a39e8120da80b2d4
-  data.tar.gz: 1157743e77c0a3dceff1f24dfe39adf5c06654b522b13c999ff04d37888f85b5
+  metadata.gz: 89999be252d7cdb9b27994ea4a149baabf876606a5899e8c7dfe5309278bf57a
+  data.tar.gz: c79f2634e9a995e6c0ad95ca68f3a04905153502560e2a25de871cb4c4782e4f
 SHA512:
-  metadata.gz: 3cd090a071824b4ec714de532134d06bb89e9c70d99d3e7acb0c6bf5b32019a5b3f5cf1c51b12855edb4617f484c4610b4398c212ef6d1bb32d16931b1537b9f
-  data.tar.gz: 014f671c9490e3c856519bc4d87a220a9998a658c09fe1d842cd616ca320ef2ca522fe0a2edbcbee8dc227b593ba12dea6a29b64e1a4ee9aabf7a56a337446e9
+  metadata.gz: 9aed32dcff5ff2bbeaeb386f289292c3a18d8bf3dde6d5a72eff792f41216041853fbbbefe01aa35aef16330f13a54bca4744235bdee5a90783e34bc8b48c1f6
+  data.tar.gz: 6ceefce5d0753a5a91df29b365579b8e84be9b252b5abe5c7e3f5183dad8a9389a0de2fc50f6668147d6b9def2efe9e6dc1dc48e221dda19767586a37a9d3d3f

data/CHANGELOG.md

@@ -1,552 +1,617 @@
-## Rails 5.2.1.1 (November 27, 2018) ##
+## Rails 6.0.1 (November 5, 2019) ##
 
-*   No changes.
+*   `ActiveSupport::SafeBuffer` supports `Enumerator` methods.
 
+    *Shugo Maeda*
 
-## Rails 5.2.1 (August 07, 2018) ##
+*   The Redis cache store fails gracefully when the server returns a "max number
+    of clients reached" error.
 
-*   Redis cache store: `delete_matched` no longer blocks the Redis server.
-    (Switches from evaled Lua to a batched SCAN + DEL loop.)
+    *Brandon Medenwald*
 
-    *Gleb Mazovetskiy*
+*   Fixed that mutating a value returned by a memory cache store would
+    unexpectedly change the cached value.
 
-*   Fix bug where `ActiveSupport::Timezone.all` would fail when tzinfo data for
-    any timezone defined in `ActiveSupport::TimeZone::MAPPING` is missing.
+    *Jonathan Hyman*
 
-    *Dominik Sander*
+*   The default inflectors in `zeitwerk` mode support overrides:
 
-*   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.
+    ```ruby
+    # config/initializers/zeitwerk.rb
+    Rails.autoloaders.each do |autoloader|
+      autoloader.inflector.inflect(
+        "html_parser" => "HTMLParser",
+        "ssl_error"   => "SSLError"
+      )
+    end
+    ```
 
-    *Godfrey Chan*
+    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.
 
-*   Fix `ActiveSupport::Cache#read_multi` bug with local cache enabled that was
-    returning instances of `ActiveSupport::Cache::Entry` instead of the raw values.
+    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.
 
-    *Jason Lee*
+    *Xavier Noria*
 
+*   Improve `Range#===`, `Range#include?`, and `Range#cover?` to work with beginless (startless)
+    and endless range targets.
 
-## Rails 5.2.0 (April 09, 2018) ##
+    *Allen Hsu*, *Andrew Hodgkinson*
 
-*   Caching: MemCache and Redis `read_multi` and `fetch_multi` speedup.
-    Read from the local in-memory cache before consulting the backend.
+*   Don't use `Process#clock_gettime(CLOCK_PROCESS_CPUTIME_ID)` on Solaris
 
-    *Gabriel Sobrinho*
+    *Iain Beeston*
 
-*   Return all mappings for a timezone identifier in `country_zones`.
 
-    Some timezones like `Europe/London` have multiple mappings in
-    `ActiveSupport::TimeZone::MAPPING` so return all of them instead
-    of the first one found by using `Hash#value`. e.g:
+## Rails 6.0.0 (August 16, 2019) ##
 
-        # Before
-        ActiveSupport::TimeZone.country_zones("GB") # => ["Edinburgh"]
+*   Let `require_dependency` in `zeitwerk` mode look the autoload paths up for
+    better backwards compatibility.
 
-        # After
-        ActiveSupport::TimeZone.country_zones("GB") # => ["Edinburgh", "London"]
+    *Xavier Noria*
 
-    Fixes #31668.
+*   Let `require_dependency` in `zeitwerk` mode support arguments that respond
+    to `to_path` for better backwards compatibility.
 
-    *Andrew White*
+    *Xavier Noria*
 
-*   Add support for connection pooling on RedisCacheStore.
+*   Make ActiveSupport::Logger Fiber-safe. Fixes #36752.
 
-    *fatkodima*
+    Use `Fiber.current.__id__` in `ActiveSupport::Logger#local_level=` in order
+    to make log level local to Ruby Fibers in addition to Threads.
 
-*   Support hash as first argument in `assert_difference`. This allows to specify multiple
-    numeric differences in the same assertion.
+    Example:
 
-        assert_difference ->{ Article.count } => 1, ->{ Post.count } => 2
+        logger = ActiveSupport::Logger.new(STDOUT)
+        logger.level = 1
+        p "Main is debug? #{logger.debug?}"
 
-    *Julien Meichelbeck*
+        Fiber.new {
+          logger.local_level = 0
+          p "Thread is debug? #{logger.debug?}"
+        }.resume
 
-*   Add missing instrumentation for `read_multi` in `ActiveSupport::Cache::Store`.
+        p "Main is debug? #{logger.debug?}"
 
-    *Ignatius Reza Lesmana*
+    Before:
 
-*   `assert_changes` will always assert that the expression changes,
-    regardless of `from:` and `to:` argument combinations.
+        Main is debug? false
+        Thread is debug? true
+        Main is debug? true
 
-    *Daniel Ma*
+    After:
 
-*   Use SHA-1 to generate non-sensitive digests, such as the ETag header.
+        Main is debug? false
+        Thread is debug? true
+        Main is debug? false
 
-    Enabled by default for new apps; upgrading apps can opt in by setting
-    `config.active_support.use_sha1_digests = true`.
+    *Alexander Varnin*
 
-    *Dmitri Dolguikh*, *Eugene Kenny*
+*   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.
 
-*   Changed default behaviour of `ActiveSupport::SecurityUtils.secure_compare`,
-    to make it not leak length information even for variable length string.
+    *Aaron Lipman*
 
-    Renamed old `ActiveSupport::SecurityUtils.secure_compare` to `fixed_length_secure_compare`,
-    and started raising `ArgumentError` in case of length mismatch of passed strings.
 
-    *Vipul A M*
+## Rails 6.0.0.rc2 (July 22, 2019) ##
 
-*   Make `ActiveSupport::TimeZone.all` return only time zones that are in
-    `ActiveSupport::TimeZone::MAPPING`.
+*   `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`.
 
-    Fixes #7245.
+    Before:
 
-    *Chris LaRose*
+        'foobar'.truncate(5).frozen?
+        # => true
+        'foobar'.truncate(6).frozen?
+        # => false
 
-*   MemCacheStore: Support expiring counters.
+    After:
 
-    Pass `expires_in: [seconds]` to `#increment` and `#decrement` options
-    to set the Memcached TTL (time-to-live) if the counter doesn't exist.
-    If the counter exists, Memcached doesn't extend its expiry when it's
-    incremented or decremented.
+        'foobar'.truncate(5).frozen?
+        # => false
+        'foobar'.truncate(6).frozen?
+        # => false
 
-    ```
-    Rails.cache.increment("my_counter", 1, expires_in: 2.minutes)
-    ```
+    *Jordan Thomas*
 
-    *Takumasa Ochi*
 
-*   Handle `TZInfo::AmbiguousTime` errors.
+## Rails 6.0.0.rc1 (April 24, 2019) ##
 
-    Make `ActiveSupport::TimeWithZone` match Ruby's handling of ambiguous
-    times by choosing the later period, e.g.
+*   Introduce `ActiveSupport::ActionableError`.
 
-    Ruby:
-    ```
-    ENV["TZ"] = "Europe/Moscow"
-    Time.local(2014, 10, 26, 1, 0, 0)   # => 2014-10-26 01:00:00 +0300
+    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.
+
+    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.
+
+    Here is how to define an actionable error:
+
+    ```ruby
+    class PendingMigrationError < MigrationError #:nodoc:
+      include ActiveSupport::ActionableError
+
+      action "Run pending migrations" do
+        ActiveRecord::Tasks::DatabaseTasks.migrate
+      end
+    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.
+
+    *Vipul A M*, *Yao Jie*, *Genadi Samokovarov*
+
+*   Preserve `html_safe?` status on `ActiveSupport::SafeBuffer#*`.
+
     Before:
-    ```
-    >> "2014-10-26 01:00:00".in_time_zone("Moscow")
-    TZInfo::AmbiguousTime: 26/10/2014 01:00 is an ambiguous local time.
-    ```
+
+        ("<br />".html_safe * 2).html_safe? #=> nil
 
     After:
-    ```
-    >> "2014-10-26 01:00:00".in_time_zone("Moscow")
-    => Sun, 26 Oct 2014 01:00:00 MSK +03:00
-    ```
 
-    Fixes #17395.
+        ("<br />".html_safe * 2).html_safe? #=> true
 
-    *Andrew White*
+    *Ryo Nakamura*
 
-*   Redis cache store.
+*   Calling test methods with `with_info_handler` method to allow minitest-hooks
+    plugin to work.
 
-    ```
-    # Defaults to `redis://localhost:6379/0`. Only use for dev/test.
-    config.cache_store = :redis_cache_store
-
-    # Supports all common cache store options (:namespace, :compress,
-    # :compress_threshold, :expires_in, :race_condition_ttl) and all
-    # Redis options.
-    cache_password = Rails.application.secrets.redis_cache_password
-    config.cache_store = :redis_cache_store, driver: :hiredis,
-      namespace: 'myapp-cache', compress: true, timeout: 1,
-      url: "redis://:#{cache_password}@myapp-cache-1:6379/0"
-
-    # Supports Redis::Distributed with multiple hosts
-    config.cache_store = :redis_cache_store, driver: :hiredis
-      namespace: 'myapp-cache', compress: true,
-      url: %w[
-        redis://myapp-cache-1:6379/0
-        redis://myapp-cache-1:6380/0
-        redis://myapp-cache-2:6379/0
-        redis://myapp-cache-2:6380/0
-        redis://myapp-cache-3:6379/0
-        redis://myapp-cache-3:6380/0
-      ]
-
-    # Or pass a builder block
-    config.cache_store = :redis_cache_store,
-      namespace: 'myapp-cache', compress: true,
-      redis: -> { Redis.new … }
-    ```
+    *Mauri Mustonen*
 
-    Deployment note: Take care to use a *dedicated Redis cache* rather
-    than pointing this at your existing Redis server. It won't cope well
-    with mixed usage patterns and it won't expire cache entries by default.
+*   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.
 
-    Redis cache server setup guide: https://redis.io/topics/lru-cache
+    *Xavier Noria*
 
-    *Jeremy Daer*
+*   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.
 
-*   Cache: Enable compression by default for values > 1kB.
+    *Xavier Noria*
 
-    Compression has long been available, but opt-in and at a 16kB threshold.
-    It wasn't enabled by default due to CPU cost. Today it's cheap and typical
-    cache data is eminently compressible, such as HTML or JSON fragments.
-    Compression dramatically reduces Memcached/Redis mem usage, which means
-    the same cache servers can store more data, which means higher hit rates.
+*   In `:zeitwerk` mode, eager load directories in engines and applications only
+    if present in their respective `config.eager_load_paths`.
 
-    To disable compression, pass `compress: false` to the initializer.
+    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.
 
-    *Jeremy Daer*
+    *Xavier Noria*
 
-*   Allow `Range#include?` on TWZ ranges.
+*   Fix bug in Range comparisons when comparing to an excluded-end Range
 
-    In #11474 we prevented TWZ ranges being iterated over which matched
-    Ruby's handling of Time ranges and as a consequence `include?`
-    stopped working with both Time ranges and TWZ ranges. However in
-    ruby/ruby@b061634 support was added for `include?` to use `cover?`
-    for 'linear' objects. Since we have no way of making Ruby consider
-    TWZ instances as 'linear' we have to override `Range#include?`.
+    Before:
 
-    Fixes #30799.
+        (1..10).cover?(1...11) # => false
 
-    *Andrew White*
+    After:
 
-*   Fix acronym support in `humanize`.
+        (1..10).cover?(1...11) # => true
 
-    Acronym inflections are stored with lowercase keys in the hash but
-    the match wasn't being lowercased before being looked up in the hash.
-    This shouldn't have any performance impact because before it would
-    fail to find the acronym and perform the `downcase` operation anyway.
+    With the same change for `Range#include?` and `Range#===`.
 
-    Fixes #31052.
+    *Owen Stephens*
 
-    *Andrew White*
+*   Use weak references in descendants tracker to allow anonymous subclasses to
+    be garbage collected.
+
+    *Edgars Beigarts*
 
-*   Add same method signature for `Time#prev_year` and `Time#next_year`
-    in accordance with `Date#prev_year`, `Date#next_year`.
+*   Update `ActiveSupport::Notifications::Instrumenter#instrument` to make
+    passing a block optional. This will let users use
+    `ActiveSupport::Notifications` messaging features outside of
+    instrumentation.
 
-    Allows pass argument for `Time#prev_year` and `Time#next_year`.
+    *Ali Ibrahim*
+
+*   Fix `Time#advance` to work with dates before 1001-03-07
 
     Before:
-    ```
-    Time.new(2017, 9, 16, 17, 0).prev_year    # => 2016-09-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).prev_year(1)
-    # => ArgumentError: wrong number of arguments (given 1, expected 0)
 
-    Time.new(2017, 9, 16, 17, 0).next_year    # => 2018-09-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).next_year(1)
-    # => ArgumentError: wrong number of arguments (given 1, expected 0)
-    ```
+        Time.utc(1001, 3, 6).advance(years: -1) # => 1000-03-05 00:00:00 UTC
 
-    After:
-    ```
-    Time.new(2017, 9, 16, 17, 0).prev_year    # => 2016-09-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).prev_year(1) # => 2016-09-16 17:00:00 +0300
+    After
 
-    Time.new(2017, 9, 16, 17, 0).next_year    # => 2018-09-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).next_year(1) # => 2018-09-16 17:00:00 +0300
-    ```
+        Time.utc(1001, 3, 6).advance(years: -1) # => 1000-03-06 00:00:00 UTC
 
-    *bogdanvlviv*
+    Note that this doesn't affect `DateTime#advance` as that doesn't use a proleptic calendar.
 
-*   Add same method signature for `Time#prev_month` and `Time#next_month`
-    in accordance with `Date#prev_month`, `Date#next_month`.
+    *Andrew White*
 
-    Allows pass argument for `Time#prev_month` and `Time#next_month`.
+*   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.
 
-    Before:
-    ```
-    Time.new(2017, 9, 16, 17, 0).prev_month    # => 2017-08-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).prev_month(1)
-    # => ArgumentError: wrong number of arguments (given 1, expected 0)
+    *Xavier Noria*
 
-    Time.new(2017, 9, 16, 17, 0).next_month    # => 2017-10-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).next_month(1)
-    # => ArgumentError: wrong number of arguments (given 1, expected 0)
-    ```
+*   Add support for supplying `locale` to `transliterate` and `parameterize`.
 
-    After:
-    ```
-    Time.new(2017, 9, 16, 17, 0).prev_month    # => 2017-08-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).prev_month(1) # => 2017-08-16 17:00:00 +0300
+        I18n.backend.store_translations(:de, i18n: { transliterate: { rule: { "ü" => "ue" } } })
 
-    Time.new(2017, 9, 16, 17, 0).next_month    # => 2017-10-16 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).next_month(1) # => 2017-10-16 17:00:00 +0300
-    ```
+        ActiveSupport::Inflector.transliterate("ü", locale: :de) # => "ue"
+        "Fünf autos".parameterize(locale: :de) # => "fuenf-autos"
+        ActiveSupport::Inflector.parameterize("Fünf autos", locale: :de) # => "fuenf-autos"
 
-    *bogdanvlviv*
+    *Kaan Ozkan*, *Sharang Dashputre*
 
-*   Add same method signature for `Time#prev_day` and `Time#next_day`
-    in accordance with `Date#prev_day`, `Date#next_day`.
+*   Allow `Array#excluding` and `Enumerable#excluding` to deal with a passed array gracefully.
 
-    Allows pass argument for `Time#prev_day` and `Time#next_day`.
+        [ 1, 2, 3, 4, 5 ].excluding([4, 5]) # => [ 1, 2, 3 ]
 
-    Before:
-    ```
-    Time.new(2017, 9, 16, 17, 0).prev_day    # => 2017-09-15 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).prev_day(1)
-    # => ArgumentError: wrong number of arguments (given 1, expected 0)
+    *DHH*
 
-    Time.new(2017, 9, 16, 17, 0).next_day    # => 2017-09-17 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).next_day(1)
-    # => ArgumentError: wrong number of arguments (given 1, expected 0)
-    ```
+*   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.
 
-    After:
-    ```
-    Time.new(2017, 9, 16, 17, 0).prev_day    # => 2017-09-15 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).prev_day(1) # => 2017-09-15 17:00:00 +0300
+    *DHH*
 
-    Time.new(2017, 9, 16, 17, 0).next_day    # => 2017-09-17 17:00:00 +0300
-    Time.new(2017, 9, 16, 17, 0).next_day(1) # => 2017-09-17 17:00:00 +0300
-    ```
+*   Added `Array#including` and `Enumerable#including` to conveniently enlarge a collection with more members using a method rather than an operator:
 
-    *bogdanvlviv*
+        [ 1, 2, 3 ].including(4, 5) # => [ 1, 2, 3, 4, 5 ]
+        post.authors.including(Current.person) # => All the authors plus the current person!
+
+    *DHH*
+
+
+## Rails 6.0.0.beta3 (March 11, 2019) ##
+
+*   No changes.
+
+
+## Rails 6.0.0.beta2 (February 25, 2019) ##
+
+*   New autoloading based on [Zeitwerk](https://github.com/fxn/zeitwerk).
+
+    *Xavier Noria*
+
+*   Revise `ActiveSupport::Notifications.unsubscribe` to correctly handle Regex or other multiple-pattern subscribers.
+
+    *Zach Kemp*
+
+*   Add `before_reset` callback to `CurrentAttributes` and define `after_reset` as an alias of `resets` for symmetry.
+
+    *Rosa Gutierrez*
+
+*   Remove the `` Kernel#` `` override that suppresses ENOENT and accidentally returns nil on Unix systems.
 
-*   `IO#to_json` now returns the `to_s` representation, rather than
-    attempting to convert to an array. This fixes a bug where `IO#to_json`
-    would raise an `IOError` when called on an unreadable object.
+    *Akinori Musha*
 
-    Fixes #26132.
+*   Add `ActiveSupport::HashWithIndifferentAccess#assoc`.
 
-    *Paul Kuruvilla*
+    `assoc` can now be called with either a string or a symbol.
 
-*   Remove deprecated `halt_callback_chains_on_return_false` option.
+    *Stefan Schüßler*
+
+*   Add `Hash#deep_transform_values`, and `Hash#deep_transform_values!`.
+
+    *Guillermo Iguaran*
+
+
+## Rails 6.0.0.beta1 (January 18, 2019) ##
+
+*   Remove deprecated `Module#reachable?` method.
 
     *Rafael Mendonça França*
 
-*   Remove deprecated `:if` and `:unless` string filter for callbacks.
+*   Remove deprecated `#acronym_regex` method from `Inflections`.
 
     *Rafael Mendonça França*
 
-*   `Hash#slice` now falls back to Ruby 2.5+'s built-in definition if defined.
+*   Fix `String#safe_constantize` throwing a `LoadError` for incorrectly cased constant references.
 
-    *Akira Matsuda*
+    *Keenan Brock*
 
-*   Deprecate `secrets.secret_token`.
+*   Preserve key order passed to `ActiveSupport::CacheStore#fetch_multi`.
 
-    The architecture for secrets had a big upgrade between Rails 3 and Rails 4,
-    when the default changed from using `secret_token` to `secret_key_base`.
+    `fetch_multi(*names)` now returns its results in the same order as the `*names` requested, rather than returning cache hits followed by cache misses.
 
-    `secret_token` has been soft deprecated in documentation for four years
-    but is still in place to support apps created before Rails 4.
-    Deprecation warnings have been added to help developers upgrade their
-    applications to `secret_key_base`.
+    *Gannon McGibbon*
 
-    *claudiob*, *Kasper Timm Hansen*
+*   If the same block is `included` multiple times for a Concern, an exception is no longer raised.
 
-*   Return an instance of `HashWithIndifferentAccess` from `HashWithIndifferentAccess#transform_keys`.
+    *Mark J. Titorenko*, *Vlad Bokov*
 
-    *Yuji Yaginuma*
+*   Fix bug where `#to_options` for `ActiveSupport::HashWithIndifferentAccess`
+    would not act as alias for `#symbolize_keys`.
 
-*   Add key rotation support to `MessageEncryptor` and `MessageVerifier`.
+    *Nick Weiland*
 
-    This change introduces a `rotate` method to both the `MessageEncryptor` and
-    `MessageVerifier` classes. This method accepts the same arguments and
-    options as the given classes' constructor. The `encrypt_and_verify` method
-    for `MessageEncryptor` and the `verified` method for `MessageVerifier` also
-    accept an optional keyword argument `:on_rotation` block which is called
-    when a rotated instance is used to decrypt or verify the message.
+*   Improve the logic that detects non-autoloaded constants.
 
-    *Michael J Coyne*
+    *Jan Habermann*, *Xavier Noria*
 
-*   Deprecate `Module#reachable?` method.
+*   Deprecate `ActiveSupport::Multibyte::Unicode#pack_graphemes(array)` and `ActiveSuppport::Multibyte::Unicode#unpack_graphemes(string)`
+    in favor of `array.flatten.pack("U*")` and `string.scan(/\X/).map(&:codepoints)`, respectively.
 
-    *bogdanvlviv*
+    *Francesco Rodríguez*
 
-*   Add `config/credentials.yml.enc` to store production app secrets.
+*   Deprecate `ActiveSupport::Multibyte::Chars.consumes?` in favor of `String#is_utf8?`.
 
-    Allows saving any authentication credentials for third party services
-    directly in repo encrypted with `config/master.key` or `ENV["RAILS_MASTER_KEY"]`.
+    *Francesco Rodríguez*
 
-    This will eventually replace `Rails.application.secrets` and the encrypted
-    secrets introduced in Rails 5.1.
+*   Fix duration being rounded to a full second.
+    ```
+      time = DateTime.parse("2018-1-1")
+      time += 0.51.seconds
+    ```
+    Will now correctly add 0.51 second and not 1 full second.
 
-    *DHH*, *Kasper Timm Hansen*
+    *Edouard Chin*
 
-*   Add `ActiveSupport::EncryptedFile` and `ActiveSupport::EncryptedConfiguration`.
+*   Deprecate `ActiveSupport::Multibyte::Unicode#normalize` and `ActiveSuppport::Multibyte::Chars#normalize`
+    in favor of `String#unicode_normalize`
 
-    Allows for stashing encrypted files or configuration directly in repo by
-    encrypting it with a key.
+    *Francesco Rodríguez*
 
-    Backs the new credentials setup above, but can also be used independently.
+*   Deprecate `ActiveSupport::Multibyte::Unicode#downcase/upcase/swapcase` in favor of
+    `String#downcase/upcase/swapcase`.
 
-    *DHH*, *Kasper Timm Hansen*
+    *Francesco Rodríguez*
 
-*   `Module#delegate_missing_to` now raises `DelegationError` if target is nil,
-    similar to `Module#delegate`.
+*   Add `ActiveSupport::ParameterFilter`.
 
-    *Anton Khamets*
+    *Yoshiyuki Kinjo*
 
-*   Update `String#camelize` to provide feedback when wrong option is passed.
+*   Rename `Module#parent`, `Module#parents`, and `Module#parent_name` to
+    `module_parent`, `module_parents`, and `module_parent_name`.
 
-    `String#camelize` was returning nil without any feedback when an
-    invalid option was passed as a parameter.
+    *Gannon McGibbon*
 
-    Previously:
+*   Deprecate the use of `LoggerSilence` in favor of `ActiveSupport::LoggerSilence`
 
-        'one_two'.camelize(true)
-        # => nil
+    *Edouard Chin*
 
-    Now:
+*   Deprecate using negative limits in `String#first` and `String#last`.
 
-        'one_two'.camelize(true)
-        # => ArgumentError: Invalid option, use either :upper or :lower.
+    *Gannon McGibbon*, *Eric Turner*
 
-    *Ricardo Díaz*
+*   Fix bug where `#without` for `ActiveSupport::HashWithIndifferentAccess` would fail
+    with symbol arguments
 
-*   Fix modulo operations involving durations.
+    *Abraham Chan*
 
-    Rails 5.1 introduced `ActiveSupport::Duration::Scalar` as a wrapper
-    around numeric values as a way of ensuring a duration was the outcome of
-    an expression. However, the implementation was missing support for modulo
-    operations. This support has now been added and should result in a duration
-    being returned from expressions involving modulo operations.
+*   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.
 
-    Prior to Rails 5.1:
+    *Janosch Müller*
 
-        5.minutes % 2.minutes
-        # => 60
+*   Changed `ActiveSupport::TaggedLogging.new` to return a new logger instance instead
+    of mutating the one received as parameter.
 
-    Now:
+    *Thierry Joyal*
 
-        5.minutes % 2.minutes
-        # => 1 minute
+*   Define `unfreeze_time` as an alias of `travel_back` in `ActiveSupport::Testing::TimeHelpers`.
 
-    Fixes #29603 and #29743.
+    The alias is provided for symmetry with `freeze_time`.
 
-    *Sayan Chakraborty*, *Andrew White*
+    *Ryan Davidson*
 
-*   Fix division where a duration is the denominator.
+*   Add support for tracing constant autoloads. Just throw
 
-    PR #29163 introduced a change in behavior when a duration was the denominator
-    in a calculation - this was incorrect as dividing by a duration should always
-    return a `Numeric`. The behavior of previous versions of Rails has been restored.
+        ActiveSupport::Dependencies.logger = Rails.logger
+        ActiveSupport::Dependencies.verbose = true
 
-    Fixes #29592.
+    in an initializer.
 
-    *Andrew White*
+    *Xavier Noria*
 
-*   Add purpose and expiry support to `ActiveSupport::MessageVerifier` and
-   `ActiveSupport::MessageEncryptor`.
+*   Maintain `html_safe?` on html_safe strings when sliced.
 
-    For instance, to ensure a message is only usable for one intended purpose:
+        string = "<div>test</div>".html_safe
+        string[-1..1].html_safe? # => true
 
-        token = @verifier.generate("x", purpose: :shipping)
+    *Elom Gomez*, *Yumin Wong*
 
-        @verifier.verified(token, purpose: :shipping) # => "x"
-        @verifier.verified(token)                     # => nil
+*   Add `Array#extract!`.
 
-    Or make it expire after a set time:
+    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.
 
-        @verifier.generate("x", expires_in: 1.month)
-        @verifier.generate("y", expires_at: Time.now.end_of_year)
+        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]
 
-    Showcased with `ActiveSupport::MessageVerifier`, but works the same for
-    `ActiveSupport::MessageEncryptor`'s `encrypt_and_sign` and `decrypt_and_verify`.
+    *bogdanvlviv*
 
-    Pull requests: #29599, #29854
+*   Support not to cache `nil` for `ActiveSupport::Cache#fetch`.
 
-    *Assain Jaleel*
+        cache.fetch('bar', skip_nil: true) { nil }
+        cache.exist?('bar') # => false
 
-*   Make the order of `Hash#reverse_merge!` consistent with `HashWithIndifferentAccess`.
+    *Martin Hong*
 
-    *Erol Fornoles*
+*   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 `freeze_time` helper which freezes time to `Time.now` in tests.
+        ActiveSupport::Notifications.subscribe('wait') do |*args|
+          @event = ActiveSupport::Notifications::Event.new(*args)
+        end
 
-    *Prathamesh Sonpatki*
+        ActiveSupport::Notifications.instrument('wait') do
+          sleep 1
+        end
 
-*   Default `ActiveSupport::MessageEncryptor` to use AES 256 GCM encryption.
+        @event.duration # => 1000.138
 
-    On for new Rails 5.2 apps. Upgrading apps can find the config as a new
-    framework default.
+    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:
 
-    *Assain Jaleel*
+        ActiveSupport::Notifications.subscribe('wait') do |event|
+          @event = event
+        end
 
-*   Cache: `write_multi`.
+        ActiveSupport::Notifications.instrument('wait') do
+          sleep 1
+        end
 
-        Rails.cache.write_multi foo: 'bar', baz: 'qux'
+        p @event.allocations # => 7
+        p @event.cpu_time    # => 0.256
+        p @event.idle_time   # => 1003.2399
 
-    Plus faster fetch_multi with stores that implement `write_multi_entries`.
-    Keys that aren't found may be written to the cache store in one shot
-    instead of separate writes.
+    Now you can enjoy event objects without making them yourself.  Neat!
 
-    The default implementation simply calls `write_entry` for each entry.
-    Stores may override if they're capable of one-shot bulk writes, like
-    Redis `MSET`.
+    *Aaron "t.lo" Patterson*
 
-    *Jeremy Daer*
+*   Add cpu_time, idle_time, and allocations to Event.
 
-*   Add default option to module and class attribute accessors.
+    *Eileen M. Uchitelle*, *Aaron Patterson*
 
-        mattr_accessor :settings, default: {}
+*   RedisCacheStore: support key expiry in increment/decrement.
 
-    Works for `mattr_reader`, `mattr_writer`, `cattr_accessor`, `cattr_reader`,
-    and `cattr_writer` as well.
+    Pass `:expires_in` to `#increment` and `#decrement` to set a Redis EXPIRE on the key.
 
-    *Genadi Samokovarov*
+    If the key is already set to expire, RedisCacheStore won't extend its expiry.
 
-*   Add `Date#prev_occurring` and `Date#next_occurring` to return specified next/previous occurring day of week.
+        Rails.cache.increment("some_key", 1, expires_in: 2.minutes)
 
-    *Shota Iguchi*
+    *Jason Lee*
 
-*   Add default option to `class_attribute`.
+*   Allow `Range#===` and `Range#cover?` on Range.
 
-    Before:
+    `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.
 
-        class_attribute :settings
-        self.settings = {}
+    *Requiring active_support/core_ext/range/include_range is now deprecated.*
+    *Use `require "active_support/core_ext/range/compare_range"` instead.*
 
-    Now:
+    *utilum*
 
-        class_attribute :settings, default: {}
+*   Add `index_with` to Enumerable.
 
-    *DHH*
+    Allows creating a hash from an enumerable with the value from a passed block
+    or a default argument.
 
-*   `#singularize` and `#pluralize` now respect uncountables for the specified locale.
+        %i( title body ).index_with { |attr| post.public_send(attr) }
+        # => { title: "hey", body: "what's up?" }
 
-    *Eilis Hamilton*
+        %i( title body ).index_with(nil)
+        # => { title: nil, body: nil }
 
-*   Add `ActiveSupport::CurrentAttributes` to provide a thread-isolated attributes singleton.
-    Primary use case is keeping all the per-request attributes easily available to the whole system.
+    Closely linked with `index_by`, which creates a hash where the keys are extracted from a block.
 
-    *DHH*
+    *Kasper Timm Hansen*
 
-*   Fix implicit coercion calculations with scalars and durations.
+*   Fix bug where `ActiveSupport::TimeZone.all` would fail when tzinfo data for
+    any timezone defined in `ActiveSupport::TimeZone::MAPPING` is missing.
 
-    Previously, calculations where the scalar is first would be converted to a duration
-    of seconds, but this causes issues with dates being converted to times, e.g:
+    *Dominik Sander*
+
+*   Redis cache store: `delete_matched` no longer blocks the Redis server.
+    (Switches from evaled Lua to a batched SCAN + DEL loop.)
+
+    *Gleb Mazovetskiy*
+
+*   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.
 
-        Time.zone = "Beijing"           # => Asia/Shanghai
-        date = Date.civil(2017, 5, 20)  # => Mon, 20 May 2017
-        2 * 1.day                       # => 172800 seconds
-        date + 2 * 1.day                # => Mon, 22 May 2017 00:00:00 CST +08:00
+    *Godfrey Chan*
 
-    Now, the `ActiveSupport::Duration::Scalar` calculation methods will try to maintain
-    the part structure of the duration where possible, e.g:
+*   Fix bug where `URI.unescape` would fail with mixed Unicode/escaped character input:
 
-        Time.zone = "Beijing"           # => Asia/Shanghai
-        date = Date.civil(2017, 5, 20)  # => Mon, 20 May 2017
-        2 * 1.day                       # => 2 days
-        date + 2 * 1.day                # => Mon, 22 May 2017
+        URI.unescape("\xe3\x83\x90")  # => "バ"
+        URI.unescape("%E3%83%90")  # => "バ"
+        URI.unescape("\xe3\x83\x90%E3%83%90")  # => Encoding::CompatibilityError
 
-    Fixes #29160, #28970.
+    *Ashe Connor*, *Aaron Patterson*
 
-    *Andrew White*
+*   Add `before?` and `after?` methods to `Date`, `DateTime`,
+    `Time`, and `TimeWithZone`.
 
-*   Add support for versioned cache entries. This enables the cache stores to recycle cache keys, greatly saving
-    on storage in cases with frequent churn. Works together with the separation of `#cache_key` and `#cache_version`
-    in Active Record and its use in Action Pack's fragment caching.
+    *Nick Holden*
 
-    *DHH*
+*   `ActiveSupport::Inflector#ordinal` and `ActiveSupport::Inflector#ordinalize` now support
+    translations through I18n.
 
-*   Pass gem name and deprecation horizon to deprecation notifications.
+        # locale/fr.rb
 
-    *Willem van Bergen*
+        {
+          fr: {
+            number: {
+              nth: {
+                ordinals: lambda do |_key, number:, **_options|
+                  if number.to_i.abs == 1
+                    'er'
+                  else
+                    'e'
+                  end
+                end,
 
-*   Add support for `:offset` and `:zone` to `ActiveSupport::TimeWithZone#change`.
+                ordinalized: lambda do |_key, number:, **_options|
+                  "#{number}#{ActiveSupport::Inflector.ordinal(number)}"
+                end
+              }
+            }
+          }
+        }
 
-    *Andrew White*
 
-*   Add support for `:offset` to `Time#change`.
+    *Christian Blais*
 
-    Fixes #28723.
+*   Add `:private` option to ActiveSupport's `Module#delegate`
+    in order to delegate methods as private:
 
-    *Andrew White*
+        class User < ActiveRecord::Base
+          has_one :profile
+          delegate :date_of_birth, to: :profile, private: true
+
+          def age
+            Date.today.year - date_of_birth.year
+          end
+        end
+
+        # User.new.age  # => 29
+        # User.new.date_of_birth
+        # => NoMethodError: private method `date_of_birth' called for #<User:0x00000008221340>
+
+    *Tomas Valent*
+
+*   `String#truncate_bytes` to truncate a string to a maximum bytesize without
+    breaking multibyte characters or grapheme clusters like 👩‍👩‍👦‍👦.
+
+    *Jeremy Daer*
+
+*   `String#strip_heredoc` preserves frozenness.
+
+        "foo".freeze.strip_heredoc.frozen?  # => true
+
+    Fixes that frozen string literals would inadvertently become unfrozen:
+
+        # frozen_string_literal: true
+
+        foo = <<-MSG.strip_heredoc
+          la la la
+        MSG
+
+        foo.frozen?  # => false !??
+
+    *Jeremy Daer*
+
+*   Rails 6 requires Ruby 2.5.0 or newer.
+
+    *Jeremy Daer*, *Kasper Timm Hansen*
 
-*   Add `fetch_values` for `HashWithIndifferentAccess`.
+*   Adds parallel testing to Rails.
 
-    The method was originally added to `Hash` in Ruby 2.3.0.
+    Parallelize your test suite with forked processes or threads.
 
-    *Josh Pencheon*
+    *Eileen M. Uchitelle*, *Aaron Patterson*
 
 
-Please check [5-1-stable](https://github.com/rails/rails/blob/5-1-stable/activesupport/CHANGELOG.md) for previous changes.
+Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/activesupport/CHANGELOG.md) for previous changes.