Fix typo in testing guide

in favor of `array.flatten.pack("U*")` and `string.scan(/\X/).map(&:codepoints)`, respectively.

Fix generated Gemfile missing gems on jruby

ActiveRecord#respond_to? No longer allocates strings

Follow up #32146.

Remove index:true option from belongs to as defaults to true.

[ci skip]

Update guide for the counter variable when rendering with the `as:` option

`init_with` and `init_from_db` are almost the same code except decode
`coder`.

And also, named `init_from_db` is a little misreading, a raw values hash
from the database is already converted to an attributes object by
`attributes_builder.build_from_database`, so passed `attributes` in that
method is just an attributes object.

I renamed that method to `init_with_attributes` since the method is
shared with `init_with` to initialize an empty model object.

[ci skip]

Consistently extract checking version for all adapters

Use \X meta character directly to get grapheme clusters.

Thanks to @mtsmfm for the tip:
https://github.com/rails/rails/pull/34123#issuecomment-429028878

r? @jeremy

I don't prefer to extract it for one adapter even though all adapters
also does.

Related to #34227.

Fix mapping of content [ci skip]

Refactored abstract MySQL adapter to support lazy version check.

Clarify docs of `ActiveJob::TestHelper` [ci skip]

Will allow sub classes to override the protected
`#check_version` method hook if desired.

For example, this will be most helpful in sub classes that wish
to support lazy initialization because the version check can
be postponed until the connection is ready to be initialized.

Add regression test against has_and_belong_to_many memoized singular_ids

Extend doc for ActiveSupport::Cache#fetch_multi

Starting in Rails 5.0.0 and still present in Rails 5.2.1, `singular_ids`
got memoized and didn't reload after more items were added to the
relation.

Although 19c80718 happens to fix the issue, it only adds tests for
`has_many` relations while this bug only affected
`has_and_belongs_to_many` relations.

This commit adds a regression test to ensure it never happens again with
`habtm` relations.

Ensures #34179 never gets reproduced.

Issue #29200 scaffold an object with a reference displays an object memory address to user

Fix Collection cache key with limit and custom select

Change query to use alias name for timestamp_column to avoid ambiguity problems when using timestamp from subquery.

I found a few sentences that should be updated as well.
See https://github.com/rails/rails/pull/33571#discussion_r209435886

Follow up #33571

This is an alternative to https://github.com/rails/rails/pull/34195

The active record `respond_to?` method needs to do two things if `super` does not say that the method exists. It has to see if the "name" being passed in represents a column in the table. If it does then it needs to pass it to `has_attribute?` to see if the key exists in the current object. The reason why this is slow is that `has_attribute?` needs a string and most (almost all) objects passed in are symbols.

The only time we need to allocate a string in this method is if the column does exist in the database, and since these are a limited number of strings (since column names are a finite set) then we can pre-generate all of them and use the same string. 

We generate a list hash of column names and convert them to symbols, and store the value as the string name. This allows us to both check if the "name" exists as a column, but also provides us with a string object we can use for the `has_attribute?` call. 

I then ran the test suite and found there was only one case where we're intentionally passing in a string and changed it to a symbol. (However there are tests where we are using a string key, but they don't ship with rails).

As re-written this method should never allocate unless the user passes in a string key, which is fairly uncommon with `respond_to?`.

This also eliminates the need to special case every common item that might come through the method via the `case` that was originally added in https://github.com/rails/rails/commit/f80aa5994603e684e3fecd3f53bfbf242c73a107 (by me) and then with an attempt to extend in https://github.com/rails/rails/pull/34195.

As a bonus this reduces 6,300 comparisons (in the CodeTriage app homepage) to 450 as we also no longer need to loop through the column array to check for an `include?`.

In favor of String#is_utf8?.

I think this method was made for internal use only, and its usage was removed here: https://github.com/rails/rails/pull/8261/files#diff-ce956ebe93786930e40f18db1da5fd46L39.

Update snippet to rails 5 syntax

[ci skip]

* Fix `ActionController::Parameters#each_value`

`each_value` should yield with "value" of the params instead of "value" as an array.
Related to #33979

* Add changelog entry about `ActionController::Parameters#each_value`.

Follow up #33979

Fix issue where duration where always rounded up to a second:

`developers.name desc` was added at d59f3a78, but any test case isn't
failed even if the `developers.name desc` is removed since all tested
developers are consistently ordered on both `name` and `id`.

I changed one developers creation ordering to ensure to test that
`project.developers` is ordered by `developers.name desc`.

Fix tests on Mail 2.7.1

Resolve Issue#29200

When scaffolding a model that references another model the
generated show and index html pages display the object directly
on the page. Basically, it just shows a memory address. That is
not very helpful. In this commit we show the object's id rather
than the memory address.

This updates the scaffold templates and the json builder files.

Up to `2.7.0`, encoding was chosen using `Mail::Encodings::TransferEncoding.negotiate`,
and base64 encoding was used.
In `2.7.1`, when `transfer_encoding` is not specified, the encoding
of the message is respected.
Related to: https://github.com/mikel/mail/commit/dead487e02f592d9058fd07deedcde39b569d18d

However, what chosen for transfer encoding is not essential in these tests.
To test more accurately, confirm that the decoded body instead.

- Adding a Float as a duration to a datetime would result in the Float
  being rounded. Doing something like would have no effect because the
  0.45 seconds would be rounded to 0 second.

  ```ruby
    time = DateTime.parse("2018-1-1")
    time += 0.45.seconds
  ```

  This behavior was intentionally added a very long time ago, the
  reason was because Ruby 1.8 was using `Integer#gcd` in the
  constructor of Rational which didn't accept a float value.

  That's no longer the case and doing `Rational(0.45, 86400)` would
  now perfectly work fine.

- Fixes #34008