Action View: Reduce public API of tag helper

The `TagBuilder` instance returned by the
[ActionView::Helpers::TagHelper#tag][] method has the ability to build
various HTML elements through its reliance on `method_missing`. The
magic of that instance hinges on the fact that it has a **minimal**
public interface, and transforms missing methods names into HTML
elements. For example, calling `tag.div` invokes a missing `#div`
method, which renders a `<div>` element.

There are two exceptional cases:

* `tag.p` is defined, since the existing [Kernel#p][] definition would
  prevent the underlying `#method_missing` invocation
* `tag.attributes` is a defined method to transform `Hash` instances and
  keyword arguments in HTML attribute strings

In addition to those two _intentional_ exceptions, there are also
several methods that are incidentally part of the public interface:

* `#tag_string`
* `#content_tag_string`
* `#tag_options`
* `#boolean_tag_option`
* `#tag_option`

Along with those methods, the class also includes [OutputSafetyHelper][]
and [CaptureHelper][], which expand surface area of the class's public
interface even further.

While it's unlikely that these methods would collide with method
invocations intended to construct HTML elements, they still impact that
design of the object.

The "public" nature of the `TagBuilder` interface has some subtle
nuances. While it **is** marked with `:nodoc:`, instances are returned
by a public `tag` method, despite it being considered a private class
only meant for internal consumption.

That same is true for the incidentally public methods mentioned above:
no consuming applications should be invoking `#tag_string` or
`#tag_options`. While that's true, those methods _are_ being invoked
**directly** by other Action View classes.

This commit removes those invocations, and instead replaces them with
public method calls.

In cases where the tag name is statically know ahead of time, they're
replaced with calls to that method (for example, `content_tag(:option)`
becomes `tag.option`). When they're dynamic, they're replaced by calls
to [public_send][] (for example, `tag(name)` becomes
`tag.public_send(name)`).

The majority of these changes are painless, with one exception. Some
calls to the `#tag` helper also pass an `open` positional argument that
isn't part of the `TagBuilder` class's public interface. As a result,
that becomes slightly more complicated, and requires some String
mutation to continue to pass the test suite.

This commit also removes the `OutputSafetyHelper` and `CaptureHelper`
modules from the class, and delegates to the methods it depended on to
`@view_context`.

Hopefully, calls to `#tag` with positional arguments are less and less
common, since the documentation describes it as a [Legacy Syntax][]
marked for deprecation in future versions of Rails.

[Kernel#p]: https://ruby-doc.org/3.2.2/Kernel.html#method-i-p
[ActionView::Helpers::TagHelper#tag]: https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-tag
[public_send]: https://ruby-doc.org/3.2.2/Object.html#method-i-public_send
[Legacy Syntax]: https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-tag-label-Legacy+syntax
[OutputSafetyHelper]: https://api.rubyonrails.org/classes/ActionView/Helpers/OutputSafetyHelper.html
[CaptureHelper]: https://api.rubyonrails.org/classes/ActionView/Helpers/CaptureHelper.html

Author: seanpdoyle

actionview/lib/action_view/helpers/form_options_helper.rb

@@ -371,7 +371,7 @@ def options_for_select(container, selected = nil)
           html_attributes[:disabled] ||= disabled && option_value_selected?(value, disabled)
           html_attributes[:value] = value
 
-          tag_builder.content_tag_string(:option, text, html_attributes)
+          tag_builder.option(text, **html_attributes)
         end.join("\n").html_safe
       end
 

actionview/lib/action_view/helpers/tag_helper.rb

@@ -44,9 +44,6 @@ module TagHelper
       PRE_CONTENT_STRINGS["textarea"] = "\n"
 
       class TagBuilder # :nodoc:
-        include CaptureHelper
-        include OutputSafetyHelper
-
         def self.define_element(name, code_generator:, method_name: name)
           return if method_defined?(name)
 
@@ -226,17 +223,7 @@ def attributes(attributes)
           tag_options(attributes.to_h).to_s.strip.html_safe
         end
 
-        def tag_string(name, content = nil, options, escape: true, &block)
-          content = @view_context.capture(self, &block) if block
-
-          content_tag_string(name, content, options, escape)
-        end
-
-        def self_closing_tag_string(name, options, escape = true, tag_suffix = " />")
-          "<#{name}#{tag_options(options, escape)}#{tag_suffix}".html_safe
-        end
-
-        def content_tag_string(name, content, options, escape = true)
+        def content_tag_string(name, content, options, escape = true) # :nodoc:
           tag_options = tag_options(options, escape) if options
 
           if escape && content.present?
@@ -245,7 +232,7 @@ def content_tag_string(name, content, options, escape = true)
           "<#{name}#{tag_options}>#{PRE_CONTENT_STRINGS[name]}#{content}</#{name}>".html_safe
         end
 
-        def tag_options(options, escape = true)
+        def tag_options(options, escape = true) # :nodoc:
           return if options.blank?
           output = +""
           sep    = " "
@@ -266,7 +253,7 @@ def tag_options(options, escape = true)
                   tokens = TagHelper.build_tag_values(v)
                   next if tokens.none?
 
-                  v = safe_join(tokens, " ")
+                  v = @view_context.safe_join(tokens, " ")
                 else
                   v = v.to_s
                 end
@@ -287,28 +274,38 @@ def tag_options(options, escape = true)
           output unless output.empty?
         end
 
-        def boolean_tag_option(key)
-          %(#{key}="#{key}")
-        end
+        private
+          def tag_string(name, content = nil, options, escape: true, &block)
+            content = @view_context.capture(self, &block) if block
 
-        def tag_option(key, value, escape)
-          key = ERB::Util.xml_name_escape(key) if escape
-
-          case value
-          when Array, Hash
-            value = TagHelper.build_tag_values(value) if key.to_s == "class"
-            value = escape ? safe_join(value, " ") : value.join(" ")
-          when Regexp
-            value = escape ? ERB::Util.unwrapped_html_escape(value.source) : value.source
-          else
-            value = escape ? ERB::Util.unwrapped_html_escape(value) : value.to_s
+            content_tag_string(name, content, options, escape)
           end
-          value = value.gsub('"', "&quot;") if value.include?('"')
 
-          %(#{key}="#{value}")
-        end
+          def self_closing_tag_string(name, options, escape = true, tag_suffix = " />")
+            "<#{name}#{tag_options(options, escape)}#{tag_suffix}".html_safe
+          end
+
+          def boolean_tag_option(key)
+            %(#{key}="#{key}")
+          end
+
+          def tag_option(key, value, escape)
+            key = ERB::Util.xml_name_escape(key) if escape
+
+            case value
+            when Array, Hash
+              value = TagHelper.build_tag_values(value) if key.to_s == "class"
+              value = escape ? @view_context.safe_join(value, " ") : value.join(" ")
+            when Regexp
+              value = escape ? ERB::Util.unwrapped_html_escape(value.source) : value.source
+            else
+              value = escape ? ERB::Util.unwrapped_html_escape(value) : value.to_s
+            end
+            value = value.gsub('"', "&quot;") if value.include?('"')
+
+            %(#{key}="#{value}")
+          end
 
-        private
           def prefix_tag_option(prefix, key, value, escape)
             key = "#{prefix}-#{key.to_s.dasherize}"
             unless value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(BigDecimal)

actionview/lib/action_view/helpers/tags/select_renderer.rb

@@ -37,15 +37,15 @@ def add_options(option_tags, options, value = nil)
             if options[:include_blank]
               content = (options[:include_blank] if options[:include_blank].is_a?(String))
               label = (" " unless content)
-              option_tags = tag_builder.content_tag_string("option", content, value: "", label: label) + "\n" + option_tags
+              option_tags = tag_builder.option(content, value: "", label: label) + "\n" + option_tags
             end
 
             if value.blank? && options[:prompt]
               tag_options = { value: "" }.tap do |prompt_opts|
                 prompt_opts[:disabled] = true if options[:disabled] == ""
                 prompt_opts[:selected] = true if options[:selected] == ""
               end
-              option_tags = tag_builder.content_tag_string("option", prompt_text(options[:prompt]), tag_options) + "\n" + option_tags
+              option_tags = tag_builder.option(prompt_text(options[:prompt]), **tag_options) + "\n" + option_tags
             end
 
             option_tags