inline_forms 6.3.3 → 7.2.10

data/lib/installer_templates/example_app_tests/test/integration/example_app_apartment_photos_pagination_test.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative "../example_app/example_integration_test_case"
+
+# Smoke test for rollout step 2 of stuff/ujs-to-turbo.md (gem-side):
+# the nested has_many list (apartments -> photos) is now wrapped in a
+# <turbo-frame> and pagination is no longer remote: true. Relies on
+# the SeedKonferenshaPhotos migration that the inline_forms installer
+# generates when invoked with --example: it creates a "Konferensha"
+# Apartment with one Photo per file in db/seed_images/, and the gem
+# ships 12 sample jpgs in pics/, so combined with `Photo.per_page = 5`
+# (also set by the installer) this gallery paginates 5 / 5 / 2.
+class ExampleAppApartmentPhotosPaginationTest < ExampleAppIntegrationTestCase
+  # `bundle exec rails test` loads the test DB from db/schema.rb, which is
+  # DDL-only -- the SeedKonferenshaPhotos migration's row inserts never
+  # land in db/test.sqlite3. We re-seed here from the same db/seed_images/
+  # the installer copied into the app so the test asserts against real
+  # records (and real CarrierWave file mounts) without depending on
+  # development-DB state.
+  setup do
+    @apartment = Apartment.find_or_create_by!(name: "Konferensha") do |a|
+      a.title = "Konferensha sobre Papiamentu"
+    end
+    seed_dir = Rails.root.join("db", "seed_images")
+    if seed_dir.directory?
+      Dir.glob(seed_dir.join("*.{jpg,jpeg,png,gif}"), File::FNM_CASEFOLD).sort.each do |abs|
+        base = File.basename(abs)
+        next if Photo.exists?(name: base, apartment_id: @apartment.id)
+        File.open(abs, "rb") do |io|
+          Photo.create!(
+            name: base,
+            caption: "Konferensha foto #{base}",
+            apartment: @apartment,
+            image: io
+          )
+        end
+      end
+    end
+    @update_span = "apartment_#{@apartment.id}_photos_list"
+  end
+
+  test "seed migration left at least 6 photos under Konferensha so pagination triggers" do
+    assert @apartment.photos.count >= 6,
+      "expected SeedKonferenshaPhotos to seed >= 6 photos for Konferensha; " \
+      "got #{@apartment.photos.count}. Check db/seed_images/ and the migration."
+  end
+
+  test "Photo.per_page is overridden so will_paginate splits the gallery" do
+    assert_equal 5, Photo.per_page,
+      "expected the installer to set `self.per_page = 5` on Photo so the seeded gallery paginates"
+  end
+
+  test "nested photos index without Turbo-Frame header renders full inline_forms layout (bookmark / full navigation)" do
+    get photos_path(
+      parent_class: "Apartment",
+      parent_id: @apartment.id,
+      update: @update_span,
+      ul_needed: true
+    )
+    assert_response :success
+
+    assert_match(
+      /id="outer_container"/,
+      @response.body,
+      "direct or full-page GET /photos?... must use the inline_forms layout " \
+      "so the page is styled; `layout: false` used to emit only a bare <turbo-frame> " \
+      "which looks broken in the address bar."
+    )
+    assert_match(
+      %r{<turbo-frame\s+id="#{Regexp.escape(@update_span)}"},
+      @response.body,
+      "expected the gallery frame inside the layout body"
+    )
+  end
+
+  test "nested photos index with Turbo-Frame header uses minimal layout without app chrome" do
+    get photos_path(
+      parent_class: "Apartment",
+      parent_id: @apartment.id,
+      update: @update_span,
+      ul_needed: true
+    ),
+        headers: { "Turbo-Frame" => @update_span }
+    assert_response :success
+
+    assert_match(
+      %r{<turbo-frame\s+id="#{Regexp.escape(@update_span)}"},
+      @response.body,
+      "expected Turbo frame navigation to receive a matching <turbo-frame id=\"#{@update_span}\">"
+    )
+    refute_match(
+      /id="outer_container"/,
+      @response.body,
+      "frame requests should not pay for the full inline_forms chrome; use turbo_rails/frame layout"
+    )
+  end
+
+  test "nested photos index is wrapped in a <turbo-frame> instead of remote-UJS <div>" do
+    get photos_path(
+      parent_class: "Apartment",
+      parent_id: @apartment.id,
+      update: @update_span,
+      ul_needed: true
+    )
+    assert_response :success
+
+    assert_match(
+      %r{<turbo-frame\s+id="#{Regexp.escape(@update_span)}"},
+      @response.body,
+      "expected the nested photos list to render as <turbo-frame id=\"#{@update_span}\">"
+    )
+
+    refute_match(
+      %r{<div[^>]+class="list_container"[^>]+id="#{Regexp.escape(@update_span)}"},
+      @response.body,
+      "nested photos list should no longer use the legacy <div class=\"list_container\"> wrapper"
+    )
+  end
+
+  test "nested photos pagination renders will_paginate links inside the frame" do
+    get photos_path(
+      parent_class: "Apartment",
+      parent_id: @apartment.id,
+      update: @update_span,
+      ul_needed: true
+    )
+    assert_response :success
+
+    assert_match(
+      /<(?:div|nav)[^>]+class="[^"]*\bpagination\b[^"]*"/,
+      @response.body,
+      "expected will_paginate to render a .pagination element (gallery has more rows than Photo.per_page)"
+    )
+
+    refute_match(
+      /class="next_page"[^>]*data-remote="true"/,
+      @response.body,
+      "pagination links should no longer carry data-remote=\"true\" (Turbo Frame handles in-frame nav)"
+    )
+  end
+
+  test "pagination links carry the same update= as the surrounding turbo-frame id" do
+    # This is the regression class that broke "Next" in 7.2.1: the
+    # legacy UJS pagination passed `update=apartment_<id>_photos`
+    # (the OUTER wrapper id from _show.html.erb, which list.js.erb
+    # used as the swap target). Turbo Frames swaps by id-match between
+    # the frame in the DOM and a frame in the response, so when a Next
+    # click re-rendered _list with update_span derived from the URL,
+    # the response contained `<turbo-frame id="apartment_<id>_photos">`
+    # while the page held `<turbo-frame id="apartment_<id>_photos_list">`,
+    # and Turbo logged "the response did not contain the expected
+    # <turbo-frame>" and dropped the swap. The `update=` param on every
+    # pagination link must be the same id as the surrounding frame.
+    get photos_path(
+      parent_class: "Apartment",
+      parent_id: @apartment.id,
+      update: @update_span,
+      ul_needed: true
+    )
+    assert_response :success
+
+    page_link_updates =
+      @response.body.scan(/href="[^"]*\?[^"]*update=([^&"]+)[^"]*"/).flatten
+
+    assert page_link_updates.any? { |u| u == @update_span },
+      "expected at least one pagination link to carry update=#{@update_span} " \
+      "(matching the <turbo-frame id=\"#{@update_span}\">), got updates=#{page_link_updates.inspect}"
+
+    refute page_link_updates.any? { |u| u == @update_span.sub(/_list\z/, "") },
+      "no pagination link should still carry the legacy outer-wrapper id " \
+      "(#{@update_span.sub(/_list\z/, "")}) -- Turbo Frame can't swap on that id"
+  end
+
+  test "top-level apartment rows do NOT carry data-turbo=\"false\" (would poison nested frames)" do
+    # 7.2.2 broke pagination of the inner photos <turbo-frame> because
+    # the top-level apartment row was emitting data-turbo="false" too.
+    # When show.js.erb swaps the inline edit (containing the nested
+    # <turbo-frame>) into that row, every link inside the nested frame
+    # -- including pagination links -- has the row as an ancestor.
+    # Turbo's Session.elementIsNavigatable does
+    # `findClosestRecursively(link, "[data-turbo]")` and does NOT stop
+    # at the intervening <turbo-frame>; it picks up the row's
+    # data-turbo="false" and refuses to intercept the click, so the
+    # browser does a full-page navigation to /photos?page=N&... and
+    # the user sees the bare partial without a layout. The attribute
+    # must stay scoped to NESTED rows (which need the opt-out for
+    # their swapped-in inline-edit forms); top-level rows must NOT
+    # carry it.
+    get apartments_path
+    assert_response :success
+
+    refute_match(
+      /<div[^>]+class="[^"]*\btop-level\b[^"]*"[^>]*data-turbo="false"|<div[^>]+data-turbo="false"[^>]*class="[^"]*\btop-level\b[^"]*"/,
+      @response.body,
+      "top-level list rows must not carry data-turbo=\"false\"; that attribute would " \
+      "be inherited by every link inside any nested <turbo-frame> swapped into the row"
+    )
+  end
+
+  test "row container opts out of Turbo so swapped-in UJS forms (replace photo etc.) keep working" do
+    get photos_path(
+      parent_class: "Apartment",
+      parent_id: @apartment.id,
+      update: @update_span,
+      ul_needed: true
+    )
+    assert_response :success
+
+    # The container-level opt-out is what protects the inline-edit /
+    # replace-photo flow: when a user replaces a photo, show.js.erb /
+    # edit.js.erb does $('#<row_id>').html(<form>), so the multipart
+    # form that submits the upload is a descendant of this row. With
+    # data-turbo="false" on the row, Turbo doesn't intercept that
+    # submission -- jquery-ujs + remotipart do, the request goes out
+    # with Accept: text/javascript, and the controller's format.js
+    # branch handles it. Without this, Turbo Frames would send
+    # Accept: text/html and the update action (no format.html for
+    # not_accessible_through_html? models like Photo) raises
+    # UnknownFormat AFTER the DB write -- a 406 with a corrupted UI.
+    sample_row_id = "apartment_#{@apartment.id}_photo_#{@apartment.photos.first.id}"
+    assert_match(
+      %r{<div[^>]+id="#{Regexp.escape(sample_row_id)}"[^>]*data-turbo="false"|<div[^>]+data-turbo="false"[^>]*id="#{Regexp.escape(sample_row_id)}"},
+      @response.body,
+      "expected the per-row container (id=\"#{sample_row_id}\") to carry data-turbo=\"false\" " \
+      "so swapped-in UJS forms inherit the Turbo opt-out"
+    )
+  end
+end

data/lib/installer_templates/example_app_tests/test/integration/example_app_turbo_layout_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../example_app/example_integration_test_case"
+
+# Smoke test for rollout step 1 of stuff/ujs-to-turbo.md (gem-side):
+# the layout loads Turbo as an ES module and disables Drive so existing
+# UJS-driven links/forms keep working unchanged. If this asserts ever
+# fails, frame/stream conversions in later slices will silently fall
+# back to full-page navigation (Turbo not loaded) instead of using the
+# `<turbo-frame>` fast path.
+class ExampleAppTurboLayoutTest < ExampleAppIntegrationTestCase
+  test "inline_forms layout loads turbo.min.js as an ES module with drive disabled" do
+    get apartments_path
+    assert_response :success
+
+    assert_match(
+      %r{<script\s+type="module">\s*import\s+\{\s*Turbo\s*\}\s+from\s+"[^"]*turbo\.min(?:-[a-f0-9]+)?\.js"}m,
+      @response.body,
+      "expected the inline_forms layout to import turbo.min.js as a module"
+    )
+
+    assert_match(
+      /Turbo\.session\.drive\s*=\s*false/,
+      @response.body,
+      "expected Turbo.session.drive = false so existing UJS keeps working"
+    )
+  end
+end

data/lib/installer_templates/example_app_tests/test/models/example_app_paper_trail_changeset_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Regression: PaperTrail (>= 13) deserializes `versions.object_changes` via
+# `YAML.safe_load`, using `ActiveRecord.yaml_column_permitted_classes` as the
+# allow-list. Rails 7's default is `[Symbol]`, so any update that touches
+# `updated_at` (an `ActiveSupport::TimeWithZone`) raises `Psych::DisallowedClass`
+# inside `version.changeset`, and PaperTrail rescues that into `{}`. The
+# inline_forms versions list then renders every changeset as `empty`.
+#
+# The installer ships `config/initializers/paper_trail_yaml_safe_load.rb`,
+# which extends the allow-list. This test fails if that initializer is
+# missing or insufficient.
+class ExampleAppPaperTrailChangesetTest < ActiveSupport::TestCase
+  test "version.changeset round-trips a normal update" do
+    PaperTrail.request.whodunnit = "test"
+
+    apartment = Apartment.create!(name: "Original", title: "Old Title")
+    apartment.update!(name: "Renamed", title: "New Title")
+
+    version = apartment.versions.last
+    assert_equal "update", version.event,
+      "expected an update version to be recorded by paper_trail"
+
+    changeset = version.changeset
+    assert_kind_of Hash, changeset
+    refute_empty changeset,
+      "version.changeset is empty; PaperTrail's YAML.safe_load probably hit a " \
+      "DisallowedClass and returned {}. Check " \
+      "config/initializers/paper_trail_yaml_safe_load.rb and the Rails " \
+      "ActiveRecord.yaml_column_permitted_classes setting."
+
+    assert_equal ["Original", "Renamed"], changeset["name"]
+    assert_equal ["Old Title", "New Title"], changeset["title"]
+  end
+
+  # `has_rich_text :description` lives in the `action_text_rich_texts` table,
+  # so `has_paper_trail` on Apartment cannot see body edits. The installer adds
+  # `config/initializers/rich_text_paper_trail.rb` (which declares
+  # `has_paper_trail` on `ActionText::RichText`), and `inline_forms_versions_for`
+  # merges rich-text versions into the parent's history. This test fails if
+  # either piece regresses.
+  test "rich_text edits surface in the merged versions list for the parent" do
+    PaperTrail.request.whodunnit = "test"
+
+    apartment = Apartment.create!(name: "RT", title: "RT", description: "v1 body")
+    apartment.update!(description: "v2 body")
+
+    rich_text = ActionText::RichText.find_by!(
+      record_type: Apartment.name, record_id: apartment.id, name: "description"
+    )
+    assert rich_text.respond_to?(:versions),
+      "ActionText::RichText is missing has_paper_trail; check " \
+      "config/initializers/rich_text_paper_trail.rb"
+    refute_empty rich_text.versions,
+      "no PaperTrail versions on ActionText::RichText; the on_load hook " \
+      "in config/initializers/rich_text_paper_trail.rb did not fire or " \
+      "has_paper_trail was not applied"
+
+    helper = Class.new { include InlineFormsHelper }.new
+    entries = helper.inline_forms_versions_for(apartment)
+
+    rich_text_entries = entries.select { |e| e[:kind] == :rich_text }
+    refute_empty rich_text_entries,
+      "inline_forms_versions_for did not return any rich_text entries"
+
+    body_changes = rich_text_entries
+      .map { |e| e[:version].changeset }
+      .select { |cs| cs && cs["body"].is_a?(Array) }
+      .map { |cs| cs["body"] }
+
+    refute_empty body_changes,
+      "no body changesets recorded for ActionText::RichText"
+    assert body_changes.any? { |old, new_| old.to_s.include?("v1 body") && new_.to_s.include?("v2 body") },
+      "expected an entry whose body change moves from 'v1 body' to 'v2 body'; got #{body_changes.inspect}"
+  end
+end

data/test/inline_forms_generator_test.rb

@@ -0,0 +1,155 @@
+# 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_generator"
+
+class InlineFormsGeneratorTest < Minitest::Test
+  def setup
+    @destination_root = Dir.mktmpdir("inline_forms_generator_test")
+    build_destination_skeleton!
+  end
+
+  def teardown
+    FileUtils.remove_entry(@destination_root) if @destination_root && Dir.exist?(@destination_root)
+  end
+
+  def test_generates_model_controller_route_migration_and_tab_injection
+    run_generator(
+      "Thing",
+      "name:string",
+      "category:dropdown",
+      "photos:has_many",
+      "_enabled:yes",
+      "_presentation:\\#{name}"
+    )
+
+    model = read("app/models/thing.rb")
+    controller = read("app/controllers/things_controller.rb")
+    routes = read("config/routes.rb")
+    application_controller = read("app/controllers/application_controller.rb")
+    migration = read_single_migration_for("things")
+
+    assert_includes(model, "class Thing < ApplicationRecord")
+    assert_includes(model, "belongs_to :category")
+    assert_includes(model, "has_many :photos")
+    assert_includes(model, "[ :name , \"name\", :text_field ]")
+    assert_includes(model, "[ :category , \"category\", :dropdown ]")
+
+    assert_includes(controller, "class ThingsController < InlineFormsController")
+    assert_includes(controller, "set_tab :thing")
+
+    assert_includes(routes, "resources :things do")
+    assert_includes(routes, "post 'revert', :on => :member")
+    assert_includes(routes, "get 'list_versions', :on => :member")
+
+    assert_includes(application_controller, "MODEL_TABS = %w(things ")
+
+    assert_includes(migration, "class InlineFormsCreateThings < ActiveRecord::Migration[7.0]")
+    assert_includes(migration, "create_table :things do |t|")
+    assert_includes(migration, "t.string :name")
+    assert_includes(migration, "t.belongs_to :category")
+    refute_includes(migration, "photos")
+  end
+
+  def test_skips_model_controller_and_routes_when_no_model_flag_is_present
+    run_generator("AuditLog", "message:string", "_no_model:yes")
+
+    refute_exist("app/models/audit_log.rb")
+    refute_exist("app/controllers/audit_logs_controller.rb")
+
+    routes = read("config/routes.rb")
+    refute_includes(routes, "resources :audit_logs")
+  end
+
+  def test_fails_fast_for_unknown_types_by_default
+    stdout, stderr = capture_io do
+      run_generator("Mystery", "payload:not_a_real_type", "--no-allow-unknown")
+    end
+    output = "#{stdout}#{stderr}"
+
+    assert_includes(output, "Unknown field type(s): payload:not_a_real_type")
+    assert_includes(output, "--allow-unknown")
+    refute_exist("app/models/mystery.rb")
+    assert_equal([], Dir.glob(File.join(@destination_root, "db/migrate/*_inline_forms_create_mysteries.rb")))
+  end
+
+  def test_allow_unknown_keeps_legacy_commented_output
+    run_generator("Mystery", "payload:not_a_real_type", "--allow-unknown")
+
+    model = read("app/models/mystery.rb")
+    migration = read_single_migration_for("mysteries")
+
+    assert_includes(model, "#     [ :payload , \"payload\", :unknown ]")
+    assert_includes(migration, "#     t.unknown :payload")
+  end
+
+  def test_rich_text_adds_has_rich_text_without_migration_column
+    run_generator("Article", "title:string", "content:rich_text")
+
+    model = read("app/models/article.rb")
+    migration = read_single_migration_for("articles")
+
+    assert_includes(model, "has_rich_text :content")
+    refute_includes(migration, "t.no_migration :content")
+    refute_includes(migration, "t.text :content")
+  end
+
+  private
+
+  def build_destination_skeleton!
+    mkdir_p("config")
+    mkdir_p("app/controllers")
+    mkdir_p("app/models")
+    mkdir_p("db/migrate")
+    mkdir_p("test/unit")
+
+    write(
+      "config/routes.rb",
+      <<~RUBY
+        Rails.application.routes.draw do
+        end
+      RUBY
+    )
+
+    write(
+      "app/controllers/application_controller.rb",
+      <<~RUBY
+        class ApplicationController < ActionController::Base
+          ActionView::CompiledTemplates::MODEL_TABS = %w()
+        end
+      RUBY
+    )
+  end
+
+  def run_generator(*args)
+    InlineForms::InlineFormsGenerator.start(args, destination_root: @destination_root)
+  end
+
+  def read(relative_path)
+    File.read(File.join(@destination_root, relative_path))
+  end
+
+  def read_single_migration_for(table_name)
+    migration_files = Dir.glob(File.join(@destination_root, "db/migrate/*_inline_forms_create_#{table_name}.rb"))
+    assert_equal(1, migration_files.size, "Expected one migration for #{table_name}, got #{migration_files.inspect}")
+    File.read(migration_files.first)
+  end
+
+  def refute_exist(relative_path)
+    refute(File.exist?(File.join(@destination_root, relative_path)), "Expected #{relative_path} to not exist")
+  end
+
+  def mkdir_p(relative_path)
+    FileUtils.mkdir_p(File.join(@destination_root, relative_path))
+  end
+
+  def write(relative_path, content)
+    File.write(File.join(@destination_root, relative_path), content)
+  end
+end