the same value that is extracted from the options hash earlier is
returned, so we don't need to pass it in in the first place.  The caller
already has the data, so stop passing it around.

this way we don't have to mutate the options hash so far away from where
the user passed it in

Require explicit counter_cache option for has_many

The `anchor` parameter [is overridden](https://github.com/rails/rails/blob/b4b4a611d0eb9aa1c640c5f521c6a43bf2a65bab/actionpack/lib/action_dispatch/routing/mapper.rb#L1528) unless it
is directly passed to `match`, so setting it in a scope must be a
mistake.

Prevent duplicating `where` clauses

Closes #21201.

How to pass arguments to ActiveJob Jobs [ci skip]

A section explaining how to pass arguments to Jobs has been added.

[ci skip] How to pass arguments to ActiveJob Jobs

Removed the "how to pass arguments" from what you will know section

[ci skip] improving Enqueue Job section

Using GuestsCleanupJob rather than MyJob for coherence.

[ci skip] Passing args section merged with enqueuing jobs

Passing args is now explained through examples withing Enqueuing the Jobs section

[ci skip] Unnecessary example removed

[ci skip] Typo fixed (missing as)

[ci skip] Clarified asset pipeline guide

The latest, currently unreleased, version of queue_classic is required
for this to work. See
https://github.com/QueueClassic/queue_classic/pull/262 for more details.

Added helper methods to stub any instance

As described in the "Follow Coding Conventions" section in our
contribution guide (http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#follow-the-coding-conventions)
we favor `assert_not` over `refute`.

While we don't usually make stylistic changes on it's own I opted to do
it in this case. The reason being that test cases are usually copied as
a starting point for new tests. This results in a spread of `refute` in
files that have been using it already.

Assert that the `:prefix` option of `number_to_human_size` is deprecated

Replace the giant comment in routes.rb with a link to the guides

[ci skip] Documentation: Switch around a common phrase for readability

I didn't like this method because it mutates the parameters.  Now that
the method is so small, just push it up to `initialize`

If the through class has default scopes we should skip the statement
cache.

Closes #20745.

now the `@defaults` variable doesn't need to be set before calling
`normalize_defaults`

These three options are stored in the `scope` chain outside of the
options hash.  If they are in the options hash, then someone passed them
in to `match` and they don't really do anything.  So lets remove the
code.

remove `format` from the options hash in the scope chain so that we
don't need to remove it later

this reduces the number of times we have to mutate the options hash.

This just ensures that `format` is applied to things inside the scope

Fewer objects and refactoring

Since we are always responding with an array and using `any?`, we don't
need to check if an array is empty

Now we don't have to manually remove this from the options hash since
the scope stores it outside of "options"

Remove the `options` reader from `Resource` because nobody needs to see
that hash.  Also remove mutations on the options hash in
`apply_common_behavior_for` because leaving the side effects in that
method makes it difficult to understand what is going on in the caller.

these two keys have a different merge strategy, and they also just get
removed from the options hash later in the code.  If we store them in a
separate place, then we don't need to remove them later

Eventually we don't want to expose the "options" hash from scope, only
read values from it.  Lets start by adding a reader method.

now we don't need to construct a Mapping object just to get an
ArgumentError if there is no `via` parameter provided.

We're going to try pulling this up further, and check `via` validity
sooner.  This way we don't have to do a bunch of processing on `options`
hashes only to find out that the route is incorrect

If we do the Regexp verification in a second method, then the
`split_constraints` method gets much easier.