inline_forms 8.1.58 → 8.1.60

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e989cef82d52e8f127898955b5741aa163ac8018c5d376a1031d2b7fc4606b36
-  data.tar.gz: 1dd15f90a192376d102aa5247502537a4427388517601dd3b4daba091a4a7385
+  metadata.gz: 51bf71fc0e838244f70a9a53db6cfe0a3515cda9e43086bfded9a08c9b56b144
+  data.tar.gz: 85796e1ea1d4dcc5d1afb094e67e045279ba862590e7bb25472e496eadd628ae
 SHA512:
-  metadata.gz: aef0b60a06a818a73ebc92defa6d2466f94aede8a39865870b3b3365e508b00642afafe05614addcc3ac0e3b2bf67a0bf3659531ef834c44050014e2bf2e3401
-  data.tar.gz: 4b478b2e1854e9c6427e13014f0694883f362184c86b6dfecfa25e9c3ef71752ca60c807c66b2d00f78eaa69dbed73b29afdc1138caece51e818ac340b9e3542
+  metadata.gz: 0b674c30e72e0ac91aebe7cbe9c619cece169be0098faa9a1e50693831eb937ae4f572b363beb26678f9caa3d6c4ceb7f368aa9127ebd310f22a996b6d36fc4a
+  data.tar.gz: e08e0398a885ca964e6403f379e4d293da09d02b204728f709aaf728ed2ee873666899f87d1408843152d3e089aa8ff3c12a9fb028246194a0df8f0b64400b0e

data/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [8.1.60] - 2026-10-28
+
+Fixes from a review of 8.1.58 and 8.1.59.
+
+### Fixed
+
+- **Dropdowns take only the order from `inline_forms_list`.** 8.1.59's rule 3 merged the whole `inline_forms_list` scope into `dropdown` and `dropdown_with_other`, so a `where` or `joins` there hid records from the dropdown. A record whose current value was hidden showed the first option instead, and saving the inline form silently changed it. Rule 3 now uses only the scope's ORDER BY (added to a `default_scope` order, as the merge did). The scope still filters `/index`.
+- **`check_list` keeps the `inline_forms_list` filter.** Under rules 1 and 2 (a declared order or a `dropdown_order` column) 8.1.59 skipped the scope, so `check_list` listed records its `where` used to hide. It now applies the scope's filter under every rule, as before 8.1.59; the order is still `InlineForms::DropdownOrder`'s.
+- **A `dropdown` whose lookup defines `disabled_for_dropdown?` loads the lookup once.** 8.1.59 loaded it to find the disabled options and again, ordered, for the options.
+- **Installer: a gem path with a space no longer breaks the Dart Sass build.** 8.1.58's initializer put the gem's stylesheet dir first as a `build_options` entry, and dartsass-rails splits those on whitespace, so a gem installed under e.g. `/Users/John Doe/…` gave Sass two broken arguments. `config/initializers/inline_forms_dartsass_builds.rb` now prepends the dir to `Dartsass::Runner`'s own `--load-path` list as a separate argument, still ahead of `app/assets/builds`. Apps generated with 8.1.58 or 8.1.59 can copy the new initializer from the installer's `lib/installer_templates/dartsass/`.
+- **Example app: rolling back the seed migration works.** Its `down` destroyed the seeded owners while the seeded apartments still pointed at them, and `apartments.owner_id` / `apartments.phase_id` have foreign keys, so `Owner#destroy` raised `ActiveRecord::InvalidForeignKey`. It now sets those columns to NULL on every apartment that points at a seeded owner or phase before destroying it.
+- The installer's `ApplicationRecord` template says rule 3 is the ORDER BY of `inline_forms_list`.
+
+### Tests
+
+- `dropdown_test`: a filtering `inline_forms_list` orders a dropdown without hiding records, `check_list` keeps that filter under a declared order, and `disabled_for_dropdown?` costs no second query.
+- Example app: `example_app_dartsass_build_test` checks that the gem's stylesheet dir is the first `--load-path` and a separate argument.
+
+### Lockstep
+
+- validation_hints 8.1.60, inline_forms_installer 8.1.60, inline_forms_schema_edit 8.1.60.
+
+## [8.1.59] - 2026-10-22
+
+### Fixed
+
+- **Dropdowns follow the model's order again, with one rule for every table-backed list.** 8.1.58 made `dropdown` sort its options alphabetically by presentation. That overrode the order lookups depend on, such as '---' / 'onbekend' first and process phases in process order. Before that, from 2017 to 8.1.57, the sort was discarded and dropdowns showed database order. Until 2015 they used the model's `order_by_clause`. `dropdown_with_other` used database order, and `check_list` used `inline_forms_list`. All three now use `InlineForms::DropdownOrder`; the first match wins:
+  1. the model declares **`inline_forms_dropdown_order :column`** (or `:column, :desc`);
+  2. the table has a **`dropdown_order`** column, used ascending: give '---' 0 and the phases 10, 20, 30;
+  3. the model's `inline_forms_list` scope (its list order; unchanged for `check_list`);
+  4. database order, including a `default_scope` order.
+
+  Rules 1 and 2 replace any `default_scope` order, put NULLs last (a record nobody has numbered yet goes to the end) and break ties on `id`.
+  - The macro is on every Active Record model (engine initializer `inline_forms.dropdown_order`), so hosts need no `ApplicationRecord` change. An unknown direction raises `ArgumentError` when the class loads; an unknown column raises when the dropdown renders.
+  - **Hosts:** lookups that declare nothing keep their `inline_forms_list` order. StProject's lookups declare `order(:name, :id)`, so they stay alphabetical; Scouting's `default_scope { order(name: :asc) }` still applies. A lookup that needs a fixed order gets a `dropdown_order` integer column, or `inline_forms_dropdown_order`. Papiamentu's `def self.order_by_clause` is still not read; use the macro instead.
+  - The installer's `ApplicationRecord` template documents the rule.
+- **Example app: a `Phase` lookup shows the rule.** `inline_forms create … --example` generates `Phase` (`name`, `dropdown_order`), gives Apartment a `phase` dropdown below `owner`, and seeds `---` 0, helprequest 10, decision 20, admittance 30, created in neither order. On an apartment the dropdown reads ---, helprequest, decision, admittance, while `/phases` lists them alphabetically (`_list_order:name`). The seeded apartments get helprequest, decision and ---.
+
+### Tests
+
+- `dropdown_test`: each rule, desc, declared column over `dropdown_order`, NULLs last, `id` tie-break, `dropdown_with_other` and `check_list`, bad direction or column. The dummy app gains a `Phase` lookup with a `dropdown_order` column (`Part belongs_to :phase`).
+- Example app: `example_app_phase_dropdown_test` checks the apartment's phase dropdown order, that choosing a phase saves it, and that `/phases` keeps its alphabetical list order.
+
+### Lockstep
+
+- validation_hints 8.1.59, inline_forms_installer 8.1.59, inline_forms_schema_edit 8.1.59.
+
 ## [8.1.58] - 2026-10-21
 
 Three gem issues found in the StProject review (2026-10-04). The fourth it listed, the CSS `@import` of `http://fonts.googleapis.com`, was already fixed in 8.1.22 (self-hosted Open Sans). Also the first step of the Sass `@import` → `@use` move.

data/lib/generators/templates/application_record.rb

@@ -26,6 +26,16 @@ class ApplicationRecord < ActiveRecord::Base
   # `unscope`/`reorder` cleanly.
   scope :inline_forms_list, -> { all }
 
+  # Dropdowns, dropdown_with_other and check_list offer a model's records in
+  # this order (first match wins; InlineForms::DropdownOrder):
+  #   1. inline_forms_dropdown_order :col            # or :col, :desc
+  #   2. a `dropdown_order` integer column, ascending (e.g. '---' 0,
+  #      'helprequest' 10, 'decision' 20, 'admittance' 30)
+  #   3. the order of inline_forms_list above (only its ORDER BY: a where
+  #      there filters #index, not the dropdowns)
+  #   4. database order
+  # 1 and 2 put NULLs last and break ties on id.
+
   # Wrapper for @model.human_attribute_name -> Model.human_attribute_name
   def human_attribute_name(*args)
     self.class.human_attribute_name(*args)

data/lib/inline_forms/dropdown_order.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module InlineForms
+  # The order in which a table-backed form element (dropdown,
+  # dropdown_with_other, check_list) offers its records. First match wins:
+  #
+  # 1. the model declares `inline_forms_dropdown_order :column, :asc|:desc`;
+  # 2. the table has a `dropdown_order` column (ascending), so a lookup can
+  #    put '---' / 'onbekend' first and process phases in process order;
+  # 3. the ORDER BY of the model's `inline_forms_list` scope (its list order;
+  #    only the order: a where/joins in that scope does not hide records here);
+  # 4. database order (a default_scope order included).
+  #
+  # 1 and 2 replace any default_scope order, put NULLs last (a record nobody
+  # numbered yet goes to the end) and break ties on the primary key. 3 adds to
+  # a default_scope order, as merging the scope did.
+  #
+  # The macro is on every Active Record model (engine initializer), so hosts
+  # need no ApplicationRecord change.
+  module DropdownOrder
+    COLUMN = "dropdown_order"
+    DIRECTIONS = %i[asc desc].freeze
+
+    module ClassMethods
+      def inline_forms_dropdown_order(column, direction = :asc)
+        direction = direction.to_s.downcase.to_sym
+        unless DIRECTIONS.include?(direction)
+          raise ArgumentError, "inline_forms_dropdown_order: direction must be :asc or :desc, got #{direction.inspect}"
+        end
+
+        @inline_forms_dropdown_order = [ column.to_s, direction ].freeze
+      end
+
+      # [column, direction] declared on this class or an ancestor, or nil.
+      def inline_forms_dropdown_order_spec
+        return @inline_forms_dropdown_order if defined?(@inline_forms_dropdown_order)
+
+        superclass.inline_forms_dropdown_order_spec if superclass.respond_to?(:inline_forms_dropdown_order_spec)
+      end
+    end
+
+    def self.apply(relation)
+      klass = relation.klass
+      column, direction = klass.inline_forms_dropdown_order_spec if klass.respond_to?(:inline_forms_dropdown_order_spec)
+      column, direction = COLUMN, :asc if column.nil? && klass.column_names.include?(COLUMN)
+
+      if column
+        unless klass.column_names.include?(column)
+          raise ArgumentError, "#{klass.name}.inline_forms_dropdown_order: #{klass.table_name} has no column #{column.inspect}"
+        end
+
+        table = klass.arel_table
+        keys = [ table[column].public_send(direction).nulls_last ]
+        keys << table[klass.primary_key].asc if klass.primary_key && klass.primary_key != column
+        relation.reorder(*keys)
+      elsif (list_order = list_order_values(klass)).any?
+        relation.order(*list_order)
+      else
+        relation
+      end
+    end
+
+    def self.list_order_values(klass)
+      klass.respond_to?(:inline_forms_list) ? klass.inline_forms_list.order_values : []
+    end
+  end
+end

data/lib/inline_forms/form_elements/check_list_helper.rb

@@ -21,7 +21,10 @@ module InlineForms
       object.send(attribute).build  if object.send(attribute).empty?
       klass = object.send(attribute).first.class
       values = cancan_enabled? ? klass.accessible_by(current_ability) : klass.all
-      values = values.merge(klass.inline_forms_list) if klass.respond_to?(:inline_forms_list)
+      # check_list has always applied the list scope's filter (a where in
+      # inline_forms_list hides records here); the order is DropdownOrder's.
+      values = values.merge(klass.inline_forms_list.unscope(:order)) if klass.respond_to?(:inline_forms_list)
+      values = InlineForms::DropdownOrder.apply(values)
       out = ''
       values.each do | item |
         out << "<div class='row #{cycle('odd', 'even')}'>"

data/lib/inline_forms/form_elements/dropdown_helper.rb

@@ -25,11 +25,12 @@ module InlineForms
       else
         values = klass.all
       end
+      values = InlineForms::DropdownOrder.apply(values)
       options_disabled = nil
       if klass.method_defined? :disabled_for_dropdown?
+        # loads values; collection_select below reuses the loaded records
         options_disabled = values.map{|v| v.id if v.disabled_for_dropdown?}.compact
       end
-      values = values.sort_by {|v|v.send presentation}
       # the leading underscore is to avoid name conflicts, like 'email' and 'email_type' will result in 'email' and 'email[email_type_id]' in the form!
       collection_select( ('_' + object.class.to_s.underscore).to_sym,
                           attribute.to_s.foreign_key.to_sym,

data/lib/inline_forms/form_elements/dropdown_with_other_helper.rb

@@ -31,6 +31,7 @@ module InlineForms
       o = attribute.camelcase.constantize
       values = o.all
       values = o.accessible_by(current_ability) if cancan_enabled?
+      values = InlineForms::DropdownOrder.apply(values)
     
       current =
         if object[foreign_key].to_i == 0

data/lib/inline_forms/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 module InlineForms
-  VERSION = "8.1.58"
+  VERSION = "8.1.60"
 end

data/lib/inline_forms.rb

@@ -10,6 +10,7 @@ require "inline_forms/schema_apply"
 require "inline_forms/schema_label"
 require "inline_forms/form_element_from_callee"
 require "inline_forms/searchable"
+require "inline_forms/dropdown_order"
 require "inline_forms/archived_form_elements"
 require "inline_forms/form_element_registry"
 require "inline_forms/form_elements"
@@ -359,6 +360,14 @@ module InlineForms
       end
     end
 
+    # `inline_forms_dropdown_order` on every model (InlineForms::DropdownOrder),
+    # so hosts need no ApplicationRecord change to declare a dropdown order.
+    initializer "inline_forms.dropdown_order" do
+      ActiveSupport.on_load(:active_record) do
+        extend InlineForms::DropdownOrder::ClassMethods
+      end
+    end
+
     initializer "inline_forms.assets.precompile" do |app|
       # Skip when the host has no Sprockets-style pipeline (e.g. the test/dummy
       # harness); generated apps always bundle sprockets-rails.

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

@@ -3,6 +3,7 @@
 # Child of Machine (see machine.rb); shaped like the example app's Photo.
 class Part < ApplicationRecord
   belongs_to :machine, optional: true
+  belongs_to :phase, optional: true
 
   def _presentation
     "#{name}"

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Lookup with a dropdown_order column: dropdowns offer its records in that
+# order (InlineForms::DropdownOrder). Part belongs_to it.
+class Phase < ApplicationRecord
+  def _presentation
+    name
+  end
+end

data/test/integration/dropdown_test.rb

@@ -2,16 +2,145 @@
 
 require_relative "../integration_test_helper"
 
-# dropdown_edit sorts its options by presentation; the sort_by result used to
-# be discarded, so the options came out in id order.
+# Order of the records table-backed form elements offer
+# (InlineForms::DropdownOrder): the model's inline_forms_dropdown_order, else
+# a dropdown_order column, else inline_forms_list, else database order.
 class DropdownTest < InlineFormsIntegrationTestCase
-  test "dropdown_edit lists the options sorted by presentation" do
-    %w[Zeta Alpha Mu].each { |name| Machine.create!(name: name) }
-    part = Part.create!(name: "Gear")
+  teardown do
+    [ Phase, Machine, Kind, Part ].each do |klass|
+      klass.remove_instance_variable(:@inline_forms_dropdown_order) if klass.instance_variable_defined?(:@inline_forms_dropdown_order)
+    end
+    # Back to ApplicationRecord's `inline_forms_list -> { all }`.
+    [ Kind, Part ].each do |klass|
+      klass.singleton_class.remove_method(:inline_forms_list) if klass.singleton_class.method_defined?(:inline_forms_list, false)
+    end
+    Phase.remove_method(:disabled_for_dropdown?) if Phase.method_defined?(:disabled_for_dropdown?, false)
+  end
 
+  def view
     get machines_path
-    html = controller.view_context.dropdown_edit(part, :machine)
+    controller.view_context
+  end
+
+  def option_texts(html)
+    html.scan(%r{<option(?: [^>]*)?>([^<]*)</option>}).flatten
+  end
+
+  def create_phases
+    Phase.create!(name: "admittance", dropdown_order: 30)
+    Phase.create!(name: "nieuw")
+    Phase.create!(name: "decision", dropdown_order: 20)
+    Phase.create!(name: "---", dropdown_order: 0)
+    Phase.create!(name: "helprequest", dropdown_order: 10)
+  end
+
+  test "a dropdown_order column orders the dropdown, NULLs last" do
+    create_phases
+
+    html = view.dropdown_edit(Part.create!(name: "Gear"), :phase)
+
+    assert_equal [ "---", "helprequest", "decision", "admittance", "nieuw" ], option_texts(html)
+  end
+
+  test "the model's declared direction applies to the dropdown_order column" do
+    create_phases
+    Phase.inline_forms_dropdown_order :dropdown_order, :desc
+
+    html = view.dropdown_edit(Part.create!(name: "Gear"), :phase)
+
+    assert_equal [ "admittance", "decision", "helprequest", "---", "nieuw" ], option_texts(html)
+  end
+
+  test "a declared column wins over the dropdown_order column" do
+    create_phases
+    Phase.inline_forms_dropdown_order :name, :desc
+
+    html = view.dropdown_edit(Part.create!(name: "Gear"), :phase)
+
+    assert_equal [ "nieuw", "helprequest", "decision", "admittance", "---" ], option_texts(html)
+  end
+
+  test "without a declaration or column, the list order applies" do
+    %w[Zeta Alpha Mu].each { |name| Machine.create!(name: name) } # inline_forms_list: order(:name, :id)
+
+    html = view.dropdown_edit(Part.create!(name: "Gear"), :machine)
+
+    assert_equal %w[Alpha Mu Zeta], option_texts(html)
+  end
+
+  test "ties on the declared column break on id" do
+    first = Phase.create!(name: "same", dropdown_order: 5)
+    second = Phase.create!(name: "same", dropdown_order: 5)
+
+    assert_equal [ first.id, second.id ], InlineForms::DropdownOrder.apply(Phase.all).map(&:id)
+  end
+
+  test "without anything declared, records come in database order" do
+    %w[Zeta Alpha].each { |name| Kind.create!(name: name) } # inline_forms_list: all
+
+    assert_equal %w[Zeta Alpha], InlineForms::DropdownOrder.apply(Kind.all).map(&:name)
+  end
+
+  test "a filtering inline_forms_list only orders a dropdown, it hides no records" do
+    %w[Zeta Hidden Alpha].each { |name| Kind.create!(name: name) }
+    Kind.define_singleton_method(:inline_forms_list) { where.not(name: "Hidden").order(:name, :id) }
+
+    html = view.dropdown_with_other_edit(Widget.create!(name: "W"), :kind)
+
+    assert_equal %w[Alpha Hidden Zeta], html.scan(/<option value="([^"]*)">/).flatten
+  end
+
+  test "disabled_for_dropdown? and the options come from one query" do
+    create_phases
+    Phase.define_method(:disabled_for_dropdown?) { name == "decision" }
+    selects = []
+    counter = ->(*, payload) { selects << payload[:sql] if payload[:sql].match?(/\ASELECT .*FROM "phases"/) }
+
+    view_context, part = view, Part.create!(name: "Gear")
+
+    html = ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+      view_context.dropdown_edit(part, :phase)
+    end
+
+    assert_equal 1, selects.size, selects.join("\n")
+    assert_match(/<option disabled="disabled" value="\d+">decision</, html)
+    assert_equal [ "---", "helprequest", "decision", "admittance", "nieuw" ], option_texts(html)
+  end
+
+  test "dropdown_with_other offers its datalist in the dropdown order" do
+    %w[Zeta Alpha Mu].each { |name| Kind.create!(name: name) }
+    Kind.inline_forms_dropdown_order :name
+
+    html = view.dropdown_with_other_edit(Widget.create!(name: "W"), :kind)
+
+    assert_equal %w[Alpha Mu Zeta], html.scan(/<option value="([^"]*)">/).flatten
+  end
+
+  test "check_list lists its records in the dropdown order" do
+    machine = Machine.create!(name: "Press")
+    %w[Bolt Nut Axle].each { |name| Part.create!(name: name) }
+    Part.inline_forms_dropdown_order :name, :desc
+
+    html = view.check_list_edit(machine, :parts)
+
+    assert_equal %w[Nut Bolt Axle], html.scan(%r{<label for=[^>]*>([^<]*)</label>}).flatten.reject(&:empty?)
+  end
+
+  test "check_list keeps the inline_forms_list filter under a declared order" do
+    machine = Machine.create!(name: "Press")
+    %w[Bolt Hidden Nut Axle].each { |name| Part.create!(name: name) }
+    Part.define_singleton_method(:inline_forms_list) { where.not(name: "Hidden").order(:name) }
+    Part.inline_forms_dropdown_order :name, :desc
+
+    html = view.check_list_edit(machine, :parts)
+
+    assert_equal %w[Nut Bolt Axle], html.scan(%r{<label for=[^>]*>([^<]*)</label>}).flatten.reject(&:empty?)
+  end
+
+  test "an unknown direction or column is refused" do
+    assert_raises(ArgumentError) { Phase.inline_forms_dropdown_order :name, :up }
 
-    assert_equal %w[Alpha Mu Zeta], html.scan(%r{<option value="\d+">([^<]*)</option>}).flatten
+    Phase.inline_forms_dropdown_order :position
+    assert_raises(ArgumentError) { InlineForms::DropdownOrder.apply(Phase.all).to_a }
   end
 end

data/test/integration_test_helper.rb

@@ -42,9 +42,18 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
+  # Lookup with a dropdown_order column (InlineForms::DropdownOrder);
+  # Part belongs_to it for the dropdown tests.
+  create_table :phases, force: true do |t|
+    t.string  :name
+    t.integer :dropdown_order
+    t.timestamps
+  end
+
   create_table :parts, force: true do |t|
     t.string  :name
     t.integer :machine_id
+    t.integer :phase_id
     t.timestamps
   end
   add_index :parts, :machine_id

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inline_forms
 version: !ruby/object:Gem::Version
-  version: 8.1.58
+  version: 8.1.60
 platform: ruby
 authors:
 - Ace Suares
@@ -223,6 +223,7 @@ files:
 - lib/inline_forms.rb
 - lib/inline_forms/archived_form_elements.rb
 - lib/inline_forms/attribute_list.rb
+- lib/inline_forms/dropdown_order.rb
 - lib/inline_forms/form_element_from_callee.rb
 - lib/inline_forms/form_element_registry.rb
 - lib/inline_forms/form_elements.rb
@@ -299,6 +300,7 @@ files:
 - test/dummy/app/models/kind.rb
 - test/dummy/app/models/machine.rb
 - test/dummy/app/models/part.rb
+- test/dummy/app/models/phase.rb
 - test/dummy/app/models/widget.rb
 - test/dummy/app/views/_gizmos_search.html.erb
 - test/dummy/app/views/stats/show.html.erb
@@ -388,6 +390,7 @@ test_files:
 - test/dummy/app/models/kind.rb
 - test/dummy/app/models/machine.rb
 - test/dummy/app/models/part.rb
+- test/dummy/app/models/phase.rb
 - test/dummy/app/models/widget.rb
 - test/dummy/app/views/_gizmos_search.html.erb
 - test/dummy/app/views/stats/show.html.erb