brut 0.0.1 → 0.0.2

data/lib/brut/front_end/form.rb

@@ -1,114 +1,157 @@
 require "forwardable"
 
+# Holds classes used in form processing
 module Brut::FrontEnd::Forms
+  autoload(:InputDeclarations, "brut/front_end/forms/input_declarations")
   autoload(:InputDefinition, "brut/front_end/forms/input_definition")
+  autoload(:SelectInputDefinition, "brut/front_end/forms/select_input_definition")
+  autoload(:RadioButtonGroupInputDefinition, "brut/front_end/forms/radio_button_group_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")
+  autoload(:SelectInput, "brut/front_end/forms/select_input")
+  autoload(:RadioButtonGroupInput, "brut/front_end/forms/radio_button_group_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
-
+# Base class for forms you create to process an HTML form. Generally, your form subclasses will only declare their inputs using
+# methods from {Brut::FrontEnd::Forms::InputDeclarations}.  That said, you will likely create instances of forms as part of the logic
+# for processing them or for testing.
 class Brut::FrontEnd::Form
 
-  include SemanticLogger::Loggable
-
-  extend Brut::FrontEnd::FormInputDeclaration
+  extend Brut::FrontEnd::Forms::InputDeclarations
 
+  # @!visibility private
   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.
+  # the given values for its params.  Because any values can be posted to a form endpoint, the initializer does not use kewyord
+  # arguments.  Instead, it's initialize with whatever parameters were received.  This intializer will then set only those values
+  # defined.
   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
+      Brut.container.instrumentation.add_attributes(ignored_unknown_params: 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 ]
+      value = @params[name] || @params[name.to_sym]
+      inputs = if value.kind_of?(Array)
+                 value.map { |one_value|
+                   input_definition.make_input(value: one_value)
+                 }
+               else
+                 [
+                   input_definition.make_input(value:)
+                 ]
+               end
+
+      [ name, inputs ]
     }.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.
+  # Generally, don't override this. Instead, override {#params_empty?}.
   def new? = @new
 
   # Access an input with the given name
-  def [](input_name) = @inputs.fetch(input_name.to_s)
+  #
+  # @param [String|Symbol] input_name the name of the input, as passed to {Brut::FrontEnd::Forms::InputDeclarations#input} et. al.
+  # @param [Integer] index the index of the input, when using arrays.
+  # @return [Brut::FrontEnd::Forms::Input]
+  def input(input_name, index: nil)
+    index ||= 0
+    inputs = self.inputs(input_name)
+    input = inputs[index]
+    if input.nil?
+      input_definition = self.class.input_definitions.fetch(input_name.to_s)
+      input = input_definition.make_input(value:"")
+      inputs[index] = input
+    end
+    input
+  end
+
+  # Return all inputs for the given name.
+  # @param [String|Symbol] input_name the name of the input, as passed to {Brut::FrontEnd::Forms::InputDeclarations#input} et. al.
+  # @return [Brut::FrontEnd::Forms::Input]
+  def inputs(input_name)
+    @inputs.fetch(input_name.to_s)
+  rescue KeyError => ex
+    raise Brut::Framework::Errors::Bug, "Form does not define the input '#{input_name}'. You must add this to your form. Found these inputs: #{@inputs.keys.join(', ')}"
+  end
 
   # Returns true if this form has constraint violations.
-  def constraint_violations? = !@inputs.values.all?(&:valid?)
+  def constraint_violations? = !@inputs.values.flatten.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)
+  #
+  # @param [String|Symbol] input_name the name of the input, as passed to {Brut::FrontEnd::Forms::InputDeclarations#input} et. al.
+  # @param [String] key the i18n key fragment representing the constraint. Assume this will be appended to `general.cv.be.` in order
+  # to form the entire key.
+  # @param [Hash] context additional information about the violation, typically interpolated values for the I18n message.
+  def server_side_constraint_violation(input_name:, key:, index: nil, context:{})
+    index ||= 0
+    self.input(input_name, index:).server_side_constraint_violation(key,context)
   end
 
+
+  # Returns a map of any input with a constraint violation and the list of violations. The keys in the hash are input names and the
+  # values are arrays of {Brut::FrontEnd::Forms::ValidityState} instances.
+  #
+  # @param [true|false] server_side_only if true, only server side constraints are returned.
+  # @return [Hash] map of input names to arrays of validity states
+  #
   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
+    @inputs.map { |input_name, inputs|
+      inputs.map.with_index { |input,index|
+        if input.valid?
+          nil
+        else
+          [
+            input_name,
+            [
+              input.validity_state.select { |constraint|
+                if server_side_only
+                  !constraint.client_side?
+                else
+                  true
+                end
+              },
+              index
+            ]
+          ]
+        end
+      }.compact
+    }.select { !it.empty? }.flatten(1).to_h
   end
 
-private
-
+  # Template method that is used to determine if the params given to the form's initializer
+  # represent an empty value.  By default, this returns true if those params were nil or empty.
+  # You'd override this if there are values you want to initialize a form with that aren't considered
+  # values provided by the user.  This can allow a form with values in it to be considered un-submitted.
   def params_empty?(params) = params.nil? || params.empty?
 
+  # Return this form as a hash, which is a map of its parameters' current values. This is not simply
+  # a filtered version of what was passed into the initializer.  This will only have the keys for the inputs
+  # this form defines.  Those keys will be strings, not symbols.  The values will be
+  # either `nil`, a String, or an array of strings.   Not every input defined by this form
+  # will be represented as a key in the resulting hash—only those keys that were passed to the initializer.
+  # @return [Hash<String,nil|String|Array<String>>] the form's params as a hash.
+  def to_h
+    @params.map { |key,value|
+      [ key.to_s, value ]
+    }.to_h
+  end
+
+private
+
   def convert_to_string_or_nil(hash)
     hash.each do |key,value|
       case value
@@ -118,54 +161,14 @@ private
       in TrueClass  then hash[key] = "true"
       in FalseClass then hash[key] = "false"
       in NilClass   then # it's fine
+      in Array      then hash[key] = value
       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")
+          Brut.container.instrumentation.add_event("convert_to_string_or_nil: Unknown class in params hash", class: value.class, key: key)
         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

@@ -1,7 +1,10 @@
-# Represents a specific error with a field.  A field can have any number of constraint violations
-# to indicate what is wrong with it.  
+# Represents a specific error with a field. Essentially wraps an i18n key fragment and interpolated values for use with other
+# form-related classes.
 class Brut::FrontEnd::Forms::ConstraintViolation
 
+  # These are underscorized versions of the attributes of the browser's `ValidityState`'s properties.
+  #
+  # @see https://developer.mozilla.org/en-US/docs/Web/API/ValidityState
   CLIENT_SIDE_KEYS = [
     "bad_input",
     "custom_error",
@@ -15,8 +18,17 @@ class Brut::FrontEnd::Forms::ConstraintViolation
     "value_missing",
   ]
 
-  attr_reader :key, :context
+  # @return [String] the key fragment representing the violation
+  attr_reader :key
+  # @return [Hash] interpolated values useful in rendering the actual message
+  attr_reader :context
 
+  # Create a constraint violations
+  #
+  # @param [String|Symbol] key I18n key fragment representing this violation.
+  # @param [Hash|nil] context interpolated values useful in rendering the message
+  # @param [true|:based_on_key] server_side If `:based_on_key`, {#client_side?} will return true if `key` is in {.CLIENT_SIDE_KEYS}.
+  # If `true`, {#client_side?} will return false no matter what.
   def initialize(key:,context:, server_side: :based_on_key)
     @key = key.to_s
     @client_side = CLIENT_SIDE_KEYS.include?(@key) && server_side != true
@@ -26,14 +38,7 @@ class Brut::FrontEnd::Forms::ConstraintViolation
     end
   end
 
+  # @return [true|false] true if this violation is a client-side violation
   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

@@ -1,12 +1,18 @@
 # 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.
+# and a {Brut::FrontEnd::Forms::ValidityState}. These are mutable, whereas the wrapped {Brut::FrontEnd::Forms::InputDefinition} is not.
 class Brut::FrontEnd::Forms::Input
 
   extend Forwardable
 
-  attr_reader :value, :validity_state
+  # @return [String] the input's value
+  attr_reader :value
+  # @return [Brut::FrontEnd::Forms::ValidityState] Validity state that captures the current constraint violations, if any
+  attr_reader :validity_state
 
+  # Create the input with the given definition and value
+  # @param [Brut::FrontEnd::Forms::InputDefinition] input_definition
+  # @param [String] value
   def initialize(input_definition:, value:)
     @input_definition = input_definition
     @validity_state = Brut::FrontEnd::Forms::ValidityState.new
@@ -21,9 +27,20 @@ class Brut::FrontEnd::Forms::Input
                                        :pattern,
                                        :required,
                                        :step,
-                                       :type
-
+                                       :type,
+                                       :array?
+
+  # Set the value, analyzing it for constraint violations based on the input's definition.
+  # This is essentially duplicating whatever the browser would be doing on its end, thus allowing
+  # for server-side validation of client-side constraints.
+  #
+  # When this method completes, the value of {#validity_state} could change.
+  #
+  # @param [String] new_value the value for the input.  Empty strings are coerced to `nil`
   def value=(new_value)
+    if new_value.kind_of?(String) && new_value.strip == ""
+      new_value = nil
+    end
     value_missing = new_value.nil? || (new_value.kind_of?(String) && new_value.strip == "")
     missing = if self.required
                 value_missing
@@ -56,7 +73,11 @@ class Brut::FrontEnd::Forms::Input
                        false
                      end
 
-    pattern_mismatch = false
+    pattern_mismatch = if self.pattern && !value_missing && !type_mismatch
+                         !new_value.match?(Regexp.new(self.pattern))
+                       else
+                         false
+                       end
     step_mismatch = false
 
     @validity_state = Brut::FrontEnd::Forms::ValidityState.new(
@@ -74,46 +95,13 @@ class Brut::FrontEnd::Forms::Input
 
   # 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.
+  #
+  # @param [String|Symbol] key the I18n key fragment that describes the server side constraint violation
+  # @param [Hash|nil] context any interpolations required to render the message
   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
-
+  # @return [true|false] true if the underlying {#validity_state} has no constraint violations
   def valid? = @validity_state.valid?
 end

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

@@ -0,0 +1,90 @@
+# Extended by {Brut::FrontEnd::Form} to allow declaring inputs. Do not use this module directly. Instead, call {#input} or {#select}
+# from within your form's class definition.
+module Brut::FrontEnd::Forms::InputDeclarations
+  # Declares an input for this form, to be modeled via an HTML `<INPUT>` tag.
+  #
+  # @param [String] name The name of the input (used in the `name` attribute)
+  # @param [Hash] attributes Attributes to be used on the tag that represent its contraints. See {Brut::FrontEnd::Forms::InputDefinition}
+  def input(name,attributes={})
+    self.add_input_definition(
+      Brut::FrontEnd::Forms::InputDefinition.new(**(attributes.merge(name: name)))
+    )
+  end
+
+  # Declares a select for this form, to be modeled via an HTML `<SELECT>` tag. Note that this will not define the values that appear
+  # in the select.  That is done when the select is rendered, which you might do with
+  # {Brut::FrontEnd::Components::Inputs::Select.for_form_input}
+  #
+  # @param [String] name The name of the input (used in the `name` attribute)
+  # @param [Hash] attributes Attributes to be used on the tag that represent its contraints. See {Brut::FrontEnd::Forms::SelectInputDefinition}
+  def select(name,attributes={})
+    self.add_input_definition(
+      Brut::FrontEnd::Forms::SelectInputDefinition.new(**(attributes.merge(name: name)))
+    )
+  end
+
+  # Declares a radio button group, which will manifest as one or more `<input type="radio">` tags that all use the same
+  # value for their `name` attribute.  Unlike `input` or `select`, this method is declaring one or more actual
+  # input tags.
+  #
+  # Note that this is not where you would define the possible values for the group. That is done in
+  # {Brut::FrontEnd::Components::Inputs::RadioButton.for_form_input}.
+  #
+  # @param [String] name The name of the group (used in the `name` attribute)
+  # @param [Hash] attributes Attributes to be used on the tag that represent its contraints. See
+  # {Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition}
+  def radio_button_group(name,attributes={})
+    self.add_input_definition(
+      Brut::FrontEnd::Forms::RadioButtonGroupInputDefinition.new(**(attributes.merge(name: name)))
+    )
+  end
+
+  # @!visibility private
+  def add_input_definition(input_definition)
+    @input_definitions ||= {}
+    @input_definitions[input_definition.name] = input_definition
+    if input_definition.array?
+      define_method input_definition.name do |index=nil|
+        if index.nil?
+          raise ArgumentError,"#{input_definition.name} is an array - you must provide an index to access one of its values"
+        end
+        self.input(input_definition.name, index:).value
+      end
+      define_method "#{input_definition.name}_each" do |&block|
+        self.inputs(input_definition.name).each_with_index do |input,i|
+          block.(input.value,i)
+        end
+      end
+    else
+      define_method input_definition.name do |index_that_should_be_omitted=nil|
+        if !index_that_should_be_omitted.nil?
+          raise ArgumentError,"#{input_definition.name} is not an array - do not provide an index when accessing its value"
+        end
+        self.input(input_definition.name, index: 0).value
+      end
+    end
+  end
+
+  # Copy the inputs from another form into this one. This is useful when one form should have identical inputs from another, plus a
+  # few of its own.
+  #
+  # @param [Class] other_class a subclass of {Brut::FrontEnd::Form}.
+  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
+
+  # Return a map of input names to input definitions
+  #
+  # @return [Hash<String,Brut::FrontEnd::Forms::InputDefinition>] a map of all defined input names to the definitions.
+  #
+  # @!visibility private
+  def input_definitions
+    @input_definitions ||= {}
+  end
+end
+

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

@@ -1,18 +1,24 @@
-# An InputDefinition captures metadata used to create an Input. Think of this
-# as a template for creating inputs.  An Input has state, such as values and thus validity.
-# An InputDefinition is immutable and defines inputs.
+# Defines an input for a form, but not it's current runtime state.  {Brut::FrontEnd::Forms::Input} is used to understand the current
+# state or value of an input.
+#
+# Note that an input definition is defining an HTML `<input>`, not a generic attribute.  Thus, the only constraints you can place on
+# an input are those that the browser supports.  If your form needs server side validation, you can accomplish that in a lot of ways,
+# such as implementing a {Brut::BackEnd::Validators::FormValidator}, or calling
+# {Brut::FrontEnd::Form#server_side_constraint_violation} directly.
 class Brut::FrontEnd::Forms::InputDefinition
   include Brut::Framework::FussyTypeEnforcement
-  attr_reader :max,
-              :maxlength,
-              :min,
-              :minlength,
-              :name,
-              :pattern,
-              :required,
-              :step,
-              :type
 
+  attr_reader :max
+  attr_reader :maxlength
+  attr_reader :min
+  attr_reader :minlength
+  attr_reader :name
+  attr_reader :pattern
+  attr_reader :required
+  attr_reader :step
+  attr_reader :type
+
+  # @!visibility private
   INPUT_TYPES_TO_CLASS = {
     "checkbox"       => String,
     "color"          => String,
@@ -35,7 +41,24 @@ class Brut::FrontEnd::Forms::InputDefinition
   }
 
   # Create an InputDefinition. This should very closely mirror
-  # the attributes used in an <INPUT> element in HTML.
+  # the attributes used in an `<INPUT>` element in HTML. The idea is to be able to create HTML that validates its values the same as
+  # we can in Ruby so that client side validations can be safely used for user experience, but also re-executed server side.
+  #
+  #
+  # @param [Integer|Date|Time] min Minimum value allowed by the input. Not relevat to all `type`s.
+  # @param [Integer|Date|Time] max Maximum value allowed by the input. Not relevat to all `type`s.
+  # @param [Integer] minlength Minimum length of the value allowed.
+  # @param [Integer] maxlength Maximum length of the value allowed.
+  # @param [String] name Name of the input (required)
+  # @param [Regexp] pattern that the value must match. Note that this technically must be a regular expression that works for both Ruby and JavaScript, so don't get fancy.
+  # @param [true|false] required true if this field is required, false otherwise. Default is `true` unless `type` is `"checkbox"`.
+  # @param [Integer] step Step value for ranged inputs.  A value that is not on a step is considered invalid.
+  # @param [String] type the type of input to create. Should be a value from the HTML spec. Default is based on the value of `name`. If `email`, `type` is `email`. If `password` or `password_confirmation`, type is `password`. Otherwise `text`.
+  # @param [true|false] array If true, the form will expect multiple values for this input.  The values will be available as an array. Any values omitted by the user will be present as empty strings.
+  #
+  #
+  # @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input INPUT Element
+  # @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#input_types Input types
   def initialize(
     max: nil,
     maxlength: nil,
@@ -45,13 +68,15 @@ class Brut::FrontEnd::Forms::InputDefinition
     pattern: nil,
     required: :based_on_type,
     step: nil,
-    type: nil
+    type: nil,
+    array: false
   )
     name = name.to_s
     type = if type.nil?
              case name
              when "email" then "email"
              when "password" then "password"
+             when "password_confirmation" then "password"
              else
                "text"
              end
@@ -68,33 +93,23 @@ class Brut::FrontEnd::Forms::InputDefinition
     @maxlength = type!( maxlength , Numeric                   , "maxlength")
     @min       = type!( min       , Numeric                   , "min")
     @minlength = type!( minlength , Numeric                   , "minlength")
-    @name      = type!( name      , String                    , "name")
+    @name      = type!( name      , String                    , "name", required: true)
     @pattern   = type!( pattern   , String                    , "pattern")
     @required  = type!( required  , [true, false]             , "required", required: true)
     @step      = type!( step      , Numeric                   , "step")
     @type      = type!( type      , INPUT_TYPES_TO_CLASS.keys , "type", required: true)
+    @array     = type!( array     , [true, false]             , "array", required: true)
 
     if @pattern.nil? && type == "email"
       @pattern = /^[^@]+@[^@]+\.[^@]+$/.source
     end
   end
 
-  # Create an Input based on this defitition, initializing it with the given value.
-  def make_input(value:)
-    Brut::FrontEnd::Forms::Input.new(input_definition: self, value: value)
-  end
-end
-class Brut::FrontEnd::Forms::SelectInputDefinition
-  include Brut::Framework::FussyTypeEnforcement
-  attr_reader :required, :name
-  def initialize(name:, required: true)
-    name = name.to_s
-    @name     = type!( name      , String        , "name")
-    @required = type!( required  , [true, false] , "required", required:true)
-  end
+  def array? = @array
 
-  # Create an Input based on this defitition, initializing it with the given value.
+
+  # Create an Input based on this definition, initializing it with the given value.
   def make_input(value:)
-    Brut::FrontEnd::Forms::SelectInput.new(input_definition: self, value: value)
+    Brut::FrontEnd::Forms::Input.new(input_definition: self, value: value)
   end
 end