The def with blank `()` was newly added in #31176, but we have not used
the blank `()` style in most part of our code base.
So I've enabled `Style/DefWithParentheses` to prevent to newly added the
code.

Even that collisions are unlikely we need to make sure the two strings
are equal.

Timing is not important in this case because this only runs after the
comparison between the SHA256 digested strings returns true.

[ci skip]

Support `expires_in` in `ActiveSupport::Cache::MemCacheStore#increment`
and `#decrement`.

Closes #30716.

`keys_to_names` is used only for `keys_to_names.keys`.

Ref: https://travis-ci.org/rails/rails/jobs/303840778#L1974

Make `ActiveSupport::TimeWithZone` match Ruby's handling of ambiguous
times by choosing the later period, e.g.

Ruby:
```
ENV["TZ"] = "Europe/Moscow"
Time.local(2014, 10, 26, 1, 0, 0)   # => 2014-10-26 01:00:00 +0300
```

Before:
```
>> "2014-10-26 01:00:00".in_time_zone("Moscow")
TZInfo::AmbiguousTime: 26/10/2014 01:00 is an ambiguous local time.
```

After:
```
>> "2014-10-26 01:00:00".in_time_zone("Moscow")
=> Sun, 26 Oct 2014 01:00:00 MSK +03:00
```

Fixes #17395.

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.

To disable compression, pass `compress: false` to the initializer.

* Supports vanilla Redis, hiredis, and Redis::Distributed.
* Supports Memcached-like sharding across Redises with Redis::Distributed.
* Fault tolerant. If the Redis server is unavailable, no exceptions are
  raised. Cache fetches are treated as misses and writes are dropped.
* Local cache. Hot in-memory primary cache within block/middleware scope.
* `read_/write_multi` support for Redis mget/mset. Use Redis::Distributed
  4.0.1+ for distributed mget support.
* `delete_matched` support for Redis KEYS globs.

Currently, credentials does not check the format when saving. As a result,
incorrect data as yaml is also saved.
If credentials is used in config files., an error will occur in credential
yaml parsing before edit, and will not be able to edit it.

In order to prevent this, verify the format when saving.

Related: #30851

[ci skip]

This is no longer used since fd6aaaa0.

## Summary

RuboCop 0.51.0 was released.
https://github.com/bbatsov/rubocop/releases/tag/v0.51.0

And rubocop-0-51 channel is available in Code Climate.
https://github.com/codeclimate/codeclimate-rubocop/issues/109

This PR will bump RuboCop to 0.51.0 and fixes the following new
offenses.

```console
% bundle exec rubocop
Inspecting 2358 files

(snip)

Offenses:

actionpack/lib/action_controller/metal/http_authentication.rb:251:59: C:
Prefer double-quoted strings unless you need single quotes to avoid
extra backslashes for escaping.
          [key.strip, value.to_s.gsub(/^"|"$/, "").delete('\'')]
                                                          ^^^^
activesupport/test/core_ext/load_error_test.rb:8:39: C: Prefer
double-quoted strings unless you need single quotes to avoid extra
backslashes for escaping.
    assert_raise(LoadError) { require 'no_this_file_don\'t_exist' }
                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^

2358 files inspected, 2 offenses detected
```

This fixes an issue where competing threads deadlock each other.

- Thread A holds the load interlock but is blocked on getting the DB lock
- Thread B holds the DB lock but is blocked on getting the load interlock (for example when there is a `Model.transaction` block that needs to autoload)

This solution allows for dependency loading in other threads while a thread is waiting to acquire the DB lock.

Fixes #31019

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?`.

Fixes #30799.

Seeing the previously issued PRs about it, we can avoid the `nil`
comparisons that can happen in `assert_changes` by using plain `assert`
calls.

This is to avoid a deprecation warning about comparing `nil` values in
`assert_equal` for Minitest 5 and a crash in Minitest 6.

You can see the preparations done in [`assert_equal`][ae]. You can also
see that [`assert`][a] does not care about `nil`s.

[ae]: https://github.com/seattlerb/minitest/blob/ca6a71ca901016db09a5ad466b4adea4b52a504a/lib/minitest/assertions.rb#L159-L188
[a]: https://github.com/seattlerb/minitest/blob/ca6a71ca901016db09a5ad466b4adea4b52a504a/lib/minitest/assertions.rb#L131-L142

These changes resolve a deprecation warning in `assert_no_changes`
when asserting that an expression evaluates to `nil` before and after
the passed block is evaluated.

The smallest demonstration of this edge case:

```ruby
assert_no_changes "nil" do
  true # noop
end
```

Under the covers, this is evaluating

```ruby
assert_equal nil, nil
```

Minitest 5 issues a deprecation warning, and Minitest will fail
completely.

For additional context, the motivations and implications of this change
to Minitest have been discussed at length in [seattlerb/minitest#666][].

[seattlerb/minitest#666]: https://github.com/seattlerb/minitest/issues/666

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.

Fixes #31052.

Trés -> Très 
https://fr.wiktionary.org/wiki/tr%C3%A8s

These methods unused since 55336960.

Follow up of #31004.

To be removed in Rails 6.0 (default for the deprecate helper).  Code
moved around as well for the ActiveSupport::Deprecation modules, since
it was dependent on ActiveSupport::Inflector being loaded for it to
work.  By "lazy loading" the Inflector code from within the Deprecation
code, we can require ActiveSupport::Deprecation from
ActiveSupport::Inflector and not get a circular dependency issue.

Related to #30972

The documentation wrongly suggests that Time extensions to Numeric include
methods months and years, when these belong to Integer.

Update both classes and guides.

The Problem
-----------

The following line from `String#camelize`:

  string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }

and the following line from `String#camelize`:

  word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }#{$2.downcase}" }

Both generate the same regexep in the first part of the `.sub`/`.gsub`
method calls every time the function is called, creating an extra object
allocation each time.  The value of `acronym_regex` only changes if the
user decides add an acronym to the current set of inflections and apends
another string on the the regexp generated here, but beyond that it
remains relatively static.

This has been around since acronym support was introduced back in 2011
in PR#1648.

Proposed Solution
-----------------
To avoid re-generating these strings every time these methods are
called, cache the values of these regular expressions in the
`ActiveSupport::Inflector::Inflections` instance, making it so these
regular expressions are only generated once, or when the acronym's are
added to.

Other notable changes is the attr_readers are nodoc'd, as they shouldn't
really be public APIs for users.  Also, the new method,
define_acronym_regex_patterns, is the only method in charge of
manipulating @acronym_regex, and initialize_dup also makes use of that
new change.

** Note about fix for non-deterministic actionpack test **

With the introduction of `@acronym_underscore_regex` and
`@acronym_camelize_regex`, tests that manipulated these for a short
time, then reset them could caused test failures to happen.  This
happened because the previous way we reset the `@acronyms` and
`@acronym_regex` was the set them using #instance_variable_set, which
wouldn't run the #define_acronym_regex_patterns method.

This has now been introduced into the actionpack tests to avoid this
failure.

activesupport/lib/active_support/core_ext/object/acts_like.rb
acts_like?

Add a case statement to use direct symbols instead of string
interpolation for the three scenarios I found in the Rails codebase:
time, date, and string.

For time/date/string, this change prevents two string allocations for
each time the method is called and speeds up the method by ~2.7x. For
other arguments, there is no memory difference and performance
difference is within margin of error.

begin
  require "bundler/inline"
rescue LoadError => e
  $stderr.puts "Bundler version 1.10 or later is required. Please update
                your Bundler"
  raise e
end

gemfile(true) do
  source "https://rubygems.org"

  gem "rails", github: "rails/rails"
  gem "arel", github: "rails/arel"
  gem "benchmark-ips"
end

def allocate_count
  GC.disable
  before = ObjectSpace.count_objects
  yield
  after = ObjectSpace.count_objects
  after.each { |k,v| after[k] = v - before[k] }
  after[:T_HASH] -= 1 # probe effect - we created the before hash.
  GC.enable
  result = after.reject { |k,v| v == 0 }
  GC.start
  result
end

class Object
  def fast_acts_like?(duck)
    case duck
    when :time
      respond_to? :acts_like_time?
    when :date
      respond_to? :acts_like_date?
    when :string
      respond_to? :acts_like_string?
    else
      respond_to? :"acts_like_#{duck}?"
    end
  end
end

puts
puts " acts_like? ".center(80, '=')
puts

obj = ''.freeze

%i(time date string super_hacka).each do |type|
  puts " #{type} ".center(80, '=')

  puts " Memory Usage ".center(80, "=")
  puts

  puts "value.acts_like?"
  puts allocate_count { 1000.times { obj.acts_like?(type) } }

  puts "value.fast_acts_like?"
  puts allocate_count { 1000.times { obj.fast_acts_like?(type) } }

  puts
  puts " Benchmark.ips ".center(80, "=")
  puts

  Benchmark.ips do |x|
    x.report("acts_like?")      { obj.acts_like?(type) }
    x.report("fast_acts_like?") { obj.fast_acts_like?(type) }
    x.compare!
  end
end

================================== acts_like? ==================================

===================================== time =====================================
================================= Memory Usage =================================

value.acts_like?
{:FREE=>-1983, :T_STRING=>2052, :T_IMEMO=>1}
value.fast_acts_like?
{:FREE=>-1}

================================ Benchmark.ips =================================

Warming up --------------------------------------
          acts_like?   104.281k i/100ms
     fast_acts_like?   155.523k i/100ms
Calculating -------------------------------------
          acts_like?      1.688M (±10.7%) i/s -      8.342M in   5.003804s
     fast_acts_like?      4.596M (±12.1%) i/s -     22.551M in   5.000124s

Comparison:
     fast_acts_like?:  4596162.4 i/s
          acts_like?:  1688163.8 i/s - 2.72x  slower

===================================== date =====================================
================================= Memory Usage =================================

value.acts_like?
{:FREE=>-2001, :T_STRING=>2000}
value.fast_acts_like?
{:FREE=>-1}

================================ Benchmark.ips =================================

Warming up --------------------------------------
          acts_like?    85.372k i/100ms
     fast_acts_like?   166.097k i/100ms
Calculating -------------------------------------
          acts_like?      1.720M (± 8.3%) i/s -      8.537M in   5.001003s
     fast_acts_like?      4.695M (±10.1%) i/s -     23.254M in   5.010734s

Comparison:
     fast_acts_like?:  4695493.1 i/s
          acts_like?:  1719637.9 i/s - 2.73x  slower

==================================== string ====================================
================================= Memory Usage =================================

value.acts_like?
{:FREE=>-2001, :T_STRING=>2000}
value.fast_acts_like?
{:FREE=>-1}

================================ Benchmark.ips =================================

Warming up --------------------------------------
          acts_like?   100.221k i/100ms
     fast_acts_like?   182.841k i/100ms
Calculating -------------------------------------
          acts_like?      1.706M (± 7.3%) i/s -      8.519M in   5.022331s
     fast_acts_like?      3.968M (±22.8%) i/s -     18.650M in   5.006762s

Comparison:
     fast_acts_like?:  3967972.9 i/s
          acts_like?:  1705773.7 i/s - 2.33x  slower

================================= super_hacka ==================================
================================= Memory Usage =================================

value.acts_like?
{:FREE=>-2004, :T_STRING=>2002, :T_SYMBOL=>1}
value.fast_acts_like?
{:FREE=>-2003, :T_STRING=>2001, :T_SYMBOL=>1}

================================ Benchmark.ips =================================

Warming up --------------------------------------
          acts_like?   100.344k i/100ms
     fast_acts_like?   101.690k i/100ms
Calculating -------------------------------------
          acts_like?      1.617M (± 7.5%) i/s -      8.128M in   5.055285s
     fast_acts_like?      1.534M (±10.1%) i/s -      7.627M in   5.031052s

Comparison:
          acts_like?:  1617390.7 i/s
     fast_acts_like?:  1533897.3 i/s - same-ish: difference falls within error