brut 0.0.1

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

@@ -0,0 +1,100 @@
+class Brut::FrontEnd::Components::Inputs::Select < Brut::FrontEnd::Components::Input
+  def self.for_form_input(form:,
+                          input_name:,
+                          options:,
+                          selected_value:,
+                          value_attribute:,
+                          option_text_attribute:,
+                          html_attributes: {})
+    default_html_attributes = {}
+    input = form[input_name]
+    default_html_attributes["required"] = input.required
+    if !form.new? && !input.valid?
+      default_html_attributes["data-invalid"] = true
+      input.validity_state.each do |constraint,violated|
+        if violated
+          default_html_attributes["data-#{constraint}"] = true
+        end
+      end
+    end
+    Brut::FrontEnd::Components::Inputs::Select.new(
+      name: input.name,
+      options:,
+      selected_value:,
+      value_attribute:,
+      option_text_attribute:,
+      html_attributes: default_html_attributes.merge(html_attributes)
+    )
+  end
+  def initialize(name:,
+                 options:,
+                 include_blank: false,
+                 selected_value:,
+                 value_attribute:,
+                 option_text_attribute:,
+                 html_attributes:)
+    @options               = options
+    @include_blank         = IncludeBlank.from_param(include_blank)
+    @selected_value        = selected_value
+    @value_attribute       = value_attribute
+    @option_text_attribute = option_text_attribute
+
+    html_attributes["name"] = name
+    @sanitized_attributes  = html_attributes.map { |key,value|
+        [
+          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
+          value
+        ]
+    }.select { |key,value|
+      !value.nil?
+    }.to_h
+  end
+
+  def render
+    html_tag(:select,**@sanitized_attributes) {
+      options = @options.map { |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.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
+
+  class IncludeBlank
+    attr_reader :text_content, :option_attributes
+    def self.from_param(include_blank)
+      if !include_blank
+        return nil
+      else
+        self.new(include_blank)
+      end
+    end
+    def initialize(include_blank)
+      if include_blank == true
+        @text_content = ""
+        @option_attributes = {}
+      elsif include_blank.kind_of?(Hash)
+        if include_blank.key?(:value) && include_blank.key?(:text_content)
+          @text_content = include_blank[:text_content]
+          @option_attributes = { value: include_blank[:value] }
+        else
+          raise ArgumentError, "when include_blank: is a Hash, it must include both :value and :text_content as keys. Got: #{include_blank.keys.join(", ")}"
+        end
+      else
+        raise ArgumentError,"include_blank: was a #{include_blank.class}. It should be true, false, nil, or a Hash"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+class Brut::FrontEnd::Components::Inputs::TextField < Brut::FrontEnd::Components::Input
+  def self.for_form_input(form:, input_name:, html_attributes: {})
+    default_html_attributes = {}
+    input = form[input_name]
+    default_html_attributes["required"] = input.required
+    default_html_attributes["pattern"]  = input.pattern
+    default_html_attributes["type"]     = input.type
+    default_html_attributes["name"]     = input.name
+    if input.max
+      default_html_attributes["max"] = input.max
+    end
+    if input.maxlength
+      default_html_attributes["maxlength"] = input.maxlength
+    end
+    if input.min
+      default_html_attributes["min"] = input.min
+    end
+    if input.minlength
+      default_html_attributes["minlength"] = input.minlength
+    end
+    if input.step
+      default_html_attributes["step"] = input.step
+    end
+    if input.type == "checkbox"
+      default_html_attributes["value"] = "true"
+      default_html_attributes["checked"] = input.value == "true"
+    else
+      default_html_attributes["value"] = input.value
+    end
+    if !form.new? && !input.valid?
+      default_html_attributes["data-invalid"] = true
+      input.validity_state.each do |constraint,violated|
+        if violated
+          default_html_attributes["data-#{constraint}"] = true
+        end
+      end
+    end
+    Brut::FrontEnd::Components::Inputs::TextField.new(default_html_attributes.merge(html_attributes))
+  end
+  def initialize(attributes)
+    @sanitized_attributes = attributes.map { |key,value|
+        [
+          key.to_s.gsub(/[\s\"\'>\/=]/,"-"),
+          value
+        ]
+    }.select { |key,value|
+      !value.nil?
+    }.to_h
+  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}>"
+  end
+end

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

@@ -0,0 +1,51 @@
+class Brut::FrontEnd::Components::Inputs::Textarea < Brut::FrontEnd::Components::Input
+  def self.for_form_input(form:, input_name:, html_attributes: {})
+    default_html_attributes = {}
+    input = form[input_name]
+    default_html_attributes["required"] = input.required
+    default_html_attributes["name"]     = input.name
+    if input.maxlength
+      default_html_attributes["maxlength"] = input.maxlength
+    end
+    if input.minlength
+      default_html_attributes["minlength"] = input.minlength
+    end
+    if !form.new? && !input.valid?
+      default_html_attributes["data-invalid"] = true
+      input.validity_state.each do |constraint,violated|
+        if violated
+          default_html_attributes["data-#{constraint}"] = true
+        end
+      end
+    end
+    Brut::FrontEnd::Components::Inputs::Textarea.new(default_html_attributes.merge(html_attributes), input.value)
+  end
+  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
+  end
+
+  def sanitized_attributes = @sanitized_attributes
+
+  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>
+    }
+  end
+end

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

@@ -0,0 +1,25 @@
+# Produces `<brut-locale-detection>`
+class Brut::FrontEnd::Components::LocaleDetection < Brut::FrontEnd::Component
+  def initialize(session:)
+    @timezone = session.timezone_from_browser
+    @locale   = session.http_accept_language.known? ? session.http_accept_language.weighted_locales.first&.locale : nil
+    @url      = Brut::FrontEnd::Handlers::LocaleDetectionHandler.routing
+  end
+
+  def render
+    attributes = {
+      "url" => @url,
+    }
+    if @timezone
+      attributes["timezone-from-server"] = @timezone.name
+    end
+    if @locale
+      attributes["locale-from-server"] = @locale
+    end
+    if !Brut.container.project_env.production?
+      attributes["show-warnings"] = true
+    end
+
+    html_tag("brut-locale-detection",**attributes)
+  end
+end

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

@@ -0,0 +1,13 @@
+require "rexml"
+class Brut::FrontEnd::Components::PageIdentifier < Brut::FrontEnd::Component
+  def initialize(page_name)
+    @page_name = page_name
+  end
+
+  def render
+    if Brut.container.project_env.production?
+      return ""
+    end
+    html_tag(:meta, name: "class", content: @page_name)
+  end
+end

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

@@ -0,0 +1,33 @@
+require "rexml"
+class Brut::FrontEnd::Components::Timestamp < Brut::FrontEnd::Component
+  include Brut::I18n::ForHTML
+  def initialize(timestamp:, format: :full, skip_year_if_same: true, attribute_format: :iso_8601, **only_contains_class)
+    @timestamp = timestamp
+    formats = [ format ]
+    if @timestamp.year == Time.now.year && skip_year_if_same
+      formats.unshift("#{format}_no_year")
+    end
+    format_keys = formats.map { |f| "time.formats.#{f}" }
+    found_format = formats.zip(::I18n.t(format_keys)).detect { |(key,value)|
+      value !~ /^Translation missing/
+    }.first
+    if found_format.nil?
+      raise ArgumentError,"format #{format} is not a known time format"
+    end
+    @format = found_format.to_sym
+
+    if ::I18n.t("time.formats.#{attribute_format}") =~ /^Translation missing/
+      raise ArgumentError,"attribute_format #{attribute_format} is not a known time format"
+    end
+    @attribute_format = attribute_format.to_sym
+    @class_attribute = only_contains_class[:class] || ""
+  end
+
+
+  def render(clock:)
+    timestamp_in_time_zone = clock.in_time_zone(@timestamp)
+    html_tag(:time, class: @class_attribute, datetime: ::I18n.l(timestamp_in_time_zone,format: @attribute_format)) do
+      ::I18n.l(timestamp_in_time_zone,format: @format)
+    end
+  end
+end

data/lib/brut/front_end/download.rb

@@ -0,0 +1,23 @@
+class Brut::FrontEnd::Download
+
+  attr_reader :data
+
+  def initialize(filename:,data:,content_type:,timestamp: false)
+    @filename     = filename
+    @data         = data
+    @content_type = content_type
+    @timestamp    = timestamp
+  end
+
+  def headers
+    filename = if @timestamp
+                 Time.now.strftime("%Y-%m-%dT%H-%M-%S") + "-" + @filename
+               else
+                 @filename
+               end
+    {
+      "content-disposition" => "attachment; filename=\"#{filename}\"",
+      "content-type" => @content_type,
+    }
+  end
+end

data/lib/brut/front_end/flash.rb

@@ -0,0 +1,57 @@
+class Brut::FrontEnd::Flash
+  def self.from_h(hash)
+    hash ||= {}
+    self.new(
+      age: hash[:age] || 0,
+      messages: hash[:messages] || {}
+    )
+  end
+  def initialize(age: 0, messages: {})
+    @age = age.to_i
+    if !messages.kind_of?(Hash)
+      raise ArgumentError,"messages must be a Hash, not a #{messages.class}"
+    end
+    @messages = messages
+  end
+
+  def clear!
+    @age = 0
+    @messages = {}
+  end
+
+  def notice=(notice)
+    self[:notice] = notice
+  end
+  def notice = self[:notice]
+  def notice? = !!self.notice
+
+  def alert=(alert)
+    self[:alert] = alert
+  end
+  def alert = self[:alert]
+  def alert? = !!self.alert
+
+  def age!
+    @age += 1
+    if @age > 1
+      @age = 0
+      @messages = {}
+    end
+  end
+
+  def [](key)
+    @messages[key]
+  end
+
+  def []=(key,message)
+    @messages[key] = message
+    @age = [0,@age-1].max
+  end
+
+  def to_h
+    {
+      age: @age,
+      messages: @messages,
+    }
+  end
+end

data/lib/brut/front_end/form.rb

@@ -0,0 +1,171 @@
+require "forwardable"
+
+module Brut::FrontEnd::Forms
+  autoload(:InputDefinition, "brut/front_end/forms/input_definition")
+  autoload(:ConstraintViolation, "brut/front_end/forms/constraint_violation")
+  autoload(:ValidityState, "brut/front_end/forms/validity_state")
+  autoload(:Input, "brut/front_end/forms/input")
+end
+
+module Brut::FrontEnd::FormInputDeclaration
+  # Declares an input for this form.
+  def input(name,attributes={})
+    self.add_input_definition(
+      Brut::FrontEnd::Forms::InputDefinition.new(**(attributes.merge(name: name)))
+    )
+  end
+
+  def select(name,attributes={})
+    self.add_input_definition(
+      Brut::FrontEnd::Forms::SelectInputDefinition.new(**(attributes.merge(name: name)))
+    )
+  end
+
+  def add_input_definition(input_definition)
+    @input_definitions ||= {}
+    @input_definitions[input_definition.name] = input_definition
+    define_method input_definition.name do
+      self[input_definition.name].value
+    end
+  end
+
+  # Copy the inputs from another form into this one
+  def inputs_from(other_class)
+    if !other_class.respond_to?(:input_definitions)
+      raise ArgumentError,"#{other_class} does not respond to #input_definitions - you cannot copy inputs from it"
+    end
+    other_class.input_definitions.each do |_name,input_definition|
+      self.add_input_definition(input_definition)
+    end
+  end
+
+  def input_definitions = @input_definitions || {}
+end
+
+class Brut::FrontEnd::Form
+
+  include SemanticLogger::Loggable
+
+  extend Brut::FrontEnd::FormInputDeclaration
+
+  def self.routing(*)
+    raise ArgumentError,"You called .routing on a form, but that form hasn't been configured with a route. You must do so in your route_config.rb file via the `form` method"
+  end
+
+  # Create an instance of this form, optionally initialized with
+  # the given values for its params.
+  def initialize(params: {})
+    params = convert_to_string_or_nil(params.to_h)
+    unknown_params = params.keys.map(&:to_s).reject { |key|
+      self.class.input_definitions.key?(key)
+    }
+    if unknown_params.any?
+      logger.info "Ignoring unknown params", keys: unknown_params
+    end
+    @params = params.except(*unknown_params)
+    @new = params_empty?(@params)
+    @inputs = self.class.input_definitions.map { |name,input_definition|
+      input = input_definition.make_input(value: @params[name] || @params[name.to_sym])
+      [ name, input ]
+    }.to_h
+  end
+
+  # Returns true if this form represents a new, empty, untouched form. This is
+  # useful for determining if this form has never been submitted and thus
+  # any required values don't represent an intentional omission by the user.
+  def new? = @new
+
+  # Access an input with the given name
+  def [](input_name) = @inputs.fetch(input_name.to_s)
+
+  # Returns true if this form has constraint violations.
+  def constraint_violations? = !@inputs.values.all?(&:valid?)
+
+  # Set a server-side constraint violation on a given input's name.
+  def server_side_constraint_violation(input_name:, key:, context:{})
+    self[input_name].server_side_constraint_violation(key,context)
+  end
+
+  def constraint_violations(server_side_only: false)
+    @inputs.map { |input_name, input|
+      if input.valid?
+        nil
+      else
+        [
+          input_name,
+          input.validity_state.select { |constraint|
+            if server_side_only
+              !constraint.client_side?
+            else
+              true
+            end
+          }
+        ]
+      end
+    }.compact.to_h
+  end
+
+private
+
+  def params_empty?(params) = params.nil? || params.empty?
+
+  def convert_to_string_or_nil(hash)
+    hash.each do |key,value|
+      case value
+      in Hash       then convert_to_string_or_nil(value)
+      in String     then hash[key] = RichString.new(value).to_s_or_nil
+      in Numeric    then hash[key] = value.to_s
+      in TrueClass  then hash[key] = "true"
+      in FalseClass then hash[key] = "false"
+      in NilClass   then # it's fine
+      else
+        if Brut.container.project_env.test?
+          raise ArgumentError, "Got #{value.class} for #{key} in params hash, which is not expected"
+        else
+          logger.warn("Got #{value.class} for #{key} in params hash, which is not expected")
+        end
+      end
+    end
+  end
+
+end
+
+class Brut::FrontEnd::FormProcessingResponse
+
+  def self.redirect_to(uri)                              = Redirect.new(uri)
+  def self.render_page(page)                             = RenderPage.new(page)
+  def self.render_component(component, http_status: 200) = RenderComponent.new(component,http_status)
+  def self.send_http_status(http_status)                 = SendHttpStatusOnly.new(http_status)
+
+  class Redirect < Brut::FrontEnd::FormProcessingResponse
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def deconstruct_keys(keys) = { redirect: @uri }
+
+  end
+
+  class RenderPage < Brut::FrontEnd::FormProcessingResponse
+    def initialize(page)
+      @page = page
+    end
+    def deconstruct_keys(keys) = { page_instance: @page }
+  end
+
+  class RenderComponent < Brut::FrontEnd::FormProcessingResponse
+    def initialize(component, http_status)
+      @component   = component
+      @http_status = http_status
+    end
+    def deconstruct_keys(keys) = { component_instance: @component, http_status: @http_status }
+  end
+
+  class SendHttpStatusOnly < Brut::FrontEnd::FormProcessingResponse
+    def initialize(http_status)
+      @http_status = http_status
+    end
+    def deconstruct_keys(keys) = { http_status: @http_status }
+  end
+
+end

data/lib/brut/front_end/forms/constraint_violation.rb

@@ -0,0 +1,39 @@
+# Represents a specific error with a field.  A field can have any number of constraint violations
+# to indicate what is wrong with it.  
+class Brut::FrontEnd::Forms::ConstraintViolation
+
+  CLIENT_SIDE_KEYS = [
+    "bad_input",
+    "custom_error",
+    "pattern_mismatch",
+    "range_overflow",
+    "range_underflow",
+    "step_mismatch",
+    "too_long",
+    "too_short",
+    "type_mismatch",
+    "value_missing",
+  ]
+
+  attr_reader :key, :context
+
+  def initialize(key:,context:, server_side: :based_on_key)
+    @key = key.to_s
+    @client_side = CLIENT_SIDE_KEYS.include?(@key) && server_side != true
+    @context = context || {}
+    if !@context.kind_of?(Hash)
+      raise "#{self.class} created for key #{key} with an invalid context: '#{context}/#{context.class}'. Context must be nil or a hash"
+    end
+  end
+
+  def client_side? = @client_side
+  def to_s = @key
+
+  def to_json(*args)
+    {
+      key: self.key,
+      context: self.context,
+      client_side: self.client_side?
+    }.to_json(*args)
+  end
+end

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

@@ -0,0 +1,119 @@
+# An Input is a stateful object representing a specific input and its value
+# during the course of a form submission process. In particular, it wraps a value
+# and a ValidityState. These are mutable, whereas the wrapped InputDefinition is not.
+class Brut::FrontEnd::Forms::Input
+
+  extend Forwardable
+
+  attr_reader :value, :validity_state
+
+  def initialize(input_definition:, value:)
+    @input_definition = input_definition
+    @validity_state = Brut::FrontEnd::Forms::ValidityState.new
+    self.value=(value)
+  end
+
+  def_delegators :"@input_definition", :max,
+                                       :maxlength,
+                                       :min,
+                                       :minlength,
+                                       :name,
+                                       :pattern,
+                                       :required,
+                                       :step,
+                                       :type
+
+  def value=(new_value)
+    value_missing = new_value.nil? || (new_value.kind_of?(String) && new_value.strip == "")
+    missing = if self.required
+                value_missing
+              else
+                false
+              end
+    too_short = if self.minlength && !value_missing
+                  new_value.length < self.minlength
+                else
+                  false
+                end
+
+    too_long = if self.maxlength && !value_missing
+                 new_value.length > self.maxlength
+               else
+                 false
+               end
+
+    type_mismatch = false # TBD
+
+    range_overflow = if self.max && !value_missing && !type_mismatch
+                       new_value.to_i > self.max
+                     else
+                       false
+                     end
+
+    range_underflow = if self.min && !value_missing && !type_mismatch
+                       new_value.to_i < self.min
+                     else
+                       false
+                     end
+
+    pattern_mismatch = false
+    step_mismatch = false
+
+    @validity_state = Brut::FrontEnd::Forms::ValidityState.new(
+      value_missing: missing,
+      too_short: too_short,
+      too_long: too_short,
+      range_overflow: range_overflow,
+      range_underflow: range_underflow,
+      pattern_mismatch: pattern_mismatch,
+      step_mismatch: step_mismatch,
+      type_mismatch: type_mismatch,
+    )
+    @value = new_value
+  end
+
+  # Set a server-side constraint violation on this input.  This is essentially arbitrary, but note
+  # that `key` should not be a key used for client-side validations.
+  def server_side_constraint_violation(key,context=true)
+    @validity_state.server_side_constraint_violation(key: key, context: context)
+  end
+
+  def valid? = @validity_state.valid?
+end
+class Brut::FrontEnd::Forms::SelectInput
+
+  extend Forwardable
+
+  attr_reader :value, :validity_state
+
+  def initialize(input_definition:, value:)
+    @input_definition = input_definition
+    @validity_state = Brut::FrontEnd::Forms::ValidityState.new
+    self.value=(value)
+  end
+
+  def_delegators :"@input_definition", :name,
+                                       :required
+
+  def value=(new_value)
+    value_missing = new_value.nil? || (new_value.kind_of?(String) && new_value.strip == "")
+    missing = if self.required
+                value_missing
+              else
+                false
+              end
+
+    @validity_state = Brut::FrontEnd::Forms::ValidityState.new(
+      value_missing: missing,
+    )
+    @value = new_value
+  end
+
+  # Set a server-side constraint violation on this input.  This is essentially arbitrary, but note
+  # that `key` should not be a key used for client-side validations.
+  def server_side_constraint_violation(key,context=true)
+    @validity_state.server_side_constraint_violation(key: key, context: context)
+  end
+
+  def valid? = @validity_state.valid?
+end