brut 0.0.12 → 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/generic_response.rb

@@ -0,0 +1,33 @@
+# A generic response to use when no built-in Brut construct will suffice. 
+# This mirrors the response a Rack server is intended to produce, and serves 
+# as merely a typed wrapper around that kind of response for the purposes of 
+# understanding the intention of whoever is returning this.
+#
+# Once created, {#to_ary} will convert this into the array that Rack requires.
+class Brut::FrontEnd::GenericResponse
+  # Create a generic response.  
+  #
+  # @param [Brut::FrontEnd::HttpStatus|number] http_status the status to send. If omitted, a 200 is used.
+  # Note that this value must be a valid HTTP status.
+  # @param [Hash<String|String>] headers hash of headers to send with the response.
+  # @param [String|Array<String>|IO|Enumerable] response_body the body of the response. This is passed
+  # through directly to the underlying Rack server so it should be whatever Rack expects, which is generally
+  # something that responds to `each`.
+  def initialize(http_status: 200, headers: {}, response_body:)
+    @response_body = response_body
+    @headers       = headers
+    @http_status   = Brut::FrontEnd::HttpStatus.new(http_status.to_i)
+  end
+
+  # Return this as an array suitable for use as a Rack response.
+  #
+  # @return [Array{String,3}] the response_body, headers, and http_status
+  def to_ary
+    [
+      @http_status.to_i,
+      @headers,
+      @response_body,
+    ]
+  end
+  alias deconstruct to_ary
+end

data/lib/brut/front_end/handler.rb

@@ -19,6 +19,8 @@ module Brut::FrontEnd
     # * Array of two items, with the first being an Instance of {Brut::FrontEnd::Component} and the second being an {Brut::FrontEnd::HttpStatus} -  renders that component or page, but responds with the given HTTP status. Useful for Ajax requests that don't return 200, but do return useful content.
     # * Instance of {Brut::FrontEnd::HttpStatus} - returns just that status code. Typically you would do this by calling {Brut::FrontEnd::HandlingResults#http_status}
     # * Instance of {Brut::FrontEnd::Download} - sends a file download to the browser.
+    # * Instance of {Brut::FrontEnd::GenericResponse} - sends itself as the rack response. Use this only if
+    # you cannot use one of the other options
     #
     # @return [URI|Brut::FrontEnd::Component,Array,Brut::FrontEnd::HttpStatus,Brut::FrontEnd::Download]
     def handle(**)

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