inline_forms 8.1.21 → 8.1.42

data/test/integration/pending_migration_gate_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# Covers the pending-migration gate: an attribute_list row whose column does
+# not exist yet (the inline_forms_addto window between the model edit and
+# `rails db:migrate`) must render a read-only placeholder and be skipped on
+# write, instead of 500ing on the missing column. Gizmo's list references
+# :pending_note, which has no column on the gizmos table (see
+# test/integration_test_helper.rb and test/dummy/app/models/gizmo.rb).
+class PendingMigrationGateTest < InlineFormsIntegrationTestCase
+  setup do
+    @gizmo = Gizmo.create!(name: "Gadget")
+  end
+
+  test "predicate flags a phantom column and only that" do
+    g = @gizmo
+    # phantom scalar column -> pending
+    assert InlineForms.attribute_pending_migration?(g, :pending_note, :text_field)
+    # real column -> not pending
+    refute InlineForms.attribute_pending_migration?(g, :name, :text_field)
+    # header is a label, never gated
+    refute InlineForms.attribute_pending_migration?(g, :section, :header)
+    # info bound to a real column
+    refute InlineForms.attribute_pending_migration?(g, :created_at, :info)
+    # relation dropdown backed by a missing foreign key -> pending
+    assert InlineForms.attribute_pending_migration?(g, :vendor, :dropdown)
+    # no-column elements are never gated
+    refute InlineForms.attribute_pending_migration?(g, :parts, :has_many)
+    refute InlineForms.attribute_pending_migration?(g, :body, :rich_text)
+    refute InlineForms.attribute_pending_migration?(g, :report, :pdf_link)
+    # exempt virtual-backed elements (column name != attribute)
+    refute InlineForms.attribute_pending_migration?(g, :amount, :money_field)
+  end
+
+  test "row show renders a pending placeholder and does not raise" do
+    frame = "gizmo_#{@gizmo.id}"
+    get gizmo_path(@gizmo, update: frame), headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, "pending migration"
+    # the real field still renders its own edit frame
+    assert_includes response.body, %(<turbo-frame id="gizmo_#{@gizmo.id}_name">)
+    # the phantom field is NOT rendered as an editable field frame
+    refute_includes response.body, %(<turbo-frame id="gizmo_#{@gizmo.id}_pending_note">)
+  end
+
+  test "new form renders a pending placeholder instead of an input" do
+    get new_gizmo_path(update: "gizmos_list"), headers: frame_headers("gizmos_list")
+
+    assert_response :success
+    assert_includes response.body, "pending migration"
+    refute_includes response.body, %(name="pending_note")
+  end
+
+  test "create skips the pending column and still saves" do
+    assert_difference -> { Gizmo.count }, +1 do
+      post gizmos_path(update: "gizmos_list"),
+           params: { name: "Fresh", pending_note: "ignored — no column yet" },
+           headers: frame_headers("gizmos_list")
+    end
+    assert_response :success
+    assert Gizmo.exists?(name: "Fresh")
+  end
+
+  test "forced update of a pending field is refused, not a 500" do
+    frame = "gizmo_#{@gizmo.id}_pending_note"
+    put gizmo_path(@gizmo, attribute: "pending_note", form_element: "text_field",
+                   update: frame),
+        params: { pending_note: "x" }, headers: frame_headers(frame)
+
+    assert_response :unprocessable_entity
+    assert_includes response.body, "pending migration"
+  end
+end

data/test/integration/schema_batch_pipeline_test.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# The batch pipeline (phases 1-3): drafting intents into a batch, freeze on
+# submit, token-authenticated export + status callback, and import/replay
+# via a recording executor (never mutates the dummy tree).
+class SchemaBatchPipelineTest < InlineFormsIntegrationTestCase
+  def teardown
+    InlineFormsSchemaEdit.export_token = nil
+    super
+  end
+
+  def draft_widget_field!(attribute: "warehouse_note", label: "Warehouse note")
+    post inline_forms_schema_draft_path,
+         params: { model_name: "Widget", attribute: attribute,
+                   form_element: "text_field", after: "name", label: label, locale: "en" }
+  end
+
+  # -- phase 1: drafting + freeze ------------------------------------------
+
+  test "drafting an intent creates a draft batch (the cart) and index shows it" do
+    draft_widget_field!
+    assert_response :redirect
+
+    batch = InlineForms::SchemaBatch.with_status(:draft).first
+    assert batch, "draft batch created"
+    assert_equal 1, batch.intents.count
+    intent = batch.intents.first
+    assert_equal %w[Widget warehouse_note text_field name], [
+      intent.target_model, intent.attr_name, intent.form_element, intent.after_attr
+    ]
+
+    get inline_forms_schema_index_path
+    assert_response :success
+    assert_includes response.body, "warehouse_note"
+    assert_includes response.body, "Submit batch"
+  end
+
+  test "invalid intents are rejected at drafting time" do
+    post inline_forms_schema_draft_path,
+         params: { model_name: "Widget", attribute: "name", form_element: "text_field" }
+    assert_response :success # renders :new with the error
+    assert_includes response.body, "already has a name column"
+    assert_equal 0, InlineForms::SchemaIntentRecord.count
+  end
+
+  test "submit freezes the batch: no more adds, edits or removals; digest sealed" do
+    draft_widget_field!
+    post inline_forms_schema_submit_batch_path
+    assert_response :redirect
+
+    batch = InlineForms::SchemaBatch.last
+    assert_equal "submitted", batch.status
+    assert batch.submitted_at
+    assert_match(/\Asha256:/, batch.content_digest)
+
+    intent = batch.intents.first
+    intent.label = "changed"
+    refute intent.save, "frozen intent must not save"
+    refute intent.destroy, "frozen intent must not be destroyed"
+
+    refute batch.intents.create(target_model: "Widget", attr_name: "late_one",
+                                form_element: "text_field").persisted?,
+           "no new intents into a frozen batch"
+
+    batch.window_at = 2.days.from_now
+    refute batch.save, "frozen batch attributes must not change"
+
+    # A new draft goes into a NEW batch.
+    draft_widget_field!(attribute: "second_note")
+    assert_equal 2, InlineForms::SchemaBatch.count
+  end
+
+  test "submitting an empty batch is refused" do
+    post inline_forms_schema_submit_batch_path
+    assert_redirected_to inline_forms_schema_index_path
+    assert_equal 0, InlineForms::SchemaBatch.where(status: "submitted").count
+  end
+
+  test "status transitions follow the pipeline; illegal jumps raise" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    batch.transition!(:processing)
+    batch.transition!(:ready, git_sha: "abc123")
+    assert_equal "abc123", batch.git_sha
+    assert_raises(ArgumentError) { batch.transition!(:submitted) }
+    batch.transition!(:applied)
+    assert batch.applied_at
+  end
+
+  # -- phase 3: machine endpoints ------------------------------------------
+
+  test "export 404s without a configured token and 401s with a wrong one" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    get inline_forms_schema_export_path(batch)
+    assert_response :not_found
+
+    InlineFormsSchemaEdit.export_token = "sekret"
+    get inline_forms_schema_export_path(batch), headers: { "Authorization" => "Bearer wrong" }
+    assert_response :unauthorized
+  end
+
+  test "export returns the sealed payload; draft batches are refused" do
+    InlineFormsSchemaEdit.export_token = "sekret"
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last
+
+    get inline_forms_schema_export_path(batch), headers: { "Authorization" => "Bearer sekret" }
+    assert_response :conflict
+
+    batch.submit!
+    get inline_forms_schema_export_path(batch), headers: { "Authorization" => "Bearer sekret" }
+    assert_response :success
+    payload = JSON.parse(response.body)
+    assert_equal 1, payload["format"]
+    assert_equal batch.content_digest, payload["digest"]
+    assert_equal "warehouse_note", payload["intents"].first["attribute"]
+  end
+
+  test "status callback drives the batch through the pipeline" do
+    InlineFormsSchemaEdit.export_token = "sekret"
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    post inline_forms_schema_batch_status_path(batch),
+         params: { status: "processing" }, headers: { "Authorization" => "Bearer sekret" }
+    assert_response :success
+    assert_equal "processing", batch.reload.status
+
+    post inline_forms_schema_batch_status_path(batch),
+         params: { status: "applied" }, headers: { "Authorization" => "Bearer sekret" }
+    assert_response :unprocessable_entity, "processing -> applied skips ready"
+
+    post inline_forms_schema_batch_status_path(batch),
+         params: { status: "failed", error: "test gate red" },
+         headers: { "Authorization" => "Bearer sekret" }
+    assert_equal "failed", batch.reload.status
+    assert_equal "test gate red", batch.error
+  end
+
+  # -- phase 2: export/import round trip -----------------------------------
+
+  test "import verifies the digest and replays intents through the executor" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    payload = InlineFormsSchemaEdit::BatchExport.payload(batch)
+
+    recorded = []
+    labels = []
+    import = InlineFormsSchemaEdit::BatchImport.new(
+      payload,
+      executor: ->(args, _root) { recorded << args },
+      label_writer: ->(**kwargs) { labels << kwargs; "/dev/null/labels.yml" }
+    )
+    result = import.apply!(destination_root: Dir.tmpdir)
+
+    assert_equal 1, result.applied
+    assert_equal [ "Widget", "warehouse_note:text_field", "--after=name" ], recorded.first
+    assert_equal "Warehouse note", labels.first[:label]
+    assert_includes result.plan.join("\n"), "inline_forms_addto Widget warehouse_note:text_field"
+  end
+
+  test "import rejects a tampered payload (digest mismatch) and stale intents" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+    payload = InlineFormsSchemaEdit::BatchExport.payload(batch)
+
+    tampered = payload.deep_dup
+    tampered["intents"].first["attribute"] = "evil_column"
+    error = assert_raises(InlineFormsSchemaEdit::BatchImport::ImportError) do
+      InlineFormsSchemaEdit::BatchImport.new(tampered).verify!
+    end
+    assert_match(/digest mismatch/, error.message)
+
+    # A column that already exists in THIS checkout fails per-intent validation.
+    stale = InlineFormsSchemaEdit::BatchExport.payload(batch)
+    stale["intents"].first["attribute"] = "name"
+    stale["digest"] = "sha256:#{Digest::SHA256.hexdigest(JSON.generate(stale['intents']))}"
+    error = assert_raises(InlineFormsSchemaEdit::BatchImport::ImportError) do
+      InlineFormsSchemaEdit::BatchImport.new(stale).verify!
+    end
+    assert_match(/already has a name column/, error.message)
+  end
+end

data/test/integration/schema_edit_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# The dev-only schema-change GUI (InlineForms::SchemaController): new -> preview
+# (no migration) -> apply (runs the addto generator, no db:migrate). Apply is
+# exercised with a RECORDING executor so the suite never mutates the dummy tree.
+class SchemaEditTest < InlineFormsIntegrationTestCase
+  def teardown
+    InlineForms::SchemaController.generator_executor = nil
+    InlineForms::SchemaController.label_writer = nil
+    super
+  end
+
+  test "new renders the form with supported elements" do
+    get inline_forms_schema_new_path
+    assert_response :success
+    assert_includes response.body, "Model"
+    assert_includes response.body, "Form element"
+    assert_includes response.body, "text_field"
+    assert_includes response.body, "Preview"
+    # data-turbo opt-out so the standalone utility navigates on POST
+    assert_includes response.body, %(data-turbo="false")
+  end
+
+  test "info is not offered and is rejected; header is not a scalar field" do
+    refute_includes InlineForms::SchemaPreview.supported_form_elements, :header
+    refute_includes InlineForms::SchemaPreview.supported_form_elements, :info
+
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "meta", form_element: "info" }
+    assert_response :success
+    assert_includes response.body, "Unsupported form element"
+  end
+
+  test "header preview adds a no-column row (no migration, no widget)" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "section_title",
+                   form_element: "header", after: "name", label: "Section" }
+    assert_response :success
+    assert_includes response.body, "no column, no migration"
+    assert_includes response.body, "section_title (new)"
+    # header shows its label, not an input widget
+    assert_includes response.body, "Section"
+    refute_includes response.body, %(name="section_title")
+    refute_includes Widget.column_names, "section_title"
+  end
+
+  test "header apply invokes the generator without a column (no migration)" do
+    recorded = []
+    InlineForms::SchemaController.generator_executor = ->(args, _root) { recorded << args }
+
+    post inline_forms_schema_path,
+         params: { model_name: "Widget", attribute: "section_title", form_element: "header" }
+    assert_response :success
+    assert_includes response.body, "header"
+    assert_includes response.body, "no migration"
+    assert_equal [ "Widget", "section_title:header" ], recorded.first
+  end
+
+  test "a label is written through the injected label writer" do
+    recorded = []
+    InlineForms::SchemaController.generator_executor = ->(_args, _root) { }
+    InlineForms::SchemaController.label_writer = ->(**kw) { recorded << kw; "/tmp/inline_forms_labels.en.yml" }
+
+    post inline_forms_schema_path,
+         params: { model_name: "Widget", attribute: "section_title", form_element: "header",
+                   label: "Section", locale: "en" }
+    assert_response :success
+    assert_includes response.body, "Wrote label"
+    assert_equal 1, recorded.size
+    assert_equal :section_title, recorded.first[:attribute]
+    assert_equal "Section", recorded.first[:label]
+    assert_equal "en", recorded.first[:locale]
+  end
+
+  test "preview shows the field at the right position with no migration" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "internal_note",
+                   form_element: "text_field", after: "name" }
+    assert_response :success
+    assert_includes response.body, "internal_note (new)"
+    # rendered live widget for the new field
+    assert_includes response.body, %(name="internal_note")
+    # placement: internal_note appears after name in the rendered order
+    assert response.body.index("name (new)").nil?
+    assert response.body.index(">name<") < response.body.index("internal_note (new)")
+
+    # No schema change happened.
+    refute_includes Widget.column_names, "internal_note"
+    assert_empty Dir.glob(Rails.root.join("db/migrate/*_inline_forms_add_to_*.rb"))
+  end
+
+  test "an unsupported (non-scalar) element is rejected with an error" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "vendor", form_element: "dropdown" }
+    assert_response :success
+    assert_includes response.body, "Unsupported form element"
+  end
+
+  test "a value-bearing element previews with a placeholder values hash (no raise)" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "rank",
+                   form_element: "dropdown_with_values_with_stars", after: "name" }
+    assert_response :success
+    assert_includes response.body, "rank (new)"
+    assert_includes response.body, "placeholder values hash"
+  end
+
+  test "invalid input re-renders the form with an error" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "Bad Name", form_element: "text_field" }
+    assert_response :success
+    assert_includes response.body, "lowercase letters"
+  end
+
+  test "apply invokes the generator (no db:migrate) via the injected executor" do
+    recorded = []
+    InlineForms::SchemaController.generator_executor = ->(args, _root) { recorded << args }
+
+    post inline_forms_schema_path,
+         params: { model_name: "Widget", attribute: "internal_note",
+                   form_element: "text_field", after: "name" }
+    assert_response :success
+    assert_includes response.body, "Applied"
+    assert_includes response.body, "db:migrate" # the "you run this" instruction
+    assert_equal 1, recorded.size
+    assert_equal [ "Widget", "internal_note:text_field", "--after=name" ], recorded.first
+    # The generator never wrote a migration (recorder), and we never migrated.
+    refute_includes Widget.column_names, "internal_note"
+  end
+
+  test "reachable only outside production" do
+    original = Rails.env
+    Rails.env = ActiveSupport::StringInquirer.new("production")
+    get inline_forms_schema_new_path
+    assert_response :not_found
+  ensure
+    Rails.env = original
+  end
+end

data/test/integration/schema_preview_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# Cheap preview of a SchemaIntent against the dummy app: a virtual typed
+# attribute on a throwaway subclass + an AttributeList with the proposed row
+# spliced in — no migration, no column, real class/table untouched.
+class SchemaPreviewTest < InlineFormsIntegrationTestCase
+  def scalar_intent(**overrides)
+    InlineForms::SchemaIntent.new(
+      **{ model_name: "Widget", attribute: :internal_note, form_element: :text_field }.merge(overrides)
+    )
+  end
+
+  test "supported? is true for scalar elements, false for relations/uploaders/virtuals" do
+    assert InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :text_field))
+    assert InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :integer_field))
+    assert InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :date_select))
+    assert InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :check_box))
+    refute InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :dropdown))
+    refute InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :rich_text))
+    refute InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :image_field))
+    refute InlineForms::SchemaPreview.supported?(scalar_intent(form_element: :money_field))
+  end
+
+  test "preview object carries the proposed attribute as a virtual, no column" do
+    object, = InlineForms::SchemaPreview.build(scalar_intent)
+
+    assert object.respond_to?(:internal_note), "preview should expose the virtual attribute"
+    assert_nil object.internal_note, "virtual attribute defaults to nil with no column"
+    object.internal_note = "boiler serviced"
+    assert_equal "boiler serviced", object.internal_note, "virtual attribute is writable in memory"
+
+    # The real class/table are untouched.
+    refute_includes Widget.column_names, "internal_note"
+    assert_equal "Widget", object.class.name, "preview masquerades as the base class"
+  end
+
+  test "preview attribute_list splices the row at --after" do
+    _, list = InlineForms::SchemaPreview.build(scalar_intent(after: :name))
+    assert_kind_of InlineForms::AttributeList, list
+    assert_equal :internal_note, list.names[list.index_of(:name) + 1]
+    # original rows are preserved
+    assert list.include_attribute?(:priority)
+  end
+
+  test "preview attribute_list appends when no anchor given" do
+    _, list = InlineForms::SchemaPreview.build(scalar_intent)
+    assert_equal :internal_note, list.names.last
+  end
+
+  test "preview seeds existing attributes from a base record" do
+    widget = Widget.create!(name: "Base", priority: 2)
+    object, = InlineForms::SchemaPreview.build(scalar_intent, widget)
+    assert_equal "Base", object.name, "existing data is carried into the preview"
+    assert_nil object.internal_note
+  end
+
+  test "building a preview does not add a column to the real table" do
+    before = Widget.column_names.dup
+    InlineForms::SchemaPreview.build(scalar_intent(after: :name))
+    Widget.reset_column_information
+    assert_equal before, Widget.column_names
+  end
+end

data/test/integration_test_helper.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# Boots the test/dummy host app for the engine's integration tests. Fast path
+# (seconds) next to the full release gate (build gems -> inline_forms create
+# MyApp --example -> rails test); catches controller/view/Turbo regressions
+# without an install cycle. See stuff/prompt/test-the-example-app.md for the
+# release gate, which remains authoritative.
+ENV["RAILS_ENV"] = "test"
+
+require_relative "dummy/config/environment"
+require "rails/test_help"
+require "minitest/autorun"
+
+# In-memory SQLite: define the schema on every boot (maintain_test_schema is
+# off; there are no migration files to run).
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Schema.define do
+  create_table :widgets, force: true do |t|
+    t.string  :name
+    t.text    :notes
+    t.date    :released_on
+    t.time    :meeting_at
+    t.date    :start_month
+    t.integer :priority
+    t.boolean :active
+    t.integer :kind_id
+    t.string  :kind_other
+    t.integer :rating
+    t.string  :manual
+    t.string  :accent
+    t.timestamps
+  end
+
+  create_table :kinds, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  # Machine has_many :parts with an :associated panel (open-after-create).
+  create_table :machines, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :parts, force: true do |t|
+    t.string  :name
+    t.integer :machine_id
+    t.timestamps
+  end
+  add_index :parts, :machine_id
+
+  # Gizmo intentionally has NO `pending_note` column: its attribute_list
+  # references one, modeling the inline_forms_addto pre-migrate window that
+  # InlineForms.attribute_pending_migration? gates. See
+  # test/integration/pending_migration_gate_test.rb.
+  create_table :gizmos, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  # Schema-GUI batch pipeline (inline_forms_schema_edit). Mirrors the gem's
+  # install-generator migration.
+  create_table :inline_forms_schema_batches, force: true do |t|
+    t.string   :status, null: false, default: "draft"
+    t.string   :requested_by
+    t.datetime :submitted_at
+    t.datetime :window_at
+    t.datetime :applied_at
+    t.string   :git_sha
+    t.string   :content_digest
+    t.text     :error
+    t.timestamps
+  end
+  add_index :inline_forms_schema_batches, :status
+
+  create_table :inline_forms_schema_intents, force: true do |t|
+    t.references :batch, null: false, index: true
+    t.string  :target_model, null: false
+    t.string  :attr_name, null: false
+    t.string  :form_element, null: false
+    t.string  :after_attr
+    t.string  :before_attr
+    t.string  :label
+    t.string  :locale
+    t.integer :position
+    t.string  :migration_version
+    t.timestamps
+  end
+
+  # PaperTrail (paper_trail 17.x shape).
+  create_table :versions, force: true do |t|
+    t.string   :item_type, null: false
+    t.bigint   :item_id, null: false
+    t.string   :event, null: false
+    t.string   :whodunnit
+    t.text     :object, limit: 1_073_741_823
+    t.text     :object_changes, limit: 1_073_741_823
+    t.datetime :created_at
+  end
+  add_index :versions, [ :item_type, :item_id ]
+end
+
+class InlineFormsIntegrationTestCase < ActionDispatch::IntegrationTest
+  # The inline UI drives every request through a <turbo-frame>; the frame
+  # layout (turbo_rails/frame) also spares the dummy the full chrome (header
+  # needs current_user, assets, ...).
+  def frame_headers(frame_id)
+    { "Turbo-Frame" => frame_id, "Accept" => "text/html" }
+  end
+
+  setup do
+    Widget.delete_all
+    Kind.delete_all
+    Part.delete_all
+    Machine.delete_all
+    Gizmo.delete_all
+    PaperTrail::Version.delete_all
+    InlineForms::SchemaIntentRecord.delete_all
+    InlineForms::SchemaBatch.delete_all
+  end
+end

data/test/plain_text_configuration_test.rb

@@ -20,7 +20,7 @@ class PlainTextConfigurationTest < Minitest::Test
 
     def inline_forms_attribute_list
       [
-        [:description, :plain_text]
+        [ :description, :plain_text ]
       ]
     end
   end
@@ -40,7 +40,7 @@ class PlainTextConfigurationTest < Minitest::Test
 
     def inline_forms_attribute_list
       [
-        [:description, :plain_text]
+        [ :description, :plain_text ]
       ]
     end
   end
@@ -56,7 +56,7 @@ class PlainTextConfigurationTest < Minitest::Test
 
     def inline_forms_attribute_list
       [
-        [:description, :rich_text]
+        [ :description, :rich_text ]
       ]
     end
   end