brut 0.0.13 → 0.0.20

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

@@ -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,4 +1,3 @@
-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.
 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.
@@ -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

@@ -4,7 +4,7 @@ class Brut::FrontEnd::Components::Inputs::CsrfToken < Brut::FrontEnd::Components
   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?

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

@@ -21,10 +21,11 @@ class Brut::FrontEnd::Components::Inputs::Select < Brut::FrontEnd::Components::I
                           option_text_attribute:,
                           index: nil,
                           html_attributes: {})
+    html_attributes = html_attributes.map { |key,value| [ key.to_sym, value ] }.to_h
     default_html_attributes = {}
     index ||= 0
     input = form.input(input_name, index:)
-    default_html_attributes["required"] = input.required
+    default_html_attributes[:required] = input.required
     if !form.new? && !input.valid?
       default_html_attributes["data-invalid"] = true
       input.validity_state.each do |constraint,violated|
@@ -61,36 +62,28 @@ class Brut::FrontEnd::Components::Inputs::Select < Brut::FrontEnd::Components::I
     @selected_value        = selected_value
     @value_attribute       = value_attribute
     @option_text_attribute = option_text_attribute
+    @html_attributes      = html_attributes
 
-    html_attributes["name"] = name
-    @sanitized_attributes  = html_attributes.map { |key,value|
-        [
-          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
-          value
-        ]
-    }.select { |key,value|
-      !value.nil?
-    }.to_h
+    @html_attributes[:name] = name
   end
 
-  def render
-    html_tag(:select,**@sanitized_attributes) {
-      options = @options.map { |option|
+  def view_template
+    select(**@html_attributes) {
+      if @include_blank
+        option(**@include_blank.option_attributes) {
+          @include_blank.text_content
+        }
+      end
+      options = @options.each do |option|
         value = option.send(@value_attribute)
         option_attributes = { value: value }
         if value == @selected_value
           option_attributes[:selected] = true
         end
-        html_tag(:option,**option_attributes) {
+        option(**option_attributes) {
           option.send(@option_text_attribute)
         }
-      }
-      if @include_blank
-        options.unshift(html_tag(:option,**@include_blank.option_attributes) {
-          @include_blank.text_content
-        })
       end
-      options.join("\n")
     }
   end
 private

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

@@ -9,40 +9,39 @@ class Brut::FrontEnd::Components::Inputs::TextField < Brut::FrontEnd::Components
   # @param [Hash] html_attributes any additional HTML attributes to include on the `<input>` element.
   def self.for_form_input(form:, input_name:, index: nil, 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, index:)
 
-    default_html_attributes["required"] = input.required
-    default_html_attributes["pattern"]  = input.pattern
-    default_html_attributes["type"]     = input.type
-    default_html_attributes["name"]     = if input.array?
+    default_html_attributes[:required] = input.required
+    default_html_attributes[:pattern]  = input.pattern
+    default_html_attributes[:type]     = input.type
+    default_html_attributes[:name]     = if input.array?
                                             "#{input.name}[]"
                                           else
                                             input.name
                                           end
 
     if input.max
-      default_html_attributes["max"] = input.max
+      default_html_attributes[:max] = input.max
     end
     if input.maxlength
-      default_html_attributes["maxlength"] = input.maxlength
+      default_html_attributes[:maxlength] = input.maxlength
     end
     if input.min
-      default_html_attributes["min"] = input.min
+      default_html_attributes[:min] = input.min
     end
     if input.minlength
-      default_html_attributes["minlength"] = input.minlength
-    end
+      default_html_attributes[:minlength] = input.minlength end
     if input.step
-      default_html_attributes["step"] = input.step
+      default_html_attributes[:step] = input.step
     end
     value = input.value
 
     if input.type == "checkbox"
-      default_html_attributes["value"] = (index || true).to_s
-      default_html_attributes["checked"] = value == "true"
+      default_html_attributes[:value] = (index || true).to_s
+      default_html_attributes[:checked] = value == "true"
     else
-      default_html_attributes["value"] = value
+      default_html_attributes[:value] = value.to_s
     end
     if !form.new? && !input.valid?
       default_html_attributes["data-invalid"] = true
@@ -55,30 +54,16 @@ class Brut::FrontEnd::Components::Inputs::TextField < Brut::FrontEnd::Components
     Brut::FrontEnd::Components::Inputs::TextField.new(default_html_attributes.merge(html_attributes))
   end
 
+  def invalid? = @attributes["data-invalid"] == true
+
   # Create an instance
   #
   # @param [Hash] attributes HTML attributes to put on the element.
   def initialize(attributes)
-    @sanitized_attributes = attributes.map { |key,value|
-        [
-          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
-          value
-        ]
-    }.select { |key,value|
-      !value.nil?
-    }.to_h
+    @attributes = attributes
   end
 
-  def render
-    attribute_string = @sanitized_attributes.map { |key,value|
-      if value == true
-        key
-      elsif value == false
-        ""
-      else
-        REXML::Attribute.new(key,value).to_string
-      end
-    }.join(" ")
-    "<input #{attribute_string}>"
+  def view_template
+    input(**@attributes)
   end
 end

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

@@ -8,22 +8,23 @@ class Brut::FrontEnd::Components::Inputs::Textarea < Brut::FrontEnd::Components:
   # @param [Integer] index if this input is part of an array, this is the index into that array. This is used to get the input's value.
   # @param [Hash] html_attributes any additional HTML attributes to include on the `<textarea>` element.
   def self.for_form_input(form:, input_name:, index: nil, html_attributes: {})
+    html_attributes = html_attributes.map { |key,value| [ key.to_sym, value ] }.to_h
     default_html_attributes = {}
 
     index ||= 0
     input = form.input(input_name, index:)
 
-    default_html_attributes["required"] = input.required
-    default_html_attributes["name"]     = if input.array?
+    default_html_attributes[:required] = input.required
+    default_html_attributes[:name]     = if input.array?
                                             "#{input.name}[]"
                                           else
                                             input.name
                                           end
     if input.maxlength
-      default_html_attributes["maxlength"] = input.maxlength
+      default_html_attributes[:maxlength] = input.maxlength
     end
     if input.minlength
-      default_html_attributes["minlength"] = input.minlength
+      default_html_attributes[:minlength] = input.minlength
     end
     if !form.new? && !input.valid?
       default_html_attributes["data-invalid"] = true
@@ -41,31 +42,15 @@ class Brut::FrontEnd::Components::Inputs::Textarea < Brut::FrontEnd::Components:
   # @param [Hash] attributes HTML attributes to put on the element.
   # @param [String] value the value to place inside the text area
   def initialize(attributes, value)
-    @sanitized_attributes = attributes.map { |key,value|
-        [
-          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
-          value
-        ]
-    }.select { |key,value|
-      !value.nil?
-    }.to_h
-    @value = value
+    @attributes = attributes
+    @value      = value
   end
 
-  def sanitized_attributes = @sanitized_attributes
+  def invalid? = @attributes["data-invalid"] == true
 
-  def render
-    attribute_string = @sanitized_attributes.map { |key,value|
-      if value == true
-        key
-      elsif value == false
-        ""
-      else
-        REXML::Attribute.new(key,value).to_string
-      end
-    }.join(" ")
-    %{
-      <textarea #{attribute_string}>#{ @value }</textarea>
+  def view_template
+    textarea(**@attributes) {
+      @value
     }
   end
 end

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

@@ -13,7 +13,7 @@ class Brut::FrontEnd::Components::LocaleDetection < Brut::FrontEnd::Component
     @url      = Brut::FrontEnd::Handlers::LocaleDetectionHandler.routing
   end
 
-  def render
+  def view_template
     attributes = {
       "url" => @url,
     }
@@ -27,6 +27,6 @@ class Brut::FrontEnd::Components::LocaleDetection < Brut::FrontEnd::Component
       attributes["show-warnings"] = true
     end
 
-    html_tag("brut-locale-detection",**attributes)
+    brut_locale_detection(**attributes)
   end
 end

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

@@ -1,15 +1,13 @@
-require "rexml"
-
 # Renders a `<meta>` tag that contains the name of the page.  This is useful for end to end tests to assert that they are on a specific page before continuing with the test.  It can eliminate a lot of confusion when a test fails.
 class Brut::FrontEnd::Components::PageIdentifier < Brut::FrontEnd::Component
   def initialize(page_name)
     @page_name = page_name
   end
 
-  def render
+  def view_template
     if Brut.container.project_env.production?
-      return ""
+      return nil
     end
-    html_tag(:meta, name: "class", content: @page_name)
+    meta(name: "class", content: @page_name)
   end
 end

data/lib/brut/front_end/components/{time.rb → time_tag.rb}

@@ -1,6 +1,5 @@
-require "rexml"
 # Renders a date or timestamp accessibly, using the `<time>` element. Likely you will use this via the {Brut::FrontEnd::Component::Helpers#time_tag} method. This will account for the current request's time zone. See {Clock}.
-class Brut::FrontEnd::Components::Time < Brut::FrontEnd::Component
+class Brut::FrontEnd::Components::TimeTag < Brut::FrontEnd::Component
   include Brut::I18n::ForHTML
   # Creates the component
   # @param timestamp [Time] the timestamp you wish to render. Mutually exclusive with `date`.
@@ -21,13 +20,18 @@ class Brut::FrontEnd::Components::Time < Brut::FrontEnd::Component
     skip_year_if_same: true,
     skip_dow_if_not_this_week: true,
     attribute_format: :iso_8601,
-    **only_contains_class,
-    &contents
+    clock: :from_request_context,
+    **only_contains_class
   )
     require_exactly_one!(timestamp:,date:)
 
     @date_only = timestamp.nil?
     @timestamp = timestamp || date
+    @clock     = if clock == :from_request_context
+                   Brut::FrontEnd::RequestContext.current[:clock]
+                 else
+                   clock
+                 end
 
     formats = [ format ]
     use_no_year = skip_year_if_same && @timestamp.year == Time.now.year
@@ -69,21 +73,20 @@ class Brut::FrontEnd::Components::Time < Brut::FrontEnd::Component
     @format           = found_format.to_sym
     @attribute_format = attribute_format.to_sym
     @class_attribute  = only_contains_class[:class] || ""
-    @contents         = contents
   end
 
-  def render(clock:)
+  def view_template
     adjusted_value = if @date_only
                        @timestamp
                      else
-                       clock.in_time_zone(@timestamp)
+                       @clock.in_time_zone(@timestamp)
                      end
 
     datetime_attribute = ::I18n.l(adjusted_value,format: @attribute_format)
 
-    html_tag(:time, class: @class_attribute, datetime: datetime_attribute) do
-      if @contents
-        @contents.()
+    time(class: @class_attribute, datetime: datetime_attribute) do
+      if block_given?
+        yield
       else
         ::I18n.l(adjusted_value,format: @format)
       end

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

@@ -8,15 +8,14 @@ class Brut::FrontEnd::Components::Traceparent < Brut::FrontEnd::Component
     @traceparent = carrier["traceparent"]
   end
 
-  def render
+  def view_template
     attributes = {
-      name: "traceparent"
+      name: "traceparent",
+      content: @traceparent,
     }
-    if @traceparent
-      attributes[:content] = @traceparent
-    else
+    if !@traceparent
       attributes["data-no-traceparent"] = "no traceparent was available - this component may have been rendered outside of an existing OpenTelemetry context"
     end
-    html_tag(:meta, **attributes)
+    meta(**attributes)
   end
 end

data/lib/brut/front_end/http_method.rb

@@ -1,5 +1,9 @@
+require "phlex"
+
 # Wrapper around an HTTP Method, ensuring it contains only a valid value.
 class Brut::FrontEnd::HttpMethod
+  include Phlex::SGML::SafeObject
+
   # Create an HTTP method from a string.
   #
   # @param [String|Symbol] string a string containing an HTTP method name. Case insensitive, and can be a symbol.

data/lib/brut/front_end/inline_svg_locator.rb

@@ -0,0 +1,21 @@
+class Brut::FrontEnd::InlineSvgLocator
+  def initialize(paths:)
+    @paths = Array(paths).map { |path| Pathname(path) }
+  end
+
+  def locate(base_name)
+    paths_to_try = @paths.map { |path|
+      path / "#{base_name}.svg"
+    }
+    paths_found = paths_to_try.select { |path|
+      path.exist?
+    }
+    if paths_found.empty?
+      raise "Could not locate SVG for #{base_name}. Tried: #{paths_to_try.map(&:to_s).join(', ')}"
+    end
+    if paths_found.length > 1
+      raise "Found more than one valid path for #{base_name}.  You must rename your files to disambiguate them. These paths were all found: #{paths_found.map(&:to_s).join(', ')}"
+    end
+    return paths_found[0]
+  end
+end

data/lib/brut/front_end/layout.rb

@@ -0,0 +1,3 @@
+class Brut::FrontEnd::Layout < Brut::FrontEnd::Component
+  def asset_path(path) = Brut.container.asset_path_resolver.resolve(path)
+end

data/lib/brut/front_end/page.rb

@@ -14,7 +14,6 @@
 # @see Brut::FrontEnd::Component
 class Brut::FrontEnd::Page < Brut::FrontEnd::Component
   include Brut::FrontEnd::HandlingResults
-  using Brut::FrontEnd::Templates::HTMLSafeString::Refinement
 
   # Returns the name of the layout for this page.  This string is used to find an ERB file in `app/src/front_end/layouts`. Every page
   # must have a layout. If you wish to render a page with no layout, create an empty layout in your app and use that.
@@ -31,43 +30,35 @@ class Brut::FrontEnd::Page < Brut::FrontEnd::Component
   # @return [URI|Brut::FrontEnd::HttpStatus|Object] If you return a `URI` (mostly likely by returning the result of calling {Brut::FrontEnd::HandlingResults#redirect_to}), the user is redirected and {#render} is never called. If you return a {Brut::FrontEnd::HttpStatus} (mostly likely by returning the result of calling {Brut::FrontEnd::HandlingResults#http_status}), {#render} is skipped and that status is returned with no content.  If anything else is returned, {#render} is called as normal.
   def before_render = nil
 
-  # @!visibility private
+  def with_layout(&block)
+    layout_class = Module.const_get(
+      layout_class = RichString.new([
+        self.layout,
+        "layout"
+      ].join("_")).camelize
+    )
+    render layout_class.new(page_name:,&block)
+  end
+
+
   def handle!
     case before_render
     in URI => uri
-      Brut.container.instrumentation.add_event("before_render got a URI", uri: uri)
       uri
     in Brut::FrontEnd::HttpStatus => http_status
-      Brut.container.instrumentation.add_event("before_render got status", http_status: http_status)
       http_status
     else
-      render
+      self.call
     end
   end
 
-  # The core method of a page, which overrides {Brut::FrontEnd::Component#render}. 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
-  # called by Brut when your page is requested.
-  #
-  # Also, generally don't override this unles you need to do something unusual.  Overriding this will completely bypass the layout
-  # system and skip all ERB processing. Unlike {Brut::FrontEnd::Component#render}, overriding this method does not provide access to injected data from the request context.
-  #
-  # @return [Brut::FrontEnd::Templates::HTMLSafeString] string containing the page's full HTML.
-  def render
-    layout_template = Brut.container.layout_locator.locate(self.layout).
-      then { |layout_erb_file| Brut::FrontEnd::Template.new(layout_erb_file) }
-
-    template = Brut.container.page_locator.locate(self.template_name).
-      then { |erb_file| Brut::FrontEnd::Template.new(erb_file) }
-
-    Brut.container.instrumentation.add_event("templates found", layout: layout_template.template_file_path, page: template.template_file_path)
-
-    page = template.render_template(self).html_safe!
-    layout_template.render_template(self) do
-      page
+  def view_template
+    with_layout do
+      page_template
     end
   end
 
+
   # @return [String] name of this page for use in debugging or for whatever reason you may want to dynamically refer to the page's name.  The default value is the class name.
   def self.page_name = self.name
 
@@ -77,10 +68,6 @@ class Brut::FrontEnd::Page < Brut::FrontEnd::Component
   # @!visibility private
   def component_name = raise Brut::Framework::Errors::Bug,"#{self.class} is not a component"
 
-private
-
-  def template_name = RichString.new(self.class.name).underscorized.to_s.gsub(/^pages\//,"")
-
 end
 
 # Holds pages included with the Brut framework