recourse 6.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 635ceebc330e4dabee8a5fc81f7e176039803b5b78373ffe9cb82ded4b4b2730
-  data.tar.gz: a2a57c8f1a521bd395a40a527b1ed823151df466867c618c58646aaa4de90de3
+  metadata.gz: 80390029ce0bfed87fcf8247faceb992a392422044f0b0641bbfadb9bd3660f0
+  data.tar.gz: 81f226e7f69b2fa9846e2bc80e610d227e182d680b8c1d563b095a26f26fee1c
 SHA512:
-  metadata.gz: 9ac64fa98077faa73d5a8f0d65bb041ffe447d7843f85724141c33d6d067570e927eeed245a8d95b2eda578327b0fae176fd281941dbb29638a5c4cbe118a8c5
-  data.tar.gz: ebae99455b03cf6861838da467a79f561ed159eb76be1b7112ab350a47c05d0fa9c3178476021106f3158583d7234ae86465cfc3c069d4caf3da2a096593ed96
+  metadata.gz: f87b1572b17070744c3c03c2f64b6d699e53a738270b4bf2d88f0040264992a050709e891fde967e2c21f64508e41191a56cab0ba3b7e3dda1fa04bb3b25f9dd
+  data.tar.gz: bcf92ebc75b14486038c81b558580ff958e49d28a17259d895a97888e5a350dd3afe610f72b959b343a9a47b9c41a09b203518b1f28532d61fada8df683b5f2c

data/CHANGELOG.md

@@ -7,6 +7,53 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 7.1.0 - 2026-09-20
+
+* [CHANGE] The card draws the button that deletes what the page is about
+
+  It was drawn by the gem's own `edit` template, so a host writing a template of its own
+  lost it and wrote `destroy_resource_button` back by hand. The card draws it now, the way
+  it draws the tabs and the buttons beside the trail, and a host's page is its body alone.
+
+  A record's own page carries it, whichever of the two is open, so a resource routed to be
+  read and deleted but never changed is deleted from the page that reads it. Nothing gains
+  the ability to delete what it could not: a route without `destroy` draws no button.
+
+* [CHANGE] A column the database generates is never offered on a form
+
+  Postgres writes a stored generated column out of the others and takes no value for one,
+  so a field for it would be refused whatever was typed. Such a column is read on every
+  other screen as before.
+
+## 7.0.0 - 2026-09-19
+
+* [BREAKING] What a page counts is the gem's to work out
+
+  `recourse_counters` is gone from every model. A column is counted where it holds a
+  counter cache, as before, and now also where it is named `<association>_count` for an
+  association the model has -- so a figure the app keeps itself, a `has_many through`
+  Rails will not cache among them, is drawn as a count without being declared.
+
+  The rule a host signs up for: a `*_count` column whose prefix names an association must
+  hold the count of that association. One naming nothing is an ordinary number, and one
+  naming an association it does not count wants another name -- the heading and the link
+  a counter draws would both say the wrong thing. `recourse_hidden` takes such a column
+  off the screens.
+
+* [BREAKING] A record's card is the layout's, not the template's
+
+  A host writing its own `show`, `edit` or nested `index` for a recoursed model used to
+  replace the whole page, card and all, and wrote `render layout: 'recourses/card'` back by
+  hand to get the tabs and the buttons beside the trail. The card is drawn around whatever
+  template answers now, so a host's page is its body and nothing else.
+
+  Every host view still wrapping itself draws a card inside a card: drop the wrapper. A page
+  that wants the width to itself assigns `@recourse_card = false`.
+
+  `card_record` is what the card is about -- the parent on a page nested under one, the
+  record itself on its look and its change -- which is the rule every hand-written wrapper
+  was already passing.
+
 ## 6.0.0 - 2026-09-19
 
 * [Change] These pages are drawn from bh

data/README.md

@@ -99,6 +99,22 @@ To change the content displayed in the `index` table of a model, override any of
 | [`recourse_position`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_position-instance_method) | `'position'` where the model keeps an integer one | the column a reader drags the rows into order by, or `nil` for a table nobody positions |
 | [`recourse_icon`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_icon-instance_method) | the model's name | the icon on the sidebar, the crumbs and the tabs |
 
+A number is drawn as a count, headed with what it counts and linking to the rows behind
+it, when its column holds a counter cache or is named `<association>_count` for an
+association the model has. So a count the app keeps itself — a `has_many through`, which
+Rails will not cache — needs nothing declared:
+
+```ruby
+class Technician < ActiveRecord::Base
+  has_many :visits, through: :dispatches            # and a visits_count column beside it
+end
+```
+
+Which means a `*_count` column whose prefix names an association must hold the count of
+that association. One naming nothing — `word_count`, `retry_count` — is an ordinary
+number, and one naming an association it does not count wants another name or a place in
+`recourse_hidden`.
+
 For instance, this would yield a more compact `index` than the default configuration:
 
 ```ruby

data/app/views/layouts/recourses.html.erb

@@ -59,6 +59,20 @@
       <%= render 'recourses/sidebar' %>
     </aside>
 
+    <%# A record's pages are drawn in its card whoever wrote the template, so the tabs and
+        the buttons beside the trail stay the gem's and a host's own page is its body. Drawn
+        here rather than where it is written, since the card is where the bare actions are
+        said and the trail below is where they are read. -%>
+    <% page = capture do %>
+      <% if (record = card_record) %>
+        <%= render layout: 'recourses/card', locals: { record: record } do %>
+          <%= yield %>
+        <% end %>
+      <% else %>
+        <%= yield %>
+      <% end %>
+    <% end %>
+
     <nav class='navbar border-bottom'>
       <%# `row-gap` rather than a margin on the search: a margin is there whether the
           form wrapped or not, and on the line it shares with the breadcrumb it drops
@@ -74,7 +88,7 @@
     </nav>
 
     <main class='py-4 px-3'>
-      <%= yield %>
+      <%= page %>
     </main>
 
     <%= toasts(data: written_data) { |key, message| written_message key, message } %>

data/app/views/recourses/_card.html.erb

@@ -4,7 +4,10 @@
 <%# Every bare action the routes drew under this record: a nested resource with no
     index of its own is reached from nowhere, so its button sits beside the
     breadcrumbs wherever the record is shown, on whichever of its pages that is. -%>
+<%# The button that deletes what the page is about, drawn here rather than in a template
+    so a host writing its own show or edit keeps it without asking. -%>
 <% content_for :actions do %>
+  <%= destroy_resource_button destroyable_record %>
   <% bare_action_buttons(record).each do |label, path, method| %>
     <%= button_to label, path, method:, form_class: 'ms-3',
                                class: 'btn theme-primary btn-sm btn-solid' %>

data/app/views/recourses/edit.html.erb

@@ -1,10 +1,3 @@
 <% content_for :title, resource_record_label %>
 
-<% content_for :actions do %>
-  <%= destroy_resource_button resource_record %>
-<% end %>
-
-<%# The card is the parent's on a page nested under one, as it is for a nested index. -%>
-<%= render layout: 'card', locals: { record: resource_parent || resource_record } do %>
-  <%= render 'form', resource_key => resource_record %>
-<% end %>
+<%= render 'form', resource_key => resource_record %>

data/app/views/recourses/index.html.erb

@@ -22,12 +22,4 @@
     cable connection down and reopens it. -%>
 <%= refresh_subscription %>
 
-<%# A nested index is a page of the parent record, so it sits in the record's own
-    card, beside the record's other pages — its tab, the count, the current one. -%>
-<% if resource_parent %>
-  <%= render layout: 'card', locals: { record: resource_parent } do %>
-    <%= render 'results', resources: @resources, pagy: @pagy, week: @recourse_week %>
-  <% end %>
-<% else %>
-  <%= render 'results', resources: @resources, pagy: @pagy, week: @recourse_week %>
-<% end %>
+<%= render 'results', resources: @resources, pagy: @pagy, week: @recourse_week %>

data/app/views/recourses/show.html.erb

@@ -1,17 +1,12 @@
 <% content_for :title, resource_record_label %>
 
-<%# A page nested under a record is that record's page, the way a nested index is:
-    the card is the parent's, so the tabs on it are about the record the path names
-    above this one rather than about this one. -%>
-<%= render layout: 'card', locals: { record: resource_parent || resource_record } do %>
-  <%# Nothing to read out where the host found no record: a singular resource is
-      reached with no id, so the one it stands for is one it may not have yet, and the
-      page says so rather than reading attributes off nothing. -%>
-  <% if resource_record %>
-    <div class='row recourse-values'>
-      <%= render 'values', resource_key => resource_record %>
-    </div>
-  <% else %>
-    <%= render 'none', models: resource_name %>
-  <% end %>
+<%# Nothing to read out where the host found no record: a singular resource is reached
+    with no id, so the one it stands for is one it may not have yet, and the page says so
+    rather than reading attributes off nothing. -%>
+<% if resource_record %>
+  <div class='row recourse-values'>
+    <%= render 'values', resource_key => resource_record %>
+  </div>
+<% else %>
+  <%= render 'none', models: resource_name %>
 <% end %>

data/lib/recourse/columns.rb

@@ -1,6 +1,14 @@
 # Reopened for the order a row reads in, which a table, a show page and a form all ask
 # for the same way.
 module Recourse
+  # Columns the database writes itself out of the others, which a form never offers: a
+  # stored generated column takes no value, and Postgres refuses the one a form would send.
+  # @param model [Class] the model the page is about.
+  # @return [Array<String>] the names of its generated columns.
+  def self.virtual_columns(model)
+    model.columns.select(&:virtual?).map(&:name)
+  end
+
   # Which part of a row a column belongs to. What a column holds is the gem's to know
   # and where the schema put it is the host's, so both have a say: the kind picks the
   # band, and the order inside the band is the one the table already has. Extended onto
@@ -55,7 +63,7 @@ module Recourse
     # what state it is in; and a key is an integer, so it has to be recognised as a key
     # before its type is asked about at all.
     def band(model, name, keys)
-      return :counter if model.recourse_counters.key? name
+      return :counter if Recourse.counters(model).key? name
       return :state if name == model.inheritance_column || model.defined_enums.key?(name)
       return :timestamp if TIMESTAMPS.include? name
       return :reference if keys.include? name

data/lib/recourse/counters.rb

@@ -0,0 +1,40 @@
+# Reopened for what a page counts, which a table, a heading and a tab all read here.
+module Recourse
+  # What a page counts, worked out once per class: a reload replaces the classes the
+  # reflections belong to, so the engine empties this where it does.
+  @counters = {}
+
+  # The counts a model's pages draw, as `{ column => association }`. A column holding a
+  # counter cache answers, read from the `belongs_to` where `counter_cache` is declared;
+  # so does any `*_count` column named after an association the model has, which is how a
+  # figure the app keeps itself -- a `has_many through`, which Rails will not cache -- is
+  # counted like any other. A `*_count` column naming no association is a number and
+  # nothing more, and one naming an association it does not count belongs under another
+  # name: the heading and the link a counter draws would both say the wrong thing.
+  # @param model [Class] the model the page is about.
+  # @return [Hash{String => ActiveRecord::Reflection::AbstractReflection}] the counts.
+  def self.counters(model)
+    @counters[model.name] ||= cached_counters(model).merge counted_columns(model)
+  end
+
+  # Empties what was read off the reflections of classes a reload has replaced.
+  # @return [Hash] the empty table.
+  def self.forget_counters = @counters.clear
+
+  private_class_method def self.cached_counters(model)
+    model.reflect_on_all_associations(:has_many).filter_map do |association|
+      column = association.inverse_of&.counter_cache_column
+      [column, association] if column
+    end.to_h
+  end
+
+  private_class_method def self.counted_columns(model)
+    model.column_names.filter_map do |column|
+      name = column.delete_suffix '_count'
+      next if name == column
+
+      association = model.reflect_on_association name
+      [column, association] if association
+    end.to_h
+  end
+end

data/lib/recourse/engine.rb

@@ -15,6 +15,10 @@ module Recourse
       ActionDispatch::Routing::Mapper.include Scopes, Routes
     end
 
+    # Reflections belong to the classes a reload replaces, so what was read off them
+    # goes with the reload.
+    config.to_prepare { Recourse.forget_counters }
+
     # `/counties.map` and `/shifts.cal` are the same page in another shape, so each
     # format is a name for HTML: without one Rails has no type for the extension and
     # answers 406.

data/lib/recourse/helpers/cards.rb

@@ -5,6 +5,13 @@ module Recourse
     module Cards
     private
 
+      # The record whose card this page is drawn in: the parent, on a page nested under
+      # one, and the record itself where the page is its look or its change. An index of
+      # its own, and a form for a record that is not there yet, stand outside a card.
+      def card_record
+        resource_parent || (resource_record if controller.action_name.in? %w[show edit])
+      end
+
       # The pages of the record the card is about, as `[label, path, current]` — a
       # look first, a change second, then one tab per nested index: `8 ZIPs` where
       # a counter cache answers, the bare `Settings` where none does. On a nested

data/lib/recourse/helpers/cells.rb

@@ -58,7 +58,7 @@ module Recourse
       # counter is headed with what it counts — `ZIPs`, not `ZIPs count` — since the
       # column holds a number and the heading says what the number is of.
       def resource_column_title(column)
-        counted = resource_model.recourse_counters[column]
+        counted = Recourse.counters(resource_model)[column]
         return dated_title column unless counted
 
         Recourse.model_title counted.klass
@@ -81,7 +81,7 @@ module Recourse
         value = resource.attributes[column]
         return blob_link resource, value if blob_filename? column
 
-        counted = resource_model.recourse_counters[column]
+        counted = Recourse.counters(resource_model)[column]
 
         # A count is the bare number — the icon in the heading already says what it
         # counts — linking to the counted rows where a block nested their index here.

data/lib/recourse/helpers/counters.rb

@@ -8,7 +8,7 @@ module Recourse
       # The class a counter's cells carry, which is what sizes the column like the
       # action columns beside it rather than like the columns carrying text.
       def counter_class(column)
-        'recourse-counter' if resource_model.recourse_counters.key? column
+        'recourse-counter' if Recourse.counters(resource_model).key? column
       end
 
       # A figure, and the word saying what it counts. The `aria-label` carries both,

data/lib/recourse/helpers/deletions.rb

@@ -12,10 +12,18 @@ module Recourse
 
     private
 
+      # The record a page may delete: the one it is about, on its own look or its own
+      # change page. A nested index wears the parent's card and deletes nothing from it.
+      # @api private
+      def destroyable_record
+        resource_record if controller.action_name.in? %w[show edit]
+      end
+
       # Deletes the record on the page, or nothing at all where no action is routed
       # to delete it with — the same two guards the edit link answers to.
+      # @api private
       def destroy_resource_button(record)
-        path = destroy_resource_path record
+        path = record && destroy_resource_path(record)
         return unless path
 
         confirm_button_to t('recourse.delete', model: resource_name), path,
@@ -24,6 +32,7 @@ module Recourse
                           form_class: 'd-inline-block'
       end
 
+      # @api private
       # What deleting this record takes with it, counted a level down and no further:
       # a state reaches counties, then ZIPs, then locations, and counting that far
       # would join 40,965 rows to draw one page.

data/lib/recourse/helpers/filters.rb

@@ -78,7 +78,7 @@ module Recourse
       def filter_counter(klass)
         return if resource_parent
 
-        klass.recourse_counters.find { |_, one| one.klass == resource_model }&.first
+        Recourse.counters(klass).find { |_, one| one.klass == resource_model }&.first
       end
 
       # Never invalid and never required: a filter narrows rather than sets.

data/lib/recourse/helpers/kinds.rb

@@ -43,7 +43,7 @@ module Recourse
       # already follow; and everything else is the type the attribute itself reports —
       # `:monetary` included, where a host has registered a type that says so.
       def attribute_kind(column)
-        return :counter if resource_model.recourse_counters.key? column
+        return :counter if Recourse.counters(resource_model).key? column
         return :enum if resource_model.defined_enums.key? column
         return :list if Recourse.list_column? resource_model, column
         return :phone if column == 'phone'

data/lib/recourse/helpers/rows.rb

@@ -39,7 +39,7 @@ module Recourse
       # showing the count it was cached with. Read off the rows in memory like the
       # version is, so this costs no query either.
       def counters_version(rows)
-        columns = resource_model.recourse_counters.keys
+        columns = Recourse.counters(resource_model).keys
         return if columns.empty?
 
         rows.map { |row| row.attributes.values_at(*columns) }

data/lib/recourse/helpers/searches.rb

@@ -44,13 +44,23 @@ module Recourse
       end
 
       # The model's search field, less the reach-through a nested route already
-      # answered: a page pinned to one provider offers no box to search them all.
+      # answered: a page pinned to one provider offers no box to search them all. A
+      # host naming a predicate of its own has said what it wants searched, and what
+      # it said is read on every page — which is what answering differently from the
+      # gem means here.
       def resource_search_field
-        resource_model.search_field except: resource_parent_association
+        chosen = resource_model.search_field
+        return chosen unless chosen == Recourse.search_field(resource_model)
+
+        Recourse.search_field resource_model, except: resource_parent_association
       end
 
+      # And the words above it, narrowed the same way and for the same reason.
       def resource_search_prompt
-        resource_model.search_prompt except: resource_parent_association
+        chosen = resource_model.search_prompt
+        return chosen unless chosen == Recourse.search_prompt(resource_model)
+
+        Recourse.search_prompt resource_model, except: resource_parent_association
       end
 
       # A foreign key's cell shows a label from the other table, so what decides is

data/lib/recourse/helpers/sorts.rb

@@ -37,7 +37,7 @@ module Recourse
       # and nobody types anything under it — and `Location address line 1` over a column
       # of addresses reads as a form's question asked where there is no form.
       def sort_title(column)
-        counted = resource_model.recourse_counters[column.to_s]
+        counted = Recourse.counters(resource_model)[column.to_s]
         return counter_title counted if counted && @recourse_headers
 
         resource_column_title column.to_s

data/lib/recourse/helpers/tabs.rb

@@ -100,7 +100,7 @@ module Recourse
       end
 
       def counter_of(model, association)
-        model.recourse_counters.find { |_, one| one == association }&.first if association
+        Recourse.counters(model).find { |_, one| one == association }&.first if association
       end
 
       def join_of(model, association)

data/lib/recourse/recoursive.rb

@@ -25,22 +25,12 @@ module Recourse
     # `%i[created_at updated_at]` asks for the two Rails keeps rather than the two
     # a record is about. A timestamp named here still lands last, and in that order,
     # whichever way round it was written.
+    # @api private
     def recourse_displayed = []
 
-    # Columns holding a counter cache, each mapped to the association it counts. Read
-    # from the `belongs_to` on the other side, which is where `counter_cache` is
-    # declared: a column merely named `quote_count` is not one of these. Worked out
-    # once per class, the way `recourse_listable?` is: associations are declared at
-    # load and a reloaded class is a new one, with a memo of its own.
-    def recourse_counters
-      @recourse_counters ||= reflect_on_all_associations(:has_many).filter_map do |association|
-        column = association.inverse_of&.counter_cache_column
-        [column, association] if column
-      end.to_h
-    end
-
     # `ZIP code`: what to call a foreign key pointing here. A form's label, a table's
     # heading and a search prompt all name the same thing, so they name it once.
+    # @api private
     def recourse_reference_name
       attribute = Recourse.downcase human_attribute_name(recourse_label)
 
@@ -49,6 +39,7 @@ module Recourse
 
     # True when the label has a length, so it is short enough to be typed and a
     # form can ask for the value instead of listing every record to pick from.
+    # @api private
     def recourse_typed_label?
       validators_on(recourse_label).any? ActiveModel::Validations::LengthValidator
     end

data/lib/recourse/searchable/columns.rb

@@ -2,6 +2,7 @@ module Recourse
   module Searchable
     # What a model's own schema offers a search: which of its columns are worth
     # looking through, and which of its foreign keys are worth looking past.
+    # @api private
     module Columns
       # Column types a search box can match on containment. An enum is a Postgres
       # type of its own, and what it holds is a word, so it reads as a string too.

data/lib/recourse/searchable/terms.rb

@@ -2,33 +2,20 @@ module Recourse
   module Searchable
     # What the search box above a table submits, and what it says while it is empty.
     module Terms
-      # The predicate a search box submits: everything it looks through at once,
-      # joined by `or`. Nil where a model has nothing worth looking through, which
-      # is also what leaves that model's index without the form — filters and all.
-      # `except:` takes the association a nested route already answered, so a page
-      # pinned to one provider offers no box to search them all.
-      def search_field(except: nil)
-        fields, predicate = recourse_search_terms(except:)
-        return if fields.empty?
-
-        "#{fields.join '_or_'}_#{predicate}"
-      end
-
-      # What the search box says while it is empty, naming what it looks through.
-      def search_prompt(except: nil)
-        fields, predicate = recourse_search_terms(except:)
-        return if fields.empty?
+      # The predicate a search box submits: everything the model looks through at once,
+      # joined by `or`. A host naming its own instead is taken whole, on every page the
+      # model is read on.
+      def search_field = Recourse.search_field(self)
 
-        list = recourse_search_names(except:).join ' or '
-        I18n.t "recourse.searched_#{predicate}", list: list
-      end
-
-    private
+      # What the search box says while it is empty, naming what it looks through. A
+      # host's own words are taken whole here too.
+      def search_prompt = Recourse.search_prompt(self)
 
       # What a search box looks through, and how it matches: the plaintext columns
       # and the labels behind foreign keys — less the one `except:` names — on
       # containment; or, for a model that keeps nothing in plaintext worth
       # searching, its encrypted columns, whole.
+      # @api private
       def recourse_search_terms(except: nil)
         plain = recourse_searchable_columns + recourse_searchable_references(except:)
         return [plain, 'cont'] if plain.any?
@@ -37,14 +24,18 @@ module Recourse
       end
 
       # Those same terms as words, lower case but for the acronyms among them.
+      # @api private
       def recourse_search_names(except: nil)
         fields, = recourse_search_terms(except:)
 
         fields.map { |field| Recourse.downcase recourse_term_name(field) }
       end
 
+    private
+
       # A term is a column of this model, or a `zip_code` reaching through one of its
       # foreign keys — which a form and a table already have a name for.
+      # @api private
       def recourse_term_name(field)
         reached = recourse_searchable_associations.find { |one| field.start_with? "#{one.name}_" }
         return reached.klass.recourse_reference_name if reached

data/lib/recourse/searchable.rb

@@ -37,7 +37,7 @@ module Recourse
     # for leaving those out too: hidden from every screen means hidden here.
     def ransortable_attributes(_auth_object = nil)
       readable = ransackable_attributes - recourse_encrypted_names
-      indexed = recourse_indexed_columns + recourse_counters.keys + Recourse::TIMESTAMPS
+      indexed = recourse_indexed_columns + Recourse.counters(self).keys + Recourse::TIMESTAMPS
 
       keys = recourse_references.map { |one| one.foreign_key.to_s }
 
@@ -47,11 +47,13 @@ module Recourse
     # True where a foreign key pointing here is typed rather than picked, which a
     # form and the controller reading its parameters back have to agree on: the label
     # is bounded, or the table is too long to list.
+    # @api private
     def recourse_typed_reference? = recourse_typed_label? || !recourse_listable?
 
     # True where every row of this model could be listed in one menu. The count is
     # bounded, so the question costs the same on ten rows as on ten million, and it
     # is asked once per class — a table that crosses the line is noticed at boot.
+    # @api private
     def recourse_listable?
       return @recourse_listable unless @recourse_listable.nil?
 

data/lib/recourse/searches.rb

@@ -0,0 +1,31 @@
+# Reopened for what a search box submits and what it says, which a page narrows by the
+# association its route has already answered.
+module Recourse
+  # The predicate a search box submits: every term the model looks through, joined by
+  # `or`. Nil where a model has nothing worth looking through, which is what leaves its
+  # index without the form -- filters and all. `except:` drops the association a nested
+  # route already answered, so a page pinned to one provider offers no box to search
+  # them all.
+  # @param model [Class] the model the page is about.
+  # @param except [ActiveRecord::Reflection::AbstractReflection, nil] what the route said.
+  # @return [String, nil] the predicate, or nothing where there is none.
+  def self.search_field(model, except: nil)
+    fields, predicate = model.recourse_search_terms(except:)
+    return if fields.empty?
+
+    "#{fields.join '_or_'}_#{predicate}"
+  end
+
+  # What the search box says while it is empty, naming what it looks through.
+  # @param model [Class] the model the page is about.
+  # @param except [ActiveRecord::Reflection::AbstractReflection, nil] what the route said.
+  # @return [String, nil] the words, or nothing where there is nothing to look through.
+  def self.search_prompt(model, except: nil)
+    fields, predicate = model.recourse_search_terms(except:)
+    return if fields.empty?
+
+    list = model.recourse_search_names(except:).join ' or '
+
+    I18n.t "recourse.searched_#{predicate}", list: list
+  end
+end

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 = '6.0.0'
+  VERSION = '7.1.0'
 end

data/lib/recourse.rb

@@ -12,6 +12,8 @@ require_relative 'recourse/bookmarks'
 require_relative 'recourse/calendars'
 require_relative 'recourse/colors'
 require_relative 'recourse/columns'
+require_relative 'recourse/counters'
+require_relative 'recourse/searches'
 require_relative 'recourse/themes'
 require_relative 'recourse/icons'
 require_relative 'recourse/controllers'
@@ -57,10 +59,11 @@ module Recourse
 
   # Columns a user may set: the form offers these, the show page reads these out, and
   # `create` permits these. A counter cache is none of a user's business — Rails keeps
-  # it, so a form that offered one would let it be typed over.
+  # it, so a form that offered one would let it be typed over, and neither is a column
+  # the database generates: it takes no value at all.
   def self.editable_columns(model)
-    ordered model, model.column_names - ['id', *TIMESTAMPS] - model.recourse_counters.keys -
-                   hidden_columns(model)
+    ordered model, model.column_names - ['id', *TIMESTAMPS] - counters(model).keys -
+                   hidden_columns(model) - virtual_columns(model)
   end
 
   # Columns no screen shows: whatever the model asked to hide through `recourse_hidden`

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recourse
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 7.1.0
 platform: ruby
 authors:
 - claudiob
@@ -185,6 +185,7 @@ files:
 - lib/recourse/colors.rb
 - lib/recourse/columns.rb
 - lib/recourse/controllers.rb
+- lib/recourse/counters.rb
 - lib/recourse/densities.rb
 - lib/recourse/engine.rb
 - lib/recourse/helpers.rb
@@ -255,6 +256,7 @@ files:
 - lib/recourse/searchable/columns.rb
 - lib/recourse/searchable/filters.rb
 - lib/recourse/searchable/terms.rb
+- lib/recourse/searches.rb
 - lib/recourse/themes.rb
 - lib/recourse/titles.rb
 - lib/recourse/version.rb