inline_forms_schema_edit 8.1.42

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4e38325358e9117cb9e8f4f10f2ea4f0e666309c1fc0309306a5536214f6f6bf
+  data.tar.gz: 94c056f121faf8216211b5d09736ea846f4014fd2aa37db743187691b05dd8e8
+SHA512:
+  metadata.gz: 68e8cc58fd4bd736a5d10cc43ccf4b37370241c5811f2e8cf733bdf09b18051a7c55e4d42a750b6e66955dfdada53a896adc22cbea0917bcf9b21e119292236b
+  data.tar.gz: bd31280e01c4fb905fe1647f7d00c33bb9cf3fae703e6771b648a75d8dc0da2bb34570860cb64410c00eee33cc23b6f899f912a4f990654282e536d3b878a62b

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this gem are documented in this file. Versions are in
+lockstep with inline_forms / inline_forms_installer / validation_hints.
+
+## [Unreleased]
+
+## [8.1.42] - 2026-07-22
+
+### Changed
+
+- Version bump to stay in lockstep with `inline_forms` /
+  `inline_forms_installer` / `validation_hints` 8.1.42. This gem packages its
+  own files (`{app,doc,lib}` glob) and was unaffected by the `stuff/`
+  gem-build leak fixed in the main gem.
+
+### Added
+
+- **Batch pipeline (plan phases 1-3, and the tenant half of 4).**
+  - Persisted intents: `InlineForms::SchemaBatch` + `InlineForms::SchemaIntentRecord`
+    (`rails g inline_forms_schema_edit:install` writes the migration; the
+    installer runs it for `--schema-edit` apps). Drafts accumulate in a
+    batch (the "cart"); **submit freezes it** — intents and batch become
+    immutable (model-enforced) and a content digest seals the intent list.
+  - GUI: `/schema` index (draft cart, submit with optional apply window,
+    batch history), "Add to batch" on preview. Direct apply stays dev-only;
+    drafting in production requires the explicit
+    `InlineFormsSchemaEdit.production_drafting = true` opt-in (default off).
+  - Machine endpoints for the CI loop, token-authenticated
+    (`InlineFormsSchemaEdit.export_token` / `INLINE_FORMS_SCHEMA_EXPORT_TOKEN`;
+    404 when unconfigured): `GET /schema/batches/:id/export.json`,
+    `POST /schema/batches/:id/status`.
+  - Export/import/replay: `rake schema_edit:export_batch[id]`,
+    `rake schema_edit:apply_batch[file]` (verifies the digest, re-validates
+    every intent against the current checkout, replays through
+    `SchemaApply#generate!` — codegen only, never migrates or commits),
+    `rake schema_edit:mark_batch[id,status]`.
+  - Deploy window (phase 4, tenant side): `rake schema_edit:apply_due`
+    migrates ready batches whose window arrived, marks them applied, runs
+    the optional `InlineFormsSchemaEdit.restart_command`. A commented
+    Forgejo Actions example ships in `doc/schema-apply-workflow.yml.example`
+    (copied to the app's `doc/` by the install generator).
+  - Routes are now drawn by `InlineFormsSchemaEdit.draw_routes(self)` (one
+    line in the app's routes.rb) so gem upgrades can add routes without
+    editing the app.
+
+- Initial extraction of the schema-change GUI out of the inline_forms engine
+  into this separate mountable engine gem (phase 0 of
+  `stuff/2026-07-11-schema-gui-gem-and-automated-pipeline-plan.md`):
+  `InlineForms::SchemaController`, its views and the `inline_forms_schema`
+  layout. The staging services (`SchemaIntent`, `SchemaPreview`,
+  `SchemaApply`, `SchemaLabel`) stay in inline_forms. Apps opt in via
+  `inline_forms create --schema-edit` (implied by `--example`).

data/app/controllers/inline_forms/schema_controller.rb

@@ -0,0 +1,228 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # GUI to add a field to a model through the browser, building on the
+  # schema-staging services in inline_forms. Two ways to act on an intent:
+  #
+  #  * DIRECT APPLY (dev only, the phase-0 flow): `create` runs
+  #    inline_forms_addto in-process (model edit + migration file) but NOT
+  #    db:migrate; the pending-migration gate covers the window.
+  #  * BATCH DRAFTING (the pipeline flow): `draft` persists the intent into
+  #    the current draft SchemaBatch (the "cart"); `submit_batch` freezes it
+  #    for the automated pull -> CI -> deploy loop. Nothing is generated in
+  #    the request cycle.
+  #
+  # Production posture: direct apply is NEVER available in production
+  # (production never writes code). Drafting is also non-production unless
+  # the app opts in (InlineFormsSchemaEdit.production_drafting = true — the
+  # SaaS tenant case). The machine endpoints (export/batch_status) are
+  # token-authenticated and environment-independent, for the CI side.
+  class SchemaController < InlineFormsApplicationController
+    HEADER = InlineFormsSchemaEdit::IntentValidator::HEADER
+
+    layout "inline_forms_schema"
+
+    skip_before_action :verify_authenticity_token, only: :batch_status, raise: false
+
+    before_action :require_non_production, only: :create
+    before_action :require_drafting_allowed, except: [ :create, :export, :batch_status ]
+    before_action :authenticate_pipeline_token!, only: [ :export, :batch_status ]
+    before_action :load_form_options, only: [ :new, :preview, :create, :draft ]
+    before_action :require_batch_tables, only: [ :index, :draft, :remove_draft, :submit_batch ]
+
+    # Injectable so tests record instead of mutating the working tree.
+    cattr_accessor :generator_executor
+    cattr_accessor :label_writer
+
+    # The cart + batch history.
+    def index
+      @draft_batch = InlineForms::SchemaBatch.with_status(:draft).order(:id).first
+      @batches = InlineForms::SchemaBatch.where.not(status: "draft").order(id: :desc).limit(25)
+    end
+
+    def new
+      @intent_params = blank_intent_params
+    end
+
+    def preview
+      @intent_params = intent_params
+      @error = InlineFormsSchemaEdit::IntentValidator.error_for(@intent_params)
+      return render(:new) if @error
+
+      @intent    = build_intent(@intent_params)
+      @is_header = @intent.form_element == :header
+      if @is_header
+        @attribute_list = InlineForms::SchemaPreview.attribute_list_for(@intent.model_class, @intent)
+      else
+        @preview, @attribute_list = InlineForms::SchemaPreview.build(@intent)
+      end
+      @batching_available = batch_tables_present?
+    end
+
+    # DIRECT APPLY (dev only): codegen into this checkout's tree.
+    def create
+      @intent_params = intent_params
+      @error = InlineFormsSchemaEdit::IntentValidator.error_for(@intent_params)
+      return render(:new) if @error
+
+      @intent    = build_intent(@intent_params)
+      @is_header = @intent.form_element == :header
+      begin
+        @migration_path = InlineForms::SchemaApply.new(@intent).generate!(
+          destination_root: Rails.root,
+          executor: generator_executor || InlineForms::SchemaApply::DEFAULT_GENERATE_EXECUTOR
+        )
+        @migration_basename = @migration_path && File.basename(@migration_path)
+        write_label!
+      rescue StandardError => e
+        @error = "Generator failed: #{e.message}"
+        render(:new)
+      end
+    end
+
+    # BATCH DRAFTING: persist the intent into the current draft batch.
+    def draft
+      @intent_params = intent_params
+      @error = InlineFormsSchemaEdit::IntentValidator.error_for(@intent_params)
+      return render(:new) if @error
+
+      batch = InlineForms::SchemaBatch.current_draft
+      batch.intents.create!(
+        target_model: @intent_params[:model_name],
+        attr_name:    @intent_params[:attribute],
+        form_element: @intent_params[:form_element],
+        after_attr:   @intent_params[:after].presence,
+        label:        @intent_params[:label].presence,
+        locale:       @intent_params[:locale].presence
+      )
+      redirect_to inline_forms_schema_index_path
+    end
+
+    def remove_draft
+      intent = InlineForms::SchemaIntentRecord.find(params[:id])
+      if intent.batch&.draft?
+        intent.destroy
+        redirect_to inline_forms_schema_index_path
+      else
+        redirect_to inline_forms_schema_index_path, alert: "Batch is frozen."
+      end
+    end
+
+    def submit_batch
+      batch = InlineForms::SchemaBatch.current_draft
+      window = params[:window_at].presence && Time.zone.parse(params[:window_at])
+      batch.submit!(requested_by: requesting_identity, window_at: window)
+      redirect_to inline_forms_schema_index_path
+    rescue ArgumentError => e
+      redirect_to inline_forms_schema_index_path, alert: e.message
+    end
+
+    # MACHINE ENDPOINT (token): the frozen batch as JSON for the CI side.
+    def export
+      batch = InlineForms::SchemaBatch.find(params[:id])
+      return render(json: { error: "batch is still a draft" }, status: :conflict) if batch.draft?
+
+      render json: InlineFormsSchemaEdit::BatchExport.payload(batch)
+    end
+
+    # MACHINE ENDPOINT (token): CI reports progress back.
+    # Params: status (processing|ready|applied|failed), git_sha, error.
+    def batch_status
+      batch = InlineForms::SchemaBatch.find(params[:id])
+      batch.transition!(params[:status].to_s, git_sha: params[:git_sha].presence, error: params[:error].presence)
+      render json: { id: batch.id, status: batch.status }
+    rescue ArgumentError => e
+      render json: { error: e.message }, status: :unprocessable_entity
+    end
+
+    private
+
+    def require_non_production
+      head :not_found if Rails.env.production?
+    end
+
+    def require_drafting_allowed
+      return unless Rails.env.production?
+
+      head :not_found unless InlineFormsSchemaEdit.production_drafting
+    end
+
+    # 404 when unconfigured (don't advertise the endpoint), 401 on mismatch.
+    def authenticate_pipeline_token!
+      configured = InlineFormsSchemaEdit.export_token
+      return head(:not_found) if configured.blank?
+
+      provided = request.headers["Authorization"].to_s[/\ABearer (.+)\z/, 1] || params[:token].to_s
+      unless ActiveSupport::SecurityUtils.secure_compare(configured, provided.to_s)
+        head :unauthorized
+      end
+    end
+
+    def batch_tables_present?
+      InlineForms::SchemaBatch.table_exists? && InlineForms::SchemaIntentRecord.table_exists?
+    rescue StandardError
+      false
+    end
+
+    def require_batch_tables
+      return if batch_tables_present?
+
+      render plain: "Schema-GUI batch tables missing. Run: bin/rails g inline_forms_schema_edit:install && bin/rails db:migrate",
+             status: :service_unavailable
+    end
+
+    def requesting_identity
+      return nil unless respond_to?(:current_user, true)
+
+      current_user&.email
+    rescue StandardError
+      nil
+    end
+
+    def load_form_options
+      @form_elements = InlineForms::SchemaPreview.supported_form_elements
+      @models        = InlineFormsSchemaEdit::IntentValidator.candidate_models
+      @locales       = I18n.available_locales.map(&:to_s)
+      @default_locale = I18n.default_locale.to_s
+    end
+
+    def blank_intent_params
+      { model_name: "", attribute: "", form_element: @form_elements.first.to_s,
+        after: "", label: "", locale: @default_locale }
+    end
+
+    def intent_params
+      {
+        model_name:   params[:model_name].to_s.strip,
+        attribute:    params[:attribute].to_s.strip,
+        form_element: params[:form_element].to_s.strip,
+        after:        params[:after].to_s.strip,
+        label:        params[:label].to_s.strip,
+        locale:       params[:locale].to_s.strip.presence || @default_locale
+      }
+    end
+
+    def build_intent(p)
+      InlineForms::SchemaIntent.new(
+        model_name:   p[:model_name],
+        attribute:    p[:attribute],
+        form_element: p[:form_element],
+        after:        p[:after].presence
+      )
+    end
+
+    def write_label!
+      return if @intent_params[:label].blank?
+
+      writer = label_writer || InlineForms::SchemaLabel.method(:write)
+      @label_path = writer.call(
+        destination_root: Rails.root,
+        model_class: @intent.model_class,
+        attribute: @intent.attribute,
+        label: @intent_params[:label],
+        locale: @intent_params[:locale]
+      )
+      @label_basename = @label_path && File.basename(@label_path.to_s)
+    end
+  end
+end

data/app/models/inline_forms/schema_batch.rb

@@ -0,0 +1,116 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # A batch of proposed schema changes (SchemaIntentRecord rows), the unit
+  # the automated pipeline processes. Lifecycle:
+  #
+  #   draft      — admin is still adding/removing intents (the "cart")
+  #   submitted  — frozen; waiting for CI to pick it up
+  #   processing — CI is generating code / running the test gate
+  #   ready      — code committed (git_sha set); waiting for the deploy window
+  #   applied    — migrated + restarted
+  #   failed     — any step failed; error holds the diagnostics
+  #
+  # IMMUTABILITY: the moment a batch leaves draft, its intents are frozen
+  # (enforced in SchemaIntentRecord) and the batch itself only accepts
+  # status-flow updates (status, git_sha, error, applied_at). content_digest
+  # seals the intent list at submit time; export re-emits it and the import
+  # side re-verifies it, so a batch provably cannot change between "admin
+  # pressed submit" and "CI replayed it".
+  class SchemaBatch < ActiveRecord::Base
+    self.table_name = "inline_forms_schema_batches"
+
+    STATUSES = %w[draft submitted processing ready applied failed].freeze
+    TRANSITIONS = {
+      "draft"      => %w[submitted],
+      "submitted"  => %w[processing failed],
+      "processing" => %w[ready failed],
+      "ready"      => %w[applied failed],
+      "failed"     => %w[submitted],   # resubmit after a fix
+      "applied"    => []
+    }.freeze
+
+    # Columns the pipeline may still write after the batch left draft.
+    STATUS_FLOW_COLUMNS = %w[status git_sha error applied_at updated_at].freeze
+
+    has_many :intents,
+             -> { order(:position, :id) },
+             class_name: "InlineForms::SchemaIntentRecord",
+             foreign_key: :batch_id,
+             inverse_of: :batch,
+             dependent: :destroy
+
+    validates :status, inclusion: { in: STATUSES }
+
+    before_update :allow_only_status_flow_after_draft
+    before_destroy :only_draft_batches_are_destroyable
+
+    scope :with_status, ->(s) { where(status: s.to_s) }
+
+    def self.current_draft
+      with_status(:draft).order(:id).first_or_create!
+    end
+
+    def draft? = status == "draft"
+    def submitted? = status == "submitted"
+    def processing? = status == "processing"
+    def ready? = status == "ready"
+    def applied? = status == "applied"
+    def failed? = status == "failed"
+
+    # ready + the requested window (if any) has arrived.
+    def due_for_apply?
+      ready? && (window_at.nil? || window_at <= Time.current)
+    end
+
+    # Freeze the batch: seal the digest, record who/when, optionally a window.
+    def submit!(requested_by: nil, window_at: nil)
+      raise ArgumentError, "only a draft batch can be submitted" unless draft?
+      raise ArgumentError, "cannot submit an empty batch" if intents.reload.empty?
+
+      with_lock do
+        self.status         = "submitted"
+        self.submitted_at   = Time.current
+        self.window_at      = window_at
+        self.requested_by   = requested_by if requested_by
+        self.content_digest = InlineFormsSchemaEdit::BatchExport.digest_for(self)
+        save!
+      end
+      self
+    end
+
+    # Status-flow update used by the pipeline (CI callback / apply task).
+    def transition!(to, git_sha: nil, error: nil)
+      to = to.to_s
+      unless TRANSITIONS.fetch(status, []).include?(to)
+        raise ArgumentError, "illegal transition #{status} -> #{to}"
+      end
+
+      self.status  = to
+      self.git_sha = git_sha if git_sha
+      self.error   = error if error
+      self.applied_at = Time.current if to == "applied"
+      save!
+      self
+    end
+
+    private
+
+    def allow_only_status_flow_after_draft
+      return if status_was == "draft"
+
+      illegal = changed - STATUS_FLOW_COLUMNS
+      return if illegal.empty?
+
+      errors.add(:base, "batch is frozen after submit (illegal change to #{illegal.join(', ')})")
+      throw :abort
+    end
+
+    def only_draft_batches_are_destroyable
+      return if draft?
+
+      errors.add(:base, "only draft batches can be deleted")
+      throw :abort
+    end
+  end
+end

data/app/models/inline_forms/schema_intent_record.rb

@@ -0,0 +1,80 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # A persisted schema intent: one proposed "add attribute X of form-element
+  # Y to model Z at this position" row inside a SchemaBatch. This is the AR
+  # counterpart of the InlineForms::SchemaIntent value object (which stays a
+  # plain object in inline_forms); #to_schema_intent bridges the two.
+  #
+  # Rows are editable only while their batch is a draft. `migration_version`
+  # is the one exception: the pipeline backfills it after apply.
+  class SchemaIntentRecord < ActiveRecord::Base
+    self.table_name = "inline_forms_schema_intents"
+
+    # Pipeline backfill columns, writable after the batch froze.
+    BACKFILL_COLUMNS = %w[migration_version updated_at].freeze
+
+    belongs_to :batch,
+               class_name: "InlineForms::SchemaBatch",
+               foreign_key: :batch_id,
+               inverse_of: :intents
+
+    # Columns are `target_model` / `attr_name` (`model_name` collides with
+    # ActiveModel::Naming, `attribute` with the AR attribute API); the export
+    # JSON keys stay "model_name"/"attribute" to match the SchemaIntent
+    # value object.
+    validates :target_model, :attr_name, :form_element, presence: true
+
+    before_save :only_in_draft_batches
+    before_destroy :only_in_draft_batches_destroy
+
+    before_create :assign_position
+
+    def to_schema_intent
+      InlineForms::SchemaIntent.new(
+        model_name:   target_model,
+        attribute:    attr_name,
+        form_element: form_element,
+        after:        after_attr.presence,
+        before:       before_attr.presence
+      )
+    end
+
+    def header? = form_element == "header"
+
+    # Canonical export shape; also the digest input (see BatchExport), so
+    # key order is fixed and values are normalized strings/nil.
+    def as_export
+      {
+        "model_name"   => target_model,
+        "attribute"    => attr_name,
+        "form_element" => form_element,
+        "after"        => after_attr.presence,
+        "before"       => before_attr.presence,
+        "label"        => label.presence,
+        "locale"       => locale.presence
+      }
+    end
+
+    private
+
+    def assign_position
+      self.position ||= (batch&.intents&.maximum(:position) || 0) + 1
+    end
+
+    def only_in_draft_batches
+      return if batch.nil? || batch.draft?
+      return if !new_record? && (changed - BACKFILL_COLUMNS).empty?
+
+      errors.add(:base, "batch is frozen; intents can no longer change")
+      throw :abort
+    end
+
+    def only_in_draft_batches_destroy
+      return if batch.nil? || batch.draft?
+
+      errors.add(:base, "batch is frozen; intents can no longer be removed")
+      throw :abort
+    end
+  end
+end

data/app/views/inline_forms/schema/create.html.erb

@@ -0,0 +1,57 @@
+<h2>Applied: <code><%= @intent.attribute %>:<%= @intent.form_element %></code> on <code><%= @intent.model_name %></code></h2>
+
+<% if @label_basename %>
+  <p class="notice">
+    Wrote label <code><%= @intent_params[:label] %></code> (locale
+    <code><%= @intent_params[:locale] %></code>) to
+    <code><%= @label_basename %></code>. Restart to load the new translation.
+  </p>
+<% end %>
+
+<% if @is_header %>
+  <p class="notice">
+    Added a <strong>header</strong> row to
+    <code>app/models/<%= @intent.model_name.underscore %>.rb</code>. No column,
+    <strong>no migration</strong> &mdash; it appears on the next reload.
+  </p>
+
+  <h2>Next steps (you run these)</h2>
+  <ol>
+    <li>Review the change: <code>git status</code> / <code>git diff</code></li>
+    <li>Commit it so the change flows through git to every environment.</li>
+    <% if @label_basename %><li>Restart the server to load the label.</li><% end %>
+  </ol>
+<% else %>
+  <% if @migration_basename %>
+    <p class="notice">
+      Generated migration <code><%= @migration_basename %></code> and edited
+      <code>app/models/<%= @intent.model_name.underscore %>.rb</code>.
+    </p>
+  <% else %>
+    <p class="notice">Ran the generator for <code><%= @intent.generator_args.join(" ") %></code>.</p>
+  <% end %>
+
+  <% if InlineForms::VALUE_BEARING_FORM_ELEMENTS.include?(@intent.form_element) %>
+    <p class="notice">
+      Choice element: a placeholder values hash was inserted. Edit the
+      <code>[ :<%= @intent.attribute %>, :<%= @intent.form_element %>, { ... } ]</code>
+      row in the model to your real values.
+    </p>
+  <% end %>
+
+  <p class="notice">
+    <strong>Heads up (development):</strong> Rails now blocks every page with a
+    <code>PendingMigrationError</code> until this migration is applied. That is
+    Rails&rsquo; own check, not inline_forms &mdash; your cue to migrate.
+  </p>
+
+  <h2>Next steps (you run these)</h2>
+  <ol>
+    <li>Review the changes: <code>git status</code> / <code>git diff</code></li>
+    <li>Apply the migration: <code>bin/rails db:migrate</code></li>
+    <li>Restart the server so the new column is picked up.</li>
+    <li>Commit the generated files so the change flows through git to every environment.</li>
+  </ol>
+<% end %>
+
+<p class="muted">After the above, add another field at <code>/schema/new</code>.</p>

data/app/views/inline_forms/schema/index.html.erb

@@ -0,0 +1,63 @@
+<% if flash[:alert].present? %>
+  <p class="error"><%= flash[:alert] %></p>
+<% end %>
+
+<h2>Draft batch (the cart)</h2>
+<% if @draft_batch && @draft_batch.intents.any? %>
+  <table class="schema_list">
+    <thead><tr><th>#</th><th>Model</th><th>Attribute</th><th>Element</th><th>Label</th><th></th></tr></thead>
+    <tbody>
+      <% @draft_batch.intents.each do |intent| %>
+        <tr>
+          <td><%= intent.position %></td>
+          <td><%= intent.target_model %></td>
+          <td><code><%= intent.attr_name %></code><%= " (after #{intent.after_attr})" if intent.after_attr.present? %></td>
+          <td><%= intent.form_element %></td>
+          <td><%= intent.label %></td>
+          <td>
+            <%= form_tag inline_forms_schema_remove_draft_path(intent), method: :delete, data: { turbo: false } do %>
+              <%= submit_tag "remove" %>
+            <% end %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+
+  <%= form_tag inline_forms_schema_submit_batch_path, method: :post, data: { turbo: false } do %>
+    <label for="window_at">Apply window (optional; blank = next default window)</label>
+    <input type="datetime-local" name="window_at" id="window_at" />
+    <div class="actions">
+      <%= submit_tag "Submit batch (freezes it)" %>
+    </div>
+  <% end %>
+  <p class="muted">Submitting freezes the batch: no more edits. The pipeline picks
+    it up, generates the code on a checkout, runs the test gate, and applies it in
+    the chosen window. New drafts go into a fresh batch.</p>
+<% else %>
+  <p class="muted">No drafted changes. <%= link_to "Add a field", inline_forms_schema_new_path %>.</p>
+<% end %>
+
+<h2>Batch history</h2>
+<% if @batches.any? %>
+  <table class="schema_list">
+    <thead><tr><th>Batch</th><th>Status</th><th>Submitted</th><th>Window</th><th>Fields</th><th>Git</th><th>Error</th></tr></thead>
+    <tbody>
+      <% @batches.each do |batch| %>
+        <tr>
+          <td>#<%= batch.id %></td>
+          <td><strong><%= batch.status %></strong></td>
+          <td><%= batch.submitted_at&.strftime("%F %R") %></td>
+          <td><%= batch.window_at ? batch.window_at.strftime("%F %R") : "next window" %></td>
+          <td><%= batch.intents.map { |i| "#{i.target_model}##{i.attr_name}" }.join(", ") %></td>
+          <td><code><%= batch.git_sha.to_s.first(10) %></code></td>
+          <td class="muted"><%= batch.error.to_s.truncate(120) %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% else %>
+  <p class="muted">No submitted batches yet.</p>
+<% end %>
+
+<p><%= link_to "Add a field", inline_forms_schema_new_path %></p>

data/app/views/inline_forms/schema/new.html.erb

@@ -0,0 +1,49 @@
+<% if @error.present? %>
+  <p class="error"><%= @error %></p>
+<% end %>
+
+<%= form_tag inline_forms_schema_preview_path, method: :post, data: { turbo: false } do %>
+  <label for="model_name">Model</label>
+  <input type="text" name="model_name" id="model_name" list="schema_models"
+         value="<%= @intent_params[:model_name] %>" placeholder="e.g. Apartment" />
+  <datalist id="schema_models">
+    <% @models.each do |m| %><option value="<%= m %>"></option><% end %>
+  </datalist>
+
+  <label for="attribute">Attribute name</label>
+  <input type="text" name="attribute" id="attribute"
+         value="<%= @intent_params[:attribute] %>" placeholder="e.g. internal_note" />
+
+  <label for="form_element">Form element</label>
+  <select name="form_element" id="form_element">
+    <optgroup label="Fields (add a column)">
+      <% @form_elements.each do |fe| %>
+        <option value="<%= fe %>" <%= "selected" if @intent_params[:form_element] == fe.to_s %>><%= fe %></option>
+      <% end %>
+    </optgroup>
+    <optgroup label="No column">
+      <option value="header" <%= "selected" if @intent_params[:form_element] == "header" %>>header (section separator &mdash; no migration)</option>
+    </optgroup>
+  </select>
+
+  <label for="after">Insert after (optional attribute name)</label>
+  <input type="text" name="after" id="after"
+         value="<%= @intent_params[:after] %>" placeholder="leave blank to append" />
+
+  <label for="label">Label (optional) &mdash; the text shown for this field/header</label>
+  <input type="text" name="label" id="label"
+         value="<%= @intent_params[:label] %>" placeholder="e.g. Internal note" />
+
+  <label for="locale">Label locale</label>
+  <select name="locale" id="locale">
+    <% @locales.each do |loc| %>
+      <option value="<%= loc %>" <%= "selected" if @intent_params[:locale] == loc %>><%= loc %></option>
+    <% end %>
+  </select>
+
+  <div class="actions">
+    <%= submit_tag "Preview" %>
+  </div>
+<% end %>
+
+<p class="muted"><%= link_to "Batches (drafts + history)", inline_forms_schema_index_path %></p>