brut 0.0.13 → 0.0.21

data/lib/brut/framework/project_environment.rb

@@ -1,5 +1,7 @@
-# Manages the interpretation of dev/test/prod. The canonical instance is available via `Brut.container.project_env`.  Generally, you
-# should avoid basing logic on this, or at least contain the conditional behavior to the configuration values. But, you do you.
+# Manages the interpretation of dev/test/prod. The canonical instance is available 
+# via `Brut.container.project_env`.  Generally, you
+# should avoid basing logic on this, or at least contain the conditional behavior
+# to the configuration values. But, you do you.
 class Brut::Framework::ProjectEnvironment
   # Create the project environment based on the string
   # @param [String] string_value value from e.g. `ENV["RACK_ENV"]` to use to set the environment
@@ -21,6 +23,8 @@ class Brut::Framework::ProjectEnvironment
   # @return [true|false] true is this is production
   def production?  = @value == "production"
 
+  def staging? = raise "Staging is a lie, please consider feature flags or literally any other way to manage in-development features of your app. I promise you, you will regret ever having to do anything with a staging server"
+
   # @return [String] the string value (which should be suitable for the constructor)
   def to_s = @value
 end

data/lib/brut/framework.rb

@@ -1,5 +1,5 @@
 module Brut
-  # The Framework module holds a lot of Brut's internals, or classes that cut across the back end and front end.
+  # Namespace for Brut's internals as well as classes that aren't strictly front or back end.
   module Framework
     autoload(:App,"brut/framework/app")
     autoload(:Config,"brut/framework/config")

data/lib/brut/front_end/asset_path_resolver.rb

@@ -0,0 +1,15 @@
+class Brut::FrontEnd::AssetPathResolver
+  def initialize(metadata_file:)
+    @metadata_file = metadata_file
+    reload
+  end
+
+  def reload
+    @asset_metadata = Brut::FrontEnd::AssetMetadata.new(asset_metadata_file: @metadata_file)
+    @asset_metadata.load!
+  end
+
+  def resolve(path)
+    @asset_metadata.resolve(path)
+  end
+end

data/lib/brut/front_end/component.rb

@@ -1,6 +1,4 @@
-require "json"
-require "rexml"
-require_relative "template"
+require "phlex"
 
 # Components holds Brut-provided components that are of general use to any web app
 module Brut::FrontEnd::Components
@@ -8,87 +6,124 @@ module Brut::FrontEnd::Components
   autoload(:Input,"brut/front_end/components/input")
   autoload(:Inputs,"brut/front_end/components/input")
   autoload(:I18nTranslations,"brut/front_end/components/i18n_translations")
-  autoload(:Time,"brut/front_end/components/time")
+  autoload(:TimeTag,"brut/front_end/components/time_tag")
   autoload(:PageIdentifier,"brut/front_end/components/page_identifier")
   autoload(:LocaleDetection,"brut/front_end/components/locale_detection")
   autoload(:ConstraintViolations,"brut/front_end/components/constraint_violations")
   autoload(:Traceparent,"brut/front_end/components/traceparent")
+
+  extend Phlex::Kit
 end
 
 # A Component is the top level class for managing the rendering of 
-# content.  A component is essentially an ERB template and a class whose
-# instance servces as it's binding. It is very similar to a View Component, though
-# not quite as fancy.
+# content.  It is a Phlex component with additional features.
+# Components are the primary mechanism for managing view complexity and managing
+# markup re-use in Brut.
+#
+# To create a component, subclass this class (or, more likely, your app's `AppComponent`) and
+# provide an initializer that accepts keyword arguments.  The names of these arguments will be used to locate the
+# values that Brut will pass in when creating your component object.
 #
-# When subclassing this to create a component, your initializer's signature will determine what data
-# is required for your component to work.  It can be anything, just keep in mind that any page or component
-# that uses your component must be able to provide those values.
+# Consult Brut's documentation on keyword injection to know what values you may use and how values are located.
 #
-# If your component does not override {#render} (which, generally, it won't), an ERB file is expected to exist alongside it in the
-# app.  For example, if you have a component named `Auth::LoginButtonComponent`, it would expected to be in
-# `app/src/front_end/components/auth/login_button_component.rb`.  Thus, Brut will also expect
-# `app/src/front_end/components/auth/login_button_component.html.erb` to exist as well. That ERB file is used with an instance of your
-# component's class to render the component's HTML.
+# Becuase this is a Phlex component, you must implement `view_template` and make calls to Phlex's API to create
+# the markup for your component.
 #
-# @see Brut::FrontEnd::Component::Helpers
-class Brut::FrontEnd::Component
-  using Brut::FrontEnd::Templates::HTMLSafeString::Refinement
+class Brut::FrontEnd::Component < Phlex::HTML
 
+  include Brut::Framework::Errors
+  include Brut::I18n::ForHTML
 
-  # @!visibility private
-  class AssetPathResolver
-    def initialize(metadata_file:)
-      @metadata_file = metadata_file
-      reload
-    end
+  register_element :brut_confirm_submit
+  register_element :brut_confirmation_dialog
+  register_element :brut_cv
+  register_element :brut_ajax_submit
+  register_element :brut_autosubmit
+  register_element :brut_confirm_submit
+  register_element :brut_confirmation_dialog
+  register_element :brut_cv
+  register_element :brut_cv_messages
+  register_element :brut_copy_to_clipboard
+  register_element :brut_form
+  register_element :brut_i18n_translation
+  register_element :brut_locale_detection
+  register_element :brut_message
+  register_element :brut_tabs
+  register_element :brut_tracing
+
+  # Inline an SVG that is part of your app.
+  #
+  # @param [String] svg path to the SVG file, relative to where SVGs are
+  #        stored, which is `app/src/front_end/svgs` or where `Brut.container.svg_locator` is
+  #        looking
+  #
+  # @see Brut::FrontEnd::InlineSvgLocator
+  def inline_svg(svg)
+    Brut.container.svg_locator.locate(svg).then { |svg_file|
+      File.read(svg_file)
+    }.then { |svg_content|
+      raw(safe(svg_content))
+    }
+  end
 
-    def reload
-      @asset_metadata = Brut::FrontEnd::AssetMetadata.new(asset_metadata_file: @metadata_file)
-      @asset_metadata.load!
-    end
+  # Include a {Brut::FrontEnd::Components::TimeTag} in your markup.
+  def time_tag(timestamp:nil,**component_options, &contents)
+    args = component_options.merge(timestamp:)
+    render Brut::FrontEnd::Components::TimeTag.new(**args,&contents)
+  end
 
-    def resolve(path)
-      @asset_metadata.resolve(path)
-    end
+  # Include a {Brut::FrontEnd::Components::FormTag} in your markup.
+  def form_tag(**args, &block)
+    render Brut::FrontEnd::Components::FormTag.new(**args,&block)
   end
 
-  # Allows helpers that create components to pass the block they were given to the component.
-  # This can be read for the purposes of nested components passing a yielded block to an inner
-  # component
-  attr_accessor :yielded_block
+  # Include a component in your markup that you would like Brut to instantiate.
+  # This will use keyword injection to create the component, which means that if the component
+  # doesn't require any data from this component, you do not need to pass through those values.
+  # For example, you may have a component that renders the flash message.  To avoid requiring your component to
+  # be passed the flash, a global component can be injected with it from Brut.
+  def global_component(component_klass)
+    render Brut::FrontEnd::RequestContext.inject(component_klass)
+  end
 
-  # Intended to be called by subclasses to render the yielded block wherever it makes sense in their markup.
-  def render_yielded_block
-    if @yielded_block
-      @yielded_block.().html_safe!
-    else
-      raise Brut::Framework::Errors::Bug, "No block was yielded to #{self.class.name}"
-		end
-	end
+  # include a {Brut::FrontEnd::Components::ConstraintViolations} in your markup.
+  def constraint_violations(form:, input_name:, index: nil, message_html_attributes: {}, **html_attributes)
+    render(
+      Brut::FrontEnd::Components::ConstraintViolations.new(
+        form:,
+        input_name:,
+        index:,
+        message_html_attributes:,
+        **html_attributes
+      )
+    )
+  end
 
-  # The core method of a component. This is expected to return
-  # a string to be sent as a response to an HTTP request. Generally, you should not call this method
-  # as it is intended to be called from {Brut::FrontEnd::Component::Helpers#component}.
-  #
-  # This implementation uses the associated template for the component
-  # and sends it through ERB using this component as
-  # the binding.
-  #
-  # You may override this method to provide your own HTML for the component. In doing so, you can add
-  # keyword args for data from the `RequestContext` you wish to receive. See {Brut::FrontEnd::RequestContext#as_method_args}.
-  #
-  # @return [Brut::FrontEnd::Templates::HTMLSafeString] string containing the component's HTML.
-  def render
-    Brut.container.instrumentation.span("#{self.class} render") do |span|
-      span.add_prefixed_attributes("brut", type: :component, class: self.class.name)
-      Brut.container.component_locator.locate(self.template_name).
-        then { Brut::FrontEnd::Template.new(it) }.
-        then { it.render_template(self).html_safe! }
-    end
+  # Create an HTML input tag for the given input of a form.  This is a convieniece method
+  # that calls {Brut::FrontEnd::Components::Inputs::TextField.for_form_input}.
+  def input_tag(form:, input_name:, index: nil, **html_attributes)
+    render(
+      Brut::FrontEnd::Components::Inputs::TextField.for_form_input(
+        form:,
+        input_name:,
+        index:,
+        html_attributes:)
+    )
   end
 
-  # For components that are private to a page, this returns the name of the page they are a part of.
-  # This is used to allow a component to render a page's I18n strings.
+  # The name of this component, used for debugging and other purposes. Do not
+  # override this.
+  def self.component_name = self.name
+
+  # Calls {.component_name} as a convienience. Do not override this.
+  def component_name = self.class.component_name
+
+  # For page components (components that are private/nested to a page), this returns
+  # the name of the page in which they are nested. This is mostly useful for
+  # locating page-specific I18n translations.
+  #
+  # @raise If this component is not nested inside a page
+  # @see Brut::I18n::BaseMethods#t
   def page_name
     @page_name ||= begin
                      page = self.class.name.split(/::/).reduce(Module) { |accumulator,class_path_part|
@@ -100,192 +135,12 @@ class Brut::FrontEnd::Component
                      }
                      if page.ancestors.include?(Brut::FrontEnd::Page)
                        page.name
+                     elsif page.respond_to?(:page_name)
+                       page.page_name
                      else
                        raise "#{self.class} is not nested inside a page, so #page_name should not have been called"
                      end
                    end
   end
 
-  # Used when an I18n string needs access to component-specific translations
-  def self.component_name = self.name
-  # (see .component_name)
-  def component_name = self.class.component_name
-
-  # Helper methods that subclasses can use.
-  # This is a separate module to distinguish the public
-  # interface of this class (`render`) from these helper methods
-  # that are useful to subclasses and their templates.
-  #
-  # This is not intended to be extracted or used outside this class!
-  module Helpers
-
-    # Render a component. This is the primary way in which
-    # view re-use happens.  The component instance will be able to locate its
-    # HTML template and render itself.  {#render} is called with variables from the `RequestContext`
-    # as described in {Brut::FrontEnd::RequestContext#as_method_args}
-    #
-    # @param [Brut::FrontEnd::Component|Class] component_instance instance of the component to render. If a `Class`
-    #                                          is passed, it must extend {Brut::FrontEnd::Component}. It will created
-    #                                          based on the logic described in {Brut::FrontEnd::RequestContext#as_constructor_args}.
-    #                                          You would do this if your component needs to be injected with information 
-    #                                          not available to the page or component that is using it.
-    # @yield this block is passed to the `component_instance` via {#yielded_block=}.
-    #
-    # @return [Brut::FrontEnd::Templates::HTMLSafeString] of the rendered component.
-    def component(component_instance,&block)
-      component_name = component_instance.kind_of?(Class) ? component_instance.name : component_instance.class.name
-      Brut.container.instrumentation.span("component #{component_name}") do |span|
-        if component_instance.kind_of?(Class)
-          if !component_instance.ancestors.include?(Brut::FrontEnd::Component)
-            raise ArgumentError,"#{component_instance} is not a component and cannot be created"
-          end
-          component_instance = Thread.current.thread_variable_get(:request_context).
-            then { |request_context| request_context.as_constructor_args(component_instance,request_params: nil)
-            }.then { |constructor_args| component_instance.new(**constructor_args) }
-          span.add_prefixed_attributes("brut", "global_component" => true)
-        else
-          span.add_prefixed_attributes("brut", "global_component" => false)
-        end
-        if !block.nil?
-          component_instance.yielded_block = block
-        end
-        Thread.current.thread_variable_get(:request_context).then {
-          it.as_method_args(component_instance,:render,request_params: nil, form: nil)
-        }.then { |render_args|
-          component_instance.render(**render_args).html_safe!
-        }
-      end
-    end
-
-    # Inline an SVG into the page.
-    #
-    # @param [String] svg name of an SVG file, relative to where SVGs are stored.
-    def svg(svg)
-      Brut.container.svg_locator.locate(svg).then { |svg_file|
-        File.read(svg_file).html_safe!
-      }
-    end
-
-    # Given a public path to an asset—the value you'd use in HTML—return
-    # the same value, but with any content hashes that are part of the filename.
-    def asset_path(path) = Brut.container.asset_path_resolver.resolve(path)
-
-    # (see Brut::FrontEnd::Components::FormTag)
-    def form_tag(route_params: {}, **html_attributes,&contents)
-      component(Brut::FrontEnd::Components::FormTag.new(route_params:, **html_attributes,&contents))
-    end
-
-    # Creates a {Brut::FrontEnd::Components::Time}.
-    #
-    # @param timestamp [Time] the timestamp to format/render. Mutually exclusive with `date`.
-    # @param date [Date] the date to format/render. Mutually exclusive with `timestamp`.
-    # @param component_options [Hash] keyword arguments to pass to {Brut::FrontEnd::Components::Time#initialize}
-    # @yield See {Brut::FrontEnd::Components::Time#initialize}
-    def time_tag(timestamp:nil,date:nil, **component_options, &contents)
-      args = component_options.merge(timestamp:,date:)
-      component(Brut::FrontEnd::Components::Time.new(**args,&contents))
-    end
-
-    # Render the {Brut::FrontEnd::Components::ConstraintViolations} component for the given form's input.
-    def constraint_violations(form:, input_name:, index: nil, message_html_attributes: {}, **html_attributes)
-      component(
-        Brut::FrontEnd::Components::ConstraintViolations.new(
-          form:,
-          input_name:,
-          index:,
-          message_html_attributes:,
-          **html_attributes
-        )
-      )
-    end
-
-    # Create an HTML input tag for the given input of a form.  This is a convieniece method
-    # that calls {Brut::FrontEnd::Components::Inputs::TextField.for_form_input}.
-    def input_tag(form:, input_name:, index: nil, **html_attributes)
-      component(Brut::FrontEnd::Components::Inputs::TextField.for_form_input(form:,input_name:,index:,html_attributes:))
-    end
-
-    # Indicates a given string is safe to render directly as HTML. No escaping will happen.
-    #
-    # @param [String] string a string that should be marked as HTML safe
-    def html_safe!(string)
-      string.html_safe!
-    end
-
-    # @!visibility private
-    VOID_ELEMENTS = [
-      :area,
-      :base,
-      :br,
-      :col,
-      :embed,
-      :hr,
-      :img,
-      :input,
-      :link,
-      :meta,
-      :source,
-      :track,
-      :wbr,
-    ]
-
-    # Generate an HTML element safely in code.  This is useful if you don't want to create
-    # a separate ERB file, but still want to create a component.
-    #
-    # @param [String|Symbol] tag_name the name of the HTML tag to create.
-    # @param [Hash] html_attributes all the HTML attributes you wish to include in the element that is generated.  Values that
-    #                                 are `true` will be included without a value, and values that are `false` will be omitted.
-    # @yield Called to get any contents that should be put into this tag.  Void elements as defined by W3C may not have a block.
-    #
-    # @example Void element
-    #
-    #     html_tag(:img, src: "trellick.png") # => <img src="trellic.png">
-    #
-    # @example Nested elements
-    #
-    #     html_tag(:nav, class: "flex items-center") do
-    #       html_tag(:a, href="/") { "Home" } + 
-    #       html_tag(:a, href="/about") { "About" } + 
-    #       html_tag(:a, href="/contact") { "Contact" }
-    #     end
-    def html_tag(tag_name, **html_attributes, &block)
-      tag_name = tag_name.to_s.downcase.to_sym
-      attributes_string = html_attributes.map { |key,value|
-        [
-          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
-          value
-        ]
-      }.select { |key,value|
-        !value.nil?
-      }.map { |key,value|
-        if value == true
-          key
-        elsif value == false
-          ""
-        else
-          REXML::Attribute.new(key,value).to_string
-        end
-      }.join(" ")
-      contents = (block.nil? ? nil : block.()).to_s
-      if VOID_ELEMENTS.include?(tag_name)
-        if !contents.empty?
-          raise ArgumentError,"#{tag_name} may not have child nodes"
-        end
-        html_safe!(%{<#{tag_name} #{attributes_string}>})
-      else
-        html_safe!(%{<#{tag_name} #{attributes_string}>#{contents}</#{tag_name}>})
-      end
-    end
-  end
-  include Helpers
-  include Brut::I18n::ForHTML
-
-private
-
-  def binding_scope = binding
-
-  # Determines the canonical name/location of the template used for this
-  # component.  It does this base do the class name. CameCase is converted
-  # to snake_case. 
-  def template_name = RichString.new(self.class.name).underscorized.to_s.gsub(/^components\//,"")
 end

data/lib/brut/front_end/components/constraint_violations.rb

@@ -17,7 +17,7 @@
 # Note that if you are using `<brut-form>` then `<brut-cv>` elements will be inserted into the `<brut-cv-messages>` element, however
 # they will not have the `server-side` attribute.
 #
-# You will most commonly use this component via {Brut::FrontEnd::Component::Helpers#constraint_violations}.
+# You will most commonly use this component via {Brut::FrontEnd::Component#constraint_violations}.
 class Brut::FrontEnd::Components::ConstraintViolations < Brut::FrontEnd::Component
   # Create a new ConstraintViolations component
   #
@@ -31,27 +31,27 @@ class Brut::FrontEnd::Components::ConstraintViolations < Brut::FrontEnd::Compone
     @input_name              =  input_name
     @array                   = !index.nil?
     @index                   =  index || 0
-    @html_attributes         =  html_attributes
-    @message_html_attributes =  message_html_attributes
+    @html_attributes         =  html_attributes.map {|name,value| [ name.to_sym, value ] }.to_h
+    @message_html_attributes =  message_html_attributes.map {|name,value| [ name.to_sym, value ] }.to_h
   end
 
-  def render
+  def view_template
     html_attributes = {
-      "input-name": @array ? "#{@input_name}[]" : @input_name
+      "input-name": @array ? "#{@input_name}[]" : @input_name.to_s,
     }.merge(@html_attributes)
 
     message_html_attributes = {
       "server-side": true,
     }.merge(@message_html_attributes)
 
-    html_tag("brut-cv-messages", **html_attributes) do
+    brut_cv_messages(**html_attributes) do
       @form.input(@input_name, index: @index).validity_state.select { |constraint|
         !constraint.client_side?
-      }.map { |constraint|
-        html_tag("brut-cv",**message_html_attributes) do
-          t("cv.be.#{constraint}", **constraint.context).capitalize
+      }.each do |constraint|
+        brut_cv(**message_html_attributes) do
+          t("cv.be.#{constraint}", **constraint.context)
         end
-      }.join("\n")
+      end
     end
   end
 end

data/lib/brut/front_end/components/form_tag.rb

@@ -1,5 +1,4 @@
-require "rexml"
-# Represents a `<form>` HTML element that includes a CSRF token as needed. You likely want to use this class via the {Brut::FrontEnd::Component::Helpers#form_tag} method.
+# Represents a `<form>` HTML element that includes a CSRF token as needed. You likely want to use this class via the {Brut::FrontEnd::Component#form_tag} method.
 class Brut::FrontEnd::Components::FormTag < Brut::FrontEnd::Component
   # Creates the form surrounding the contents of the block yielded to it. If the form's action is a POST, it will include a CSRF token.
   # If the form's action is GET, it will not.
@@ -22,7 +21,7 @@ class Brut::FrontEnd::Components::FormTag < Brut::FrontEnd::Component
   # @option html_attributes [Class|Brut::FrontEnd::Form] :for the form object or class representing this HTML form *or* the class of a handler the form should submit to. If you pass this, you may not pass the HTML attributes `:action` or `:method`. Both will be derived from this object.
   # @option html_attributes [String] «any-other-key» attributes to set on the `<form>` tag
   # @yield No parameters given. This is expected to return additional markup to appear inside the `<form>` element.
-  def initialize(route_params: {}, **html_attributes,&contents)
+  def initialize(route_params: {}, **html_attributes)
     form_class = html_attributes.delete(:for) # Cannot be a keyword arg, since for is a reserved word
     if !form_class.nil?
       if form_class.kind_of?(Brut::FrontEnd::Form)
@@ -49,34 +48,23 @@ class Brut::FrontEnd::Components::FormTag < Brut::FrontEnd::Component
 
     @include_csrf_token = http_method.post?
     @csrf_token_omit_reasoning = http_method.get? ? "because this form's action is a GET" : nil
-    @attributes = html_attributes
-    @contents = contents
+    @attributes = html_attributes.merge(method: http_method)
   end
 
-  # @!visibility private
-  def render
-    attribute_string = @attributes.map { |key,value|
-      key = key.to_s
-      if value == true
-        key
-      elsif value == false
-        ""
-      else
-        REXML::Attribute.new(key,value).to_string
+  def view_template
+    form(**@attributes) do
+      if @include_csrf_token
+        render Brut::FrontEnd::RequestContext.inject(Brut::FrontEnd::Components::Inputs::CsrfToken)
+      elsif Brut.container.project_env.development?
+        comment do
+          "CSRF Token omitted #{@csrf_token_omit_reasoning} (this message only appears in development)"
+        end
       end
-    }.join(" ")
-    csrf_token_component = if @include_csrf_token
-                             component(Brut::FrontEnd::Components::Inputs::CsrfToken)
-                           elsif Brut.container.project_env.development?
-                             html_safe!("<!-- CSRF Token omitted #{@csrf_token_omit_reasoning} (this message only appears in development) -->")
-                           else
-                             ""
-                           end
-    %{
-      <form #{attribute_string}>
-        #{ csrf_token_component }
-        #{ @contents.() }
-      </form>
-    }
+      if block_given?
+        yield
+      end
+    end
   end
+
+
 end

data/lib/brut/front_end/components/i18n_translations.rb

@@ -1,5 +1,3 @@
-require "rexml"
-
 # Produces `<brut-i18n-translation>` entries for the given values. This is used for client-side constraint violation messaging with
 # JavaScript.  The `<brut-constraint-violation-message>` tag uses these keys to produce messages on the client.
 #
@@ -39,13 +37,13 @@ class Brut::FrontEnd::Components::I18nTranslations < Brut::FrontEnd::Component
   end
 
   # @!visibility private
-  def render
+  def view_template
     values = ::I18n.t(@i18n_key_root)
     if values.kind_of?(String)
       values = { "" => values }
     end
 
-    values.map { |key,value|
+    values.each do |key,value|
       if !value.kind_of?(String)
         raise "Key #{key} under #{@i18n_key_root} maps to a #{value.class} instead of a String. For #{self.class} to work, the value must be a String"
       end
@@ -54,16 +52,17 @@ class Brut::FrontEnd::Components::I18nTranslations < Brut::FrontEnd::Component
                  else
                    "#{@i18n_key_root}.#{key}"
                  end
-      attributes = [
-        REXML::Attribute.new("key",i18n_key),
-        REXML::Attribute.new("value",value.to_s),
-      ]
+      attributes = {
+        key: i18n_key,
+        value: value.to_s,
+      }
       if !Brut.container.project_env.production?
-        attributes << REXML::Attribute.new("show-warnings",true)
-        attributes << REXML::Attribute.new("id","brut-18n-#{key}")
+        attributes[:show_warnings] = true
+        attributes[:id] = "brut-18n-#{key}"
       end
-      attribute_string = attributes.map(&:to_string).join(" ")
-      %{<brut-i18n-translation #{attribute_string}></brut-i18n-translation>}
-    }.join("\n")
+
+      brut_i18n_translation(**attributes)
+
+    end
   end
 end

data/lib/brut/front_end/components/input.rb

@@ -1,4 +1,3 @@
-require "rexml"
 module Brut::FrontEnd::Components
 
   # Holds components designed to render HTML `<input>` and other form components.

data/lib/brut/front_end/components/inputs/csrf_token.rb

@@ -1,10 +1,10 @@
 # Renders a hidden field for a form that contains the current CSRF token. You only need
-# to use this directly if you are building a form without {Brut::FrontEnd::Component::Helpers#form_tag}.
+# to use this directly if you are building a form without {Brut::FrontEnd::Component#form_tag}.
 class Brut::FrontEnd::Components::Inputs::CsrfToken < Brut::FrontEnd::Components::Input
   def initialize(csrf_token:)
     @csrf_token = csrf_token
   end
-  def render
-    html_tag(:input, type: "hidden", name: "authenticity_token", value: @csrf_token)
+  def view_template
+    input(type: "hidden", name: "authenticity_token", value: @csrf_token)
   end
 end

data/lib/brut/front_end/components/inputs/radio_button.rb

@@ -14,18 +14,18 @@ class Brut::FrontEnd::Components::Inputs::RadioButton < Brut::FrontEnd::Componen
   # @param [Hash] html_attributes any additional HTML attributes to include on the `<input>` element.
   def self.for_form_input(form:, input_name:, value:, html_attributes: {})
     default_html_attributes = {}
-    html_attributes = html_attributes.map { |key,value| [ key.to_s, value ] }.to_h
+    html_attributes = html_attributes.map { |key,value| [ key.to_sym, value ] }.to_h
     input = form.input(input_name)
 
-    default_html_attributes["required"] = input.required
-    default_html_attributes["type"]     = "radio"
-    default_html_attributes["name"]     = input.name
-    default_html_attributes["value"]    = value
+    default_html_attributes[:required] = input.required
+    default_html_attributes[:type]     = "radio"
+    default_html_attributes[:name]     = input.name
+    default_html_attributes[:value]    = value
 
     selected_value = input.value
 
     if selected_value == value
-      default_html_attributes["checked"] = true
+      default_html_attributes[:checked] = true
     end
 
     if !form.new? && !input.valid?