Ruby 2.7 warning: creating a Proc without a block

This reverts commit 3420a145, reversing
changes made to afb66a5a.

* Allow a default value to be declared for class_attribute

* Convert to using class_attribute default rather than explicit setter

* Removed instance_accessor option by mistake

* False is a valid default value

* Documentation

In Rails 4.2, `ActionController::Metal` controllers did not include the
default headers from `ActionDispatch::Response`. However, through e16afe61, and a
general shift towards having `ActionController::Metal` objects contain
`ActionDispatch::Response` objects (instead of just returning an array
of status, headers, and body), this behavior was lost. This PR helps to
restore the original behavior by having `ActionController::Metal`
controllers generate Response objects without the default headers, while
`ActionController::Base` now overrides the factory method to make sure
its version does have the default headers.

[ci skip]

This commit changes `parameter_encoding` to `skip_parameter_encoding`.
`skip_parameter_encoding` will set encoding on all parameters to
ASCII-8BIT for a given action on a particular controller.  This allows
the controller to handle data when the encoding of that data is unknown,
for example file systems or truly binary parameters.

At GitHub we need to handle parameter encodings that are not UTF-8. This
patch allows us to specify encodings per parameter per action.

The current code base is not uniform. After some discussion,
we have chosen to go with double quotes by default.

we need to continue setting the body on the request object because of
Fiber based streaming templates.  Fixes #23659

There are some cases when the `body` in `response_body=` can be set to
nil. One of those cases is in `actionpack-action_caching` which I found
while upgrading it for Rails 5.

It's not possible to run `body.each` on a `nil` body so we have to
return after we run `response.reset_body!`.

When `require 'active_support/rails'`, 'active_support/deprecation'
is automatically loaded.

Just a slight refactor that delegates file sending to the response
object.  This gives us the advantage that if a webserver (in the future)
provides a response object that knows how to do accelerated file
serving, it can implement this method.

Committing the flash needs to happen in order for the session to be
written correctly, so lets guarantee that it actually does happen.

I'm making this change so that I can construct response objects that
*don't* have the default headers applied.  For example, I would like to
construct a response object from the return value of a controller.

If you need to construct a response object with the default headers,
then please use the alternate constructor:
`ActionDispatch::Response.create`

This commit is to abstract the code away from the env hash.  It no
longer needs to have the routes key hard coded.

Since all controller instances are required to have a request and
response object, RackDelegation is no longer needed (we always have to
delegate to the response)

without this module, the content type is not set correctly

since the controller always has a request on it, we can just ask the
request for the content type.

The controller instance always has an instance of a response object.  We
should store the status code on the response object so that it's only
store in one place.

We always have a response object in controller instances, so we can
remove this conditional

controller instances always have a response object, so we don't need to
test to see if there is one, just always call to_a on the response.

Controllers should always have a request and response when responding.
Since we make this The Rule(tm), then controllers don't need to be
somewhere in limbo between "asking a response object for a rack
response" or "I, myself contain a rack response".  This duality leads to
conditionals spread through the codebase that we can delete:

  * https://github.com/rails/rails/blob/85a78d9358aa728298cd020cdc842b55c16f9549/actionpack/lib/action_controller/metal.rb#L221-L223

This saves a lambda and request allocation on each request.

controllers should always go through the `action` class method so that
their middleware is respected.

people should be accessing request information through the request
object, not via the env hash.  If they really really want at the env
hash, then they can get it off the request.

remove the setter.  The request object manages the env hash, so any
mutations need to go through it

Actions are processed through `dispatch`, so they should have the
request set on them before any user land code can be executed.  Lets
stop setting _env on the controller, and give access to it through the
`env` method.

Convert things like this:

  middleware.use "Foo::Bar"

to this:

  middleware.use Foo::Bar

use a strategy pattern to calculate the conditional in `valid?` in
advance.

We should do the hard work outside the constructor.  Also fix the tests
to not directly construct middleware objects, but to go through the
stack object.