inline_forms 8.1.21 → 8.1.42

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.21"
+  VERSION = "8.1.42"
 end

data/lib/inline_forms.rb

@@ -1,9 +1,16 @@
 # -*- encoding : utf-8 -*-
+
 require "inline_forms/version"
+require "inline_forms/attribute_list"
+require "inline_forms/schema_intent"
+require "inline_forms/schema_preview"
+require "inline_forms/schema_apply"
+require "inline_forms/schema_label"
 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 +40,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 +74,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,7 +103,7 @@ 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[
@@ -104,6 +111,25 @@ module InlineForms
     plain_text_area
   ].freeze
 
+  # Form elements that render a set of choices and therefore REQUIRE a values
+  # hash as the 3rd element of their attribute_list row (their _show/_edit
+  # helpers call `attribute_values`, which raises when it is missing). Shared by
+  # the addto generator and the schema GUI/preview so both insert a placeholder.
+  VALUE_BEARING_FORM_ELEMENTS = %i[
+    dropdown_with_values
+    dropdown_with_integers
+    dropdown_with_values_with_stars
+    radio_button
+    check_box
+    scale_with_integers
+    scale_with_values
+    slider_with_values
+  ].freeze
+
+  # Placeholder values hash inserted when a value-bearing element is added
+  # programmatically (generator / GUI); the user edits it to real values after.
+  PLACEHOLDER_VALUES = { 1 => "one", 2 => "two" }.freeze
+
   def self.plain_text_form_element?(form_element)
     PLAIN_TEXT_FORM_ELEMENTS.include?(form_element.to_sym)
   rescue NoMethodError
@@ -119,6 +145,68 @@ module InlineForms
       "Use :rich_text for ActionText-backed attributes, or add a text column for :plain_text."
   end
 
+  # Form elements exempt from the pending-migration gate. They either render a
+  # label only (:header), or read a *virtual* attribute whose name is not its
+  # backing column — :devise_password_field (backed by encrypted_password),
+  # :money_field (backed by a *_cents column via money-rails), :info
+  # (conventionally bound to pre-existing columns like created_at). None of
+  # these are produced by `inline_forms_addto` in the transient pre-migrate
+  # window, so gating them would only ever mis-fire.
+  PENDING_GATE_EXEMPT_FORM_ELEMENTS = %i[
+    header
+    info
+    devise_password_field
+    money_field
+  ].freeze
+
+  # True when an attribute_list row references a column that its model's table
+  # does not have yet — i.e. the model file was edited (row added) but the
+  # migration adding the column has not run. Rendering or writing such a row
+  # raises (e.g. `object[:foo]` / `foo_show` on a missing column), so callers
+  # gate on this to show a "pending migration" placeholder and skip writes
+  # instead of 500ing during the window between `rails g inline_forms_addto`
+  # and `rails db:migrate`.
+  #
+  # Detection is column-presence based (robust): the expected column is derived
+  # from the form element via the same type maps the generator uses. `nil`
+  # (associations, rich_text, pdf_link, unknown elements) and virtual-backed
+  # elements (see PENDING_GATE_EXEMPT_FORM_ELEMENTS) are never gated. The gate
+  # self-heals: once the migration runs and the schema cache reflects the new
+  # column, the column is present and the row renders normally — no flag to
+  # clear, nothing to maintain.
+  def self.attribute_pending_migration?(object, attribute, form_element)
+    fe = form_element.to_sym
+    return false if PENDING_GATE_EXEMPT_FORM_ELEMENTS.include?(fe)
+
+    klass = object.class
+    return false unless klass.respond_to?(:table_exists?) && klass.respond_to?(:column_names)
+    return false unless klass.table_exists?
+
+    column = pending_gate_expected_column(attribute, fe)
+    return false if column.nil?
+
+    !klass.column_names.include?(column)
+  rescue StandardError
+    # The gate must never itself break rendering; fail open (render as before).
+    false
+  end
+
+  # The column an attribute_list row expects on the model's own table, or nil
+  # when the form element needs no such column (has_many/habtm/has_one/
+  # rich_text -> :no_migration; pdf_link/info_list/unknown -> nil). Relation
+  # dropdowns are backed by a foreign key (`<attribute>_id`); every other
+  # column-backed element uses a column named after the attribute.
+  def self.pending_gate_expected_column(attribute, form_element)
+    column_type =
+      SPECIAL_COLUMN_TYPES[form_element] ||
+      (DEFAULT_FORM_ELEMENTS.value?(form_element) ? :__scalar__ : nil)
+
+    return nil if column_type.nil? || column_type == :no_migration
+    return "#{attribute}_id" if column_type == :belongs_to
+
+    attribute.to_s
+  end
+
   def self.validate_plain_text_configuration_for!(klass)
     return unless klass.respond_to?(:table_exists?) &&
                   klass.respond_to?(:column_names) &&
@@ -161,19 +249,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
@@ -182,7 +270,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
@@ -204,25 +291,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
@@ -242,8 +343,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/lib/locales/inline_forms.en.yml

@@ -31,6 +31,8 @@ en:
       trash: trash
       list_versions: List versions
       close_versions_list: Close versions list
+    pending_migration:
+      notice: "pending migration \u2014 run rails db:migrate"
   succes: success.
   activerecord:
     models:

data/lib/locales/inline_forms.nl.yml

@@ -28,6 +28,8 @@ nl:
       add_new: Maak een nieuw %{model}
       undo: terughalen
       trash: weggooien
+    pending_migration:
+      notice: "migratie in afwachting \u2014 draai rails db:migrate"
   succes: het ding is aangemaakt.
   activerecord:
     models:

data/test/archived_form_elements_test.rb

@@ -6,25 +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]]
+      [ [ :body, :ckeditor ] ]
     end
   end
 
   class ModelWithArchivedTextAreaWithoutCkeditor
     def inline_forms_attribute_list
-      [[:notes, :text_area_without_ckeditor]]
+      [ [ :notes, :text_area_without_ckeditor ] ]
     end
   end
 
@@ -68,4 +68,34 @@ class ArchivedFormElementsTest < Minitest::Test
     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