inline_forms 8.1.40 → 8.1.42

data/lib/generators/inline_forms_addto_generator.rb

@@ -33,11 +33,27 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
     INSTALL_TIME_ONLY_NAMES = %w[_no_model _no_migration _id _enabled].freeze
     REPLACE_ONLY_NAMES      = %w[_presentation _list_order _list_search _order].freeze
 
+    # Form elements that render a set of choices and therefore need a values
+    # hash as the 3rd element of their attribute_list row. Emitting the bare
+    # 2-element row for these raises at show time, so we insert a placeholder
+    # hash and warn the user to fill it in. Canonical list lives in InlineForms
+    # (shared with the schema GUI/preview).
+    VALUE_BEARING_ELEMENTS = InlineForms::VALUE_BEARING_FORM_ELEMENTS
+
+    # attribute_list rows whose form element (or name) marks the start of the
+    # trailing "metadata" block. The smart-default placement inserts new rows
+    # above this block instead of at the very end of the list.
+    METADATA_ROW_NAMES = %w[created_at updated_at].freeze
+
     argument :attributes, type: :array, banner: "[name:form_element]..."
     class_option :allow_unknown, type: :boolean, default: false,
                  desc: "Allow unknown field types (legacy behavior: comment generated lines instead of failing)."
     class_option :replace, type: :boolean, default: false,
                  desc: "Replace existing _presentation/_list_order/_list_search instead of skipping."
+    class_option :before, type: :string, default: nil,
+                 desc: "Insert the new attribute_list row before this existing attribute name."
+    class_option :after, type: :string, default: nil,
+                 desc: "Insert the new attribute_list row after this existing attribute name."
 
     source_root File.expand_path("inline_forms_addto/templates", __dir__)
 
@@ -94,6 +110,10 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
         next if INSTALL_TIME_ONLY_NAMES.include?(attribute.name)
         next if REPLACE_ONLY_NAMES.include?(attribute.name)
         next unless attribute.migration?
+        # A :header is a display-only separator in the attribute list; it has
+        # no backing column, so it must not emit a migration line (otherwise
+        # `foo:header` created a pointless `foo` string column).
+        next if attribute.attribute_type == :header
 
         if attribute.column_type == :belongs_to
           @migration_lines << "    add_reference :#{table_name}, :#{attribute.name}, foreign_key: true\n"
@@ -106,7 +126,7 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
       return if @migration_lines.empty?
 
       template "add_columns_migration.erb",
-               "db/migrate/#{time_stamp}_#{migration_file_basename}.rb"
+               "db/migrate/#{unique_time_stamp}_#{migration_file_basename}.rb"
     end
 
     def update_model
@@ -146,6 +166,20 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
       end
     end
 
+    # Run last (Thor invokes public methods in definition order). The model
+    # row was injected above, but it references a column that does not exist
+    # until the generated migration is applied; rendering the model before
+    # then raises. Remind the user loudly. No-op when no migration was written
+    # (e.g. only has_many/rich_text/habtm additions).
+    def remind_to_migrate
+      return if @migration_lines.nil? || @migration_lines.empty?
+
+      say ""
+      say "  Next step: apply the generated migration before rendering #{model_class_name}:", :yellow
+      say "    bundle exec rails db:migrate", :yellow
+      say "  (the attribute_list row was added now, but its column only exists after migrating.)", :yellow
+    end
+
     private
 
     def model_file_name
@@ -204,43 +238,181 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
     end
 
     # Inserts a new row into the existing `inline_forms_attribute_list`
-    # method. Falls back to appending a fresh method when the model has
-    # only `attr_writer :inline_forms_attribute_list` (inherited from
-    # `ApplicationRecord`) and no body.
+    # method. Falls back to appending a fresh method when the model has no
+    # generator-shaped list (e.g. only the inherited
+    # `attr_writer :inline_forms_attribute_list` and no body).
+    #
+    # Row-aware, not regex-greedy: we locate the `[` after
+    # `@inline_forms_attribute_list ||=` and bracket-depth scan to its
+    # matching `]`, so the edit survives `].freeze`, trailing comments, and
+    # any methods defined after the list. Placement honors `--after`/`--before`
+    # (by attribute name) and otherwise lands above the trailing metadata block
+    # (`:info` rows / created_at / updated_at, and a `:header` directly above
+    # them) instead of after it.
     def add_attribute_list_row!(attribute)
-      content = File.read(File.join(destination_root, model_file_path))
-      row = "      [ :#{attribute.name}, :#{attribute.attribute_type} ],\n"
+      path    = File.join(destination_root, model_file_path)
+      content = File.read(path)
 
-      if content.match?(/@inline_forms_attribute_list \|\|=\s*\[/)
-        if content.match?(/\[\s*:#{Regexp.escape(attribute.name)}\s*,/)
-          say_status :identical, "#{model_file_path}: row :#{attribute.name}", :blue
-          return
-        end
-        # Insert before the closing `]` of the array, keeping appended order.
-        # Match against the file's full text and write it back so we work
-        # around Thor's `gsub_file` block-arg quirk (the block sees only the
-        # full match, no $1/$2). MatchData captures are explicit here.
-        m = content.match(/(@inline_forms_attribute_list \|\|=\s*\[(?:.|\n)*?)(\n\s*\]\s*\n\s*end)/)
-        if m
-          replacement = m[1] + "\n" + row.chomp + m[2]
-          new_content = content.sub(m[0], replacement)
-          File.write(File.join(destination_root, model_file_path), new_content)
-          say_status :insert, "#{model_file_path}: row :#{attribute.name}", :green
-        else
-          say_status :warn, "#{model_file_path}: could not locate end of @inline_forms_attribute_list, skipping :#{attribute.name}", :yellow
-        end
-      else
+      # Idempotent: skip if a row for this attribute already exists anywhere.
+      if content.match?(/\[\s*:#{Regexp.escape(attribute.name)}\s*,/)
+        say_status :identical, "#{model_file_path}: row :#{attribute.name}", :blue
+        return
+      end
+
+      bounds = attribute_list_bounds(content)
+      unless bounds
         say_status :warn, "#{model_file_path}: no inline_forms_attribute_list found, appending a fresh method", :yellow
         body = <<~RUBY.gsub(/^/, "  ")
 
           def inline_forms_attribute_list
             @inline_forms_attribute_list ||= [
-              [ :#{attribute.name}, :#{attribute.attribute_type} ],
+              #{attribute_row_literal(attribute)},
             ]
           end
         RUBY
         inject_into_class model_file_path, model_class_name, body
+        return
+      end
+
+      warn_if_value_bearing!(attribute)
+
+      open_idx, close_idx = bounds
+      inner  = content[(open_idx + 1)...close_idx]
+      lines  = inner.lines
+      indent = detect_row_indent(lines)
+      new_line = "#{indent}#{attribute_row_literal(attribute)},\n"
+
+      insert_at, note = insertion_index(lines, attribute)
+
+      # Keep the array valid: ensure the row we insert after ends with a comma.
+      if insert_at.positive?
+        prev = lines[insert_at - 1]
+        if prev && prev.match?(/\S/) && !prev.match?(/,\s*\z/)
+          lines[insert_at - 1] = prev.sub(/(\S)(\s*)\z/, "\\1,\\2")
+        end
+      end
+
+      lines.insert(insert_at, new_line)
+      new_content = content[0..open_idx] + lines.join + content[close_idx..-1]
+      File.write(path, new_content)
+      say_status :insert, "#{model_file_path}: row :#{attribute.name}#{note}", :green
+    end
+
+    # Returns [open_bracket_index, close_bracket_index] for the
+    # `@inline_forms_attribute_list ||= [ ... ]` array literal, or nil when the
+    # model has no such list. Bracket-depth scan; nested `[ ]` (e.g. an
+    # options_disabled array inside a choice row) balances correctly.
+    def attribute_list_bounds(content)
+      m = content.match(/@inline_forms_attribute_list\s*\|\|=\s*\[/)
+      return nil unless m
+
+      open_idx = m.end(0) - 1 # index of the '[' itself
+      depth = 0
+      i = open_idx
+      while i < content.length
+        case content[i]
+        when "[" then depth += 1
+        when "]"
+          depth -= 1
+          return [ open_idx, i ] if depth.zero?
+        end
+        i += 1
+      end
+      nil
+    end
+
+    # Decide where the new row goes. Returns [line_index, status_note].
+    def insertion_index(lines, _attribute)
+      if (anchor = options[:after].to_s) != ""
+        idx = row_line_index(lines, anchor)
+        return [ idx + 1, " (after :#{anchor})" ] if idx
+        say_status :warn, "#{model_file_path}: --after #{anchor} not found; using default placement", :yellow
+      elsif (anchor = options[:before].to_s) != ""
+        idx = row_line_index(lines, anchor)
+        return [ idx, " (before :#{anchor})" ] if idx
+        say_status :warn, "#{model_file_path}: --before #{anchor} not found; using default placement", :yellow
+      end
+
+      if (meta = metadata_start_index(lines))
+        return [ meta, " (above metadata)" ]
+      end
+
+      [ last_row_index(lines) + 1, "" ]
+    end
+
+    def row_line_index(lines, name)
+      lines.index { |l| row_name(l) == name.to_s }
+    end
+
+    def row_name(line)
+      m = line.match(/\A\s*\[\s*:(\w+)\s*,/)
+      m && m[1]
+    end
+
+    def row_element(line)
+      m = line.match(/\A\s*\[\s*:\w+\s*,\s*:(\w+)/)
+      m && m[1]
+    end
+
+    # Index of the first row that starts the trailing metadata block. If a
+    # `:header` sits directly above that row, the header is treated as the
+    # block start (so the new field lands above the header, not between it and
+    # its info rows). nil when the list has no metadata block.
+    def metadata_start_index(lines)
+      first = nil
+      lines.each_with_index do |l, i|
+        if row_element(l) == "info" || METADATA_ROW_NAMES.include?(row_name(l))
+          first = i
+          break
+        end
+      end
+      return nil unless first
+
+      prev = first - 1
+      (prev >= 0 && row_element(lines[prev]) == "header") ? prev : first
+    end
+
+    def last_row_index(lines)
+      idx = nil
+      lines.each_with_index { |l, i| idx = i if row_name(l) }
+      idx || (lines.length - 1)
+    end
+
+    def detect_row_indent(lines)
+      lines.each do |l|
+        m = l.match(/\A(\s*)\[/)
+        return m[1] if m
+      end
+      "      " # 6 spaces, matching the create-time template
+    end
+
+    # `[ :name, :element ]`, or `[ :name, :element, { 1 => 'one', 2 => 'two' } ]`
+    # for value-bearing choice elements (a placeholder the user then edits).
+    def attribute_row_literal(attribute)
+      el = attribute.attribute_type
+      if VALUE_BEARING_ELEMENTS.include?(el)
+        "[ :#{attribute.name}, :#{el}, { 1 => 'one', 2 => 'two' } ]"
+      else
+        "[ :#{attribute.name}, :#{el} ]"
+      end
+    end
+
+    def warn_if_value_bearing!(attribute)
+      return unless VALUE_BEARING_ELEMENTS.include?(attribute.attribute_type)
+
+      say_status :warn,
+                 "#{model_file_path}: :#{attribute.name} is a #{attribute.attribute_type}; " \
+                 "edit the placeholder values hash { 1 => 'one', ... }",
+                 :yellow
+    end
+
+    def unique_time_stamp
+      base = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      dir  = File.join(destination_root, "db", "migrate")
+      existing = Dir.glob(File.join(dir, "*.rb")).filter_map do |f|
+        File.basename(f)[/\A(\d{14})/, 1]&.to_i
       end
+      [ base, (existing.max || 0) + 1 ].max.to_s.rjust(14, "0")
     end
 
     def replace_special!(attribute)

data/lib/inline_forms/attribute_list.rb

@@ -0,0 +1,191 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # A structured, mutable view over a model's `inline_forms_attribute_list`.
+  #
+  # The list has always been (and remains) an Array of positional rows:
+  #
+  #   [ :name,      :text_field ]
+  #   [ :priority,  :dropdown_with_values, { 1 => 'low', 2 => 'high' } ]
+  #   [ :priority2, :dropdown_with_values, { 1 => 'low', 2 => 'high' }, [ 2 ] ]
+  #
+  # where index 0 is the attribute, index 1 the form element, index 2 an
+  # optional values hash, and index 3 an optional disabled-options array.
+  #
+  # Every downstream consumer relies on that shape: the views destructure
+  # `|attribute, form_element|`, and the helpers/validator fetch the values
+  # hash positionally with `list.assoc(attr)[2]`. `AttributeList` therefore
+  # *subclasses Array* and keeps rows as plain arrays — so an `AttributeList`
+  # IS a valid attribute list everywhere the old literal array was, with zero
+  # migration. What it adds is a small DSL/API for building and editing the
+  # list procedurally (append / insert / remove / move / replace) instead of
+  # hand-editing an array literal or regex-surgery on model source.
+  #
+  # Build fresh:
+  #
+  #   InlineForms::AttributeList.build do
+  #     header :basics
+  #     field  :name,     :text_field
+  #     field  :priority, :dropdown_with_values, values: { 1 => 'low', 2 => 'high' }
+  #     info   :created_at, :updated_at
+  #   end
+  #
+  # Wrap and edit an existing list (what generators / the staging pipeline do):
+  #
+  #   InlineForms::AttributeList.wrap(model.inline_forms_attribute_list)
+  #     .insert_after(:name, :internal_note, :text_field)
+  #     .remove(:legacy_field)
+  #
+  # Mutating methods return self, so calls chain.
+  class AttributeList < Array
+    # Build a list from a block evaluated in the list's context.
+    def self.build(&block)
+      list = new
+      list.instance_eval(&block) if block
+      list
+    end
+
+    # Return `rows` as an AttributeList without copying when it already is one.
+    def self.wrap(rows)
+      return rows if rows.is_a?(self)
+
+      new(rows || [])
+    end
+
+    # -- builder / append -------------------------------------------------
+
+    # Append a row. `values` becomes index 2, `disabled` index 3 (disabled
+    # requires values, since the slot is positional).
+    def field(name, form_element, values: nil, disabled: nil)
+      push(build_row(name, form_element, values, disabled))
+      self
+    end
+    alias add field
+
+    # Append a `:header` pseudo-row (no column, no form element behavior).
+    def header(name)
+      field(name, :header)
+    end
+
+    # Append one or more read-only `:info` rows.
+    def info(*names)
+      names.each { |n| field(n, :info) }
+      self
+    end
+
+    # -- insertion --------------------------------------------------------
+
+    def insert_after(anchor, name, form_element, values: nil, disabled: nil)
+      insert_relative(anchor, 1, build_row(name, form_element, values, disabled))
+    end
+
+    def insert_before(anchor, name, form_element, values: nil, disabled: nil)
+      insert_relative(anchor, 0, build_row(name, form_element, values, disabled))
+    end
+
+    # -- removal ----------------------------------------------------------
+
+    # Remove every row for `name`. Idempotent: absent name is a no-op.
+    def remove(name)
+      sym = name.to_sym
+      reject! { |row| row_name(row) == sym }
+      self
+    end
+
+    # -- reordering -------------------------------------------------------
+
+    def move_after(name, anchor)
+      relocate(name, anchor, 1)
+    end
+
+    def move_before(name, anchor)
+      relocate(name, anchor, 0)
+    end
+
+    # -- replacement ------------------------------------------------------
+
+    # Swap the form element (and optional values/disabled) for an existing
+    # attribute, preserving its position. No-op if the attribute is absent.
+    def replace_element(name, form_element, values: nil, disabled: nil)
+      idx = index_of(name)
+      return self unless idx
+
+      self[idx] = build_row(name, form_element, values, disabled)
+      self
+    end
+
+    # -- queries ----------------------------------------------------------
+
+    def index_of(name)
+      sym = name.to_sym
+      index { |row| row_name(row) == sym }
+    end
+
+    def include_attribute?(name)
+      !index_of(name).nil?
+    end
+
+    def row_for(name)
+      sym = name.to_sym
+      find { |row| row_name(row) == sym }
+    end
+
+    # The form element symbol for `name`, or nil.
+    def form_element_for(name)
+      row = row_for(name)
+      row && row[1]
+    end
+
+    # The values hash for `name` (row index 2), or nil.
+    def values_for(name)
+      row = row_for(name)
+      row && row[2]
+    end
+
+    def names
+      map { |row| row_name(row) }
+    end
+
+    private
+
+    def row_name(row)
+      first = row.respond_to?(:first) ? row.first : nil
+      first&.to_sym
+    end
+
+    def build_row(name, form_element, values, disabled)
+      raise ArgumentError, "disabled: requires values: (the row slot is positional)" if !disabled.nil? && values.nil?
+
+      row = [ name.to_sym, form_element.to_sym ]
+      row << values unless values.nil?
+      row << disabled unless disabled.nil?
+      row
+    end
+
+    def insert_relative(anchor, offset, row)
+      idx = index_of(anchor)
+      raise ArgumentError, "insert anchor :#{anchor} not found in attribute list" unless idx
+
+      insert(idx + offset, row)
+      self
+    end
+
+    def relocate(name, anchor, offset)
+      row = row_for(name)
+      raise ArgumentError, "move target :#{name} not found in attribute list" unless row
+      raise ArgumentError, "cannot move :#{name} relative to itself" if name.to_sym == anchor.to_sym
+
+      remove(name)
+      idx = index_of(anchor)
+      raise ArgumentError, "move anchor :#{anchor} not found in attribute list" unless idx
+
+      insert(idx + offset, row)
+      self
+    end
+  end
+
+  # Convenience entry point mirroring AttributeList.build.
+  def self.attribute_list(&block)
+    AttributeList.build(&block)
+  end
+end

data/lib/inline_forms/gem_files.rb

@@ -9,6 +9,24 @@ module InlineFormsGemFiles
     inline_forms_installer.gemspec
   ].freeze
 
+  # The schema-GUI gem lives in its own subdirectory with its own gemspec
+  # (inline_forms_schema_edit/inline_forms_schema_edit.gemspec) and packages
+  # its files itself; exclude the whole subtree from BOTH gems here.
+  SCHEMA_GUI_FILE_PREFIXES = %w[
+    inline_forms_schema_edit/
+  ].freeze
+
+  # Scratch / local-notes dir. It holds working notes and, crucially, secrets
+  # such as stuff/forgejo-token (mode 0600, only used by CI pushes to forgejo).
+  # It must NEVER be packaged into a gem. Do not rely on git ignore for this:
+  # gem_files sweeps untracked files too, and the global excludes file that
+  # ignores stuff/ is per-machine (present here, absent on the release box), so
+  # the token leaked into `gem build` on the release machine. Exclude it hard,
+  # independent of any ignore configuration.
+  EXCLUDED_FILE_PREFIXES = %w[
+    stuff/
+  ].freeze
+
   module_function
 
   REPO_ROOT = File.expand_path("../..", __dir__)
@@ -32,6 +50,14 @@ module InlineFormsGemFiles
 
     files.select! { |f| File.file?(File.join(REPO_ROOT, f)) }
 
+    files.reject! do |f|
+      EXCLUDED_FILE_PREFIXES.any? { |prefix| f == prefix || f.start_with?(prefix) }
+    end
+
+    files.reject! do |f|
+      SCHEMA_GUI_FILE_PREFIXES.any? { |prefix| f == prefix || f.start_with?(prefix) }
+    end
+
     files.reject do |f|
       installer_file = INSTALLER_FILE_PREFIXES.any? { |prefix| f == prefix || f.start_with?(prefix) }
       include_installer ? !installer_file : installer_file

data/lib/inline_forms/schema_apply.rb

@@ -0,0 +1,85 @@
+# -*- encoding : utf-8 -*-
+
+require "shellwords"
+
+module InlineForms
+  # Skeleton of the "apply" step of the staging pipeline: turn an approved
+  # SchemaIntent into the ordered shell commands a developer would run by hand
+  # (generate the migration + model edit, migrate, test, commit, restart). This
+  # is the rare, expensive, deliberate step — see the staging doc.
+  #
+  # The engine does NOT execute these itself by default: which host runs them
+  # (a rake task on a single-server box, or a CI job after a PR on a clustered
+  # deploy) is an app decision. #commands returns the plan for inspection;
+  # #run! executes it via an injectable runner (defaults to Kernel#system) and
+  # stops at the first failure, so an app/rake task can opt in.
+  class SchemaApply
+    STEPS = %i[generate migrate].freeze
+
+    # In-process generate-only executor used by the schema GUI: runs the addto
+    # generator against the app's tree (edits the model, writes the migration
+    # file) but never migrates. Overridable so tests can record the args
+    # instead of mutating the working tree.
+    DEFAULT_GENERATE_EXECUTOR = lambda do |args, destination_root|
+      require "generators/inline_forms_addto_generator"
+      InlineFormsAddtoGenerator.start(args, destination_root: destination_root)
+    end
+
+    attr_reader :intent
+
+    def initialize(intent, runner: nil)
+      @intent = intent
+      @runner = runner || ->(cmd) { system(*cmd) }
+    end
+
+    # Run the addto generator in-process (model edit + migration file) WITHOUT
+    # running db:migrate. Returns the path of the migration it created (or nil
+    # when the executor did not create one, e.g. a recording test executor).
+    # The caller (GUI) then tells the user to run `rails db:migrate` + restart;
+    # the pending-migration gate covers the interim.
+    def generate!(destination_root:, executor: DEFAULT_GENERATE_EXECUTOR)
+      before = addto_migrations(destination_root)
+      executor.call(intent.generator_args, destination_root)
+      # Only report a migration this run actually created. nil is correct and
+      # expected for a :header (no column -> no migration) and must NOT fall
+      # back to a pre-existing migration file.
+      (addto_migrations(destination_root) - before).max
+    end
+
+    # `rails g inline_forms_addto <Model> <attr:fe> [--after=..]`.
+    def generator_command
+      %w[bundle exec rails g inline_forms_addto] + intent.generator_args
+    end
+
+    def migrate_command
+      %w[bundle exec rails db:migrate]
+    end
+
+    # Ordered plan (each value is an argv array).
+    def commands
+      { generate: generator_command, migrate: migrate_command }
+    end
+
+    # Human-readable plan (what an app would show before the user confirms).
+    def preview_plan
+      STEPS.map { |step| "#{step}: #{Shellwords.join(commands.fetch(step))}" }
+    end
+
+    # Execute generate -> migrate, stopping at the first failure. Returns the
+    # step that failed, or nil on success. NOT run in tests (would shell out);
+    # an app/rake task calls this after approval + a git-clean check.
+    def run!
+      STEPS.each do |step|
+        ok = @runner.call(commands.fetch(step))
+        return step unless ok
+      end
+      nil
+    end
+
+    private
+
+    def addto_migrations(destination_root)
+      Dir.glob(File.join(destination_root.to_s, "db", "migrate", "*_inline_forms_add_to_*.rb"))
+    end
+  end
+end

data/lib/inline_forms/schema_intent.rb

@@ -0,0 +1,76 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # A *proposed* schema change: "add attribute X of form-element Y to model Z,
+  # at this position". This is the unit the end-user-facing staging pipeline
+  # (see stuff/2026-07-11-end-user-schema-changes-staging-and-pending-gate.md)
+  # drafts, previews, and finally applies.
+  #
+  # It is a plain value object — deliberately NOT an ActiveRecord model. Where
+  # intents are persisted (a drafts table) and edited (a GUI) is an app-level
+  # concern; the engine only needs the structured description plus the mapping
+  # to the generator that realizes it. Nothing renders from an intent at
+  # runtime, so it is an audit/work-queue artifact, not config-as-data.
+  #
+  # STATUS is advisory metadata for a persisting app: draft -> approved ->
+  # applied (or failed).
+  class SchemaIntent
+    STATUSES = %i[draft approved applied failed].freeze
+
+    attr_reader :model_name, :attribute, :form_element, :values, :disabled, :after, :before
+    attr_accessor :status
+
+    def initialize(model_name:, attribute:, form_element:,
+                   values: nil, disabled: nil, after: nil, before: nil, status: :draft)
+      @model_name   = model_name.to_s
+      @attribute    = attribute.to_sym
+      @form_element = form_element.to_sym
+      @values       = values
+      @disabled     = disabled
+      @after        = after&.to_sym
+      @before       = before&.to_sym
+      self.status   = status
+    end
+
+    def status=(value)
+      sym = value.to_sym
+      unless STATUSES.include?(sym)
+        raise ArgumentError, "unknown status #{value.inspect} (expected one of #{STATUSES.inspect})"
+      end
+
+      @status = sym
+    end
+
+    # The model class this intent targets. Raises NameError if it is not
+    # defined (an app should validate the name before drafting).
+    def model_class
+      model_name.constantize
+    end
+
+    # The `attr:form_element` token exactly as the generator expects it.
+    def column_token
+      "#{attribute}:#{form_element}"
+    end
+
+    # argv for `rails g inline_forms_addto <Model> <attr:form_element> [--after=..]`.
+    def generator_args
+      args = [ model_name, column_token ]
+      args << "--after=#{after}"   if after
+      args << "--before=#{before}" if before
+      args
+    end
+
+    def to_h
+      {
+        model_name: model_name,
+        attribute: attribute,
+        form_element: form_element,
+        values: values,
+        disabled: disabled,
+        after: after,
+        before: before,
+        status: status
+      }
+    end
+  end
+end