inline_forms 8.1.40 → 8.1.42

data/lib/inline_forms/schema_label.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+
+require "yaml"
+require "fileutils"
+
+module InlineForms
+  # Writes a human label for a model attribute (or header) into a locale file,
+  # so `human_attribute_name` renders it. Used by the schema GUI's optional
+  # "Label" field. Like the header/field edits, this is a code/config change
+  # that lands in the working tree (git-tracked) — never the DB.
+  #
+  # The label is merged (not clobbered) into
+  #   config/locales/inline_forms_labels.<locale>.yml
+  # under the key inline_forms renders from:
+  #   <locale>: activerecord: attributes: <model_i18n_key>: <attribute>: "Label"
+  #
+  # A dedicated file (rather than editing an existing app locale file) keeps the
+  # write a whole-document load -> deep_merge -> dump, which is robust against
+  # comments/formatting concerns.
+  module SchemaLabel
+    module_function
+
+    def file_path(destination_root, locale)
+      File.join(destination_root.to_s, "config", "locales", "inline_forms_labels.#{locale}.yml")
+    end
+
+    def i18n_key_for(model_class)
+      if model_class.respond_to?(:model_name)
+        model_class.model_name.i18n_key.to_s
+      else
+        model_class.to_s.underscore
+      end
+    end
+
+    # Merge the label into the locale file and return its path.
+    def write(destination_root:, model_class:, attribute:, label:, locale:)
+      path      = file_path(destination_root, locale)
+      key       = i18n_key_for(model_class)
+      existing  = load_document(path)
+      addition  = {
+        locale.to_s => {
+          "activerecord" => {
+            "attributes" => {
+              key => { attribute.to_s => label.to_s }
+            }
+          }
+        }
+      }
+      merged = existing.deep_merge(addition)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, merged.to_yaml)
+      path
+    end
+
+    def load_document(path)
+      return {} unless File.exist?(path)
+
+      loaded = YAML.safe_load(File.read(path))
+      loaded.is_a?(Hash) ? loaded : {}
+    rescue StandardError
+      {}
+    end
+  end
+end

data/lib/inline_forms/schema_preview.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # Cheap preview of a SchemaIntent, WITHOUT running a migration or booting a
+  # second app. The trick (see the staging doc): declare the proposed attribute
+  # as a *virtual* typed attribute on a throwaway subclass of the target model,
+  # so it reads/writes in memory with no column, and render the stock inline
+  # forms against an AttributeList that has the proposed row spliced in at the
+  # requested position. The real class and its table are untouched.
+  #
+  #   obj, list = InlineForms::SchemaPreview.build(intent, existing_record)
+  #   # render "inline_forms/show" with @object = obj,
+  #   #   @inline_forms_attribute_list = list  (the controller already supports
+  #   #   this per-request override — see attr_writer :inline_forms_attribute_list)
+  #
+  # Scope of the stab: scalar attributes preview fully. Relation dropdowns
+  # (backed by a foreign key + association) and uploader/rich_text fields need
+  # model-side wiring the preview does not synthesize; #supported? reports this
+  # so a caller can fall back to a "available after apply" placeholder.
+  module SchemaPreview
+    module_function
+
+    # Map an AR column type (from the engine's form-element maps) to an
+    # ActiveModel::Type symbol for a virtual attribute.
+    COLUMN_TYPE_TO_VIRTUAL = {
+      string: :string,
+      text: :string,
+      integer: :integer,
+      decimal: :decimal,
+      float: :float,
+      boolean: :boolean,
+      date: :date,
+      time: :time,
+      datetime: :datetime,
+      timestamp: :datetime
+    }.freeze
+
+    # Form elements the GUI must not offer as "add a scalar field":
+    #  * :header / :info are not real fields — :header is a display-only
+    #    separator (adding one via addto would create a pointless string
+    #    column), :info is read-only over an existing column.
+    #  * uploaders need a mounted CarrierWave uploader; :money_field a
+    #    monetize declaration; :devise_password_field a Devise model; :pdf_link
+    #    a route — a virtual attribute alone cannot faithfully preview them.
+    PREVIEW_UNSUPPORTED_FORM_ELEMENTS = %i[
+      header
+      info
+      image_field
+      audio_field
+      file_field
+      multi_image_field
+      simple_file_field
+      pdf_link
+      money_field
+      devise_password_field
+    ].freeze
+
+    # Returns [preview_object, attribute_list]. `base_record` seeds the preview
+    # object's existing attributes when given (so the rest of the form shows
+    # real data); otherwise a blank instance is used.
+    def build(intent, base_record = nil)
+      base_class = intent.model_class
+      list       = attribute_list_for(base_class, intent)
+      preview    = preview_class_for(base_class, intent)
+
+      object = base_record ? preview.new(base_record.attributes) : preview.new
+      object.inline_forms_attribute_list = list
+      [ object, list ]
+    end
+
+    # False when the intent's form element needs model-side wiring the preview
+    # cannot synthesize (relations, uploaders, rich_text).
+    def supported?(intent)
+      !virtual_type(intent.form_element).nil?
+    end
+
+    # The sorted list of form elements the GUI offers (those that preview via a
+    # virtual attribute): scalar text/number/date/boolean/choice elements.
+    def supported_form_elements
+      candidates = InlineForms::SPECIAL_COLUMN_TYPES.keys +
+                   InlineForms::DEFAULT_FORM_ELEMENTS.values
+      candidates.uniq.select { |fe| !virtual_type(fe).nil? }.sort
+    end
+
+    # The AttributeList the preview should render: the model's current list with
+    # the proposed row inserted at --after/--before (falling back to append).
+    def attribute_list_for(base_class, intent)
+      current = base_class.new.inline_forms_attribute_list
+      list    = InlineForms::AttributeList.wrap(current.map(&:dup))
+      opts    = { values: intent.values, disabled: intent.disabled }.compact
+
+      # Value-bearing choice elements need a values hash or their _edit/_show
+      # helper raises. Mirror the addto generator: inject a placeholder the user
+      # edits after apply (so preview and apply produce the same row).
+      if opts[:values].nil? && InlineForms::VALUE_BEARING_FORM_ELEMENTS.include?(intent.form_element)
+        opts[:values] = InlineForms::PLACEHOLDER_VALUES
+      end
+
+      if intent.after && list.include_attribute?(intent.after)
+        list.insert_after(intent.after, intent.attribute, intent.form_element, **opts)
+      elsif intent.before && list.include_attribute?(intent.before)
+        list.insert_before(intent.before, intent.attribute, intent.form_element, **opts)
+      else
+        list.field(intent.attribute, intent.form_element, **opts)
+      end
+      list
+    end
+
+    # A throwaway subclass with the proposed attribute declared virtual (when
+    # supported), masquerading as the base class so partials/routes resolve.
+    def preview_class_for(base_class, intent)
+      type = virtual_type(intent.form_element)
+      klass = Class.new(base_class)
+      klass.attribute(intent.attribute, type) if type
+
+      base_name       = base_class.name
+      base_model_name = base_class.model_name
+      klass.define_singleton_method(:name) { base_name }
+      klass.define_singleton_method(:model_name) { base_model_name }
+      klass
+    end
+
+    def virtual_type(form_element)
+      fe = form_element.to_sym
+      return nil if PREVIEW_UNSUPPORTED_FORM_ELEMENTS.include?(fe)
+
+      column_type =
+        InlineForms::SPECIAL_COLUMN_TYPES[fe] ||
+        (InlineForms::DEFAULT_FORM_ELEMENTS.value?(fe) ? :string : nil)
+      return nil if column_type.nil? || column_type == :no_migration || column_type == :belongs_to
+
+      COLUMN_TYPE_TO_VIRTUAL[column_type]
+    end
+  end
+end

data/lib/inline_forms/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 module InlineForms
-  VERSION = "8.1.40"
+  VERSION = "8.1.42"
 end

data/lib/inline_forms.rb

@@ -1,6 +1,11 @@
 # -*- encoding : utf-8 -*-
 
 require "inline_forms/version"
+require "inline_forms/attribute_list"
+require "inline_forms/schema_intent"
+require "inline_forms/schema_preview"
+require "inline_forms/schema_apply"
+require "inline_forms/schema_label"
 require "inline_forms/form_element_from_callee"
 require "inline_forms/archived_form_elements"
 require "inline_forms/form_element_registry"
@@ -106,6 +111,25 @@ module InlineForms
     plain_text_area
   ].freeze
 
+  # Form elements that render a set of choices and therefore REQUIRE a values
+  # hash as the 3rd element of their attribute_list row (their _show/_edit
+  # helpers call `attribute_values`, which raises when it is missing). Shared by
+  # the addto generator and the schema GUI/preview so both insert a placeholder.
+  VALUE_BEARING_FORM_ELEMENTS = %i[
+    dropdown_with_values
+    dropdown_with_integers
+    dropdown_with_values_with_stars
+    radio_button
+    check_box
+    scale_with_integers
+    scale_with_values
+    slider_with_values
+  ].freeze
+
+  # Placeholder values hash inserted when a value-bearing element is added
+  # programmatically (generator / GUI); the user edits it to real values after.
+  PLACEHOLDER_VALUES = { 1 => "one", 2 => "two" }.freeze
+
   def self.plain_text_form_element?(form_element)
     PLAIN_TEXT_FORM_ELEMENTS.include?(form_element.to_sym)
   rescue NoMethodError
@@ -121,6 +145,68 @@ module InlineForms
       "Use :rich_text for ActionText-backed attributes, or add a text column for :plain_text."
   end
 
+  # Form elements exempt from the pending-migration gate. They either render a
+  # label only (:header), or read a *virtual* attribute whose name is not its
+  # backing column — :devise_password_field (backed by encrypted_password),
+  # :money_field (backed by a *_cents column via money-rails), :info
+  # (conventionally bound to pre-existing columns like created_at). None of
+  # these are produced by `inline_forms_addto` in the transient pre-migrate
+  # window, so gating them would only ever mis-fire.
+  PENDING_GATE_EXEMPT_FORM_ELEMENTS = %i[
+    header
+    info
+    devise_password_field
+    money_field
+  ].freeze
+
+  # True when an attribute_list row references a column that its model's table
+  # does not have yet — i.e. the model file was edited (row added) but the
+  # migration adding the column has not run. Rendering or writing such a row
+  # raises (e.g. `object[:foo]` / `foo_show` on a missing column), so callers
+  # gate on this to show a "pending migration" placeholder and skip writes
+  # instead of 500ing during the window between `rails g inline_forms_addto`
+  # and `rails db:migrate`.
+  #
+  # Detection is column-presence based (robust): the expected column is derived
+  # from the form element via the same type maps the generator uses. `nil`
+  # (associations, rich_text, pdf_link, unknown elements) and virtual-backed
+  # elements (see PENDING_GATE_EXEMPT_FORM_ELEMENTS) are never gated. The gate
+  # self-heals: once the migration runs and the schema cache reflects the new
+  # column, the column is present and the row renders normally — no flag to
+  # clear, nothing to maintain.
+  def self.attribute_pending_migration?(object, attribute, form_element)
+    fe = form_element.to_sym
+    return false if PENDING_GATE_EXEMPT_FORM_ELEMENTS.include?(fe)
+
+    klass = object.class
+    return false unless klass.respond_to?(:table_exists?) && klass.respond_to?(:column_names)
+    return false unless klass.table_exists?
+
+    column = pending_gate_expected_column(attribute, fe)
+    return false if column.nil?
+
+    !klass.column_names.include?(column)
+  rescue StandardError
+    # The gate must never itself break rendering; fail open (render as before).
+    false
+  end
+
+  # The column an attribute_list row expects on the model's own table, or nil
+  # when the form element needs no such column (has_many/habtm/has_one/
+  # rich_text -> :no_migration; pdf_link/info_list/unknown -> nil). Relation
+  # dropdowns are backed by a foreign key (`<attribute>_id`); every other
+  # column-backed element uses a column named after the attribute.
+  def self.pending_gate_expected_column(attribute, form_element)
+    column_type =
+      SPECIAL_COLUMN_TYPES[form_element] ||
+      (DEFAULT_FORM_ELEMENTS.value?(form_element) ? :__scalar__ : nil)
+
+    return nil if column_type.nil? || column_type == :no_migration
+    return "#{attribute}_id" if column_type == :belongs_to
+
+    attribute.to_s
+  end
+
   def self.validate_plain_text_configuration_for!(klass)
     return unless klass.respond_to?(:table_exists?) &&
                   klass.respond_to?(:column_names) &&

data/lib/locales/inline_forms.en.yml

@@ -31,6 +31,8 @@ en:
       trash: trash
       list_versions: List versions
       close_versions_list: Close versions list
+    pending_migration:
+      notice: "pending migration \u2014 run rails db:migrate"
   succes: success.
   activerecord:
     models:

data/lib/locales/inline_forms.nl.yml

@@ -28,6 +28,8 @@ nl:
       add_new: Maak een nieuw %{model}
       undo: terughalen
       trash: weggooien
+    pending_migration:
+      notice: "migratie in afwachting \u2014 draai rails db:migrate"
   succes: het ding is aangemaakt.
   activerecord:
     models:

data/test/attribute_list_test.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class AttributeListTest < Minitest::Test
+  def build_sample
+    InlineForms::AttributeList.build do
+      header :basics
+      field  :name,     :text_field
+      field  :priority, :dropdown_with_values, values: { 1 => "low", 2 => "high" }
+      field  :flag,     :dropdown_with_values, values: { 1 => "a", 2 => "b" }, disabled: [ 2 ]
+      info   :created_at, :updated_at
+    end
+  end
+
+  # -- array compatibility (the whole point) -----------------------------
+
+  def test_is_an_array
+    assert_kind_of Array, build_sample
+  end
+
+  def test_destructures_like_the_legacy_literal
+    seen = []
+    build_sample.each { |attribute, form_element| seen << [ attribute, form_element ] }
+    assert_includes seen, [ :name, :text_field ]
+    assert_includes seen, [ :priority, :dropdown_with_values ]
+  end
+
+  def test_assoc_positional_values_hash_still_works
+    list = build_sample
+    # Consumers fetch the values hash as list.assoc(attr)[2].
+    assert_equal({ 1 => "low", 2 => "high" }, list.assoc(:priority)[2])
+    assert_equal([ 2 ], list.assoc(:flag)[3])
+    assert_nil list.assoc(:name)[2]
+  end
+
+  def test_build_produces_expected_rows
+    list = build_sample
+    assert_equal(
+      [
+        [ :basics, :header ],
+        [ :name, :text_field ],
+        [ :priority, :dropdown_with_values, { 1 => "low", 2 => "high" } ],
+        [ :flag, :dropdown_with_values, { 1 => "a", 2 => "b" }, [ 2 ] ],
+        [ :created_at, :info ],
+        [ :updated_at, :info ]
+      ],
+      list.to_a
+    )
+  end
+
+  # -- append -------------------------------------------------------------
+
+  def test_field_appends_and_returns_self_for_chaining
+    list = InlineForms::AttributeList.new
+    result = list.field(:a, :text_field).field(:b, :check_box)
+    assert_same list, result
+    assert_equal %i[a b], list.names
+  end
+
+  def test_disabled_without_values_raises
+    assert_raises(ArgumentError) do
+      InlineForms::AttributeList.new.field(:x, :dropdown_with_values, disabled: [ 1 ])
+    end
+  end
+
+  # -- insertion ----------------------------------------------------------
+
+  def test_insert_after
+    list = build_sample.insert_after(:name, :nickname, :text_field)
+    assert_equal :nickname, list.names[list.index_of(:name) + 1]
+  end
+
+  def test_insert_before
+    list = build_sample.insert_before(:priority, :urgent, :check_box)
+    assert_equal :urgent, list.names[list.index_of(:priority) - 1]
+  end
+
+  def test_insert_after_missing_anchor_raises
+    assert_raises(ArgumentError) { build_sample.insert_after(:nope, :x, :text_field) }
+  end
+
+  # -- removal ------------------------------------------------------------
+
+  def test_remove_present
+    list = build_sample.remove(:priority)
+    refute list.include_attribute?(:priority)
+  end
+
+  def test_remove_absent_is_noop
+    list = build_sample
+    before = list.dup
+    list.remove(:does_not_exist)
+    assert_equal before.to_a, list.to_a
+  end
+
+  # -- reordering ---------------------------------------------------------
+
+  def test_move_after
+    list = build_sample.move_after(:name, :updated_at)
+    assert_equal :name, list.names.last
+    assert_equal 1, list.names.count(:name)
+  end
+
+  def test_move_before
+    list = build_sample.move_before(:updated_at, :basics)
+    assert_equal 0, list.index_of(:updated_at)
+    assert_equal 1, list.names.count(:updated_at)
+  end
+
+  def test_move_relative_to_itself_raises
+    assert_raises(ArgumentError) { build_sample.move_after(:name, :name) }
+  end
+
+  # -- replacement --------------------------------------------------------
+
+  def test_replace_element_preserves_position
+    list = build_sample
+    pos = list.index_of(:priority)
+    list.replace_element(:priority, :radio_button, values: { 1 => "x" })
+    assert_equal pos, list.index_of(:priority)
+    assert_equal :radio_button, list.form_element_for(:priority)
+    assert_equal({ 1 => "x" }, list.values_for(:priority))
+  end
+
+  def test_replace_element_absent_is_noop
+    list = build_sample
+    before = list.dup
+    list.replace_element(:nope, :text_field)
+    assert_equal before.to_a, list.to_a
+  end
+
+  # -- queries ------------------------------------------------------------
+
+  def test_query_helpers
+    list = build_sample
+    assert_equal 1, list.index_of(:name)
+    assert list.include_attribute?(:flag)
+    refute list.include_attribute?(:ghost)
+    assert_equal :dropdown_with_values, list.form_element_for(:priority)
+    assert_equal({ 1 => "low", 2 => "high" }, list.values_for(:priority))
+    assert_equal [ :name, :text_field ], list.row_for(:name)
+  end
+
+  # -- wrap ---------------------------------------------------------------
+
+  def test_wrap_existing_array_enables_editing
+    legacy = [ [ :name, :text_field ], [ :email, :text_field ] ]
+    list = InlineForms::AttributeList.wrap(legacy)
+    assert_kind_of InlineForms::AttributeList, list
+    list.insert_after(:name, :phone, :text_field)
+    assert_equal %i[name phone email], list.names
+  end
+
+  def test_wrap_is_idempotent_for_attribute_list
+    list = build_sample
+    assert_same list, InlineForms::AttributeList.wrap(list)
+  end
+
+  def test_module_level_builder
+    list = InlineForms.attribute_list { field :a, :text_field }
+    assert_kind_of InlineForms::AttributeList, list
+    assert_equal %i[a], list.names
+  end
+end

data/test/dummy/app/controllers/gizmos_controller.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class GizmosController < InlineFormsController
+end

data/test/dummy/app/models/gizmo.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Models the `inline_forms_addto` pre-migrate window: the attribute_list has a
+# row (`:pending_note`) whose column does NOT exist on the gizmos table yet, so
+# it exercises InlineForms.attribute_pending_migration? end to end. `:name` and
+# `:created_at` are real columns; `:section` is a header. See
+# test/integration/pending_migration_gate_test.rb.
+class Gizmo < ApplicationRecord
+  validates :name, presence: true
+
+  scope :inline_forms_list, -> { order(:name, :id) }
+
+  def _presentation
+    "#{name}"
+  end
+
+  def inline_forms_attribute_list
+    @inline_forms_attribute_list ||= [
+      [ :name, :text_field ],
+      [ :section, :header ],
+      [ :pending_note, :text_field ],
+      [ :created_at, :info ]
+    ]
+  end
+end

data/test/dummy/config/application.rb

@@ -16,6 +16,9 @@ require "action_view/railtie"
 Bundler.require(*Rails.groups)
 
 require "inline_forms"
+# The schema-GUI engine (separate gem, same repo; on the load path via the
+# Gemfile's test group). Its integration tests live in test/integration/.
+require "inline_forms_schema_edit"
 
 module Dummy
   class Application < Rails::Application

data/test/dummy/config/routes.rb

@@ -19,4 +19,13 @@ Rails.application.routes.draw do
     post "revert", on: :member
     get "list_versions", on: :member
   end
+
+  resources :gizmos do
+    post "revert", on: :member
+    get "list_versions", on: :member
+  end
+
+  # Schema-change GUI (opt-in in real installs; routed here for the engine's
+  # fast test suite). One line, so gem upgrades can add routes freely.
+  InlineFormsSchemaEdit.draw_routes(self)
 end