A string S matches ([.]|\b)html if an only if matches \bhtml:

  * If S matches [.]html, then it matches \bhtml.

  * If S matches \bhtml, then it matches \bhtml.

Reciprocally:

  * If S matches \bhtml, then it matches ([.]|\b)html.

The character class can be removed, and since we are on it we remove the
group too so that it is clear to a reader of the code that there is no
grouping going on.

References #35166.

Co-Authored-By: Ntenderlove <tenderlove@github.com>

`virtual_path` is calculated in the constructor when the Template object
is allocated.  We don't actually need to set it in the `decorate`
method.  That means we can remove the decorate method all together.

This commit ensures that locals are passed in to the template objects
when they are constructed, then removes the `locals=` mutator on the
template object.  This means we don't need to mutate Template objects
with locals in the `decorate` method.

* Don't call inspect from identifier_method_name

* Add locals Template#inspect

Handler, formats, and variant are usually obvious from looking at the
identifier. However it's not uncommon to have different locals for the
same template so we should make that obvious in inspect.

* Add tests for short_identifier and inspect

[John Hawthorn + Rafael Mendonça França]

Templates only have one variant, so we should not store it in an array.
This commit converts `variants` to `variant` and deprecates the plural
accessor

Even if the template is constructed with a `nil` variant, the array it
constructs will never be `empty?`:

  https://github.com/rails/rails/blob/56b030605b4d968077a4ddb96b4ab619e75fb999/actionview/lib/action_view/template.rb#L152

We get an array that is `[nil]`, which is not empty, so this conditional
is never true.

Templates only have one format.  Before this commit, templates would be
constructed with a single element array that contained the format.  This
commit eliminates the single element array and just implements a
`format` method.  This saves one array allocation per template.

Co-Authored-By: Ntenderlove <tenderlove@github.com>

The format should always be exactly one symbol.  Now we don't need to
check whether or not the format is a `Type` in the constructor.

This means we can eliminate nil checks and remove some mutations from
the `decorate` method.

This commit adds a finalizer just to inline templates.  We can't cache
compilation of inline templates because it's possible that people could
have render calls that look like this:

```ruby
loop do
  render inline: "#{rand}"
end
```

and we would cache every one of these different inline templates.  That
would cause a memory leak.  OTOH, we don't need finalizers on regular
templates because we can cache, control, and detect changes to the
template source.

Fixes: #35372

This removes one call to `lookup_context` and also eliminates a
conditional in `_render_template`.

I want to start reducing the calls to `lookup_context`.  That method
caches the lookup context in an ivar, but I would like to cache the
lookup context on the stack.  That way we aren't coupled to the behavior
of the `lookup_context` method.

Currently, `ActionView::Base.new` will raise a `NotImplementedError` when given an instance of `ActionView::PathSet` on initialization. This commit prevents the raised error in favor of a deprecation warning.

We no longer depend on `rendered_format` side effects, so we can remove
this method now. 🎉

This commit introduces "rendered template" and "rendered collection"
objects.  The template renderers can now return a more complex object
than just strings.  This allows the framework to get more information
about the templates that were rendered.  In this commit we use the
rendered template object to set the "rendered_format" on the lookup
context in the controller rather than all the way in the template renderer.
That means we don't need to check the "rendered_format" every time we
render a template, we just do it once after all templates have been
rendered.

Since #35036, the subclasses of `ActionView::Base` requires
the `compiled_method_container`.
This is incompatible. For example, `web-console` use view class that
subclass of `ActionView::Base`, and does not work it now cause of this.

Actually, since it seems that it is only `ActionView::Base` that
`compiled_method_container` is necessary, modified the condition that
emits a warning.

This commit passes the template format to the digestor in order to come
up with a key.  Before this commit, the digestor would depend on the
side effect of the template renderer setting the rendered_format on the
lookup context.  I would like to remove that mutation, so I've changed
this to pass the template format in to the digestor.

I've introduced a new instance variable that will be alive during a
template render.  When the template is being rendered, it pushes the
current template on to a stack, setting `@current_template` to the
template currently being rendered.  When the cache helper asks the
digestor for a key, it uses the format of the template currently on the
stack.

Currently `csp_meta_tag` generates `name` attribute only.
However, in libraries like `Material-UI` and `JSS`, expect that the meta tag
that contains the nonce with `property` attribute.

https://material-ui.com/css-in-js/advanced/#how-does-one-implement-csp
https://github.com/cssinjs/jss/blob/master/docs/csp.md

This patch allows `csp_meta_tag` to specify arbitrary options and
allows `nonce` to be passed to those libraries.

Cached collections only work if there is one template.  If there are
more than one templates, the caching mechanism doesn't have a key.

https://codeclimate.com/github/rails/rails/pull/35254

This commit keeps a stack of lookup contexts on the ActionView::Base
instance.  If a format is passed to render, we instantiate a new lookup
context and push it on the stack, that way any child calls to "render"
will use the same format information as the parent.  This also isolates
"sibling" calls to render (multiple calls to render in the same
template).

Fixes #35222 #34138