inline_forms 8.1.0 → 8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3b934b94b7f4b5298dea2e2a51b8c97c37c06969a3484d528e336edf17ddfde
-  data.tar.gz: fedfafb7fba445712299b4c240fc905418c665d8f29e139c17cb9abc4138fe36
+  metadata.gz: 86869c3131530e4764f1a16620e48bd0eaf920461f0471697c07d2e30bda69f3
+  data.tar.gz: 5c304a602f87fcc37b403d3b2299b5f467da1eef65f1fde8d624cadc8085b1c9
 SHA512:
-  metadata.gz: b9d1abfecdf6fa9c75c4d79967e8604e0bb408a40a08475fb7106e12b0b301a437e8192f836a39b9b5c75261ac97d5dfade6f2ba5ecea9005015814bd257028f
-  data.tar.gz: 5f62f997de89dd93334a6324d2d02fe3bd283036d3f68ee39947cd400ab57f6d3a2d959745498d2b7f5e5c567889cd02e258ed7c15fef3cf3f051f3a21ee3d60
+  metadata.gz: 940a25c0f1ac072dbc7c1bd098e72f37e81b5f24e96230e399bbf0d4e22eba3260177ce2029751ada4c572d9e04585dafd97cfac7513ae9848c8deb5c91ed8a4
+  data.tar.gz: 372c3f53240ded87cee02386f6b0b52586c9abb5fec8889b2968483383f4f01c09483f408a06eb6a1ccb0716c5b01ab4db3d6dfb9e76cc72f555a16739ca3f07

data/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [8.1.1] - 2026-05-26
+
+### Added
+
+- **`rails g inline_forms_addto <Model> attr:type [...]`:** new generator that adds fields to an *existing* inline_forms model. Emits an additive migration (`add_column` for scalars, `add_reference :table, :name, foreign_key: true` for `:belongs_to`/`:references`/`:dropdown`, single `:string` column for `:image_field`/`:audio_field`; no column for `:rich_text`/`has_many`/`has_one`/`habtm`) and edits the model file: injects `belongs_to` / `has_many` / `has_one` / `has_and_belongs_to_many` / `has_rich_text` / `mount_uploader` lines (idempotent), and inserts new rows into the model's `inline_forms_attribute_list` (handles both the generator-shaped and the installer's hand-written `User`/`Member` block). Does NOT touch routes, controller, or `MODEL_TABS` — those are already wired for the existing model. Use case: extending the narrow `User` (or `--user-model Member`) shipped by the installer with app-specific fields like `occupation`, `birthdate`, `organization:dropdown`, `bio:rich_text` without hand-writing migrations or attribute-list edits. Plan: [`stuff/inline_forms_addto.md`](stuff/inline_forms_addto.md).
+- **`--allow-unknown` parity** with `inline_forms`: unknown field types raise `Thor::Error` by default; pass `--allow-unknown` to keep the legacy commented output (`#    add_column …`, `#     [ :name , "name", :unknown ]`).
+- **`--replace`** flag: opt-in rewrite of existing `_presentation` / `_list_order` (and the legacy `_order`) / `_list_search` scopes/methods. Without `--replace` these special names are skipped with `say_status :skipped` so re-runs don't silently mutate the model's ordering/search policy.
+
+### Changed
+
+- **Refactor — `Rails::Generators::GeneratedAttribute` overrides moved to `lib/generators/inline_forms_attribute_overrides.rb`** and shared by both `InlineFormsGenerator` (`rails g inline_forms`) and the new `InlineFormsAddtoGenerator` (`rails g inline_forms_addto`). Pure refactor: same `column_type` / `attribute_type` / `relation?` / `migration?` / `attribute?` / `SPECIAL_GENERATOR_NAMES` semantics, now qualified with `InlineForms::` constants so the file works outside the `module InlineForms` lexical scope.
+
+### Notes
+
+- The new generator class is top-level (`InlineFormsAddtoGenerator`, not `InlineForms::InlineFormsAddtoGenerator`) so `rails g inline_forms_addto …` resolves directly. Rails' generator lookup only collapses `name:name` namespaces (the `inline_forms:inline_forms` → `inline_forms` rule that `InlineFormsGenerator` relies on). A `module InlineForms; InlineFormsAddtoGenerator = ::InlineFormsAddtoGenerator; end` alias is provided for any programmatic invokers that reach for the namespaced constant.
+
 ## [8.1.0] - 2026-05-25
 
 ### Added

data/lib/generators/inline_forms_addto_generator.rb

@@ -0,0 +1,291 @@
+# -*- encoding : utf-8 -*-
+require "inline_forms"
+require_relative "inline_forms_attribute_overrides"
+
+# == Usage
+#
+#   rails g inline_forms_addto Model attribute:type [attribute:type ...] [options]
+#
+# Adds fields to an existing inline_forms model. Emits an additive
+# migration (`add_column` / `add_reference` / single :string column for
+# `:image_field`/`:audio_field`) and edits the model file:
+#
+# * adds `belongs_to` / `has_many` / `has_one` / `has_and_belongs_to_many` /
+#   `has_rich_text` / `mount_uploader` lines (idempotent)
+# * inserts new rows into the model's `inline_forms_attribute_list`
+#
+# Does NOT touch routes, the controller, or `MODEL_TABS` (those are
+# already wired for the existing model). Use `rails g inline_forms <Model>`
+# to create new models.
+#
+# == Special generator names
+#
+# `_no_model`, `_no_migration`, `_id`, `_enabled` are install-time only and
+# are rejected. `_presentation`, `_list_order`, `_list_search` are
+# accepted but only acted on when `--replace` is passed; otherwise the
+# generator skips them with a `say_status :skipped` notice.
+#
+# Top-level (no `InlineForms` module wrapper) so Rails resolves
+# `rails g inline_forms_addto Model …` to this class without the
+# `inline_forms:inline_forms_addto` double-segment trick that Rails only
+# applies for matching `name:name` pairs (`inline_forms:inline_forms`).
+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
+
+    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."
+
+    source_root File.expand_path("templates", __dir__)
+
+    def validate!
+      unless File.exist?(File.join(destination_root, model_file_path))
+        raise Thor::Error,
+          "Model #{model_file_path} not found. " \
+          "Use `rails g inline_forms #{name} ...` for new models."
+      end
+    end
+
+    def set_some_flags
+      @unknown_attributes = []
+      @forbidden_names    = []
+      @skipped_replace_names = []
+      attributes.each do |attribute|
+        if INSTALL_TIME_ONLY_NAMES.include?(attribute.name)
+          @forbidden_names << attribute.name
+          next
+        end
+        if REPLACE_ONLY_NAMES.include?(attribute.name) && !options[:replace]
+          @skipped_replace_names << "#{attribute.name}:#{attribute.type}"
+          next
+        end
+        if !attribute.name.start_with?("_") && (
+            (attribute.attribute? && attribute.attribute_type == :unknown) ||
+            (attribute.migration? && attribute.column_type == :unknown)
+          )
+          @unknown_attributes << "#{attribute.name}:#{attribute.type}"
+        end
+      end
+
+      unless @forbidden_names.empty?
+        raise Thor::Error,
+          "Names #{@forbidden_names.uniq.join(', ')} are install-time only " \
+          "and not supported by inline_forms_addto."
+      end
+
+      allow_unknown = options[:allow_unknown].to_s == "true"
+      if !allow_unknown && !@unknown_attributes.empty?
+        raise Thor::Error,
+          "Unknown field type(s): #{@unknown_attributes.uniq.join(', ')}. " \
+          "Add a valid form element type or pass --allow-unknown to keep legacy commented output."
+      end
+
+      @skipped_replace_names.each do |label|
+        say_status :skipped, "#{label} (pass --replace to rewrite the existing scope/method)", :yellow
+      end
+    end
+
+    def generate_migration
+      @migration_lines = String.new
+      attributes.each do |attribute|
+        next if INSTALL_TIME_ONLY_NAMES.include?(attribute.name)
+        next if REPLACE_ONLY_NAMES.include?(attribute.name)
+        next unless attribute.migration?
+
+        if attribute.column_type == :belongs_to
+          @migration_lines << "    add_reference :#{table_name}, :#{attribute.name}, foreign_key: true\n"
+        else
+          commenter = attribute.attribute_type == :unknown ? "#" : " "
+          @migration_lines << "#{commenter}    add_column :#{table_name}, :#{attribute.name}, :#{attribute.column_type}\n"
+        end
+      end
+
+      return if @migration_lines.empty?
+
+      template "add_columns_migration.erb",
+               "db/migrate/#{time_stamp}_#{migration_file_basename}.rb"
+    end
+
+    def update_model
+      attributes.each do |attribute|
+        next if INSTALL_TIME_ONLY_NAMES.include?(attribute.name)
+        next if REPLACE_ONLY_NAMES.include?(attribute.name) && !options[:replace]
+
+        if REPLACE_ONLY_NAMES.include?(attribute.name) && options[:replace]
+          replace_special!(attribute)
+          next
+        end
+
+        case attribute.column_type
+        when :belongs_to
+          inject_class_line!("  belongs_to :#{attribute.name}\n")
+        end
+
+        case attribute.type
+        when :image_field, :audio_field
+          uploader_class = "#{attribute.name}_uploader".camelcase
+          inject_class_line!("  mount_uploader :#{attribute.name}, #{uploader_class}\n")
+        when :has_many
+          inject_class_line!("  has_many :#{attribute.name}\n")
+        when :has_many_destroy
+          inject_class_line!("  has_many :#{attribute.name}, :dependent => :destroy\n")
+        when :has_one
+          inject_class_line!("  has_one :#{attribute.name}\n")
+        when :habtm, :has_and_belongs_to_many, :check_list
+          inject_class_line!("  has_and_belongs_to_many :#{attribute.name}\n")
+        when :rich_text
+          inject_class_line!("  has_rich_text :#{attribute.name}\n")
+        end
+
+        next unless attribute.attribute?
+
+        add_attribute_list_row!(attribute)
+      end
+    end
+
+    private
+
+    def model_file_name
+      name.underscore
+    end
+
+    def model_file_path
+      "app/models/#{model_file_name}.rb"
+    end
+
+    def model_class_name
+      name.camelize
+    end
+
+    def table_name
+      name.pluralize.underscore
+    end
+
+    def migration_class_name
+      "InlineFormsAddTo#{table_name.camelize}#{migration_class_suffix}"
+    end
+
+    # Suffix keeps re-runs from colliding (Rails would reject duplicate
+    # migration class names). Built from the column names being added.
+    def migration_class_suffix
+      cols = attributes.reject { |a| INSTALL_TIME_ONLY_NAMES.include?(a.name) || REPLACE_ONLY_NAMES.include?(a.name) }
+                       .map { |a| a.name.camelize }
+      cols.empty? ? "Fields" : cols.first(3).join
+    end
+
+    def migration_file_basename
+      cols = attributes.reject { |a| INSTALL_TIME_ONLY_NAMES.include?(a.name) || REPLACE_ONLY_NAMES.include?(a.name) }
+                       .map(&:name)
+      label = cols.first(3).join("_")
+      label = "fields" if label.empty?
+      "inline_forms_add_to_#{table_name}_#{label}"
+    end
+
+    def time_stamp
+      # Mirrors InlineFormsGenerator#time_stamp.
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+
+    # Idempotent inject: skip if `line` (sans trailing newline) already
+    # appears inside the model file. Uses `inject_into_class` so the
+    # injection lands at the top of the class body (after `class Foo <
+    # ApplicationRecord`).
+    def inject_class_line!(line)
+      content = File.read(File.join(destination_root, model_file_path))
+      probe = line.rstrip
+      if content.include?(probe)
+        say_status :identical, "#{model_file_path}: #{probe.strip}", :blue
+        return
+      end
+      inject_into_class model_file_path, model_class_name, line
+    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.
+    def add_attribute_list_row!(attribute)
+      content = File.read(File.join(destination_root, model_file_path))
+      row = "      [ :#{attribute.name} , \"#{attribute.name}\", :#{attribute.attribute_type} ],\n"
+
+      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
+        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.name}", :#{attribute.attribute_type} ],
+            ]
+          end
+        RUBY
+        inject_into_class model_file_path, model_class_name, body
+      end
+    end
+
+    def replace_special!(attribute)
+      case attribute.name
+      when "_presentation"
+        new_method = "  def _presentation\n    \"#{attribute.type}\"\n  end\n"
+        if File.read(File.join(destination_root, model_file_path)).match?(/def _presentation\b/)
+          gsub_file model_file_path,
+                    /  def _presentation\b.*?\n  end\n/m,
+                    new_method
+        else
+          inject_into_class model_file_path, model_class_name, "\n#{new_method}"
+        end
+      when "_list_order", "_order"
+        col = attribute.type
+        new_scope = "  scope :inline_forms_list, -> { order(:#{col}, :id) }\n"
+        new_spaceship = "  def <=>(other)\n    self.#{col} <=> other.#{col}\n  end\n"
+        path = File.join(destination_root, model_file_path)
+        content = File.read(path)
+        if content.match?(/scope :inline_forms_list\b/)
+          gsub_file model_file_path, /  scope :inline_forms_list, ->.*\n/, new_scope
+        else
+          inject_into_class model_file_path, model_class_name, new_scope
+        end
+        if content.match?(/def <=>\(other\)/)
+          gsub_file model_file_path, /  def <=>\(other\).*?\n  end\n/m, new_spaceship
+        else
+          inject_into_class model_file_path, model_class_name, "\n#{new_spaceship}"
+        end
+      when "_list_search"
+        col = attribute.type
+        new_scope = "  scope :inline_forms_search, ->(q) { where(\"#{col} LIKE ?\", \"%\#{q}%\") }\n"
+        if File.read(File.join(destination_root, model_file_path)).match?(/scope :inline_forms_search\b/)
+          gsub_file model_file_path, /  scope :inline_forms_search, ->.*\n/, new_scope
+        else
+          inject_into_class model_file_path, model_class_name, new_scope
+        end
+      end
+    end
+end
+
+module InlineForms
+  # Backwards-compatible alias (tests and any programmatic invokers that
+  # addressed the namespaced version while the generator was scoped to
+  # `module InlineForms`). Rails generator discovery uses the top-level
+  # constant above.
+  InlineFormsAddtoGenerator = ::InlineFormsAddtoGenerator unless const_defined?(:InlineFormsAddtoGenerator, false)
+end

data/lib/generators/inline_forms_attribute_overrides.rb

@@ -0,0 +1,85 @@
+# -*- encoding : utf-8 -*-
+require "rails/generators"
+require "rails/generators/generated_attribute"
+require "inline_forms"
+
+# Shared `Rails::Generators::GeneratedAttribute` extensions used by both
+# `InlineForms::InlineFormsGenerator` (`rails g inline_forms`) and
+# `InlineForms::InlineFormsAddtoGenerator` (`rails g inline_forms_addto`).
+#
+# Loaded once; idempotent (the `class_eval` re-defines methods to the
+# same bodies on a re-require, no behavior drift).
+Rails::Generators::GeneratedAttribute.class_eval do
+  # Override Rails::Generators::GeneratedAttribute.valid_type? so that our
+  # custom field types (dropdown, check_list, image_field, rich_text, ...)
+  # pass through parsing. We do our own unknown-type detection later (with
+  # Thor::Error + --allow-unknown), so it is safe to accept everything here.
+  #
+  # Rails 6.1 used to rescue ActiveRecord::Base.connection failures, which
+  # masked the issue; Rails 7+ raises NameError when ActiveRecord is not
+  # loaded yet, breaking generator unit tests.
+  def self.valid_type?(_type)
+    true
+  end
+
+  # Deducts the column_type for migrations from the type.
+  #
+  # We first merge the Special Column Types with the Default Column Types,
+  # which has the effect that the Default Column Types with the same key
+  # override the Special Column Types.
+  #
+  # If the type is not in the merged hash, then column_type defaults to :unknown
+  #
+  # You are advised to check your migrations for the :unknown, because either you made a
+  # typo in the generator command line or you need to add a Form Element!
+  def column_type
+    InlineForms::SPECIAL_COLUMN_TYPES
+      .merge(InlineForms::DEFAULT_COLUMN_TYPES)
+      .merge(InlineForms::RELATIONS)
+      .merge(InlineForms::SPECIAL_RELATIONS)[type] || :unknown
+  end
+
+  # Override the attribute_type to include our special column types.
+  #
+  # If a type is not in the Special Column Type hash, then the default
+  # column type hash is used, and if that fails, the attribute_type
+  # will be :unknown. Make sure to check your models for the :unknown.
+  def attribute_type
+    if InlineForms::SPECIAL_COLUMN_TYPES.merge(InlineForms::RELATIONS).has_key?(type)
+      type
+    else
+      InlineForms::DEFAULT_FORM_ELEMENTS[type] || :unknown
+    end
+  end
+
+  def special_relation?
+    InlineForms::SPECIAL_RELATIONS.has_key?(type)
+  end
+
+  def relation?
+    InlineForms::RELATIONS.has_key?(type) || special_relation?
+  end
+
+  # Special "attribute" names that drive the generator (presentation,
+  # ordering, search, etc.) but never become real columns or fields.
+  SPECIAL_GENERATOR_NAMES = %w[
+    _presentation
+    _order
+    _list_order
+    _list_search
+    _enabled
+    _id
+    _no_migration
+    _no_model
+  ].freeze unless const_defined?(:SPECIAL_GENERATOR_NAMES)
+
+  def migration?
+    not ( column_type == :no_migration  ||
+        SPECIAL_GENERATOR_NAMES.include?(name) )
+  end
+
+  def attribute?
+    not ( SPECIAL_GENERATOR_NAMES.include?(name) ||
+        relation? )
+  end
+end

data/lib/generators/inline_forms_generator.rb

@@ -1,5 +1,6 @@
 # -*- encoding : utf-8 -*-
 require "inline_forms"
+require_relative "inline_forms_attribute_overrides"
 module InlineForms
   # == Usage
   # This generator generates a migration, a model and a controller.
@@ -13,82 +14,12 @@ module InlineForms
   #  rails g example_generator Modelname attribute:type attribute:type ...
   # an array with attributes and types is created for use in the generator.
   #
-  # Rails::Generators::GeneratedAttribute creates, among others, a attribute_type.
+  # Rails::Generators::GeneratedAttribute creates, among others, an attribute_type.
   # This attribute_type maps column types to form attribute helpers like text_field.
-  # We override it here to make our own.
+  # We override it in `lib/generators/inline_forms_attribute_overrides.rb`
+  # (shared with `InlineFormsAddtoGenerator`).
   #
   class InlineFormsGenerator < Rails::Generators::NamedBase
-    Rails::Generators::GeneratedAttribute.class_eval do #:doc:
-      # Override Rails::Generators::GeneratedAttribute.valid_type? so that our
-      # custom field types (dropdown, check_list, image_field, rich_text, ...)
-      # pass through parsing. We do our own unknown-type detection later (with
-      # Thor::Error + --allow-unknown), so it is safe to accept everything here.
-      #
-      # Rails 6.1 used to rescue ActiveRecord::Base.connection failures, which
-      # masked the issue; Rails 7+ raises NameError when ActiveRecord is not
-      # loaded yet, breaking generator unit tests.
-      def self.valid_type?(_type)
-        true
-      end
-
-      # Deducts the column_type for migrations from the type.
-      #
-      # We first merge the Special Column Types with the Default Column Types,
-      # which has the effect that the Default Column Types with the same key override
-      # the Special Column Types.
-      #
-      # If the type is not in the merged hash, then column_type defaults to :unknown
-      #
-      # You are advised to check you migrations for the :unknown, because either you made a
-      # typo in the generator command line or you need to add a Form Element!
-      #
-      def column_type
-        SPECIAL_COLUMN_TYPES.merge(DEFAULT_COLUMN_TYPES).merge(RELATIONS).merge(SPECIAL_RELATIONS)[type] || :unknown
-      end
-
-      # Override the attribute_type to include our special column types.
-      #
-      # If a type is not in the Special Column Type hash, then the default
-      # column type hash is used, and if that fails, the attribute_type
-      # will be :unknown. Make sure to check your models for the :unknown.
-      #
-      def attribute_type
-        SPECIAL_COLUMN_TYPES.merge(RELATIONS).has_key?(type) ? type : DEFAULT_FORM_ELEMENTS[type] || :unknown
-      end
-
-      def special_relation?
-        SPECIAL_RELATIONS.has_key?(type)
-      end
-
-      def relation?
-        RELATIONS.has_key?(type) || special_relation?
-      end
-
-      # Special "attribute" names that drive the generator (presentation,
-      # ordering, search, etc.) but never become real columns or fields.
-      SPECIAL_GENERATOR_NAMES = %w[
-        _presentation
-        _order
-        _list_order
-        _list_search
-        _enabled
-        _id
-        _no_migration
-        _no_model
-      ].freeze
-
-      def migration?
-        not ( column_type == :no_migration  ||
-            SPECIAL_GENERATOR_NAMES.include?(name) )
-      end
-
-      def attribute?
-        not ( SPECIAL_GENERATOR_NAMES.include?(name) ||
-            relation? )
-      end
-
-
-    end
     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)."
 

data/lib/generators/templates/add_columns_migration.erb

@@ -0,0 +1,7 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[8.0]
+
+  def change
+<%= @migration_lines -%>
+  end
+
+end

data/lib/inline_forms/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module InlineForms
-  VERSION = "8.1.0"
+  VERSION = "8.1.1"
 end

data/test/inline_forms_addto_generator_test.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "tmpdir"
+require "fileutils"
+require "logger"
+require "rails"
+require "rails/generators"
+require "inline_forms"
+require_relative "../lib/generators/inline_forms_addto_generator"
+
+class InlineFormsAddtoGeneratorTest < Minitest::Test
+  GENERATOR_SHAPED_MODEL = <<~RUBY
+    class Widget < ApplicationRecord
+
+      belongs_to :category
+
+      def inline_forms_attribute_list
+        @inline_forms_attribute_list ||= [
+          [ :name , "name", :text_field ],
+          [ :category , "category", :belongs_to ],
+        ]
+      end
+
+    end
+  RUBY
+
+  INSTALLER_SHAPED_USER = <<~RUBY
+    class User < ApplicationRecord
+
+      devise :database_authenticatable
+      belongs_to :locale
+      has_and_belongs_to_many :roles
+
+      def _presentation
+        "\#{name}"
+      end
+
+      def inline_forms_attribute_list
+        @inline_forms_attribute_list ||= [
+          [ :header_user_login,         '', :header ],
+          [ :name,                      '', :text_field ],
+          [ :email,                     '', :text_field ],
+          [ :locale ,                   '', :dropdown ],
+          [ :password,                  '', :devise_password_field ],
+          [ :header_user_roles,         '', :header ],
+          [ :roles,                     '', :check_list ],
+        ]
+      end
+
+    end
+  RUBY
+
+  BARE_MODEL = <<~RUBY
+    class Bare < ApplicationRecord
+    end
+  RUBY
+
+  def setup
+    @destination_root = Dir.mktmpdir("inline_forms_addto_generator_test")
+    mkdir_p("app/models")
+    mkdir_p("db/migrate")
+  end
+
+  def teardown
+    FileUtils.remove_entry(@destination_root) if @destination_root && Dir.exist?(@destination_root)
+  end
+
+  def test_raises_when_model_file_missing
+    stdout, stderr = capture_io do
+      run_generator("DoesNotExist", "occupation:string")
+    end
+    output = "#{stdout}#{stderr}"
+    assert_includes(output, "rails g inline_forms DoesNotExist")
+    refute(File.exist?(File.join(@destination_root, "app/models/does_not_exist.rb")))
+  end
+
+  def test_adds_scalar_column_belongs_to_rich_text_and_image_field_to_existing_model
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    run_generator(
+      "Widget",
+      "occupation:string",
+      "organization:belongs_to",
+      "supplier:dropdown",
+      "bio:rich_text",
+      "avatar:image_field"
+    )
+
+    model = read("app/models/widget.rb")
+    migration = read_single_addto_migration_for("widgets")
+
+    assert_includes(model, "belongs_to :organization")
+    assert_includes(model, "belongs_to :supplier")
+    assert_includes(model, "has_rich_text :bio")
+    assert_includes(model, "mount_uploader :avatar, AvatarUploader")
+    assert_includes(model, '[ :occupation , "occupation", :text_field ]')
+    # :belongs_to is a relation -> no row in inline_forms_attribute_list
+    # (matches InlineFormsGenerator semantics). :dropdown is not a relation
+    # at lookup time, so it does get a row.
+    refute_includes(model, '[ :organization , "organization", :belongs_to ]')
+    assert_includes(model, '[ :supplier , "supplier", :dropdown ]')
+    assert_includes(model, '[ :avatar , "avatar", :image_field ]')
+
+    assert_includes(migration, "add_column :widgets, :occupation, :string")
+    assert_includes(migration, "add_reference :widgets, :organization, foreign_key: true")
+    assert_includes(migration, "add_reference :widgets, :supplier, foreign_key: true")
+    assert_includes(migration, "add_column :widgets, :avatar, :string")
+    refute_includes(migration, ":bio")
+    refute_includes(migration, "create_table")
+  end
+
+  def test_idempotent_rerun_does_not_duplicate_lines
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    run_generator("Widget", "occupation:string", "organization:belongs_to")
+    sleep 1 # unique migration timestamp on second run
+    run_generator("Widget", "occupation:string", "organization:belongs_to")
+
+    model = read("app/models/widget.rb")
+
+    assert_equal(1, model.scan("belongs_to :organization").size)
+    assert_equal(1, model.scan('[ :occupation , "occupation", :text_field ]').size)
+  end
+
+  def test_appends_row_to_installer_shaped_user_attribute_list
+    write_model("user.rb", INSTALLER_SHAPED_USER)
+
+    run_generator("User", "occupation:string", "birthdate:date")
+
+    model = read("app/models/user.rb")
+
+    assert_includes(model, '[ :occupation , "occupation", :text_field ]')
+    assert_includes(model, '[ :birthdate , "birthdate", :date_select ]')
+    refute_match(/\]\s*\n\s*\[\s*:occupation/, model)
+
+    user_array_section = model[/@inline_forms_attribute_list \|\|=\s*\[(.|\n)*?\n\s*\]/]
+    assert(user_array_section, "could not locate @inline_forms_attribute_list array")
+    assert_match(/\[ :roles,.*\].*?\[ :occupation\b/m, user_array_section)
+  end
+
+  def test_bare_model_gets_fresh_attribute_list_method
+    write_model("bare.rb", BARE_MODEL)
+
+    out, _err = capture_io do
+      run_generator("Bare", "occupation:string")
+    end
+
+    model = read("app/models/bare.rb")
+
+    assert_includes(out, "no inline_forms_attribute_list found")
+    assert_includes(model, "def inline_forms_attribute_list")
+    assert_includes(model, '[ :occupation , "occupation", :text_field ]')
+  end
+
+  def test_unknown_type_raises_thor_error_by_default
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    stdout, stderr = capture_io do
+      run_generator("Widget", "payload:not_a_real_type")
+    end
+    output = "#{stdout}#{stderr}"
+    assert_includes(output, "Unknown field type(s): payload:not_a_real_type")
+    assert_includes(output, "--allow-unknown")
+
+    refute_addto_migration_for("widgets")
+  end
+
+  def test_allow_unknown_keeps_legacy_commented_output
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    run_generator("Widget", "payload:not_a_real_type", "--allow-unknown")
+
+    model = read("app/models/widget.rb")
+    migration = read_single_addto_migration_for("widgets")
+
+    assert_includes(model, '[ :payload , "payload", :unknown ]')
+    assert_includes(migration, "#    add_column :widgets, :payload, :unknown")
+  end
+
+  def test_install_time_only_names_are_rejected
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    %w[_no_model _no_migration _id _enabled].each do |forbidden|
+      stdout, stderr = capture_io do
+        run_generator("Widget", "#{forbidden}:yes")
+      end
+      output = "#{stdout}#{stderr}"
+      assert_includes(output, forbidden, "expected error to mention #{forbidden}")
+      assert_includes(output, "install-time only")
+    end
+  end
+
+  def test_skips_replace_only_names_without_replace_flag
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    out, _err = capture_io do
+      run_generator("Widget", "_list_order:title")
+    end
+
+    assert_includes(out, "_list_order:title")
+    assert_includes(out, "skipped")
+    model = read("app/models/widget.rb")
+    refute_includes(model, "scope :inline_forms_list, -> { order(:title, :id) }")
+  end
+
+  def test_replace_flag_rewrites_list_order_scope
+    initial = GENERATOR_SHAPED_MODEL.sub(
+      /class Widget < ApplicationRecord\n/,
+      "class Widget < ApplicationRecord\n\n  scope :inline_forms_list, -> { order(:name, :id) }\n  def <=>(other)\n    self.name <=> other.name\n  end\n"
+    )
+    write_model("widget.rb", initial)
+
+    run_generator("Widget", "_list_order:title", "--replace")
+
+    model = read("app/models/widget.rb")
+    assert_includes(model, "scope :inline_forms_list, -> { order(:title, :id) }")
+    refute_includes(model, "order(:name, :id)")
+    assert_includes(model, "self.title <=> other.title")
+    refute_includes(model, "self.name <=> other.name")
+  end
+
+  private
+
+  def run_generator(*args)
+    InlineForms::InlineFormsAddtoGenerator.start(args, destination_root: @destination_root)
+  end
+
+  def write_model(file, content)
+    File.write(File.join(@destination_root, "app/models", file), content)
+  end
+
+  def read(relative_path)
+    File.read(File.join(@destination_root, relative_path))
+  end
+
+  def mkdir_p(relative_path)
+    FileUtils.mkdir_p(File.join(@destination_root, relative_path))
+  end
+
+  def read_single_addto_migration_for(table_name)
+    files = Dir.glob(File.join(@destination_root, "db/migrate/*_inline_forms_add_to_#{table_name}_*.rb"))
+    assert_equal(1, files.size, "Expected one addto migration for #{table_name}, got #{files.inspect}")
+    File.read(files.first)
+  end
+
+  def refute_addto_migration_for(table_name)
+    files = Dir.glob(File.join(@destination_root, "db/migrate/*_inline_forms_add_to_#{table_name}_*.rb"))
+    assert_equal([], files, "Expected no addto migration for #{table_name}")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inline_forms
 version: !ruby/object:Gem::Version
-  version: 8.1.0
+  version: 8.1.1
 platform: ruby
 authors:
 - Ace Suares
@@ -495,8 +495,11 @@ files:
 - inline_forms.gemspec
 - lib/generators/USAGE
 - lib/generators/assets/stylesheets/inline_forms_devise.css
+- lib/generators/inline_forms_addto_generator.rb
+- lib/generators/inline_forms_attribute_overrides.rb
 - lib/generators/inline_forms_generator.rb
 - lib/generators/templates/_inline_forms_tabs.html.erb
+- lib/generators/templates/add_columns_migration.erb
 - lib/generators/templates/application_record.rb
 - lib/generators/templates/controller.erb
 - lib/generators/templates/migration.erb
@@ -558,6 +561,7 @@ files:
 - test/archived_form_elements_test.rb
 - test/form_element_from_callee_test.rb
 - test/inline_edit_polymorphic_path_test.rb
+- test/inline_forms_addto_generator_test.rb
 - test/inline_forms_generator_test.rb
 - test/plain_text_configuration_test.rb
 - test/test_helper.rb
@@ -590,6 +594,7 @@ test_files:
 - test/archived_form_elements_test.rb
 - test/form_element_from_callee_test.rb
 - test/inline_edit_polymorphic_path_test.rb
+- test/inline_forms_addto_generator_test.rb
 - test/inline_forms_generator_test.rb
 - test/plain_text_configuration_test.rb
 - test/test_helper.rb