inline_forms 8.1.20 → 8.1.40

data/lib/inline_forms/tabs.rb

@@ -0,0 +1,175 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # Vendored replacement for the tabs_on_rails gem (8.1.23).
+  #
+  # inline_forms used tabs_on_rails 3.0.0 (MIT, Copyright (c) 2009-2017
+  # Simone Carletti <weppos@weppos.net>; last released 2017) for exactly four
+  # things: the controller `set_tab` DSL, the `current_tab`/`current_tab?`
+  # helpers, the `tabs_tag` view helper, and the `TabsBuilder` base class that
+  # InlineForms::TurboTabsBuilder subclasses. This file ports that surface —
+  # API-compatible with the gem — so generated apps no longer need an
+  # unmaintained dependency (which was also an *undeclared* one: the engine
+  # required "tabs_on_rails" but the gemspec never listed it; only the
+  # installer-written Gemfile made it load).
+  #
+  # The port keeps upstream semantics:
+  #
+  #   class OwnersController < ApplicationController
+  #     set_tab :owner                     # class-level, uses before_action
+  #     set_tab :naw, :subtabs, only: :show
+  #   end
+  #
+  #   <%= tabs_tag builder: InlineForms::TurboTabsBuilder do |tab| %>
+  #     <%= tab.naw "NAW", owner_path(@object, tab: :naw) %>
+  #   <% end %>
+  #
+  # If the host app still bundles the tabs_on_rails gem (apps generated before
+  # 8.1.23), the engine skips its own controller include and leaves the gem's
+  # identical implementation in charge — see the engine initializer in
+  # lib/inline_forms.rb.
+  module Tabs
+    # Controller mixin: tab state lives in @tab_stack per namespace.
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+        helper HelperMethods
+        helper_method :current_tab, :current_tab?
+      end
+
+      protected
+
+      def set_tab(name, namespace = nil)
+        tab_stack[namespace || :default] = name
+      end
+
+      def current_tab(namespace = nil)
+        tab_stack[namespace || :default]
+      end
+
+      def current_tab?(name, namespace = nil)
+        current_tab(namespace).to_s == name.to_s
+      end
+
+      def tab_stack
+        @tab_stack ||= {}
+      end
+
+      module ClassMethods
+        # set_tab :foo
+        # set_tab :foo, only: [:index, :show]
+        # set_tab :foo, :namespace, except: :new
+        def set_tab(*args)
+          options = args.extract_options!
+          name, namespace = args
+
+          before_action(options) do |controller|
+            controller.send(:set_tab, name, namespace)
+          end
+        end
+      end
+
+      module HelperMethods
+        def tabs_tag(options = {}, &block)
+          Renderer.new(self, { namespace: :default }.merge(options)).render(&block)
+        end
+      end
+    end
+
+    # Renders a tab group: open tag, one tab_for per named tab, close tag.
+    # `tab.anything(...)` is dispatched to the builder's tab_for via
+    # method_missing, exactly like upstream.
+    class Renderer
+      def initialize(context, options = {})
+        @context = context
+        @builder = (options.delete(:builder) || TabsBuilder).new(@context, options)
+        @options = options
+      end
+
+      def open_tabs(*args)
+        call_builder(:open_tabs, *args)
+      end
+
+      def close_tabs(*args)
+        call_builder(:close_tabs, *args)
+      end
+
+      def method_missing(*args, &block)
+        @builder.tab_for(*args, &block)
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      def render(&block)
+        raise LocalJumpError, "no block given" unless block_given?
+
+        options = @options.dup
+        open_tabs_options  = options.delete(:open_tabs)  || {}
+        close_tabs_options = options.delete(:close_tabs) || {}
+
+        "".dup.tap do |html|
+          html << open_tabs(open_tabs_options).to_s
+          html << @context.capture(self, &block)
+          html << close_tabs(close_tabs_options).to_s
+        end.html_safe
+      end
+
+      private
+
+      def call_builder(name, *args)
+        method = @builder.method(name)
+        method.arity.zero? ? method.call : method.call(*args)
+      end
+    end
+
+    # Abstract builder API (initialize signature is part of the contract:
+    # custom builders from either this module or the old gem are duck-typed
+    # against it).
+    class Builder
+      def initialize(context, options = {})
+        @context   = context
+        @namespace = options.delete(:namespace) || :default
+        @options   = options
+      end
+
+      def current_tab?(tab)
+        tab.to_s == @context.current_tab(@namespace).to_s
+      end
+
+      def tab_for(*args)
+        raise NotImplementedError
+      end
+
+      def open_tabs(*args); end
+
+      def close_tabs(*args); end
+    end
+
+    # Default builder: <ul> of <li><a>, active tab as <li class="current"><span>.
+    class TabsBuilder < Builder
+      def tab_for(tab, name, url_options, item_options = {})
+        if current_tab?(tab)
+          item_options[:class] = item_options[:class].to_s.split(" ")
+                                                     .push(@options[:active_class] || "current")
+                                                     .join(" ")
+        end
+        content = @context.link_to_unless(current_tab?(tab), name, url_options) do
+          @context.content_tag(:span, name)
+        end
+        @context.content_tag(:li, content, item_options)
+      end
+
+      def open_tabs(options = {})
+        @context.tag("ul", options, true)
+      end
+
+      def close_tabs(_options = {})
+        "</ul>".html_safe
+      end
+    end
+  end
+end

data/lib/inline_forms/turbo_tabs_builder.rb

@@ -1,5 +1,6 @@
 # -*- encoding : utf-8 -*-
-require "tabs_on_rails"
+
+require "inline_forms/tabs"
 
 module InlineForms
   # Tabs_on_rails 3.0 (weppos, RubyGems) only threads the 4th argument of
@@ -29,9 +30,14 @@ module InlineForms
   #
   # `link_options:` is consumed by the builder and forwarded to `link_to`;
   # everything else still applies to the `<li>` exactly like the upstream
-  # `TabsBuilder`. Active-tab highlighting still uses tabs_on_rails'
-  # `current_tab?` (driven by controller `set_tab :foo`).
-  class TurboTabsBuilder < TabsOnRails::Tabs::TabsBuilder
+  # `TabsBuilder`. Active-tab highlighting still uses `current_tab?` (driven
+  # by controller `set_tab :foo`).
+  #
+  # Since 8.1.23 this subclasses the vendored InlineForms::Tabs::TabsBuilder
+  # (tabs_on_rails itself is no longer a dependency). The builder contract is
+  # duck-typed, so this class also still works if a pre-8.1.23 app renders it
+  # through the tabs_on_rails gem's `tabs_tag`.
+  class TurboTabsBuilder < InlineForms::Tabs::TabsBuilder
     def tab_for(tab, name, url_options, item_options = {})
       link_options = item_options.delete(:link_options) || {}
       active = current_tab?(tab)
@@ -39,7 +45,7 @@ module InlineForms
       if active
         active_class = @options[:active_class] || "current"
         existing = item_options[:class].to_s.split(/\s+/).reject(&:empty?)
-        item_options[:class] = (existing + [active_class]).uniq.join(" ")
+        item_options[:class] = (existing + [ active_class ]).uniq.join(" ")
       end
 
       # The active label is rendered as an `<a>` *without* an href so that
@@ -48,14 +54,15 @@ module InlineForms
       # it up just like the inactive tabs. Skipping the href keeps the
       # active tab non-clickable, and `aria-current="page"` advertises
       # the selection state to assistive tech / Foundation's CSS.
-      content = if active
-                  @context.content_tag(:a, name,
-                    link_options.merge("aria-current" => "page",
-                                       "aria-selected" => "true"))
-                else
-                  @context.link_to(name, url_options,
-                    link_options.merge("aria-selected" => "false"))
-                end
+      content =
+        if active
+          @context.content_tag(:a, name,
+            link_options.merge("aria-current" => "page",
+                               "aria-selected" => "true"))
+        else
+          @context.link_to(name, url_options,
+            link_options.merge("aria-selected" => "false"))
+        end
 
       @context.content_tag(:li, content, item_options)
     end

data/lib/inline_forms/version.rb

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

data/lib/inline_forms.rb

@@ -1,9 +1,11 @@
 # -*- encoding : utf-8 -*-
+
 require "inline_forms/version"
 require "inline_forms/form_element_from_callee"
 require "inline_forms/archived_form_elements"
 require "inline_forms/form_element_registry"
 require "inline_forms/form_elements"
+require "inline_forms/tabs"
 require "inline_forms/turbo_tabs_builder"
 # 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.
@@ -33,17 +35,17 @@ module InlineForms
   #   end
   #
   DEFAULT_COLUMN_TYPES = {
-    :string     => :string,
-    :text       => :text,
-    :integer    => :integer,
-    :float      => :float,
-    :decimal    => :decimal,
-    :datetime   => :datetime,
-    :timestamp  => :timestamp,
-    :time       => :time,
-    :date       => :date,
-    :binary     => :binary,
-    :boolean    => :boolean,
+    string: :string,
+    text: :text,
+    integer: :integer,
+    float: :float,
+    decimal: :decimal,
+    datetime: :datetime,
+    timestamp: :timestamp,
+    time: :time,
+    date: :date,
+    binary: :binary,
+    boolean: :boolean
     # :references => :belongs_to,
     # :belongs_to => :belongs_to,
   }
@@ -67,17 +69,17 @@ module InlineForms
   # as you see, both :string and :integer are mapped to a :text_field
   #
   DEFAULT_FORM_ELEMENTS = {
-    :string     => :text_field,
-    :text       => :plain_text,
-    :integer    => :text_field,
-    :float      => :text_field,
-    :decimal    => :text_field,
-    :datetime   => :datetime_select,
-    :timestamp  => :datetime_select,
-    :time       => :time_select,
-    :date       => :date_select,
-    :binary     => :text_field,
-    :boolean    => :check_box,
+    string: :text_field,
+    text: :plain_text,
+    integer: :text_field,
+    float: :text_field,
+    decimal: :text_field,
+    datetime: :datetime_select,
+    timestamp: :datetime_select,
+    time: :time_select,
+    date: :date_select,
+    binary: :text_field,
+    boolean: :check_box
   }
 
   # SPECIAL_COLUMN_TYPES maps the column types that we define here and in
@@ -96,13 +98,12 @@ module InlineForms
   # to the inline_forms_attribute_list in the model.
   #
   SPECIAL_COLUMN_TYPES = {
-    :associated => :no_migration
+    associated: :no_migration
   }
 
   PLAIN_TEXT_FORM_ELEMENTS = %i[
     plain_text
     plain_text_area
-    text_area_without_ckeditor
   ].freeze
 
   def self.plain_text_form_element?(form_element)
@@ -162,19 +163,19 @@ module InlineForms
   #  rails g inline_forms Example phone_number:string type_of_number:dropdown client:belongs_to
   #
   RELATIONS = {
-    :belongs_to => :belongs_to,
-    :references => :belongs_to,
+    belongs_to: :belongs_to,
+    references: :belongs_to
   }
 
   # SPECIAL_RELATIONS maps AR relations to migrations.
   # In most cases, these relations have no migration at all, but they do need
   # a line in the model.
   SPECIAL_RELATIONS = {
-    :has_many                 => :no_migration,
-    :has_many_destroy         => :no_migration,
-    :has_one                  => :no_migration,
-    :has_and_belongs_to_many  => :no_migration,
-    :habtm                    => :no_migration,
+    has_many: :no_migration,
+    has_many_destroy: :no_migration,
+    has_one: :no_migration,
+    has_and_belongs_to_many: :no_migration,
+    habtm: :no_migration
   }
 
   # load form elements. Each element goes into a separate file
@@ -183,7 +184,6 @@ module InlineForms
 
   # Declare as a Rails::Engine, see http://www.ruby-forum.com/topic/211017#927932
   class Engine < Rails::Engine
-
     initializer "inline_forms.form_element_registry" do
       InlineForms::FormElementRegistry.apply!
     end
@@ -205,25 +205,39 @@ module InlineForms
       ValidationHints::ValidationsPatch.apply!
     end
 
+    # Tabs support (set_tab / current_tab? / tabs_tag) is vendored in
+    # InlineForms::Tabs since 8.1.23. Apps generated before 8.1.23 still bundle
+    # the tabs_on_rails gem, whose Railtie includes the identical API into
+    # ActionController::Base — skip ours then so the two don't stack.
+    initializer "inline_forms.tabs" do
+      ActiveSupport.on_load(:action_controller) do
+        unless defined?(TabsOnRails::ActionController)
+          ::ActionController::Base.include(InlineForms::Tabs::Controller)
+        end
+      end
+    end
+
     initializer "inline_forms.assets.precompile" do |app|
-      app.config.assets.precompile += %w(
+      # Skip when the host has no Sprockets-style pipeline (e.g. the test/dummy
+      # harness); generated apps always bundle sprockets-rails.
+      next unless app.config.respond_to?(:assets)
+
+      app.config.assets.precompile += %w[
         inline_forms/inline_forms.css
         inline_forms/devise.css
         inline_forms/inline_forms.js
+        inline_forms_fonts.css
         popper.min.js
         tippy-bundle.umd.min.js
+        trix.min.js
+        trix.css
         inline_forms/glass_plate.gif
-      )
-    end
-
-    # Vendored jQuery UI SCSS lives under stylesheets/jquery_ui/ and uses @import
-    # "jquery.ui.core" etc. Dart Sass (dartsass-rails) only adds --load-path entries
-    # from config.assets.paths, not config.dartsass.extra_load_paths.
-    initializer "inline_forms.jquery_ui_stylesheet_path" do |app|
-      path = root.join("app", "assets", "stylesheets", "jquery_ui")
-      next unless path.directory?
-
-      app.config.assets.paths << path unless app.config.assets.paths.include?(path)
+        foundation-icons.woff
+        foundation-icons.ttf
+        foundation-icons.svg
+        opensans-v44-latin-regular.woff2
+        opensans-v44-latin-italic.woff2
+      ]
     end
 
     config.to_prepare do
@@ -243,8 +257,7 @@ module InlineForms
       end
     end
 
-    I18n.load_path << Dir[File.join(File.expand_path(File.dirname(__FILE__) + '/locales'), '*.yml')]
+    I18n.load_path << Dir[File.join(File.expand_path(File.dirname(__FILE__) + "/locales"), "*.yml")]
     I18n.load_path.flatten!
   end
-
 end

data/test/archived_form_elements_test.rb

@@ -6,13 +6,25 @@ require "inline_forms/archived_form_elements"
 class ArchivedFormElementsTest < Minitest::Test
   class ModelWithArchivedElement
     def inline_forms_attribute_list
-      [[:address, :geo_code_curacao]]
+      [ [ :address, :geo_code_curacao ] ]
     end
   end
 
   class ModelWithArchivedTree
     def inline_forms_attribute_list
-      [[:children, :tree]]
+      [ [ :children, :tree ] ]
+    end
+  end
+
+  class ModelWithArchivedCkeditor
+    def inline_forms_attribute_list
+      [ [ :body, :ckeditor ] ]
+    end
+  end
+
+  class ModelWithArchivedTextAreaWithoutCkeditor
+    def inline_forms_attribute_list
+      [ [ :notes, :text_area_without_ckeditor ] ]
     end
   end
 
@@ -33,9 +45,57 @@ class ArchivedFormElementsTest < Minitest::Test
     assert_includes err.message, "archived/form_elements/tree"
   end
 
+  def test_raises_when_model_declares_archived_ckeditor
+    err = assert_raises(InlineForms::ArchivedFormElementError) do
+      InlineForms.validate_no_archived_form_elements_for!(ModelWithArchivedCkeditor)
+    end
+    assert_includes err.message, "ckeditor"
+    assert_includes err.message, "8.1.21"
+    assert_includes err.message, "archived/form_elements/ckeditor"
+  end
+
+  def test_raises_when_model_declares_archived_text_area_without_ckeditor
+    err = assert_raises(InlineForms::ArchivedFormElementError) do
+      InlineForms.validate_no_archived_form_elements_for!(ModelWithArchivedTextAreaWithoutCkeditor)
+    end
+    assert_includes err.message, "text_area_without_ckeditor"
+    assert_includes err.message, "8.1.21"
+    assert_includes err.message, "archived/form_elements/ckeditor"
+  end
+
   def test_archived_registry_documents_absence_list_without_path
     meta = InlineForms::ARCHIVED_FORM_ELEMENTS[:absence_list]
     assert_equal "6.3.0", meta[:removed_in_version]
     assert_nil meta[:archive_path]
   end
+
+  class ModelWithArchivedQuestionList
+    def inline_forms_attribute_list
+      [ [ :questions, :question_list ] ]
+    end
+  end
+
+  class ModelWithArchivedDnsrecords
+    def inline_forms_attribute_list
+      [ [ :records, :dnsrecords ] ]
+    end
+  end
+
+  def test_raises_when_model_declares_archived_question_list
+    err = assert_raises(InlineForms::ArchivedFormElementError) do
+      InlineForms.validate_no_archived_form_elements_for!(ModelWithArchivedQuestionList)
+    end
+    assert_includes err.message, "question_list"
+    assert_includes err.message, "8.1.30"
+    assert_includes err.message, "archived/form_elements/question_list"
+  end
+
+  def test_raises_when_model_declares_archived_dnsrecords
+    err = assert_raises(InlineForms::ArchivedFormElementError) do
+      InlineForms.validate_no_archived_form_elements_for!(ModelWithArchivedDnsrecords)
+    end
+    assert_includes err.message, "dnsrecords"
+    assert_includes err.message, "8.1.30"
+    assert_includes err.message, "archived/form_elements/dns_records"
+  end
 end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class ApplicationController < ActionController::Base
+  # Devise/role stand-in. The full `layouts/inline_forms` chrome (rendered by
+  # create/new HTML responses) calls `current_user.name` and
+  # `current_user.role?`, so a nil current_user cannot render it. The stub is
+  # superadmin so `destroy_permitted?` allows hard destroy, matching the
+  # generated apps' test user.
+  DummyUser = Struct.new(:id, :name) do
+    def role?(role)
+      role.to_sym == :superadmin
+    end
+  end
+
+  helper_method :current_user
+
+  def current_user
+    @current_user ||= DummyUser.new(1, "Dummy User")
+  end
+
+  def devise_controller?
+    false
+  end
+end

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

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

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

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

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

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

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Mirrors the helper the installer writes into host apps (installer_core.rb);
+# the full `layouts/inline_forms` chrome needs it.
+module ApplicationHelper
+  def application_name
+    "Dummy"
+  end
+
+  def application_title
+    "Dummy"
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Mirrors the host-app contract the installer's application_record.rb template
+# establishes (lib/generators/templates/application_record.rb): paper_trail on
+# every model, will_paginate per_page, inline_forms list/search scopes, and
+# the not_accessible_through_html? default the engine controller consults.
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  has_paper_trail on: [ :create, :update, :destroy ]
+
+  attr_writer :inline_forms_attribute_list
+
+  self.per_page = 7
+
+  scope :inline_forms_list, -> { all }
+  scope :inline_forms_search, ->(_q) { all }
+
+  def human_attribute_name(*args)
+    self.class.human_attribute_name(*args)
+  end
+
+  def self.not_accessible_through_html?
+    false
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Lookup model for Widget's dropdown_with_other (kind / kind_other).
+class Kind < ApplicationRecord
+  def _presentation
+    name
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Parent with an :associated (has_many) panel, shaped like the example app's
+# Apartment (photos:has_many photos:associated). Exercises the
+# open-after-create flow (InlineFormsController#render_created_row_open_streams).
+class Machine < ApplicationRecord
+  has_many :parts
+
+  validates :name, presence: true
+
+  scope :inline_forms_list, -> { order(:name, :id) }
+
+  def _presentation
+    "#{name}"
+  end
+
+  def inline_forms_attribute_list
+    @inline_forms_attribute_list ||= [
+      [ :name, :text_field ],
+      [ :parts, :associated ]
+    ]
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Child of Machine (see machine.rb); shaped like the example app's Photo.
+class Part < ApplicationRecord
+  belongs_to :machine, optional: true
+
+  def _presentation
+    "#{name}"
+  end
+
+  def inline_forms_attribute_list
+    @inline_forms_attribute_list ||= [
+      [ :name, :text_field ]
+    ]
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Exercises one representative of each form-element family the integration
+# tests cover; shaped exactly like a `rails g inline_forms` model.
+class Widget < ApplicationRecord
+  belongs_to :kind, optional: true
+
+  validates :name, presence: true
+
+  scope :inline_forms_list, -> { order(:name, :id) }
+  scope :inline_forms_search, ->(q) { where("name LIKE ?", "%#{q}%") }
+
+  def _presentation
+    "#{name}"
+  end
+
+  def inline_forms_attribute_list
+    @inline_forms_attribute_list ||= [
+      [ :name, :text_field ],
+      [ :notes, :plain_text_area ],
+      [ :released_on, :date_select ],
+      [ :meeting_at, :time_select ],
+      [ :start_month, :month_year_picker ],
+      [ :priority, :dropdown_with_values, { 1 => "low", 2 => "mid", 3 => "high" } ],
+      [ :active, :check_box, { 0 => "no", 1 => "yes" } ],
+      [ :kind, :dropdown_with_other ],
+      [ :rating, :slider_with_values, { 1 => "one", 2 => "two", 3 => "three", 4 => "four", 5 => "five" } ],
+      # simple_file_field's values entry names the host download route method
+      # (attribute_values(...)[0][1]); only used when a file is present.
+      [ :manual, :simple_file_field, { 0 => "download" } ],
+      [ :accent, :color_field ],
+      [ :report, :pdf_link ]
+    ]
+  end
+
+  def <=>(other)
+    name <=> other.name
+  end
+end