`yield` was missing in #with_dup, due to which 57 assertions were not running
in real, and all tests were passing by default.
Error was introduced in commit - 31ceb5e6.

`Array#to` is working for negative position

We need to test if the same method defined more than once only register
one subscriber for it. We can safelly remove because the method body is
the same and Subscriber use method_added hook for register the
subscriber.

Removed `FIMXE` tag to require necessary file but not the whole core_ext

- Fix `test_to_with_instruct` typo to `test_to_xml_with_instruct`

- Rename `test_to_xml` to `test_to_xml_with_hash_elements` to make test
name more specific.

- Add `test_to_xml_with_non_hash_elements` and
`test_to_xml_with_non_hash_different_type_elements`

  `to_xml` behaves different when containing elements are same and
  different types.

- Add `test_to_xml_with_indent_set`

Require active_support/core_ext/string/output_safety and use html_safe rather than use non-public SafeBuffer API.

Use block parameter rather than `$1` during `gsub!` so `ActiveSupport::SafeBuffer` values aren't mangled.

Fixes #15064

Namely, if the mday is omitted but any other upper components are, then instead
of supplying the mday from the current time, it defaults to 1.

ActiveSupport::Subscriber no longer creates multiple subscribers when
you redefine a method.

* Strips leading underscores.
* Changes some unnecessary gsub!s to sub!s.
* Replaces some anchors ^, $ with \A, \z.
* Documents that human inflection rules are applied.
* Documents that words are downcased except acronyms.
* Adds an example with an acronym.
* Rewords docs.

Empty Hash or Array should not present in serialization result

    {a: []}.to_query # => ""
    {a: {}}.to_query # => ""

For more info see #14948.

Before:
  When calling String#pluralize with count=1 then it returned same
  string, but with count other than 1, returned new string.

After:
  String#pluralize always return a new string.

  => Prevent mutation of a string inadvertently.

While calling String#first or String#last with zero or a Fixnum < the
string's length returns a new string, a Fixnum >= the string's length
returns the string itself. This inconsistency can lead to inadvertent
mutation of a string.

1. Improve tests
2. Remove unnecessary constant
3. Add docs for BigDecimal#duplicable?

This fixes:
    1.second.eql?(1.second) #=> false

The new `eql?` requires that `other` is an `ActiveSupport::Duration`.
This requirement makes `ActiveSupport::Duration`'s behavior consistent
with other numeric types in Ruby.

    1.eql?(1.0) #=> false
    1.0.eql?(1) #=> false

    1.second.eql?(1) #=> false (was true)
    1.eql?(1.second) #=> false

    { 1 => "foo", 1.0 => "bar" }
    #=> { 1 => "foo", 1.0 => "bar" }

    { 1 => "foo", 1.second => "bar" }
    # now => { 1 => "foo", 1.second => "bar" }
    # was => { 1 => "bar" }

And though the behavior here hasn't changed, for reference:

    1 == 1.0 #=> true
    1.0 == 1 #=> true

    1 == 1.second #=> true
    1.second == 1 #=> true

Change to require all active_support/deprecation since that's the actual
entry point for the deprecation methods.

Make `#prepend` method modify instance in-place and return self
instead of just returning modified value. That is exactly what
`#prepend!` method was doing previously, so it's deprecated from
now on.

In particular, `.new`, `#update`, `#merge`, `#replace` all accept
objects which respond to `#to_hash`, even if those objects are not
Hashes directly.

Closes #14405.

This is a follow-up to 9e997e90 to restore
the documented behavior.

On ruby 2.1.1 the behavior of .select and .reject has changed.
They will return a Hash new instance, so we need to override them to
keep the instance object class.

This reverts commit 475c9658, reversing
changes made to 705915ab.

We decided that this is not worth busting everyone's cache as this
seems like a very unlikely problem. The problem only occurs when the
user is 1) not using a namespace, or 2) using the same namesapce for
different *kinds* of cache items. The recommended "fix" is to put
those cache items into their own namspace:

    id = 1
    Rails.cache.fetch(id, namespace: "user"){ User.find(id) }

    ids = [1]
    Rails.cache.fetch(ids, namespace: "users"){ User.find(ids) }

See the discussion on #14269 for details.

`cache.fetch(['foo'])` and `cache.fetch('foo')` should generate
different cache keys as they are not equivalents.

[related #8615]
[related #8614]

The 'cow' => 'kine' inflection has gone with c300dca9 but it should
not be removed from the tested irregularities since it ensures that
inflections work with words that do not begin with the same letters.

The current implementation of `fetch_multi` returns an array and has no
means to easily backtrack which names yielded which results. By changing
the return value to a Hash we retain the name information. Hash#values
can be used on the response if only the values are needed.

Go with #presence_in instead of #present_in -- it doesnt sound quite as good, but the closer relationship to #presence over #present is ultimately worth it