inline_forms 8.0.4 → 8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83fc3ebab88e414806da9e2c7f9a47088eb1d69579f607af783e647f374ada2b
-  data.tar.gz: 76348168e6d35fb88a7142e66e92938ae6938b83cd606a894f1985c37c7cd219
+  metadata.gz: 86869c3131530e4764f1a16620e48bd0eaf920461f0471697c07d2e30bda69f3
+  data.tar.gz: 5c304a602f87fcc37b403d3b2299b5f467da1eef65f1fde8d624cadc8085b1c9
 SHA512:
-  metadata.gz: d3d2b9b5a2cc0239857123cf16cd6605f58d27e324accddb8232015445767e3b06214c4c869d6089218b42aa72f737a11611d83abc3b53e731573ea628987944
-  data.tar.gz: 29d10dd86bb1c3bff98a5653b513de213e08250ab43b3fd3969e1aeaa71cd690f73f9034f51c64e775debeff69abd6180b5895867e7c4ca0a9aa10bda879fe07
+  metadata.gz: 940a25c0f1ac072dbc7c1bd098e72f37e81b5f24e96230e399bbf0d4e22eba3260177ce2029751ada4c572d9e04585dafd97cfac7513ae9848c8deb5c91ed8a4
+  data.tar.gz: 372c3f53240ded87cee02386f6b0b52586c9abb5fec8889b2968483383f4f01c09483f408a06eb6a1ccb0716c5b01ab4db3d6dfb9e76cc72f555a16739ca3f07

data/CHANGELOG.md

@@ -4,6 +4,54 @@ 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
+
+- **`ApplicationRecord` template carries shared model behavior:** `has_paper_trail on: [:create, :update, :destroy]`, `attr_writer :inline_forms_attribute_list`, `self.per_page = 7`, `human_attribute_name` instance wrapper, and `def self.not_accessible_through_html?` default. Generated models inherit all of this; `lib/generators/templates/model.erb` only emits per-model differences (associations, `inline_forms_attribute_list`, `_presentation`, `<=>`, `not_accessible_through_html?` override when `_enabled` is absent).
+- **`scope :inline_forms_list, -> { all }` and `scope :inline_forms_search, ->(_q) { all }`** on `ApplicationRecord`. Both are no-ops by default; subclasses opt in. Replaces the old `def self.order_by_clause` contract with composable Active Record relations.
+- **Generator flags `_list_order:col` and `_list_search:col`:** emit `scope :inline_forms_list, -> { order(:col, :id) }` and `scope :inline_forms_search, ->(q) { where("col LIKE ?", "%#{q}%") }` respectively. `_list_order` also still emits `def <=>(other)` for in-memory sort on associations (used by `check_list` show). Tie-break on `:id` is added automatically so will_paginate pages stay stable.
+- **`SPECIAL_GENERATOR_NAMES` constant** in `InlineForms::InlineFormsGenerator` consolidates `_presentation`, `_order`, `_list_order`, `_list_search`, `_enabled`, `_id`, `_no_migration`, `_no_model` so `migration?` / `attribute?` no longer drift.
+
+### Changed
+
+- **`order_by_clause` is gone from the gem.** `InlineFormsController#index` / `#create`, `check_list_helper.rb`, and `app/views/inline_forms/_list.html.erb` now compose `merge(@Klass.inline_forms_list)` and `merge(@Klass.inline_forms_search(params[:search]))` instead of building raw `"table.col"` strings. Search and order are now independent (one column had to do both jobs before); models can declare each separately or neither.
+- **Per-page pagination fix in `ApplicationRecord`:** `self.per_page = 7` (class-level, what will_paginate's `class_attribute :per_page` reads). The old `attr_reader :per_page` + `@per_page = 7` instance pair on every generated model was a no-op (described at length in 8.0.x notes); models that need a different value override with `self.per_page = N` (Photo uses `5`). The installer’s Photo override now uses `inject_into_class "app/models/photo.rb", "Photo", "  self.per_page = 5\n"` instead of patching the legacy `attr_reader` block out.
+- **`_order:col` is deprecated as an alias for `_list_order:col`.** Still works (emits the same scope plus `<=>`); the generator prints `say_status :deprecated, "_order:col is deprecated; use _list_order:col"` so existing scripts keep generating but the migration path is visible.
+- **Installer User model:** dropped `default_scope { order :name }` and the `def self.order_by_clause; nil; end` stub. Added `scope :inline_forms_list, -> { order(:name, :id) }` with a comment about why named scopes beat `default_scope` (no `unscope`/`reorder` foot-guns; cleaner `update_all` / association inheritance).
+- **Installer example-app generator calls** for `Locale`, `Role`, `Photo`, `Apartment`, `Owner` now pass `_list_order:name` (and `_list_search:name` for the searchable top-level models `Apartment` and `Owner`) to declare ordering and search explicitly. Replaces the implicit `order_by_clause = "name"` default that the old generator produced.
+
+### Removed
+
+- **`lib/generators/assets/javascripts/`** (including the empty `ckeditor/` subfolder). Leftover from the CKEditor era; nothing in the gem or installer copied from it. The engine still ships JS under `app/assets/javascripts/` and `vendor/assets/javascripts/`.
+- **`lib/generators/assets/stylesheets/inline_forms.scss`** mirror. The installer doesn't copy it; the gem stylesheet at `app/assets/stylesheets/inline_forms/inline_forms.scss` is the single source consumed via `@use "inline_forms/inline_forms"`. `inline_forms_devise.css` stays — it is the host-app override hook copied by the installer and linked from `layouts/devise.html.erb`.
+
+### Migration notes
+
+Existing apps upgrading from 8.0.x:
+
+1. Replace your `app/models/application_record.rb` with the contents of `lib/generators/templates/application_record.rb` (or just merge in the new `has_paper_trail`, `self.per_page`, `inline_forms_list` / `inline_forms_search` scopes, and `not_accessible_through_html?` default).
+2. For each model that had `def self.order_by_clause; "col"; end`, replace with `scope :inline_forms_list, -> { order(:col, :id) }`. Drop the old method; the gem no longer reads it.
+3. If you used `default_scope { order(:name) }` for inline_forms list ordering, swap to the named scope above.
+4. Per-model `attr_reader :per_page` / `@per_page = N` pairs are no-ops; replace with `self.per_page = N` (or remove and inherit `7` from `ApplicationRecord`).
+5. `_order:col` in your generator scripts still works but emits a deprecation notice; switch to `_list_order:col` and add `_list_search:col` if you want the search box to filter on that column.
+
 ## [8.0.4] - 2026-05-24
 
 ### Added

data/app/controllers/inline_forms_controller.rb

@@ -36,14 +36,12 @@ class InlineFormsController < ApplicationController
     @parent_class = params[:parent_class]
     @parent_id = params[:parent_id]
     @ul_needed = params[:ul_needed]
-    # if the parent_class is not nill, we are in associated list and we don't search there.
-    # also, make sure the Model that you want to do a search on has a :name attribute. TODO
-    conditions = nil
-    if @parent_class.nil? || @Klass.reflect_on_association(@parent_class.underscore.to_sym).nil?
-      conditions = [ @Klass.table_name + "." + @Klass.order_by_clause + " like ?", "%#{params[:search]}%" ] if @Klass.respond_to?(:order_by_clause) && ! @Klass.order_by_clause.nil?
-    else
+    # Nested associated lists scope to the parent FK. Top-level lists may
+    # apply the model's `inline_forms_search` scope when ?search= is passed.
+    fk_conditions = nil
+    if @parent_class.present? && @Klass.reflect_on_association(@parent_class.underscore.to_sym)
       foreign_key = @Klass.reflect_on_association(@parent_class.underscore.to_sym).options[:foreign_key] || @parent_class.foreign_key
-      conditions =  [ "#{foreign_key} = ?", @parent_id ]
+      fk_conditions = [ "#{foreign_key} = ?", @parent_id ]
     end
     # CanCan's load_and_authorize_resource sets @apartments (etc.); keep @objects in sync.
     collection_ivar = :"@#{controller_name}"
@@ -52,9 +50,13 @@ class InlineFormsController < ApplicationController
       @objects = loaded unless loaded.nil?
     end
     @objects ||= @Klass.accessible_by(current_ability) if cancan_enabled?
-    @objects ||= @Klass
-    @objects = @objects.order(@Klass.table_name + "." + @Klass.order_by_clause) if @Klass.respond_to?(:order_by_clause) && ! @Klass.order_by_clause.nil?
-    @objects = @objects.where(conditions).paginate(:page => params[:page])
+    @objects ||= @Klass.all
+    @objects = @objects.merge(@Klass.inline_forms_list) if @Klass.respond_to?(:inline_forms_list)
+    if fk_conditions.nil? && params[:search].present? && @Klass.respond_to?(:inline_forms_search)
+      @objects = @objects.merge(@Klass.inline_forms_search(params[:search]))
+    end
+    @objects = @objects.where(fk_conditions) if fk_conditions
+    @objects = @objects.paginate(:page => params[:page])
     respond_to do |format|
       # `not_accessible_through_html?` is about preventing direct top-level
       # HTML CRUD on this resource (e.g. /photos when only Apartment is the
@@ -139,22 +141,23 @@ class InlineFormsController < ApplicationController
     end
     @parent_class = params[:parent_class]
     @parent_id = params[:parent_id]
-    # for the logic behind the :conditions see the #index method.
-    conditions = nil
-    if @parent_class.nil? || @Klass.reflect_on_association(@parent_class.underscore.to_sym).nil?
-      conditions = [ @Klass.table_name + "." + @Klass.order_by_clause + " like ?", "%#{params[:search]}%" ] if @Klass.respond_to?(:order_by_clause) && ! @Klass.order_by_clause.nil?
-    else
+    # See #index for the order/search/parent-fk decomposition.
+    fk_conditions = nil
+    if @parent_class.present? && @Klass.reflect_on_association(@parent_class.underscore.to_sym)
       foreign_key = @Klass.reflect_on_association(@parent_class.underscore.to_sym).options[:foreign_key] || @parent_class.foreign_key
-      conditions =  [ "#{foreign_key} = ?", @parent_id ]
+      fk_conditions = [ "#{foreign_key} = ?", @parent_id ]
       @object[foreign_key] = @parent_id
     end
 
     if @object.save
       flash.now[:success] = t('success', :message => @object.class.model_name.human)
-      @objects = @Klass
-      @objects = @Klass.accessible_by(current_ability) if cancan_enabled?
-      @objects = @objects.order(@Klass.table_name + "." + @Klass.order_by_clause) if @Klass.respond_to?(:order_by_clause) && ! @Klass.order_by_clause.nil?
-      @objects = @objects.where(conditions).paginate(:page => params[:page])
+      @objects = cancan_enabled? ? @Klass.accessible_by(current_ability) : @Klass.all
+      @objects = @objects.merge(@Klass.inline_forms_list) if @Klass.respond_to?(:inline_forms_list)
+      if fk_conditions.nil? && params[:search].present? && @Klass.respond_to?(:inline_forms_search)
+        @objects = @objects.merge(@Klass.inline_forms_search(params[:search]))
+      end
+      @objects = @objects.where(fk_conditions) if fk_conditions
+      @objects = @objects.paginate(:page => params[:page])
       @object = nil
       respond_to do |format|
         format.html { render_list_frame_after_save } if html_list_flow_allowed?

data/app/views/inline_forms/_list.html.erb

@@ -34,9 +34,10 @@
     <% foreign_key = parent_class.reflect_on_association(attribute.to_sym).options[:foreign_key] || parent_class.name.foreign_key -%>
     <% model = attribute.to_s.singularize.camelcase.constantize %>
     <% conditions =  [ "#{model.table_name}.#{foreign_key} = ?", parent_id ] %>
+    <% klass = attribute.to_s.singularize.camelcase.constantize %>
     <% objects = parent_class.find(parent_id).send(attribute) %>
     <% objects = parent_class.find(parent_id).send(attribute).accessible_by(current_ability) if cancan_enabled? %>
-    <% objects = objects.order(attribute.to_s.singularize.camelcase.constantize.order_by_clause) if attribute.to_s.singularize.camelcase.constantize.respond_to?(:order_by_clause) && ! attribute.to_s.singularize.camelcase.constantize.order_by_clause.nil? %>
+    <% objects = objects.merge(klass.inline_forms_list) if klass.respond_to?(:inline_forms_list) %>
     <% objects = objects.where(conditions).paginate(:page => params[:page]) %>
   <% end %>
 <% end %>

data/inline_forms.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
-  s.add_dependency("validation_hints", ">= 8.0.4", "< 9.0")
+  s.add_dependency("validation_hints", ">= 8.1.0", "< 9.0")
   s.add_dependency("rails", ">= 8.0", "< 8.1")
   s.add_dependency("rails-i18n", ">= 8.0", "< 9.0")
 

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