hecks 3.4.2 → 3.6.0

data/lib/hecks/forms/app/responses.rb

@@ -0,0 +1,46 @@
+require "json"
+require_relative "../page"
+
+module Hecks
+  module Forms
+    class App
+      # The Rack response triples `Forms::App` answers with: HTML pages, JSON bodies, redirects,
+      # and the refusal shapes both formats share.
+      module Responses
+        private
+
+        def html(title, body, breadcrumbs: [], status: 200)
+          respond(status, "text/html; charset=utf-8", Page.render(title: title, body: body, breadcrumbs: breadcrumbs))
+        end
+
+        def json(status, payload)
+          respond(status, "application/json", JSON.pretty_generate(payload))
+        end
+
+        def redirect(location)
+          [302, { "location" => location }, []]
+        end
+
+        def respond(status, content_type, body)
+          [status, { "content-type" => content_type }, [body]]
+        end
+
+        # A missing record is a 404; every other refusal of the domain or its arguments is a 422.
+        def refusal_status(error) = error.is_a?(Runtime::NotFound) ? 404 : 422
+
+        def refusal_json(error, status)
+          json(status, { error: error.class.name.split("::").last, message: error.message })
+        end
+
+        def not_found(aggregate, id, format)
+          return json(404, { error: "NotFound", message: "no #{aggregate.hecks_name} #{id}" }) if format != "html"
+
+          respond(404, "text/html; charset=utf-8",
+                  Page.render(title: "not found",
+                              body:  "<h1>Not found</h1><p>No #{Escape.html(aggregate.hecks_name)} " \
+                                     "#{Escape.html(id)}.</p>"))
+        end
+      end
+    end
+  end
+end

data/lib/hecks/forms/app.rb

@@ -1,20 +1,21 @@
-require "json"
 require "rack"
 require_relative "page"
-require_relative "field_shape"
 require_relative "index_renderer"
-require_relative "record_renderer"
-require_relative "command_form_renderer"
-require_relative "query_form_renderer"
-require_relative "params"
-require_relative "../doors/command_request"
-require_relative "../doors/json_door"
+require_relative "app/responses"
+require_relative "app/records"
+require_relative "app/commands"
+require_relative "app/queries"
 
 module Hecks
   module Forms
     # A Rack app that content-negotiates one route: `/Banking/Account/Overdrawn.html`
     # renders HTML, and the same path with no extension or `.json` answers JSON.
     class App
+      include Responses
+      include Records
+      include Commands
+      include Queries
+
       # Builds the Rack app for a configured app name, exposing exactly the chapters its
       # `Forms.configure` block declared.
       #
@@ -61,32 +62,39 @@ module Hecks
         segments = request.path_info.split("/").reject(&:empty?)
         return home(request) if segments.empty?
 
-        domain = segments[0]
-        refuse_unexposed(domain)
-        chapter = @registry.bluebook(domain) || raise(RouteNotFound, "no domain #{domain.inspect} loaded")
+        chapter = chapter_for(segments[0])
+        case segments.size
+        when 2 then aggregate_route(request, chapter, *split_format(segments[1]))
+        when 3 then verb_or_record_route(request, chapter, segments[1], *split_format(segments[2]))
+        else unrouted(request, chapter, segments)
+        end
+      end
 
-        return aggregate_route(request, chapter, *split_format(segments[1])) if segments.size == 2
+      def unrouted(request, chapter, segments)
+        refuse_entity_command if segments.size == 4 && entity_command?(chapter, segments)
+        respond(404, "text/plain", "no route for #{request.path_info}")
+      end
 
-        return verb_or_record_route(request, chapter, segments[1], *split_format(segments[2])) if segments.size == 3
+      def chapter_for(domain)
+        refuse_unexposed(domain)
+        @registry.bluebook(domain) || raise(RouteNotFound, "no domain #{domain.inspect} loaded")
+      end
 
-        if segments.size == 4
-          aggregate = chapter.aggregate(segments[1])
-          entity = aggregate&.entities&.find { |candidate| candidate.hecks_name == segments[2] }
-          entity_command = entity&.command(split_format(segments[3]).first)
-          if entity_command
-            raise RouteNotFound,
-                  "entity command routes are not supported by Forms; use a command door with " \
-                  "to.aggregate and to.entity"
-          end
-        end
+      def entity_command?(chapter, segments)
+        entity = chapter.aggregate(segments[1])&.entities&.find { |candidate| candidate.hecks_name == segments[2] }
+        !entity&.command(split_format(segments[3]).first).nil?
+      end
 
-        respond(404, "text/plain", "no route for #{request.path_info}")
+      def refuse_entity_command
+        raise RouteNotFound,
+              "entity command routes are not supported by Forms; use a command door with " \
+              "to.aggregate and to.entity"
       end
 
       def refuse_unexposed(domain)
         return if @exposed.include?(domain)
 
-        raise RouteNotFound, "#{domain.inspect} is not exposed by this app — declared chapters: #{@exposed.join(', ')}"
+        raise RouteNotFound, "#{domain.inspect} is not exposed by this app — declared chapters: #{@exposed.join(", ")}"
       end
 
       # Only a trailing ".html"/".json" is a format; other dots belong to the identity
@@ -105,202 +113,6 @@ module Hecks
 
         html("Exposed domains", IndexRenderer.render(chapters))
       end
-
-      def aggregate_route(request, chapter, aggregate_name, format)
-        aggregate = find_aggregate(chapter, aggregate_name)
-        return respond(405, "text/plain", "GET only") unless request.get?
-
-        if format == "html"
-          html("#{chapter.name}::#{aggregate.hecks_name}",
-               RecordRenderer.index(registry: @registry, domain: chapter.name, aggregate: aggregate),
-               breadcrumbs: [[chapter.name, "/"], [aggregate.hecks_name, nil]])
-        else
-          instances = @registry.repository(chapter.name, aggregate).all
-          # `id:` is merged last so an attribute named `id` in the state cannot clobber it.
-          json(200, instances.map { |i| i.state.merge(id: i.id) })
-        end
-      end
-
-      def verb_or_record_route(request, chapter, aggregate_name, verb_or_id, format)
-        aggregate = find_aggregate(chapter, aggregate_name)
-        domain = chapter.name
-
-        # A record id is free-form and can equal a verb name ("Close"), so a GET checks for
-        # a record first. POST never views a record, so it matches the verb first.
-        if request.get? && (instance = @registry.repository(domain, aggregate).find(verb_or_id))
-          return record_route(request, domain, aggregate, verb_or_id, format, instance: instance)
-        end
-
-        if (command = aggregate.command(verb_or_id))
-          return command_route(request, domain, aggregate, command, format)
-        end
-
-        if (query = aggregate.query(verb_or_id))
-          return query_route(request, domain, aggregate, query, format)
-        end
-
-        record_route(request, domain, aggregate, verb_or_id, format)
-      end
-
-      def command_route(request, domain, aggregate, command, format)
-        action = "/#{domain}/#{aggregate.hecks_name}/#{command.hecks_name}.html"
-        return command_json(request, domain, aggregate, command) if format != "html"
-        if request.get?
-          return command_form(domain, aggregate, command, action,
-                              prefill: receiver_compatibility(request.GET, command))
-        end
-        return respond(405, "text/plain", "GET or POST only") unless request.post?
-
-        submit_command(request, domain, aggregate, command, action)
-      end
-
-      def command_form(domain, aggregate, command, action, status: 200, values: nil, error: nil, prefill: {})
-        html("#{domain}::#{aggregate.hecks_name}.#{command.hecks_name}",
-             CommandFormRenderer.render(registry: @registry, domain: domain, aggregate: aggregate, command: command,
-                                        action: action, values: values, error: error, prefill: prefill),
-             breadcrumbs: [[domain, "/"], [aggregate.hecks_name, "/#{domain}/#{aggregate.hecks_name}.html"],
-                           [command.hecks_name, nil]],
-             status:      status)
-      end
-
-      def submit_command(request, domain, aggregate, command, action)
-        raw, envelope = submitted_command(request, aggregate, command)
-        result = @dispatcher.dispatch_flat("#{domain}::#{aggregate.hecks_name}.#{command.hecks_name}", envelope)
-        # The id is free-form, so it is percent-encoded as a path segment.
-        redirect("/#{domain}/#{aggregate.hecks_name}/#{Escape.path(result.id)}.html")
-      rescue *Runtime::DOMAIN_REFUSALS, ArgumentError, TypeError, JSON::ParserError => e
-        status = e.is_a?(Runtime::NotFound) ? 404 : 422
-        command_form(domain, aggregate, command, action, status: status, values: raw, error: e)
-      end
-
-      def command_json(request, domain, aggregate, command)
-        return json(200, command.to_h) if request.get? && request.GET.except("format").empty?
-        return respond(405, "text/plain", "GET or POST only") unless request.post?
-
-        _, envelope = submitted_command(request, aggregate, command)
-        result = @dispatcher.dispatch_flat("#{domain}::#{aggregate.hecks_name}.#{command.hecks_name}", envelope)
-        # `id:` last, as in `aggregate_route`.
-        json(201, result.state.merge(id: result.id))
-      rescue *Runtime::DOMAIN_REFUSALS, ArgumentError, TypeError, JSON::ParserError => e
-        status = e.is_a?(Runtime::NotFound) ? 404 : 422
-        json(status, { error: e.class.name.split("::").last, message: e.message })
-      end
-
-      def query_route(request, domain, aggregate, query, format)
-        return respond(405, "text/plain", "GET only") unless request.get?
-
-        params = request.GET
-        asked = params.except("format")
-        return query_json(domain, aggregate, query, asked) if format != "html"
-
-        query_html(domain, aggregate, query, asked)
-      end
-
-      def query_html(domain, aggregate, query, asked)
-        action = "/#{domain}/#{aggregate.hecks_name}/#{query.hecks_name}.html"
-        fields = query.attributes.map { |a| FieldShape.resolve(a, aggregate: aggregate) }
-        results, error = asked.empty? ? [nil, nil] : run_query(domain, aggregate, query, fields, asked)
-        html("#{domain}::#{aggregate.hecks_name}.#{query.hecks_name}",
-             QueryFormRenderer.render(registry: @registry, domain: domain, aggregate: aggregate, query: query,
-                                      action: action, params: asked, results: results, error: error),
-             breadcrumbs: [[domain, "/"], [aggregate.hecks_name, "/#{domain}/#{aggregate.hecks_name}.html"],
-                           [query.hecks_name, nil]],
-             status:      error ? 422 : 200)
-      end
-
-      def query_json(domain, aggregate, query, asked)
-        return json(200, query.to_h) if asked.empty?
-
-        fields = query.attributes.map { |a| FieldShape.resolve(a, aggregate: aggregate) }
-        results, error = run_query(domain, aggregate, query, fields, asked)
-        return json(422, { error: error.class.name.split("::").last, message: error.message }) if error
-
-        # `id:` last, as in `aggregate_route`.
-        json(200, results.map { |i| i.state.merge(id: i.id) })
-      end
-
-      # `Dispatcher#query` answers plain hashes, not `Runtime::Instance`; wrapping them
-      # in `Record` gives the renderers one shape.
-      def run_query(domain, aggregate, query, fields, asked)
-        args = Params.extract(fields, asked)
-        rows = @dispatcher.query("#{domain}::#{aggregate.hecks_name}.#{query.hecks_name}", **args)
-        [rows.map { |row| Record.new(row[:id], row.except(:id)) }, nil]
-      # `Params.extract` parses a list-of-value-object line as JSON; rescuing
-      # `JSON::ParserError` turns a malformed line into a 422 rather than a 500.
-      rescue *Runtime::DOMAIN_REFUSALS, ArgumentError, TypeError, JSON::ParserError => e
-        [nil, e]
-      end
-
-      def record_route(request, domain, aggregate, id, format, instance: nil)
-        return respond(405, "text/plain", "GET only") unless request.get?
-
-        instance ||= @registry.repository(domain, aggregate).find(id)
-        return not_found(aggregate, id, format) unless instance
-        # `id:` last, as in `aggregate_route`.
-        return json(200, instance.state.merge(id: instance.id)) if format != "html"
-
-        html("#{domain}::#{aggregate.hecks_name} #{id}",
-             RecordRenderer.show(registry: @registry, domain: domain, aggregate: aggregate, id: id),
-             breadcrumbs: [[domain, "/"], [aggregate.hecks_name, "/#{domain}/#{aggregate.hecks_name}.html"], [id, nil]])
-      end
-
-      def not_found(aggregate, id, format)
-        return json(404, { error: "NotFound", message: "no #{aggregate.hecks_name} #{id}" }) if format != "html"
-
-        respond(404, "text/html; charset=utf-8",
-                Page.render(title: "not found",
-                            body:  "<h1>Not found</h1><p>No #{Escape.html(aggregate.hecks_name)} " \
-                                   "#{Escape.html(id)}.</p>"))
-      end
-
-      def find_aggregate(chapter, name)
-        chapter.aggregate(name) || raise(RouteNotFound, "#{chapter.name} has no aggregate #{name.inspect}")
-      end
-
-      def command_envelope(command, args)
-        Doors::CommandRequest.normalize(args, receiver: command_receiver(command), legacy_receiver: :id)
-      end
-
-      def command_receiver(command) = command.creates? ? nil : :aggregate
-
-      def submitted_command(request, aggregate, command)
-        if request.media_type == "application/json"
-          raw = Doors::JsonDoor.parse(request.body.read)
-          envelope = Doors::JsonDoor.command_request(raw, receiver:        command_receiver(command),
-                                                          legacy_receiver: :id)
-          return [raw, envelope]
-        end
-
-        raw = receiver_compatibility(request.POST, command)
-        fields = CommandFormRenderer.fields_for(aggregate, command)
-        args = Params.extract(fields, raw)
-        [raw, command_envelope(command, args)]
-      end
-
-      # Existing integrations may still submit id. It remains an accepted
-      # edge spelling, but new forms expose only the receiver name to.
-      def receiver_compatibility(raw, command)
-        return raw if command.creates?
-        return raw unless raw.key?("id") && !raw.key?("to")
-
-        raw.merge("to" => raw["id"])
-      end
-
-      def html(title, body, breadcrumbs: [], status: 200)
-        respond(status, "text/html; charset=utf-8", Page.render(title: title, body: body, breadcrumbs: breadcrumbs))
-      end
-
-      def json(status, payload)
-        respond(status, "application/json", JSON.pretty_generate(payload))
-      end
-
-      def redirect(location)
-        [302, { "location" => location }, []]
-      end
-
-      def respond(status, content_type, body)
-        [status, { "content-type" => content_type }, [body]]
-      end
     end
   end
 end

data/lib/hecks/forms/banking_presentation.rb

@@ -36,6 +36,11 @@ module Hecks
         end
         Hecks::Adapters::Folder.new.load_bluebooks(File.join(root, "examples/banking/bluebook"))
         Kernel.load(File.join(root, "lib/hecks/forms/examples/banking_console.bluebook"))
+        persist_in_memory
+      end
+
+      # @api private
+      def persist_in_memory
         Hecks.hecksagon("Banking") do
           attaches "Governance"
           AGGREGATES.each { |name| ::Banking.const_get(name).persisted_by("Memory") }

data/lib/hecks/forms/command_form_renderer.rb

@@ -38,22 +38,36 @@ module Hecks
       # @param error [Exception, nil] the refusal to show in the banner; nil for a fresh form
       # @param prefill [Hash{String => String}] values the caller arrived with, by dotted path
       # @return [String] the HTML page body, without the surrounding page chrome
-      def self.render(registry:, domain:, aggregate:, command:, action:, values: nil, error: nil, prefill: {})
+      def self.render(registry:, domain:, aggregate:, command:, **form)
         all_fields = fields_for(aggregate, command)
-        reference_options = ReferenceOptions.collect(registry, domain, all_fields)
-        shown_values = values || prefill
+        fields_html = fields_markup(registry, domain, all_fields, form)
+        action = form.fetch(:action)
+        cancel = "/#{domain}/#{aggregate.hecks_name}"
+        [header(domain, aggregate, command), error_banner(form[:error]),
+         form_markup(action, fields_html, command, cancel).chomp,
+         inspect_panel(domain, aggregate, command, action, all_fields)].join("\n").concat("\n")
+      end
+
+      # @param form [Hash] the submission being re-shown: `values:`, `error:` and `prefill:`
+      # @return [String] every field's HTML, populated from the submission or the prefill
+      def self.fields_markup(registry, domain, fields, form)
+        reference_options = ReferenceOptions.collect(registry, domain, fields)
+        shown_values = form[:values] || form.fetch(:prefill, {})
+        fields.map do |f|
+          FieldRenderer.render(f, values: shown_values, errors: field_errors(form[:error]), reference_options: reference_options)
+        end.join
+      end
 
+      # @return [String] the `<form>` element: the fields, the submit button and the cancel link
+      def self.form_markup(action, fields_html, command, cancel)
         <<~HTML
-          #{header(domain, aggregate, command)}
-          #{error_banner(error)}
           <form method="post" action="#{Escape.attr(action)}" novalidate>
-            #{all_fields.map { |f| FieldRenderer.render(f, values: shown_values, errors: field_errors(error), reference_options: reference_options) }.join}
+            #{fields_html}
             <div class="actions">
               <button type="submit">#{Escape.html(command.hecks_name)}</button>
-              <a class="button secondary" href="#{Escape.attr("/#{domain}/#{aggregate.hecks_name}")}">Cancel</a>
+              <a class="button secondary" href="#{Escape.attr(cancel)}">Cancel</a>
             </div>
           </form>
-          #{inspect_panel(domain, aggregate, command, action, all_fields)}
         HTML
       end
 
@@ -63,7 +77,7 @@ module Hecks
       # @param aggregate [Bluebook::Aggregate] the aggregate whose records the picker offers
       # @return [Forms::Field] a `:reference` field at path `"to"` targeting `aggregate`
       def self.identity_field(aggregate)
-        Field.new(path: "to", label: "#{aggregate.hecks_name} (#{aggregate.identity_paths.join(', ')})",
+        Field.new(path: "to", label: "#{aggregate.hecks_name} (#{aggregate.identity_paths.join(", ")})",
                   kind: :reference, html_type: "text", target_aggregate: aggregate,
                   help: "The record this command acts on.")
       end
@@ -107,7 +121,7 @@ module Hecks
 
         <<~HTML
           <div class="error-banner" role="alert">
-            <p><strong>#{Escape.html(error.class.name.split('::').last)}</strong> — #{Escape.html(error.message)}</p>
+            <p><strong>#{Escape.html(error.class.name.split("::").last)}</strong> — #{Escape.html(error.message)}</p>
           </div>
         HTML
       end
@@ -134,17 +148,44 @@ module Hecks
       def self.inspect_panel(domain, aggregate, command, action, fields)
         verb = "#{domain}::#{aggregate.hecks_name}.#{command.hecks_name}"
         paths = Params.paths(fields)
-        curl = <<~SH.strip
+        inspect_head(verb, command, curl_snippet(action, paths)) + inspect_tail(command, paths)
+      end
+
+      # @param action [String] URL path the form posts to
+      # @param paths [Array<String>] the dotted field paths the request carries
+      # @return [String] the `curl` call equivalent to submitting the form
+      def self.curl_snippet(action, paths)
+        <<~SH.strip
           curl -X POST '#{action}' \\
             #{paths.map { |path| "-d '#{path}=...'" }.join(" \\\n  ")}
         SH
+      end
+
+      # @param command [Bluebook::Command] the command whose emitted events are listed
+      # @return [String] the events as `<code>` items, or a note that none are declared
+      def self.emitted_events(command)
+        return "<em>nothing declared</em>" if command.emits.empty?
+
+        command.emits.map { |e| "<code>#{Escape.html(e)}</code>" }.join(", ")
+      end
+
+      # @return [String] the first half of the inspect panel: the summary, emitted events and the
+      #   `curl` snippet
+      def self.inspect_head(verb, command, curl)
         <<~HTML
           <details class="inspect">
             <summary>Inspect — #{Escape.html(verb)}</summary>
-            <p>Emits: #{command.emits.empty? ? '<em>nothing declared</em>' : command.emits.map { |e| "<code>#{Escape.html(e)}</code>" }.join(', ')}</p>
-            <p>Equivalent request (as <code>curl</code>) — every field is <code>#{Escape.html('name.path')}</code>-encoded, form or JSON alike:</p>
+            <p>Emits: #{emitted_events(command)}</p>
+            <p>Equivalent request (as <code>curl</code>) — every field is <code>#{Escape.html("name.path")}</code>-encoded, form or JSON alike:</p>
             <div class="link-row"><code id="curl-snippet">#{Escape.html(curl)}</code><button type="button" class="copy" data-copy="#curl-snippet">copy</button></div>
-            <p>Fields this command takes: #{paths.map { |p| "<code>#{Escape.html(p)}</code>" }.join(', ')}</p>
+        HTML
+      end
+
+      # @return [String] the second half of the inspect panel: the field paths and the command's
+      #   declaration as JSON
+      def self.inspect_tail(command, paths)
+        <<~HTML
+            <p>Fields this command takes: #{paths.map { |p| "<code>#{Escape.html(p)}</code>" }.join(", ")}</p>
             <p>The command's own declaration, as the runtime holds it:</p>
             <pre>#{Escape.html(JSON.pretty_generate(command.to_h))}</pre>
           </details>

data/lib/hecks/forms/field_controls.rb

@@ -0,0 +1,95 @@
+require_relative "html"
+require_relative "../naming"
+
+module Hecks
+  module Forms
+    module FieldRenderer
+      # The single controls a leaf field renders as: input, textarea, checkbox, radio group,
+      # select and reference picker.
+      module Controls
+        # @return [String] an `<input>`, with a live preview beside a money amount in cents
+        def self.input(field, value)
+          money = field.kind == :number && field.help.to_s.include?("cents")
+          tag = Tag.void("input", **input_attrs(field, value), **(money ? { data_money_cents: preview_target(field) } : {}))
+          return tag unless money
+
+          %(#{tag} <span id="#{FieldRenderer.dom_id(field.path)}-preview" class="mono help" aria-live="polite"></span>)
+        end
+
+        def self.input_attrs(field, value)
+          { id: FieldRenderer.dom_id(field.path), name: field.path, type: field.html_type,
+            value: value || field.default, step: field.step, pattern: leaf_pattern(field),
+            placeholder: field.default }.merge(FieldRenderer.aria_attrs(field))
+        end
+
+        # A :reference input takes a record id, so the attribute's own pattern must not apply.
+        def self.leaf_pattern(field) = field.kind == :reference ? nil : field.pattern
+
+        def self.preview_target(field) = "##{FieldRenderer.dom_id(field.path)}-preview"
+
+        # @return [String] a `<textarea>` holding the value
+        def self.textarea(field, value)
+          id = FieldRenderer.dom_id(field.path)
+          %(<textarea id="#{id}" name="#{Escape.attr(field.path)}" #{FieldRenderer.aria(field)}>#{Escape.html(value)}</textarea>)
+        end
+
+        # The hidden "0" input makes an unticked box still submit a value.
+        def self.checkbox(field, value)
+          checked = value.nil? ? field.default == true : [true, "true", "on", "1"].include?(value)
+          <<~HTML
+            <div class="checkbox-row">
+              <input type="hidden" name="#{Escape.attr(field.path)}" value="0">
+              #{Tag.void("input", id: FieldRenderer.dom_id(field.path), name: field.path, type: "checkbox", value: "1", checked: checked)}
+              <label for="#{FieldRenderer.dom_id(field.path)}">#{Escape.html(field.label)}</label>
+            </div>
+          HTML
+        end
+
+        def self.radio_group(field, value)
+          selected = value || field.default
+          options = field.options.map { |option_value, option_label| radio(field, option_value, option_label, selected) }
+          %(<div class="radio-group" role="radiogroup">#{options.join}</div>)
+        end
+
+        def self.radio(field, option_value, option_label, selected)
+          checked = option_value.to_s == selected.to_s
+          id = "#{FieldRenderer.dom_id(field.path)}-#{Naming.snake(option_value)}"
+          <<~HTML
+            <label>#{Tag.void("input", id: id, type: "radio", name: field.path, value: option_value, checked: checked)} #{Escape.html(option_label)}</label>
+          HTML
+        end
+
+        def self.select(field, value)
+          selected = value || field.default
+          options = field.options.map do |option_value, option_label|
+            %(<option value="#{Escape.attr(option_value)}"#{" selected" if option_value.to_s == selected.to_s}>) \
+              "#{Escape.html(option_label)}</option>"
+          end
+          blank = field.optional? ? %(<option value="">—</option>) : ""
+          select_tag(field, "#{blank}#{options.join}")
+        end
+
+        # Falls back to a plain text id input when no records are on offer.
+        def self.reference_select(field, value, options)
+          return input(field.tap { |f| f.html_type = "text" }, value) unless options && !options.empty?
+
+          rendered = options.map do |id, label|
+            %(<option value="#{Escape.attr(id)}"#{" selected" if id.to_s == value.to_s}>#{Escape.html(label)}</option>)
+          end
+          select_tag(field, "#{reference_blank(field, value)}#{rendered.join}")
+        end
+
+        def self.reference_blank(field, value)
+          return %(<option value="">—</option>) if field.optional?
+
+          %(<option value="" disabled#{" selected" unless value}>choose one…</option>)
+        end
+
+        def self.select_tag(field, options_html)
+          id = FieldRenderer.dom_id(field.path)
+          %(<select id="#{id}" name="#{Escape.attr(field.path)}" #{FieldRenderer.aria(field)}>#{options_html}</select>)
+        end
+      end
+    end
+  end
+end