inline_forms 6.2.14 → 7.0.4

data/lib/generators/inline_forms_generator.rb

@@ -19,6 +19,18 @@ module InlineForms
   #
   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,
@@ -71,6 +83,7 @@ module InlineForms
 
     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)."
 
     source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
 
@@ -80,11 +93,24 @@ module InlineForms
       @flag_create_migration              = true
       @flag_create_model                  = true
       @create_id                          = true
+      @unknown_attributes                 = []
       for attribute in attributes
         @flag_not_accessible_through_html = false if attribute.name == '_enabled'
         @flag_create_migration            = false if attribute.name == '_no_migration'
         @flag_create_model                = false if attribute.name == '_no_model'
         @create_id                        = false if attribute.name == "_id" && attribute.type == :false
+        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
+      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
       @flag_create_controller             = @flag_create_model
       @flag_create_resource_route         = @flag_create_model
@@ -96,6 +122,7 @@ module InlineForms
         @has_many                 = "\n"
         @has_one                  = "\n"
         @habtm                    = "\n"
+        @has_rich_text            = "\n"
         @has_attached_files       = "\n"
         @presentation             = "\n"
         @order                    = "\n"
@@ -129,6 +156,9 @@ module InlineForms
               attribute.type         == :check_list
             @habtm << '  has_and_belongs_to_many :' + attribute.name + "\n"
           end
+          if attribute.type == :rich_text
+            @has_rich_text << '  has_rich_text :' + attribute.name + "\n"
+          end
           if attribute.name == '_presentation'
             @presentation <<  "  def _presentation\n" +
               "    \"#{attribute.type.to_s}\"\n" +

data/lib/generators/templates/migration.erb

@@ -1,4 +1,4 @@
-class InlineFormsCreate<%= table_name.camelize %> < ActiveRecord::Migration[6.1]
+class InlineFormsCreate<%= table_name.camelize %> < ActiveRecord::Migration[7.0]
 
   def self.up
     create_table :<%= table_name + @primary_key_option %> do |t|

data/lib/generators/templates/model.erb

@@ -8,6 +8,7 @@ class <%= name %> < ApplicationRecord
 <%= @has_many if @has_many.length > 1 -%>
 <%= @has_one if @has_one.length > 1 -%>
 <%= @habtm if @habtm.length > 1 -%>
+<%= @has_rich_text if @has_rich_text.length > 1 -%>
 <%= @has_attached_files if @has_attached_files.length > 1 -%>
 <%= @presentation  if @presentation.length > 1 -%>
 <%= @inline_forms_attribute_list -%>

data/lib/inline_forms/form_element_from_callee.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module InlineForms
+  # Maps +__callee__+ from a +*_show+ helper to the +params[:form_element]+ string
+  # (e.g. +:text_field_show+ → +"text_field"+).
+  def self.form_element_string_from_callee(from_callee)
+    s = from_callee.to_s
+    s = s.sub(/\Ablock in /, "")
+    s.delete_suffix("_show")
+  end
+end

data/lib/inline_forms/version.rb

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

data/lib/inline_forms.rb

@@ -1,5 +1,6 @@
 # -*- encoding : utf-8 -*-
 require ('inline_forms/version.rb')
+require_relative ('inline_forms/form_element_from_callee')
 # InlineForms is a Rails Engine that let you setup an admin interface quick and
 # easy. Please install it as a gem or include it in your Gemfile.
 module InlineForms
@@ -153,16 +154,3 @@ module InlineForms
   end
 
 end
-
-# make the current method and the calling method available
-#   http://www.ruby-forum.com/topic/75258
-#   supposedly, this is fixed in 1.9
-module Kernel
-  private
-  def this_method
-    caller[0] =~ /`([^']*)'/ and $1
-  end
-  def calling_method
-    caller[1] =~ /`([^']*)'/ and $1
-  end
-end

data/lib/installer_templates/example_app_tests/test/example_app/example_integration_test_case.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Base class for integration tests shipped only with `inline_forms create … --example`.
+# See test/integration/example_app_*_test.rb
+require "test_helper"
+require "devise/test/integration_helpers"
+
+class ExampleAppIntegrationTestCase < ActionDispatch::IntegrationTest
+  include Devise::Test::IntegrationHelpers
+
+  setup do
+    host!("www.example.com")
+    sign_in(example_app_admin_user)
+  end
+
+  private
+
+  def example_app_admin_user
+    @example_app_admin_user ||= begin
+      locale = Locale.find_or_create_by!(name: "en") { |l| l.title = "English" }
+      role = Role.find_or_create_by!(name: "superadmin") { |r| r.description = "Super Admin" }
+      user = User.find_or_initialize_by(email: "admin@example.com")
+      if user.new_record?
+        user.assign_attributes(
+          name: "Admin",
+          password: "admin999",
+          password_confirmation: "admin999",
+          locale: locale
+        )
+        user.save!
+      end
+      user.roles << role unless user.roles.where(id: role.id).exists?
+      user
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "devise/test/integration_helpers"
+
+class ExampleAppGuestAccessTest < ActionDispatch::IntegrationTest
+  include Devise::Test::IntegrationHelpers
+
+  setup { host!("www.example.com") }
+
+  test "apartments index redirects when not signed in" do
+    get apartments_path
+    assert_response :redirect
+    assert_match %r{/auth/users/sign_in}, @response.redirect_url
+  end
+
+  test "root redirects when not signed in" do
+    get root_path
+    assert_response :redirect
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../example_app/example_integration_test_case"
+
+class ExampleAppPhotosTest < ExampleAppIntegrationTestCase
+  setup do
+    @apartment = Apartment.create!(name: "Beach", title: "Ocean view")
+  end
+
+  test "photos are not served as standalone html resource" do
+    assert Photo.not_accessible_through_html?
+    assert_raises(ActionController::UnknownFormat) do
+      get photos_path
+    end
+  end
+
+  test "can create a photo for an apartment" do
+    assert_difference("Photo.count", 1) do
+      Photo.create!(name: "Sunset", apartment: @apartment)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../example_app/example_integration_test_case"
+
+class ExampleAppRoutingTest < ExampleAppIntegrationTestCase
+  test "root routes to apartments index" do
+    get root_path
+    assert_response :success
+  end
+
+  test "apartments index is reachable when signed in" do
+    get apartments_path
+    assert_response :success
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ExampleAppApartmentPhotoTest < ActiveSupport::TestCase
+  setup do
+    @apartment = Apartment.create!(name: "North", title: "Tower")
+    @photo = Photo.create!(name: "Lobby", apartment: @apartment)
+  end
+
+  test "photo belongs to apartment" do
+    assert_equal @apartment, @photo.apartment
+  end
+
+  test "apartment has many photos" do
+    assert_includes @apartment.photos.to_a, @photo
+  end
+
+  test "photo model hides resource from standalone html crud" do
+    assert Photo.not_accessible_through_html?
+  end
+
+  test "apartment model allows standalone html crud" do
+    assert_not Apartment.not_accessible_through_html?
+  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/form_element_from_callee_test.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+# Documents the contract between *_show helpers, +__callee__+, and
+# +params[:form_element]+ (used by InlineFormsController#update as +"#{form_element}_update"+).
+class FormElementFromCalleeTest < Minitest::Test
+  def test_symbol_callee_typical_show_method_maps_to_controller_suffix
+    got = InlineForms.form_element_string_from_callee(:text_field_show)
+    assert_equal(
+      "text_field",
+      got,
+      ":text_field_show must become the string \"text_field\" so the edit URL's " \
+      "form_element matches text_field_update / text_field_edit."
+    )
+  end
+
+  def test_string_callee_same_as_symbol
+    got = InlineForms.form_element_string_from_callee("dropdown_with_values_show")
+    assert_equal(
+      "dropdown_with_values",
+      got,
+      "String callee from backtrace-style names must match Symbol behavior."
+    )
+  end
+
+  def test_block_in_prefix_from_nested_call_still_maps_correctly
+    got = InlineForms.form_element_string_from_callee("block in text_field_show")
+    assert_equal(
+      "text_field",
+      got,
+      "When *_show runs inside a block, Ruby may prefix the callee label with " \
+      "\"block in \"; that prefix must be stripped before removing _show."
+    )
+  end
+
+  def test_only_one_trailing_show_suffix_removed
+    got = InlineForms.form_element_string_from_callee(:foo_show)
+    assert_equal(
+      "foo",
+      got,
+      "delete_suffix('_show') must remove only the trailing _show once " \
+      "(not leave \"foo\" with a spurious strip)."
+    )
+  end
+
+  def test_multi_word_element_name_underscores_preserved
+    got = InlineForms.form_element_string_from_callee(:chicas_dropdown_with_family_members_show)
+    assert_equal(
+      "chicas_dropdown_with_family_members",
+      got,
+      "Form element names with underscores must survive unchanged except for _show."
+    )
+  end
+
+  def test_callee_without_show_suffix_is_unchanged_modulo_block_prefix
+    got = InlineForms.form_element_string_from_callee(:already_plain)
+    assert_equal(
+      "already_plain",
+      got,
+      "If someone passes a callee without _show, output is unchanged (minus block prefix)."
+    )
+  end
+
+  def test_nil_callee_yields_empty_string
+    got = InlineForms.form_element_string_from_callee(nil)
+    assert_equal(
+      "",
+      got,
+      "nil.to_s is empty; callers must pass __callee__ from a *_show method."
+    )
+  end
+end

data/test/inline_edit_polymorphic_path_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "logger"
+require "active_model"
+require "action_dispatch"
+
+# Record double with the same +model_name+ routing key as +resources :articles+
+# (a class nested under Minitest::Test would get +inline_edit_…_article+, not +article+).
+class InlineFormsArticlesRouteDouble
+  include ActiveModel::Model
+  include ActiveModel::Conversion
+
+  attr_accessor :id
+
+  def self.model_name
+    ActiveModel::Name.new(self, nil, "Article")
+  end
+
+  def initialize(id = 1)
+    @id = id
+  end
+
+  def persisted?
+    true
+  end
+
+  def to_param
+    id.to_s
+  end
+end
+
+# Class-only double for +polymorphic_path(Model)+ (collection +articles+).
+class InlineFormsArticleClassRouteDouble
+  def self.model_name
+    ActiveModel::Name.new(self, nil, "Article")
+  end
+end
+
+# Parity between polymorphic URL helpers and named +edit_article_path+,
+# +article_path+, and +articles_path+ for a standard +resources :articles+
+# route (no full Rails app boot).
+class InlineEditPolymorphicPathTest < Minitest::Test
+  def setup
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @routes.draw { resources :articles }
+    routes = @routes
+    holder_class = Class.new do
+      include routes.url_helpers
+    end
+    holder_class.default_url_options = { only_path: true }
+    @holder = holder_class.new
+  end
+
+  def test_edit_polymorphic_path_matches_named_edit_helper
+    article = InlineFormsArticlesRouteDouble.new(42)
+    options = {
+      attribute: "title",
+      form_element: "text_field",
+      update: "field_article_42_title"
+    }
+    poly = @holder.edit_polymorphic_path(article, **options)
+    named = @holder.edit_article_path(article, **options)
+    assert_equal named, poly
+  end
+
+  def test_member_polymorphic_path_matches_article_path
+    article = InlineFormsArticlesRouteDouble.new(7)
+    options = { update: "span", close: true }
+    poly = @holder.polymorphic_path(article, **options)
+    named = @holder.article_path(article, **options)
+    assert_equal named, poly
+  end
+
+  def test_collection_polymorphic_path_matches_articles_path
+    options = { update: "list", parent_class: "Parent", parent_id: "3" }
+    poly = @holder.polymorphic_path(InlineFormsArticleClassRouteDouble, **options)
+    named = @holder.articles_path(**options)
+    assert_equal named, poly
+  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

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "minitest/autorun"
+require "inline_forms/form_element_from_callee"