recourse 5.12.2 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dde202165a7bfa0c497a0ae06b118b3108536014fe7b439c6ef0f658f2bb295
-  data.tar.gz: 17d8781fda77d53d5bdf01199146342be707f634b955259a4499969c0341fdd6
+  metadata.gz: d4c5d237ba9ace6d0bde291127548ea5202ea729de90541d11240a5d2db0dae3
+  data.tar.gz: 7f266eaa7ba56f045c692702fa94c4163d09621bedfd3eb963ab025af5efba39
 SHA512:
-  metadata.gz: adf3b5711fd9327cde802204c2d0a3a69c8943b602e133ba66863106a621719c46dc507706de2bfedc42116e5f97dcf751fa8a333c772c8b71fa747cb4e7d087
-  data.tar.gz: 41d333d13e8e3d5645b3314c8ef2ab61137fae5cf381e4197c7598893e45c188e624a5eafb3dd1fc813e39adf504448357726bf4c9b1028e663f37f63e2d8e49
+  metadata.gz: c03bfff3a9f95fa135fd7aaf1b5b16e8c905dab9431d13bdc139aaf58cf5188d36164e1921260b6ba21fe3829bdea087bcefbf9f2082ddc73e06d6201ccee885
+  data.tar.gz: c79417ff860145a2da9a5e987d842f9d7351e1a92c91916a65714ae83b68786f4f6c557d6e60cdd35dbed670d24974831490235a5127cb4f8437962576e7dd7d

data/CHANGELOG.md

@@ -7,6 +7,65 @@ 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
+
+  They were drawn from a package named after one company's design system, pinned by hand in
+  `Recourse::BUNDLE` and fetched from a CDN. They are drawn from `bh` now, which is the
+  Bootstrap layer under that package and is a dependency of this gem, so the version in the
+  lock file is the version on the page and nothing is fetched across a network.
+
+  `Recourse::BUNDLE` is gone. `Recourse.assets` stays, defaulting to bh's own engine, for a
+  host serving those three folders from somewhere else.
+
+  The host's `recourses/head` partial is drawn last in the head rather than before the
+  script, so a stylesheet of the host's outranks the rules above it and a module of its own
+  runs after the application this one starts.
+
+* [Change] The flash is bh's toasts
+
+  `recourses/_flash` and `FLASH_THEMES` are gone: the markup was bh's, written twice. What
+  is this gem's own stays — the row a write landed on, and the link spliced into the words
+  a message says — and rides on `toasts` through its `data:` and its block.
+
+* [Feature] Every tab wears its model's icon
+
+  A tab earned one only where the parent kept a `has_many` of that name, so a nested index
+  reached through a join, and every singular resource, read as words alone beside tabs that
+  had pictures. The icon is now looked up from the route, which is the same question the
+  sidebar and the crumbs already ask.
+
+
 ## 5.6.2 - 2026-09-18
 
 * [Fix] A kept table notices a count that changed

data/README.md

@@ -10,16 +10,16 @@ gem install recourse
 
 ```ruby
 # Gemfile
-gem 'recourse', '~> 5.0'
+gem 'recourse', '~> 6.0'
 ```
 
-`~> 5.0` follows Semantic Versioning: `bundle update` takes every 5.x and never a
+`~> 6.0` follows Semantic Versioning: `bundle update` takes every 6.x and never a
 breaking change. Rails 8.1 and Ruby 3.2 are the minimum; the pages need Turbo, which
 `turbo-rails` brings, and nothing else in the host. Everything a page is styled and
 scripted by — Bootstrap 6, its icons, Turbo, Stimulus and the controllers behind these
-screens — is linked from https://design.houseaccount.com, so a host without an asset
-pipeline gets the same screens, and a host with a Content Security Policy allows that
-origin for `style-src`, `script-src` and `font-src`.
+screens — is `bh`, which this gem depends on and whose engine serves them at `/bh/`, so a
+host without an asset pipeline gets the same screens and nothing is fetched across a
+network.
 
 ## Step 1. Edit your routes
 
@@ -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
@@ -344,20 +360,18 @@ The dummy app under `test/dummy` runs on SQLite; the gem names no adapter.
 
 ### Reading an unpublished bundle
 
-The pages link `houseaccount` from a CDN, pinned to `Recourse::BUNDLE`, so a stylesheet or
-a Stimulus controller that is not published yet cannot be read on a page. Two lines change
-that — one in this Gemfile, kept out of it because CI checks out this repo alone:
+The pages link bh's own files, so a stylesheet or a Stimulus controller that is not
+published yet is read by pointing the Gemfile at a checkout of it beside this one:
 
 ```bash
-echo "gem 'houseaccount', path: '../design'" >> Gemfile && bundle install
-cd test/dummy && bin/rails db:migrate && HOUSE_ASSETS=1 bin/rails server
+echo "gem 'bh', path: '../bh'" >> Gemfile && bundle install
+cd test/dummy && bin/rails db:migrate && bin/rails server
 ```
 
-`HOUSE_ASSETS` is what loads that gem and sets `Recourse.assets = ''`, so the page asks
-this app for `/css`, `/js` and `/theme` and the gem's engine answers them out of its own
-`public/`. Behind a variable because what a deployed app links is what the suite asserts,
-and because the dummy is also the stand-in for a host with no such gem at all. The dummy's
-development database is migrated on its own, which the line above is why.
+A host serving those three folders from somewhere else — a CDN, a bundle of its own
+carrying bh's layer — says so in `Recourse.assets`, and that is the whole of what it
+writes. The dummy's development database is migrated on its own, which the line above is
+why.
 
 ## License
 

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

@@ -16,18 +16,10 @@
 
     <%= yield :head %>
 
-    <%# Everything the page is styled by, from the one place every HouseAccount app draws
-        on: Bootstrap 6, its icons and the house's own rules for this gem's markup. Served
-        from the `houseaccount` package on a CDN, pinned to a version — `Recourse.assets`
-        is where, and `Recourse::BUNDLE` is which — so a change there reaches these pages
-        when somebody moves that line and not before. Two connections opened before the
-        parser finds either tag: the stylesheet's plain one and the CORS one a module
-        script and a font are fetched over. They name the CDN outright, being a hint
-        about it and nothing more, so a host serving the bundle itself simply never uses
-        them. -%>
-    <link rel='preconnect' href='https://cdn.jsdelivr.net'>
-    <link rel='preconnect' href='https://cdn.jsdelivr.net' crossorigin>
-    <link rel='stylesheet' href='<%= Recourse.asset 'css/houseaccount.css' %>'>
+    <%# Everything the page is styled by: Bootstrap 6 and bh's rules for this gem's
+        markup, served by bh's own engine. `Recourse.assets` is where, and a host
+        serving those files from somewhere else says so there. -%>
+    <link rel='stylesheet' href='<%= Recourse.asset 'css/bh.css' %>'>
     <%# The one thing these screens set that the house's stylesheet does not: system faces
         at a compact size, for pages dense with figures. 14px as rem, so a browser's own
         text-size setting still scales it. After the stylesheet, since both are `:root`. -%>
@@ -43,15 +35,17 @@
     <%= render 'recourses/scheme' %>
     <%= primary_color_style %>
 
-    <%# The rest of the head is the host's: whatever it puts in a `recourses/head` partial
-        — the icons its tab wears, say — is drawn here, from the host's own views or from a
-        gem it loads, and nothing is guessed at where nobody has written one. -%>
-    <%= render 'recourses/head' if lookup_context.exists? 'recourses/head', [], true %>
-
     <%# Turbo, Bootstrap and a Stimulus application with every controller this markup
         names, started once under `window.Stimulus`. In the head, so a controller exists
         before the body's first `data-controller`. -%>
-    <script type='module' src='<%= Recourse.asset 'js/houseaccount.js' %>'></script>
+    <script type='module' src='<%= Recourse.asset 'js/bh.js' %>'></script>
+
+    <%# The rest of the head is the host's: whatever it puts in a `recourses/head` partial
+        — the icons its tab wears, a layer of its own over this one — is drawn here, from
+        the host's own views or from a gem it loads, and nothing is guessed at where nobody
+        has written one. Last, so a stylesheet of the host's outranks the rules above it and
+        a module of its own runs after the application this one started. -%>
+    <%= render 'recourses/head' if lookup_context.exists? 'recourses/head', [], true %>
   </head>
 
   <%# The reader's zone is told to the server here rather than from a page of its
@@ -65,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
@@ -80,9 +88,9 @@
     </nav>
 
     <main class='py-4 px-3'>
-      <%= yield %>
+      <%= page %>
     </main>
 
-    <%= render 'recourses/flash' %>
+    <%= toasts(data: written_data) { |key, message| written_message key, message } %>
   </body>
 </html>

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

@@ -5,7 +5,7 @@
     select is named with `[]`, so the browser submits every pick the way Ransack reads a
     list predicate. -%>
 <%= tag.select name: (multiple ? "#{name}[]" : name), id: id, multiple: multiple, required: required,
-               class: class_names('form-select', 'form-select-sm': small, 'is-invalid': invalid),
+               class: class_names('form-control', 'form-control-sm': small, 'is-invalid': invalid),
                aria: { label: aria_label, describedby: described },
                data: { controller: 'combobox', combobox_placeholder_value: placeholder,
                        combobox_more_value: t('recourse.more'), combobox_all_value: all,

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/assets.rb

@@ -1,28 +1,19 @@
-# Reopened for where the house bundle these pages are drawn from is served from.
+# Reopened for where the design layer these pages are drawn from is served from.
 module Recourse
-  # The release of `houseaccount` they are drawn from, named once — the layout links its
-  # stylesheet and its script, and the sidebar's toggle swaps a palette out of the same
-  # release. A published version is never written again, so the bytes behind these URLs
-  # cannot move under us, and a change to the bundle reaches these pages when somebody
-  # moves this line and not before.
-  BUNDLE = '0.17.0'
-
   class << self
-    # Where that release is served from, with no trailing slash. jsdelivr's copy of the
-    # published package by default, which is what every deployed app reads and the one
-    # place all five of them draw from.
+    # Where bh's built files answer from, with no trailing slash. Its own engine by
+    # default, which every app holding the gem already serves, so nothing is fetched
+    # across a network and no version is written down twice: the gem in the lock file
+    # is the one on the page.
     #
-    # A host that sets it to `''` serves the bundle itself, out of the `houseaccount`
-    # gem: its engine answers `/css`, `/js` and `/theme` from its own `public/`. That is
-    # how the bundle is worked on — a stylesheet or a controller can be tried on a real
-    # page before the version carrying it is published — and it is the whole of what
-    # such a host writes.
+    # A host serving those files from somewhere else — a CDN, a bundle of its own that
+    # carries bh's layer — points this at it, and that is the whole of what it writes.
     attr_accessor :assets
   end
 
-  @assets = "https://cdn.jsdelivr.net/npm/houseaccount@#{BUNDLE}/public"
+  @assets = Bh::Engine::PREFIX.chomp '/'
 
-  # One file of the bundle.
+  # One file of the design layer.
   def self.asset(path) = "#{assets}/#{path}"
 
   # And the folder one palette is read from, which three places ask for: the layout

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/actions.rb

@@ -81,11 +81,11 @@ module Recourse
       def destroy_button(record)
         path = url_for controller: "/#{destroy_action_path}", action: :destroy, id: record
 
-        button_to icon_tag(ICONS[:destroy], class: 'fg-danger'), path,
-                  method: :delete, class: 'btn btn-sm btn-link btn-icon p-0',
-                  aria: { label: t('recourse.delete', model: resource_name) },
-                  form: { data: { turbo_frame: '_top',
-                                  turbo_confirm: destroy_warning(record), } }
+        confirm_button_to icon_tag(ICONS[:destroy], class: 'fg-danger'), path,
+                          confirm: destroy_warning(record), method: :delete,
+                          class: 'btn btn-sm btn-link btn-icon p-0',
+                          aria: { label: t('recourse.delete', model: resource_name) },
+                          form: { data: { turbo_frame: '_top' } }
       end
     end
   end

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,
@@ -43,7 +43,8 @@ module Recourse
         word = Recourse.model_title association.klass, count: value, lower: true
 
         safe_join [
-          tag.span(count, class: 'recourse-counter-figure', data: tooltip_on_top(title)),
+          tag.span(count, class: 'recourse-counter-figure',
+                          data: tooltip_data(title, placement: 'top')),
           tag.span("#{count} #{word}", class: 'recourse-counter-word'),
         ]
       end

data/lib/recourse/helpers/deletions.rb

@@ -18,12 +18,10 @@ module Recourse
         path = destroy_resource_path record
         return unless path
 
-        options = {
-          method: :delete, class: 'btn btn-sm btn-solid theme-danger ms-3',
-          form_class: 'd-inline-block', data: { turbo_confirm: destroy_warning(record) },
-        }
-
-        button_to t('recourse.delete', model: resource_name), path, **options
+        confirm_button_to t('recourse.delete', model: resource_name), path,
+                          confirm: destroy_warning(record), method: :delete,
+                          class: 'btn btn-sm btn-solid theme-danger ms-3',
+                          form_class: 'd-inline-block'
       end
 
       # What deleting this record takes with it, counted a level down and no further:

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/flashes.rb

@@ -1,24 +1,16 @@
 module Recourse
   module Helpers
-    # What a flash message is drawn as: its toast's theme, the row it marks, and the
-    # words it leads somewhere.
+    # What a flash message is drawn as: the row it marks, and the words it leads somewhere.
     module Flashes
-      # Bootstrap theme for each flash key, so a notice and an alert read apart.
-      FLASH_THEMES = { 'notice' => 'theme-success', 'alert' => 'theme-danger' }
-
     private
 
-      # Theme for one flash entry, falling back to a neutral one for a host's key.
-      def flash_theme(key)
-        FLASH_THEMES.fetch key.to_s, 'theme-primary'
-      end
-
       # What marks the row a write just landed on, and nothing at all on a page no write
       # brought about — which is every page but the one after a create or an update.
       def written_data
         written = flash[Recourse::WRITTEN]
+        return {} if written.blank?
 
-        { controller: 'written', written_row_value: written['row'] } if written.present?
+        { controller: 'written', written_row_value: written['row'] }
       end
 
       # The message with the record it names led to that record's page, where a write

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/pictures.rb

@@ -20,13 +20,7 @@ module Recourse
       # an icon alone says nothing to one, and given the tooltip that says the same
       # word to everyone else.
       def icon_heading(concept, title, **)
-        icon_tag concept, label: title, role: :img, data: tooltip_on_top(title), **
-      end
-
-      def tooltip_on_top(title)
-        # `bs_title` is what Bootstrap's tooltip reads, and the controller is what
-        # makes one: Bootstrap never wires a tooltip on its own.
-        { controller: 'tooltip', bs_placement: 'top', bs_title: title }
+        icon_tag concept, label: title, role: :img, data: tooltip_data(title, placement: 'top'), **
       end
     end
   end

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

@@ -14,7 +14,7 @@ module Recourse
         association = nested_association record, name if action == :index
         return association_tab_label record, association, namespace if association
 
-        routed_tab_name name, namespace, action
+        tab_label_for Recourse.known_icon(name), routed_tab_name(name, namespace, action)
       end
 
       def nested_association(record, name)
@@ -36,15 +36,19 @@ module Recourse
         [lead.presence&.upcase_first, title].compact.join ' '
       end
 
-      # The icon is the counted model's own, whatever leads the words beside it. The
-      # words are wrapped where a picture or a figure stands beside them, so a phone,
-      # which has room for neither, keeps the picture and the figure and drops the words.
-      # A figure and its words share one element: the link lays its children out with a
-      # gap, and two of them would stand a gap and a space apart.
+      # The icon is the counted model's own, whatever leads the words beside it.
       def association_tab_label(record, association, namespace)
         icon = Recourse.known_model_icon association.klass
         count = tab_count record, association
-        words = tab_words association, namespace, count
+
+        tab_label_for icon, tab_words(association, namespace, count), count
+      end
+
+      # The words with whatever stands beside them. The words are wrapped where a picture
+      # or a figure does, so a phone, which has room for neither, keeps the picture and the
+      # figure and drops the words. A figure and its words share one element: the link lays
+      # its children out with a gap, and two of them would stand a gap and a space apart.
+      def tab_label_for(icon, words, count = nil)
         words = tag.span words, class: 'recourse-tab-word' if icon || count
         words = tag.span safe_join([count, words], ' ') if count
 
@@ -96,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 = '5.12.2'
+  VERSION = '7.0.0'
 end

data/lib/recourse.rb

@@ -1,3 +1,4 @@
+require 'bh'
 require 'pagy'
 # Before searchable.rb, so its `extend` lands ahead of Ransack's own defaults.
 require 'ransack'
@@ -11,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'
@@ -58,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: 5.12.2
+  version: 7.0.0
 platform: ruby
 authors:
 - claudiob
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: bh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.7'
 - !ruby/object:Gem::Dependency
   name: pagy
   requirement: !ruby/object:Gem::Requirement
@@ -144,7 +158,6 @@ files:
 - app/views/recourses/_color.html.erb
 - app/views/recourses/_combobox.html.erb
 - app/views/recourses/_fields.html.erb
-- app/views/recourses/_flash.html.erb
 - app/views/recourses/_footer.html.erb
 - app/views/recourses/_form.html.erb
 - app/views/recourses/_map.html.erb
@@ -172,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
@@ -242,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

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

@@ -1,27 +0,0 @@
-<% if flash.any? -%>
-  <%# `data-turbo-temporary`: a toast born visible would otherwise replay from the
-      page snapshot on every Back, announcing a save that happened a page ago. -%>
-  <%# The row a write landed on rides here rather than on a toast: this exists once
-      per page, `hidden.bs.toast` bubbles up to it from whichever toast hides, and
-      `data-turbo-temporary` already takes the whole thing away on a Back. The same
-      key carries the record's words and its page, which the notice below links. -%>
-  <div class='toast-container position-fixed bottom-0 end-0 p-3' data-turbo-temporary
-       <%= tag.attributes data: written_data %>>
-    <%# Every key here becomes a toast, whoever invented it — so the one carrying the
-        written row, which is data rather than a message, is taken out first. -%>
-    <% flash.to_hash.except(Recourse::WRITTEN).each do |key, message| -%>
-      <%# `fade show` from the server: visible at first paint, before any JavaScript.
-          The `toast` controller owns the timed hide, and hovering or focusing holds
-          the toast open while someone reads it or aims for the X. -%>
-      <div class='toast fade show <%= flash_theme key %>' role='alert' aria-live='assertive' aria-atomic='true'
-           data-controller='toast'
-           data-action='mouseenter->toast#stopTimer mouseleave->toast#startTimer focusin->toast#stopTimer focusout->toast#startTimer'>
-        <div class='toast-header border-0'>
-          <span class='me-auto'><%= written_message key, message %></span>
-          <button type='button' class='btn-close' data-bs-dismiss='toast' aria-label='Close'></button>
-        </div>
-        <div class='toast-body d-none'></div>
-      </div>
-    <% end -%>
-  </div>
-<% end -%>