recourse 6.0.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 635ceebc330e4dabee8a5fc81f7e176039803b5b78373ffe9cb82ded4b4b2730
-  data.tar.gz: a2a57c8f1a521bd395a40a527b1ed823151df466867c618c58646aaa4de90de3
+  metadata.gz: d4c5d237ba9ace6d0bde291127548ea5202ea729de90541d11240a5d2db0dae3
+  data.tar.gz: 7f266eaa7ba56f045c692702fa94c4163d09621bedfd3eb963ab025af5efba39
 SHA512:
-  metadata.gz: 9ac64fa98077faa73d5a8f0d65bb041ffe447d7843f85724141c33d6d067570e927eeed245a8d95b2eda578327b0fae176fd281941dbb29638a5c4cbe118a8c5
-  data.tar.gz: ebae99455b03cf6861838da467a79f561ed159eb76be1b7112ab350a47c05d0fa9c3178476021106f3158583d7234ae86465cfc3c069d4caf3da2a096593ed96
+  metadata.gz: c03bfff3a9f95fa135fd7aaf1b5b16e8c905dab9431d13bdc139aaf58cf5188d36164e1921260b6ba21fe3829bdea087bcefbf9f2082ddc73e06d6201ccee885
+  data.tar.gz: c79417ff860145a2da9a5e987d842f9d7351e1a92c91916a65714ae83b68786f4f6c557d6e60cdd35dbed670d24974831490235a5127cb4f8437962576e7dd7d

data/CHANGELOG.md

@@ -7,6 +7,35 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 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/edit.html.erb

@@ -4,7 +4,4 @@
   <%= 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

@@ -55,7 +55,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,16 @@ 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. A
+      # host drawing a page whole says so by assigning `@recourse_card = false`.
+      def card_record
+        return if controller_assign('recourse_card') == false
+
+        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/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

@@ -27,18 +27,6 @@ module Recourse
     # whichever way round it was written.
     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.
     def recourse_reference_name

data/lib/recourse/searchable/terms.rb

@@ -2,28 +2,14 @@ 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
@@ -43,6 +29,8 @@ module Recourse
         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.
       def recourse_term_name(field)

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 }
 

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.0.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'
@@ -59,7 +61,7 @@ module Recourse
   # `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.
   def self.editable_columns(model)
-    ordered model, model.column_names - ['id', *TIMESTAMPS] - model.recourse_counters.keys -
+    ordered model, model.column_names - ['id', *TIMESTAMPS] - counters(model).keys -
                    hidden_columns(model)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recourse
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 7.0.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