recourse 7.6.1 → 7.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8e518ee85484be8de5cc4a1533a9b8677d97417706a8c93210a02b2ad067040
-  data.tar.gz: 98e1b1f4173a12c8935783d5194715affd66ebfd33de377b0010c86352be83c4
+  metadata.gz: a39f935e577b873d97305e1b599b01b7c36a7e8f7c07b584df0f2449a2a58042
+  data.tar.gz: ccce6838f769dcd9b3bc8bdbb00143b17f1a593e39f58567f3054373335f0a6d
 SHA512:
-  metadata.gz: 11c62eca29bcd4fdd171ff3d1fe2f5829b41ff0d4d057cff38a8c24749b5bb8d610962906746ba828e6163d7ad0ac89bb0e7a5a1ef44b84250967b95e4173708
-  data.tar.gz: f4801d3c52a5228fe075f50940fd01833c81966c232b17e0d093dffda29d0b75f93e73cf91d13fdf05a9a55bd41e7adaad2c84653d8a5f5b79fe7102c8146458
+  metadata.gz: 16faf5ac22fbc37539dd84b991b58f7027abbcd26bdedb13ecbcd9d877c966844508d8106eb66e99223bbce9e5998fc81ed9df781e03b6f8864ad036abcc8e62
+  data.tar.gz: 3155b9735871a0de16dd9e95ea9375bce9ad062d46827afc4549a30c67cf868bd97d2c252e1062ac798b65612c52d7cf4525d52f654b66b82ee1428641dac134

data/CHANGELOG.md

@@ -7,6 +7,23 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 7.7.0 - 2026-09-20
+
+* [CHANGE] `filter_fields` is a list of predicates, and nothing else
+
+  A filter was a predicate to the options that drew it — `label:` for its heading,
+  `values:` for its words, `scope:` for the rows it offered. All three are gone: a model
+  names the filters it wants and the gem works out the rest. A predicate may now reach
+  through an association, so `skilled_specialties_id_in` lists the specialties and
+  `integration_type_in` the kinds the integrations table holds, each read as the locale
+  calls that model.
+
+* [FEATURE] A filter Ransack will not answer is refused
+
+  A predicate whose attribute is missing from `ransackable_attributes` drew a menu that
+  narrowed nothing and handed back every row. Ransack is asked first, since Ransack is
+  what would drop it, and a model that names one raises rather than drawing it.
+
 ## 7.6.1 - 2026-09-20
 
 * [FIX] The three write seams are marked `@api private`

data/config/locales/recourse.en.yml

@@ -74,6 +74,10 @@ en:
     unindexed: "You asked for `recourses %{names}, positionable: true`, which draws no
       index to put in order. A row is dragged from the table that lists it, so there is
       nowhere for a drop to be reported from."
+    unanswerable: "%{model} lists `%{predicate}` among its `filter_fields`, and Ransack
+      will not answer it: the attribute behind it is missing from
+      `ransackable_attributes` or `ransackable_associations`. A menu drawn for it would
+      narrow nothing and hand back every row."
     # What a menu with several picks reads as, the first named and the rest counted.
     more: "%{first} + %{count} more"
     new: New %{model}

data/lib/recourse/helpers/choices.rb

@@ -9,10 +9,10 @@ module Recourse
       # The values a column admits of itself, where it admits a known set of them:
       # an enum's words, or a boolean's two. Nil for anything else, which is what
       # hands the question on to the key it might be.
-      def choice_filter(predicate, column, label)
-        return enum_filter predicate, column, label if resource_model.defined_enums.key? column
+      def choice_filter(predicate, column)
+        return enum_filter predicate, column if resource_model.defined_enums.key? column
 
-        boolean_filter predicate, column, label if boolean_column? column
+        boolean_filter predicate, column if boolean_column? column
       end
 
       # The two a boolean admits, read as a reader reads them rather than as the
@@ -21,8 +21,8 @@ module Recourse
       # `Reachable` over a column called `stopped` -- names them with `values:`. The
       # way back is the bare `All`: a column called `signed` pluralizes to nothing
       # anybody would write, so the line says what it does rather than what it is of.
-      def boolean_filter(predicate, column, label)
-        title = label || resource_model.human_attribute_name(column)
+      def boolean_filter(predicate, column)
+        title = resource_model.human_attribute_name column
         values = [[t('recourse.affirmative'), true], [t('recourse.negative'), false]]
 
         filter_menu predicate, title, values, t('recourse.all_values')
@@ -36,8 +36,8 @@ module Recourse
       # A menu of the words the column admits, which are the words the form's own menu
       # offers and the badge on a show page reads. Headed by the attribute rather than
       # by a model, since a status is the table's own and not another table's.
-      def enum_filter(predicate, column, label)
-        title = label || resource_model.human_attribute_name(column)
+      def enum_filter(predicate, column)
+        title = resource_model.human_attribute_name column
         values = resource_model.defined_enums[column].keys
 
         filter_menu predicate, title, values, choices_all(title)

data/lib/recourse/helpers/filter_menus.rb

@@ -0,0 +1,54 @@
+module Recourse
+  module Helpers
+    # The markup a filter menu is: the records it lists, the order they read in, and
+    # the count beside each where the model keeps one.
+    module FilterMenus
+    private
+
+      def filter_combobox(predicate, title, recourses)
+        label = recourses.klass.recourse_label
+        counter = filter_counter recourses.klass
+        # What it reads as when nothing is ticked, so the way back is a line in the menu.
+        models = Recourse.model_title recourses.klass, lower: true
+
+        filter_menu predicate, title, nil, t('recourse.all', models: models),
+                    label: label.to_s, counter: counter,
+                    recourses: filter_options(recourses, label, counter)
+      end
+
+      # The commonest choice first where the model keeps a count, since a menu is read
+      # from the top and most requests want the option most rows are behind — and by
+      # name where it keeps none. The name breaks ties, or two markets on the same
+      # number would swap places between one request and the next.
+      def filter_options(recourses, label, counter)
+        return recourses.select(:id, label).order label unless counter
+
+        recourses.select(:id, label, counter).order counter => :desc, label => :asc
+      end
+
+      # The column on the model a filter lists that counts the rows being filtered —
+      # `markets.zips_count` on `/zips`. Read from the counter caches that model keeps
+      # rather than from a column named after this one, so a `zips_count` nobody
+      # maintains is not a count. None on a nested page: the count is of every row in
+      # the table, and the page shows the parent's share of them, which nothing counted.
+      def filter_counter(klass)
+        return if resource_parent
+
+        Recourse.counters(klass).find { |_, one| one.klass == resource_model }&.first
+      end
+
+      # Never invalid and never required: a filter narrows rather than sets.
+      def filter_menu(predicate, title, values, all, **)
+        render('recourses/combobox', name: "q[#{predicate}]", id: "q_#{predicate}",
+                                     placeholder: title, multiple: true, aria_label: title,
+                                     selected: filter_values(predicate), small: true,
+                                     all: all, values: Array(values), **)
+      end
+
+      # A multiple select submits one value per pick, and a link carries them the same way.
+      def filter_values(predicate)
+        Array(query_params[predicate]).map(&:to_s).compact_blank
+      end
+    end
+  end
+end

data/lib/recourse/helpers/filters.rb

@@ -10,7 +10,7 @@ module Recourse
       # rather than picked — so what is left is what a form would hold, which is
       # what decides whether there is a form at all.
       def resource_filter_fields
-        resource_filters.filter_map { |predicate, options| filter_field predicate, **options }
+        resource_filters.filter_map { |predicate| filter_field predicate }
       end
 
       # The model's filters, less the one a nested route already answered:
@@ -18,80 +18,48 @@ module Recourse
       # for it would only offer to re-ask — or to contradict — the address.
       def resource_filters
         parent = resource_parent_association
-        filters = resource_model.filter_fields
+        filters = declared_filters
         return filters unless parent
 
-        filters.except "#{parent.foreign_key}_in"
+        filters - ["#{parent.foreign_key}_in"]
       end
 
-      # One filter: the words a host named, the values a column of its own admits, or
-      # a menu of the records a foreign key points at, holding whichever the request
-      # already asked for. `values:` is the shape for a predicate no column of this
-      # model describes, and it needs the `label:` there is no column to read one off.
-      def filter_field(predicate, label: nil, scope: nil, values: nil)
-        return values_filter predicate, label, values if values
+      # The predicates the model named, as words. A filter is named and nothing else:
+      # what it reads as and what it offers are the column's to say.
+      def declared_filters
+        resource_model.filter_fields.map(&:to_s)
+      end
+
+      # One filter: the values a column of its own admits, a menu of the records a
+      # foreign key points at, or one reached through an association. A predicate
+      # Ransack will not answer is refused here rather than drawn, a menu that
+      # narrows nothing being worse than no menu at all.
+      def filter_field(predicate)
+        refuse_unanswerable predicate
+        column = predicate.sub Search::LIST_PREDICATES, ''
 
-        column = predicate.to_s.sub Search::LIST_PREDICATES, ''
+        choice_filter(predicate, column) || reference_filter(predicate, column) ||
+          reached_filter(predicate, column)
+      end
 
-        choice_filter(predicate, column, label) || reference_filter(predicate, column, label, scope)
+      # Ransack decides, since Ransack is what would drop it: a model answers for the
+      # attributes it allows and no others, and a filter naming one it does not allow
+      # comes back holding every row.
+      def refuse_unanswerable(predicate)
+        resource_model.ransack({ predicate => ['1'] }, ignore_unknown_conditions: false)
+      rescue ::Ransack::InvalidSearchError
+        raise Error, I18n.t('recourse.unanswerable', model: resource_model, predicate:)
       end
 
       # A menu of the records a foreign key points at. Nothing where that key is typed
       # rather than picked, which is the same question the field beside it asks: the
       # label is bounded, or the table is too long to list. Either way the menu would
-      # be a table of its own. A `scope:` draws one anyway.
-      def reference_filter(predicate, column, label, scope)
+      # be a table of its own.
+      def reference_filter(predicate, column)
         association = belongs_to_association column
-        return if association.nil? ||
-                  (scope.nil? && association.klass.recourse_typed_reference?)
-
-        filter_combobox predicate, label || reference_title(column, association),
-                        (scope || association.klass).all
-      end
-
-      def filter_combobox(predicate, title, recourses)
-        label = recourses.klass.recourse_label
-        counter = filter_counter recourses.klass
-        # What it reads as when nothing is ticked, so the way back is a line in the menu.
-        models = Recourse.model_title recourses.klass, lower: true
-
-        filter_menu predicate, title, nil, t('recourse.all', models: models),
-                    label: label.to_s, counter: counter,
-                    recourses: filter_options(recourses, label, counter)
-      end
-
-      # The commonest choice first where the model keeps a count, since a menu is read
-      # from the top and most requests want the option most rows are behind — and by
-      # name where it keeps none. The name breaks ties, or two markets on the same
-      # number would swap places between one request and the next.
-      def filter_options(recourses, label, counter)
-        return recourses.select(:id, label).order label unless counter
-
-        recourses.select(:id, label, counter).order counter => :desc, label => :asc
-      end
-
-      # The column on the model a filter lists that counts the rows being filtered —
-      # `markets.zips_count` on `/zips`. Read from the counter caches that model keeps
-      # rather than from a column named after this one, so a `zips_count` nobody
-      # maintains is not a count. None on a nested page: the count is of every row in
-      # the table, and the page shows the parent's share of them, which nothing counted.
-      def filter_counter(klass)
-        return if resource_parent
-
-        Recourse.counters(klass).find { |_, one| one.klass == resource_model }&.first
-      end
-
-      # Never invalid and never required: a filter narrows rather than sets.
-      def filter_menu(predicate, title, values, all, **)
-        render('recourses/combobox', name: "q[#{predicate}]", id: "q_#{predicate}",
-                                     placeholder: title, multiple: true, aria_label: title,
-                                     selected: filter_values(predicate), small: true,
-                                     all: all, values: Array(values), **)
-      end
+        return if association.nil? || association.klass.recourse_typed_reference?
 
-      # A multiple select submits one value per pick, and a link carries them the same way.
-      def filter_values(predicate)
-        Array(query_params[predicate]).map(&:to_s).compact_blank
+        filter_combobox predicate, reference_title(column, association), association.klass.all
       end
     end
   end

data/lib/recourse/helpers/reaches.rb

@@ -0,0 +1,66 @@
+module Recourse
+  module Helpers
+    # A filter that reaches through an association: `skilled_specialties_id_in` on a
+    # provider names the specialties it is skilled in, and `integration_type_in` the
+    # CRM its integration is. The predicate says which association and which of its
+    # columns, and the column says what the menu is of.
+    module Reaches
+    private
+
+      # A menu for a column on another model, where the predicate names the way there.
+      # The rows a key points at, or the kinds a table holds where the column is the
+      # one Rails keeps a subclass in, or whatever else that column holds.
+      def reached_filter(predicate, column)
+        association, attribute = reached_association column
+        return unless association
+
+        klass = association.klass
+        title = klass.model_name.human
+        return rows_filter predicate, title, klass if attribute == klass.primary_key
+
+        held_filter predicate, title, klass, attribute
+      end
+
+      # Every row of the other table, unless it is too long to be a menu — the same
+      # question a key pointing at it answers, since a menu of forty thousand buttons
+      # is a table wearing the wrong clothes.
+      def rows_filter(predicate, title, klass)
+        filter_combobox predicate, title, klass.all unless klass.recourse_typed_reference?
+      end
+
+      # The association a column reaches through, and what is left of the column once
+      # its name is taken off. The longest name wins, so `listed_contact_id` reaches
+      # through `listed_contact` rather than through a `listed` beside it.
+      def reached_association(column)
+        named = resource_model.reflect_on_all_associations.select do |one|
+          column.start_with? "#{one.name}_"
+        end
+        one = named.max_by { |association| association.name.length }
+
+        [one, column.delete_prefix("#{one.name}_")] if one
+      end
+
+      # The values a column on the other table holds, read from the rows rather than
+      # from anywhere they are declared: a value nobody has written is a filter that
+      # would answer nothing, and a column holding more of them than a menu takes is a
+      # table wearing the wrong clothes.
+      def held_filter(predicate, title, klass, attribute)
+        return unless klass.column_names.include? attribute
+
+        held = klass.distinct.limit(Searchable::MENU_LIMIT + 1).pluck(attribute).compact.sort
+        return if held.empty? || held.size > Searchable::MENU_LIMIT
+
+        values_filter(predicate, title, held.map { |one| [held_title(klass, attribute, one), one] })
+      end
+
+      # What one of them reads as: the word itself, unless the column is the one Rails
+      # keeps a subclass in, where it reads as the locale calls that model — the key
+      # Rails writes a subclass under, so no class is named to find it.
+      def held_title(klass, attribute, value)
+        return value unless attribute == klass.inheritance_column
+
+        t "activerecord.models.#{value.underscore}", default: value.demodulize.titleize
+      end
+    end
+  end
+end

data/lib/recourse/helpers.rb

@@ -19,6 +19,7 @@ require_relative 'helpers/details'
 require_relative 'helpers/events'
 require_relative 'helpers/examples'
 require_relative 'helpers/fields'
+require_relative 'helpers/filter_menus'
 require_relative 'helpers/filters'
 require_relative 'helpers/flashes'
 require_relative 'helpers/formats'
@@ -32,6 +33,7 @@ require_relative 'helpers/navigation'
 require_relative 'helpers/parents'
 require_relative 'helpers/pictures'
 require_relative 'helpers/previews'
+require_relative 'helpers/reaches'
 require_relative 'helpers/references'
 require_relative 'helpers/resources'
 require_relative 'helpers/refreshes'
@@ -56,11 +58,11 @@ module Recourse
   module Helpers
     include Actions, Positions, Attachments, Blobs, Bookmarks, Breadcrumbs, Buttons,
             Calendars, Cards, Cells, Choices, Colors, Comboboxes, Constraints, Counters,
-            Deletions, Densities, Details, Events, Examples, Fields, Filters, Flashes,
-            Formats, Inputs, Kinds, Limits, Links, Maps, Names, Navigation, Parents,
-            Pictures, Previews, References, Refreshes, Routing, Resources, Rows, Searches,
-            Shapes, Shortcuts, Sidebars, Sorts, Spans, Tabs, Themes, Times, Values,
-            Warnings, Weeks, Zones
+            Deletions, Densities, Details, Events, Examples, Fields, FilterMenus, Filters,
+            Flashes, Formats, Inputs, Kinds, Limits, Links, Maps, Names, Navigation,
+            Parents, Pictures, Previews, Reaches, References, Refreshes, Routing,
+            Resources, Rows, Searches, Shapes, Shortcuts, Sidebars, Sorts, Spans, Tabs,
+            Themes, Times, Values, Warnings, Weeks, Zones
 
     # The grid a record's own two pages lay an attribute out in: two columns on a large
     # viewport, and the same padding on both, so a value and the field that edits it sit

data/lib/recourse/searchable/filters.rb

@@ -11,7 +11,7 @@ module Recourse
       # big to list. The model's own columns come first, before the menus that name
       # other tables.
       def filter_fields
-        enum_filter_fields.merge(boolean_filter_fields).merge reference_filter_fields
+        enum_filter_fields + boolean_filter_fields + reference_filter_fields
       end
 
     private
@@ -27,7 +27,7 @@ module Recourse
       # Every one of the three comes to the same shape, and `_in` is what lets a
       # request tick more than one of the values a menu offers.
       def filters_for(names)
-        names.index_with({}).transform_keys { |name| "#{name}_in" }
+        names.map { |name| "#{name}_in" }
       end
 
       # One per enum: a dozen words a column admits are a menu whatever else is on the

data/lib/recourse/version.rb

@@ -1,4 +1,4 @@
 module Recourse
   # Version of the gem, read by the gemspec and by hosts checking compatibility.
-  VERSION = '7.6.1'
+  VERSION = '7.7.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recourse
 version: !ruby/object:Gem::Version
-  version: 7.6.1
+  version: 7.7.0
 platform: ruby
 authors:
 - claudiob
@@ -211,6 +211,7 @@ files:
 - lib/recourse/helpers/events.rb
 - lib/recourse/helpers/examples.rb
 - lib/recourse/helpers/fields.rb
+- lib/recourse/helpers/filter_menus.rb
 - lib/recourse/helpers/filters.rb
 - lib/recourse/helpers/flashes.rb
 - lib/recourse/helpers/formats.rb
@@ -225,6 +226,7 @@ files:
 - lib/recourse/helpers/pictures.rb
 - lib/recourse/helpers/positions.rb
 - lib/recourse/helpers/previews.rb
+- lib/recourse/helpers/reaches.rb
 - lib/recourse/helpers/references.rb
 - lib/recourse/helpers/refreshes.rb
 - lib/recourse/helpers/resources.rb