This helper creates a link tag with preload keyword that allows to
browser to initiate early fetch of resources. Additionally this send
Early Hints if supported.

See https://github.com/rails/rails/pull/30744/commits/59a02fb7bcbe68f26e1e7fdcec45c00c66e4a065
for more details about Early Hints.

Preload spec: https://w3c.github.io/preload/

Action Mailer context for example responds to request but don't have a
a request object.

Fixes #31265

This will keep the behavior of an application with the defaults of a 4.2
or 5.0 application behaving the same when upgrading to 5.2.

When the defaults being loaded are the 5.0 or 5.1 we disable generation
of ids with form_with.

When `form_with` was introduced we disabled the automatic
generation of ids that was enabled in `form_for`. This usually
is not an good idea since labels don't work when the input
doesn't have an id and it made harder to test with Capybara.

You can still disable the automatic generation of ids setting
`config.action_view.form_with_generates_ids` to `false.`

### Summary

The [`:field_error_proc`](https://github.com/rails/rails/blob/master/actionview/lib/action_view/base.rb#L145) is responsible for decorating input tags that refer to attributes with errors. This default build-in rails feature wrap invalid form elements with additional markup: `<div class="field_with_errors">[…]</div>`.

* Fix for `field_error_proc` wraps form select `optgroup`
* Fix for `field_error_proc` wraps form select divider `option`
* Add tests for uncovered elements with errors

[Fixes #31088]

#### Test coverage
* `test_select_grouped_options_with_errors`
* `test_time_zone_select_with_priority_zones_and_errors`

#### Extend test coverage
* `test_collection_select_with_errors`
* `test_label_with_errors`
* `test_check_box_with_errors`
* `test_check_boxes_with_errors`
* `test_radio_button_with_errors`
* `test_radio_buttons_with_errors`
* `test_collection_check_boxes_with_errors`
* `test_collection_radio_buttons_with_errors`

Since #24923, if use `select_tag` with `include_blank: true`, an empty
label is added.

Prevents two string allocations per method call for common REST verbs
plus a ~1.5x speedup for :get in particular

```ruby
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 "benchmark-ips"
  gem "rails"
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

@html_options = {}

def master_version
  if @method && @method.to_s.downcase != "get" && @html_options["rel".freeze] !~ /nofollow/
    @html_options["rel".freeze] = "#{@html_options["rel".freeze]} nofollow".lstrip
  end
  @html_options["data-method".freeze] = @method
end

def fast_version
  if method_not_get_method?(@method) && @html_options["rel".freeze] !~ /nofollow/
    @html_options["rel".freeze] = "#{@html_options["rel".freeze]} nofollow".lstrip
  end
  @html_options["data-method".freeze] = @method
end

STRINGIFIED_COMMON_METHODS = {
  get:    'get',
  delete: 'delete',
  patch:  'patch',
  post:   'post',
  put:    'put',
}.freeze

def method_not_get_method?(method)
  return false unless method
  (STRINGIFIED_COMMON_METHODS[method] || method.to_s.downcase) != 'get'
end

puts 'get'
@method = :get

puts "master_version"
puts allocate_count { 1000.times { master_version } }
puts "fast_version"
puts allocate_count { 1000.times { fast_version } }

Benchmark.ips do |x|
  x.report("master_version") { master_version }
  x.report("fast_version")     { fast_version }
  x.compare!
end

puts 'delete'
@method = :delete

puts "master_version"
puts allocate_count { 1000.times { master_version } }
puts "fast_version"
puts allocate_count { 1000.times { fast_version } }

Benchmark.ips do |x|
  x.report("master_version") { master_version }
  x.report("fast_version")     { fast_version }
  x.compare!
end
```

```
get
master_version
{:FREE=>-1819, :T_STRING=>2052}
fast_version
{:FREE=>-1}
Warming up --------------------------------------
      master_version   140.839k i/100ms
        fast_version   175.639k i/100ms
Calculating -------------------------------------
      master_version      2.683M (± 7.1%) i/s -     13.380M in   5.013447s
        fast_version      3.988M (±10.1%) i/s -     19.847M in   5.039580s

Comparison:
        fast_version:  3988340.3 i/s
      master_version:  2683336.2 i/s - 1.49x  slower

delete
master_version
{:FREE=>-5003, :T_STRING=>3003, :T_MATCH=>999, :T_IMEMO=>1000}
fast_version
{:FREE=>-3002, :T_STRING=>1001, :T_MATCH=>1000, :T_IMEMO=>1000}
Warming up --------------------------------------
      master_version    47.221k i/100ms
        fast_version    44.153k i/100ms
Calculating -------------------------------------
      master_version    597.881k (±11.4%) i/s -      2.975M in   5.047200s
        fast_version    686.014k (±11.6%) i/s -      3.400M in   5.036564s

Comparison:
        fast_version:   686014.5 i/s
      master_version:   597881.4 i/s - same-ish: difference falls within error
```

This allows us to prevent an extra string allocation when there is a rel
argument and performs better/within error of the key check for other
scenarios such as passing in rel: nil

```ruby
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 "benchmark-ips"
  gem "rails"
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

@hash = {}

def master_version
  "#{@hash["rel"]} nofollow".lstrip
end

def key_version
  if @hash.key?("rel")
    "#{@hash["rel"]} nofollow".lstrip
  else
    "nofollow"
  end
end

def present_version
  if @hash["rel"].present?
    "#{@hash["rel"]} nofollow"
  else
    "nofollow".freeze
  end
end

def nil_version
  if @hash["rel"].nil?
    "nofollow".freeze
  else
    "#{@hash["rel"]} nofollow"
  end
end

def blank_version
  if @hash["rel"].blank?
    "nofollow".freeze
  else
    "#{@hash["rel"]} nofollow"
  end
end

def test
  puts "master_version"
  puts allocate_count { 1000.times { master_version } }
  puts "key_version"
  puts allocate_count { 1000.times { key_version } }
  puts "present_version"
  puts allocate_count { 1000.times { present_version } }
  puts "nil_version"
  puts allocate_count { 1000.times { nil_version } }
  puts "blank_version"
  puts allocate_count { 1000.times { blank_version } }

  Benchmark.ips do |x|
    x.report("master_version")  { master_version }
    x.report("key_version")     { key_version }
    x.report("present_version") { present_version }
    x.report("nil_version")     { nil_version }
    x.report("blank_version")     { blank_version }
    x.compare!
  end
end

puts 'no rel key'

test

puts 'rel key with real stuff'

@hash['rel'] = 'hi'.freeze

test

puts 'rel key with nil'

@hash['rel'] = nil

test

puts 'rel key with ""'

@hash['rel'] = ""

test
```

```
no rel key
master_version
{:FREE=>-2818, :T_STRING=>3052}
key_version
{:FREE=>-1}
present_version
{:FREE=>-1}
nil_version
{:FREE=>-1}
blank_version
{:FREE=>-1}
Warming up --------------------------------------
      master_version   124.677k i/100ms
         key_version   227.992k i/100ms
     present_version   208.068k i/100ms
         nil_version   235.272k i/100ms
       blank_version   176.274k i/100ms
Calculating -------------------------------------
      master_version      1.968M (±10.8%) i/s -      9.725M in   5.010763s
         key_version      7.734M (±11.2%) i/s -     38.075M in   5.001613s
     present_version      5.688M (±11.4%) i/s -     28.089M in   5.019560s
         nil_version      6.965M (±10.2%) i/s -     34.585M in   5.024806s
       blank_version      6.139M (±18.7%) i/s -     29.085M in   5.010919s

Comparison:
         key_version:  7734058.3 i/s
         nil_version:  6965050.2 i/s - same-ish: difference falls within error
       blank_version:  6138744.3 i/s - same-ish: difference falls within error
     present_version:  5688248.4 i/s - 1.36x  slower
      master_version:  1967932.3 i/s - 3.93x  slower

rel key with real stuff
master_version
{:FREE=>-2001, :T_STRING=>2000}
key_version
{:FREE=>-2001, :T_STRING=>2000}
present_version
{:FREE=>-1001, :T_STRING=>1000}
nil_version
{:FREE=>-1002, :T_STRING=>1000, :T_IMEMO=>1}
blank_version
{:FREE=>-1001, :T_STRING=>1000}
Warming up --------------------------------------
      master_version    93.351k i/100ms
         key_version    89.747k i/100ms
     present_version    91.963k i/100ms
         nil_version   103.370k i/100ms
       blank_version    74.845k i/100ms
Calculating -------------------------------------
      master_version      2.179M (±21.4%) i/s -     10.362M in   5.044668s
         key_version      2.345M (± 9.8%) i/s -     11.667M in   5.030982s
     present_version      1.738M (±14.8%) i/s -      8.553M in   5.056406s
         nil_version      2.485M (±19.1%) i/s -     11.888M in   5.015940s
       blank_version      1.951M (±12.3%) i/s -      9.580M in   5.011932s

Comparison:
         nil_version:  2484704.1 i/s
         key_version:  2344664.8 i/s - same-ish: difference falls within error
      master_version:  2178975.8 i/s - same-ish: difference falls within error
       blank_version:  1950532.0 i/s - same-ish: difference falls within error
     present_version:  1737866.7 i/s - 1.43x  slower

rel key with nil
master_version
{:FREE=>-3001, :T_STRING=>3000}
key_version
{:FREE=>-3001, :T_STRING=>3000}
present_version
{:FREE=>-1}
nil_version
{:FREE=>-1}
blank_version
{:FREE=>-1}
Warming up --------------------------------------
      master_version   112.655k i/100ms
         key_version   105.048k i/100ms
     present_version   136.219k i/100ms
         nil_version   192.026k i/100ms
       blank_version   184.846k i/100ms
Calculating -------------------------------------
      master_version      1.893M (±12.6%) i/s -      9.238M in   5.002621s
         key_version      1.672M (±13.5%) i/s -      8.194M in   5.021197s
     present_version      4.484M (±20.5%) i/s -     21.114M in   5.002982s
         nil_version      5.294M (±18.1%) i/s -     25.155M in   5.020721s
       blank_version      5.588M (± 6.7%) i/s -     27.912M in   5.019305s

Comparison:
       blank_version:  5588489.6 i/s
         nil_version:  5293929.9 i/s - same-ish: difference falls within error
     present_version:  4484493.7 i/s - same-ish: difference falls within error
      master_version:  1892919.0 i/s - 2.95x  slower
         key_version:  1672343.9 i/s - 3.34x  slower

rel key with ""
master_version
{:FREE=>-2001, :T_STRING=>2000}
key_version
{:FREE=>-2001, :T_STRING=>2000}
present_version
{:FREE=>-1}
nil_version
{:FREE=>-1001, :T_STRING=>1000}
blank_version
{:FREE=>-1}
Warming up --------------------------------------
      master_version   140.499k i/100ms
         key_version   124.738k i/100ms
     present_version   186.659k i/100ms
         nil_version   148.063k i/100ms
       blank_version   178.707k i/100ms
Calculating -------------------------------------
      master_version      1.826M (±24.2%) i/s -      8.289M in   5.026603s
         key_version      1.561M (±15.3%) i/s -      7.609M in   5.005662s
     present_version      3.622M (±19.9%) i/s -     17.173M in   5.042217s
         nil_version      2.438M (±11.5%) i/s -     12.141M in   5.053335s
       blank_version      4.911M (±15.5%) i/s -     23.768M in   5.009106s

Comparison:
       blank_version:  4910741.1 i/s
     present_version:  3622183.5 i/s - same-ish: difference falls within error
         nil_version:  2437606.2 i/s - 2.01x  slower
      master_version:  1825652.2 i/s - 2.69x  slower
         key_version:  1560530.5 i/s - 3.15x  slower
```

`MissingRequestError` is no longer used since 1e2b0ce9.

Do a check if the 'rel' argument is passed in, and simply set it to
'nofollow' if 'rel' was not passed in. This prevents three string
allocations for each call to `link_to` in that scenario. In the scenario
where the 'rel' argument is passed in, performance is around the same as
before as the `key?` check is very fast.

```ruby
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 "benchmark-ips"
  gem "rails"
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

@hash = {}

def master_version
  "#{@hash['rel'.freeze]} nofollow".lstrip
end

def fast_version
  if @hash.key?('rel'.freeze)
    "#{@hash["rel"]} nofollow".lstrip
  else
    "nofollow".freeze
  end
end

puts 'no rel key'

puts "master_version"
puts allocate_count { 1000.times { master_version } }
puts "fast_version"
puts allocate_count { 1000.times { fast_version } }

Benchmark.ips do |x|
  x.report("master_version") { master_version }
  x.report("fast_version")     { fast_version }
  x.compare!
end

puts 'rel key'

@hash['rel'] = 'hi'.freeze

puts "master_version"
puts allocate_count { 1000.times { master_version } }
puts "fast_version"
puts allocate_count { 1000.times { fast_version } }

Benchmark.ips do |x|
  x.report("master_version") { master_version }
  x.report("fast_version")     { fast_version }
  x.compare!
end
```

```
no rel key
master_version
{:FREE=>-2791, :T_STRING=>3052}
fast_version
{:FREE=>-1}
Warming up --------------------------------------
      master_version    80.324k i/100ms
        fast_version   200.262k i/100ms
Calculating -------------------------------------
      master_version      2.049M (±11.9%) i/s -     10.121M in   5.025613s
        fast_version      6.645M (±21.3%) i/s -     29.439M in   5.007488s

Comparison:
        fast_version:  6644506.3 i/s
      master_version:  2048833.0 i/s - 3.24x  slower

rel key
master_version
{:FREE=>-2001, :T_STRING=>2000}
fast_version
{:FREE=>-2001, :T_STRING=>2000}
Warming up --------------------------------------
      master_version   155.673k i/100ms
        fast_version   106.515k i/100ms
Calculating -------------------------------------
      master_version      2.652M (±20.4%) i/s -     12.610M in   5.036494s
        fast_version      2.237M (±16.8%) i/s -     10.865M in   5.035366s

Comparison:
      master_version:  2651702.2 i/s
        fast_version:  2237470.6 i/s - same-ish: difference falls within error
```

This basically reverts c4d1a4ef

Follow up of #30862.

Colons, periods, etc. can also be included in id.
The sanitize_to_id method does not remove them.

When puma/puma#1403 is merged Puma will support the Early Hints status
code for sending assets before a request has finished.

While the Early Hints spec is still in draft, this PR prepares Rails to
allowing this status code.

If the proxy server supports Early Hints, it will send H2 pushes to the
client.

This PR adds a method for setting Early Hints Link headers via Rails,
and also automatically sends Early Hints if supported from the
`stylesheet_link_tag` and the `javascript_include_tag`.

Once puma supports Early Hints the `--early-hints` argument can be
passed to the server to enable this or set in the puma config with
`early_hints(true)`. Note that for Early Hints to work
in the browser the requirements are 1) a proxy that can handle H2,
and 2) HTTPS.

To start the server with Early Hints enabled pass `--early-hints` to
`rails s`.

This has been verified to work with h2o, Puma, and Rails with Chrome.

The commit adds a new option to the rails server to enable early hints
for Puma.

Early Hints spec:
https://tools.ietf.org/html/draft-ietf-httpbis-early-hints-04

[Eileen M. Uchitelle, Aaron Patterson]

Currently `:api:` tag has leaked on the doc directly since RDoc doesn't
support `:api:` tag directive.

http://api.rubyonrails.org/v5.1/classes/AbstractController/Rendering.html

So `:api: private` doesn't work as expected. We are using `:nodoc:` for
the purpose.

Related #13989.

`ActionView::Helpers::Tags::Base` has `@object` and
all passed arguments for

* `#value`
* `#value_before_type_cast`
* `#value_came_from_user?`

are `@object`, so we do not need to pass arguments in this case.

We do not use double assign since 61f92f8b.

`def a() x = x = 1; end` warns since Ruby 2.5 (r59585)

Don't use remove_method or remove_possible_method just before a new
definition: at best the purpose is unclear, and at worst it creates a
race condition.

Instead, prefer redefine_method when practical, and
silence_redefinition_of_method otherwise.

Follow up of #30213

Add back a bit about a resource oriented style of routing.

- Auto-generating content from the filename of an image is not suitable
  alternative text; alt text that isn't fully considered can be
  distracting and fatiguing for screen readers users (blind, low vision,
  dyslexic people).
- Setting a filename fallback short circuits screen reader default
  behavior and configuration for blank descriptions.
- Setting poor defaults also creates false negatives for accessibility
  linting and testing software, that makes it harder to improve
  application accessibility.

***

- After this change, if authors leave images without alt text, screen
  readers will fallback to default behavior for missing alt text.
- Also with this change, Automated linting and testing tools will
  correctly generate warnings.

[Fixes #30096]

refs: https://github.com/rails/rails/pull/30161

```
$ echo "+@size+" | rdoc --pipe
<p>+@size+</p>

$ echo "<tt>@size</tt>" | rdoc --pipe
<p><code>@size</code></p>
```

[ci skip]

[ci skip]

The `@` ivar format doesn’t work with RDoc's `+` code formatting; needs `<tt>`.

[ci skip]

* Extend image_tag to accept ActiveStorage's Attachments and Variants

* Flip resolve_image_source around

* Add tests for the new use-cases of image_tag

* Remove the higher-level test

* Update image_tag documentation

* Add error states into the test suite

* Re-raise polymorhic_url's NoMethodError as ArgumentError

* delegate_missing_to will raise DelegationError instead of NoMethodError