brut 0.0.13 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e8b01889cc06839d9cca47e021c8b781e6f21417b08ba0658d55697285bb061
-  data.tar.gz: 4d1bf20dac16e8e6322402aa364f886235140028e53f8aa313ddc6d3b2de81c6
+  metadata.gz: 8a6e2324291c72fa3b3012b38b604104ce6d00af875326c20df00cfc42d16a9c
+  data.tar.gz: c16981e60940c676e21590f9a3db5845c8cc77ee2c7dd86eba9cfb8777ac7a32
 SHA512:
-  metadata.gz: 77c38b80c31452da7db8ef80ce2532aa1d3193257193d70625135d23af01695cc5f0c3f46568988bcf0c02849af8b8f9f3f166f9065445efd90a160c1e3206c0
-  data.tar.gz: e36fa4f081d48518cf941d0e0323cde04a6370082e0a594da73221f65c1f319d29df29c7cbd5663f30b2da2776fa8ec24295a16cc55b41b94c6f1096590282f7
+  metadata.gz: b41d3231c6e589b06deb3f668ff42983bf1021757961e1edf5c0b040f8e64dc4c4d4e481bf9feb34a3104371eecd11e5e0a63414a221f8748eca4982cebccec9
+  data.tar.gz: 5896d743754d4e9538a85268a3b72856b3b07ca940798e3732db577d67691fc819b7e927aa2a15a309c4440c7ea10beca45df5473d9ca7247b75e6f83678e4e8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brut (0.0.13)
+    brut (0.0.20)
       concurrent-ruby
       i18n
       irb
@@ -9,15 +9,13 @@ PATH
       opentelemetry-exporter-otlp
       opentelemetry-sdk
       ostruct
+      phlex
       prism
       rack-protection
       rackup
-      rexml
       semantic_logger
       sequel
       sinatra
-      temple
-      tilt
       tzinfo
       tzinfo-data
       zeitwerk
@@ -114,6 +112,8 @@ GEM
     opentelemetry-semantic_conventions (1.10.1)
       opentelemetry-api (~> 1.0)
     ostruct (0.6.1)
+    phlex (2.2.1)
+      zeitwerk (~> 2.7)
     pp (0.6.2)
       prettyprint
     prettyprint (0.2.0)
@@ -136,7 +136,6 @@ GEM
       psych (>= 4.0.0)
     reline (0.6.0)
       io-console (~> 0.5)
-    rexml (3.3.9)
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -163,7 +162,6 @@ GEM
       rack-session (>= 2.0.0, < 3)
       tilt (~> 2.0)
     stringio (3.1.3)
-    temple (0.10.3)
     tilt (2.4.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)

data/brut.gemspec

@@ -39,15 +39,13 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "concurrent-ruby"
   spec.add_runtime_dependency "i18n"
   spec.add_runtime_dependency "nokogiri"
+  spec.add_runtime_dependency "phlex"
   spec.add_runtime_dependency "prism"
   spec.add_runtime_dependency "rack-protection"
   spec.add_runtime_dependency "rackup"
-  spec.add_runtime_dependency "rexml"
   spec.add_runtime_dependency "semantic_logger"
   spec.add_runtime_dependency "sequel"
   spec.add_runtime_dependency "sinatra"
-  spec.add_runtime_dependency "temple"
-  spec.add_runtime_dependency "tilt"
   spec.add_runtime_dependency "tzinfo"
   spec.add_runtime_dependency "tzinfo-data"
   spec.add_runtime_dependency "zeitwerk"

data/lib/brut/back_end.rb

@@ -0,0 +1,7 @@
+# The _back end_ of a Brut app is where your app's business logic and database are managed.  While the bulk of your Brut app's code
+# will be in the back end, Brut is far less prescriptive about how to manage that than it is the front end.
+module Brut::BackEnd
+  autoload(:Validators, "brut/back_end/validator")
+  autoload(:Sidekiq, "brut/back_end/sidekiq")
+  # Do not put SeedData here - it must be loaded only when needed
+end

data/lib/brut/cli/apps/scaffold.rb

@@ -184,7 +184,7 @@ end}
   end
 
   class Component < Brut::CLI::Command
-    description "Create a new component, template, and associated test"
+    description "Create a new component and associated test"
     detailed_description "New components go in the `components/` folder of your app, however using --page will create a 'page private' component.  To do that, the component name must be an inner class of an existing page, for example HomePage::Welcome. This component goes in a sub-folder inside the `pages/` area of your app"
     opts.on("--page","If set, this component is for a specific page and won't go with the other components")
     args "ComponentName"
@@ -217,12 +217,10 @@ end}
       end
 
       source_path      = Pathname( (components_src_dir / relative_path).to_s + ".rb" )
-      html_source_path = Pathname( (components_src_dir / relative_path).to_s + ".html.erb" )
       spec_path        = Pathname( (components_specs_dir / relative_path).to_s + ".spec.rb" )
 
       exists = [
         source_path,
-        html_source_path,
         spec_path,
       ].select(&:exist?)
 
@@ -236,22 +234,21 @@ end}
 
       if global_options.dry_run?
         out.puts "FileUtils.mkdir_p #{source_path.dirname}"
-        out.puts "FileUtils.mkdir_p #{html_source_path.dirname}"
         out.puts "FileUtils.mkdir_p #{spec_path.dirname}"
       else
         FileUtils.mkdir_p source_path.dirname
-        FileUtils.mkdir_p html_source_path.dirname
         FileUtils.mkdir_p spec_path.dirname
 
         File.open(source_path,"w") do |file|
           file.puts %{class #{class_name} < AppComponent
   def initialize
   end
+
+  def view_template
+    h2 { "Welcome to your new template" }
+  end
 end}
         end
-        File.open(html_source_path,"w") do |file|
-          file.puts "<h1>#{class_name} is ready!</h1>"
-        end
         File.open(spec_path,"w") do |file|
           file.puts %{require "spec_helper"
 
@@ -262,9 +259,8 @@ RSpec.describe #{class_name} do
 end}
         end
       end
-      out.puts "Component source is in        #{source_path.relative_path_from(Brut.container.project_root)}"
-      out.puts "Component HTML template is in #{html_source_path.relative_path_from(Brut.container.project_root)}"
-      out.puts "Component test is in          #{spec_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Component source is in #{source_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Component test is in   #{spec_path.relative_path_from(Brut.container.project_root)}"
       0
     end
   end
@@ -283,7 +279,7 @@ end}
         end
       end
     end
-    description "Create a new page, template, and associated test"
+    description "Create a new page and associated test"
     args "page_route"
     def execute
       if args.length != 1
@@ -299,14 +295,12 @@ end}
       i18n_locales_dir = Brut.container.i18n_locales_dir
 
       page_source_path     = Pathname( (pages_src_dir   / page_relative_path).to_s + ".rb" )
-      template_source_path = Pathname( (pages_src_dir   / page_relative_path).to_s + ".html.erb" )
       page_spec_path       = Pathname( (pages_specs_dir / page_relative_path).to_s + ".spec.rb" )
       app_path             = Pathname( Brut.container.app_src_dir / "app.rb" )
       app_translations     = Pathname(  i18n_locales_dir / "en" / "2_app.rb")
 
       exists = [
         page_source_path,
-        template_source_path,
         page_spec_path,
       ].select(&:exist?)
 
@@ -319,7 +313,6 @@ end}
       end
 
       FileUtils.mkdir_p page_source_path.dirname,     noop: global_options.dry_run?
-      FileUtils.mkdir_p template_source_path.dirname, noop: global_options.dry_run?
       FileUtils.mkdir_p page_spec_path.dirname,       noop: global_options.dry_run?
 
       route_code = "page \"#{route.path_template}\""
@@ -334,8 +327,11 @@ end}
       page_class_code = %{class #{page_class_name} < AppPage
   def initialize#{initializer_params_code} # add needed arguments here
   end
+
+  def page_template
+    h1 { "#{page_class_name} is ready!" }
+  end
 end}
-      template_code = %{<h1>#{page_class_name} is ready!</h1>}
       page_spec_code = %{require "spec_helper"
 
 RSpec.describe #{page_class_name} do
@@ -352,8 +348,6 @@ end}
         out.puts "will contain:\n\n#{route_code}\n\n"
         out.puts page_source_path.relative_path_from(Brut.container.project_root)
         out.puts "will contain:\n\n#{page_class_code}\n\n"
-        out.puts template_source_path.relative_path_from(Brut.container.project_root)
-        out.puts "will contain:\n\n#{template_code}\n\n"
         out.puts page_spec_path.relative_path_from(Brut.container.project_root)
         out.puts "will contain:\n\n#{page_spec_code}\n\n"
         out.puts app_translations.relative_path_from(Brut.container.project_root)
@@ -361,7 +355,6 @@ end}
       else
 
         File.open(page_source_path,"w")     { it.puts page_class_code }
-        File.open(template_source_path,"w") { it.puts template_code }
         File.open(page_spec_path,"w")       { it.puts page_spec_code }
 
         existing_translations = File.read(app_translations).split(/\n/)
@@ -393,11 +386,10 @@ end}
           out.puts "Please make sure everything is correct.  Here is the defintion that was not inserted:\n\n#{route_code}"
         end
       end
-      out.puts "Page source is in        #{page_source_path.relative_path_from(Brut.container.project_root)}"
-      out.puts "Page HTML template is in #{template_source_path.relative_path_from(Brut.container.project_root)}"
-      out.puts "Page test is in          #{page_spec_path.relative_path_from(Brut.container.project_root)}"
-      out.puts "Added title to           #{app_translations.relative_path_from(Brut.container.project_root)}"
-      out.puts "Added route to           #{app_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Page source is in #{page_source_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Page test is in   #{page_spec_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Added title to    #{app_translations.relative_path_from(Brut.container.project_root)}"
+      out.puts "Added route to    #{app_path.relative_path_from(Brut.container.project_root)}"
       0
     end
   end

data/lib/brut/framework/config.rb

@@ -238,21 +238,6 @@ class Brut::Framework::Config
         config_dir / "asset_metadata.json"
       end
 
-
-      c.store(
-        "layout_locator",
-        "Brut::FrontEnd::Templates::Locator",
-        "Object to use to locate templates for layouts"
-      ) do |layouts_src_dir,project_env,brut_internal_dir|
-        paths = if project_env.development?
-                  [ layouts_src_dir, brut_internal_dir / "lib" / "brut" / "front_end" / "layouts" ]
-                else
-                  layouts_src_dir
-                end
-        Brut::FrontEnd::Templates::Locator.new(paths: paths,
-                                               extension: "html.erb")
-      end
-
       c.store_required_path(
         "brut_internal_dir",
         "Location to where the Brut gem is installed."
@@ -260,44 +245,20 @@ class Brut::Framework::Config
         (Pathname(__FILE__).dirname / ".." / ".." / "..").expand_path
       end
 
-      c.store(
-        "page_locator",
-        "Brut::FrontEnd::Templates::Locator",
-        "Object to use to locate templates for pages"
-      ) do |pages_src_dir,project_env,brut_internal_dir|
-        paths = if project_env.development?
-                  [ pages_src_dir, brut_internal_dir / "lib" / "brut" / "front_end" / "pages" ]
-                else
-                  pages_src_dir
-                end
-        Brut::FrontEnd::Templates::Locator.new(paths: paths,
-                                               extension: "html.erb")
-      end
-
-      c.store(
-        "component_locator",
-        "Brut::FrontEnd::Templates::Locator",
-        "Object to use to locate templates for components"
-      ) do |components_src_dir, pages_src_dir|
-        Brut::FrontEnd::Templates::Locator.new(paths: [ components_src_dir, pages_src_dir ],
-                                               extension: "html.erb")
-      end
-
       c.store(
         "svg_locator",
-        "Brut::FrontEnd::Templates::Locator",
+        "Brut::FrontEnd::InlineSvgLocator",
         "Object to use to locate SVGs"
       ) do |svgs_src_dir|
-        Brut::FrontEnd::Templates::Locator.new(paths: svgs_src_dir,
-                                               extension: "svg")
+        Brut::FrontEnd::InlineSvgLocator.new(paths: svgs_src_dir)
       end
 
       c.store(
         "asset_path_resolver",
-        "Brut::FrontEnd::Component::AssetPathResolver",
+        "Brut::FrontEnd::AssetPathResolver",
         "Object to use to resolve logical asset paths to actual asset paths"
       ) do |asset_metadata_file|
-        Brut::FrontEnd::Component::AssetPathResolver.new(metadata_file: asset_metadata_file)
+        Brut::FrontEnd::AssetPathResolver.new(metadata_file: asset_metadata_file)
       end
 
       c.store(

data/lib/brut/framework/mcp.rb

@@ -186,7 +186,7 @@ class Brut::Framework::MCP
               end
 
               if name == :request_context
-                args[name] = Thread.current.thread_variable_get(:request_context)
+                args[name] = Brut::FrontEnd::RequestContext.current
               elsif name == :session
                 args[name] = Brut.container.session_class.new(rack_session: session)
               elsif name == :request

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,11 +6,13 @@ 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 
@@ -31,64 +31,76 @@ end
 # component's class to render the component's HTML.
 #
 # @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
+
+  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
+  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
+  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
+  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
+  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.
+  def self.component_name = self.name
+  def component_name = self.class.component_name
+
   def page_name
     @page_name ||= begin
                      page = self.class.name.split(/::/).reduce(Module) { |accumulator,class_path_part|
@@ -100,192 +112,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