recourse 3.0.4 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cce1478088ca8a7cd21ab9313499443eeef77727490ca582fc14c8ebf3b6708e
-  data.tar.gz: e645df54615a3e8ba34cbced95bfdd8507fe0238e498533a8aa61152285a7d7e
+  metadata.gz: 4258e3870b7a65f742563e24f02f45e2c2716bcc22666fbbb63867f70b656e71
+  data.tar.gz: 5d2ae92ccde9995457f78060fd9f22d74fd3971bae0c5de68ec7aa022e290603
 SHA512:
-  metadata.gz: 90004a8f07a6133836cd96addbf3effcba9ab62f9f8fe00711b94b64d88f332e86a3c2a92c95ae7d824a6f80667ec4f78bf39e9a05d3a3504587758edd2e0295
-  data.tar.gz: c28b768ae7d3b8b0c60aa5b36931b98af42511bd52f3ed116c54a281b6b0ec3c21cb4c6641e91c4f331955564e0ef806963975edaecd0a277ea775dcdc099661
+  metadata.gz: 343ca9a2eba9663618236339649c017f00934d3d01cf8741e6b152a8cc6c6bf17036eff91ea63f46acf5cf804e65ae7f59b68ffdf541ae1bd06e9c5dd1332793
+  data.tar.gz: 5f5946a02e7d397bec49ac1089912933f730758215ea4e18559f003a5a13522e5de587db0abb9c75d00a9fab5ba7978a73858a634bfda05956d0267c70617df0

data/CHANGELOG.md

@@ -0,0 +1,245 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+For more information about changelogs, check [Keep a Changelog](http://keepachangelog.com) and
+[Vandamme](http://tech-angels.github.io/vandamme).
+
+## 4.1.0 - 2026-09-08
+
+* [Feature] Rows with nothing in the sorted column come last
+
+  Whichever way a table is ordered — by the model's own `recourse_order`, or by the
+  heading a reader clicked — the rows with nothing in that column now come after every
+  row that has something, where the database's default put them first on a descending
+  sort. A `recourse_order` given as a Symbol or a Hash earns this; a SQL string a host
+  wrote is still taken as written, so `'size desc nulls last'` and `{ size: :desc }` now
+  say the same thing.
+
+## 4.0.0 - 2026-09-08
+
+Version 4 is a rewrite, developed under the working name `drive` and released here
+because it is the same library: the module is still `Recourse` and the entry point is
+still one word in `config/routes.rb`.
+
+Version 3 drew the routes and served one screen — a paginated, searchable index — and
+left the controller, the other six actions and every form to the host app. Version 4
+serves all seven, defines the controllers itself, and works out what each screen should
+look like by reading the model: its validators, its associations, its column types and
+its indexes. Most of what a host used to override is now something it no longer writes.
+
+* [BREAKING CHANGE] Rails 8.1 and Ruby 3.2 are the minimum; so are Pagy 43 and Ransack 4.4
+* [BREAKING CHANGE] `recourses` defines the controller as well as the routes
+
+  A host no longer writes `class PostsController < RecoursesController` for each
+  resource. The controller is defined as the route is drawn, and a host that wants one
+  of its own still writes it — the gem only fills the gap. `RecoursesController`
+  changes meaning with that: it is no longer the class each resource subclasses but the
+  one they all inherit, and a host defines it — `class RecoursesController <
+  Recourse::BaseController` — to put a `before_action` above every screen at once.
+
+* [BREAKING CHANGE] `search_field`, `search_prompt` and `searchable_fields` are no
+  longer yours to define
+
+  The search box looks through every indexed string column the table shows, plus the
+  label behind a foreign key too long to list, and says so in its own placeholder.
+
+* [BREAKING CHANGE] The Ransack hooks default to something instead of to nothing
+
+  `ransackable_attributes`, `ransackable_associations`, `ransortable_attributes` and
+  `filter_fields` are still yours to override, but a model that says nothing is now
+  fully searchable, sortable and filterable: a column is sortable when an index covers
+  it, an enum and a boolean earn a filter, and so does each `belongs_to`.
+
+* [BREAKING CHANGE] A `filter_fields` entry is keyed by the predicate and carries its
+  options: `{ 'state_id_in' => { label: 'Home state' } }`
+* [BREAKING CHANGE] `recourse_searchable?`, `recourse_sortable?`, `recourse_cachable?`
+  and `recourse_timestamps` are gone
+
+  The first two follow from the indexes. The table is a fragment keyed on the
+  relation, so caching needs no switch. `recourse_displayed` names a timestamp back.
+
+* [BREAKING CHANGE] `Recourse.resources`, `navigation_links` and `NavigableHelper` are gone
+
+  The gem draws its own sidebar from the resources `recourses` declared. An icon comes
+  from the `unicon` gem, named by `recourse_icon`, which defaults to the model's name.
+
+* [BREAKING CHANGE] `search_highlight` takes the column, not the model:
+  `search_highlight(post.content, :content)`
+* [BREAKING CHANGE] A row partial sorts with `sort_header`, not Ransack's `sort_link`
+* [BREAKING CHANGE] A row reads in the order its columns' kinds earn — state, keys,
+  words, flags, long values, dates, timestamps, counts — and the schema's order inside each
+* [BREAKING CHANGE] A link reads as its host rather than as the whole address
+* [Feature] Every action is served: index, show, new, create, edit, update and destroy
+* [Feature] A form field is chosen to suit each column, and carries the rules the
+  model's validators state — a length becomes a `maxlength`, a format becomes a
+  `pattern`, a numericality becomes a numeric keyboard
+* [Feature] An enum becomes a badge on a page and a menu in a form; a foreign key
+  becomes a menu of the records it points at, or a field to type into where there are
+  too many to list — and a typed label naming two rows is refused rather than guessed at
+* [Feature] Values are formatted by what the column holds: delimited integers, money,
+  phone numbers, a month by its name, a URL as a link, JSON as JSON, a list as a count
+  that opens, and a timestamp in the reader's own time zone saying how long ago
+* [Feature] Nested resources are drawn as tabs on the parent's card, counted where a
+  counter cache exists; a nested `create` with no index is a button on the parent
+* [Feature] Active Record Encryption is respected throughout: an encrypted column never
+  reaches a table, arrives masked on a record's own page behind a `Show`, and is offered
+  in the clear on the form that edits it
+* [Feature] A viewer keeps a row: `Recourse.bookmarks` names the viewer's rows, and every
+  table that can hold one opens with a square, kept rows first
+* [Feature] A route named `exit` gives the sidebar a log-out button
+* [Feature] Turbo drives the screens — frames, live refreshes of an open index when a row
+  changes, a delete that names what goes with it before it goes, and the row a write
+  landed on marked
+* [Feature] A reader picks how many rows a page shows, and whether the page is light or dark
+* [Feature] Bootstrap 6 and Bootstrap Icons are vendored and served by the engine, so a
+  host with no asset pipeline and no CDN still gets styled screens
+* [Feature] `Recourse.color = :purple` restyles every screen at once
+* [Feature] Model hooks: `recourse_label`, `recourse_hidden`, `recourse_displayed`,
+  `recourse_order`, `recourse_icon`, `recourse_includes`, `recourse_comment` and
+  `recourse_broadcasts?`
+* [Feature] Every string the gem shows is a key in `config/locales/recourse.en.yml`
+
+## 3.0.4 - 2026-07-24
+
+* [Feature] Add "Inquiries" icon
+
+## 3.0.3 - 2026-07-24
+
+* [Feature] Add "Agents" icon
+
+## 3.0.2 - 2026-07-23
+
+* [Feature] Add "Contacts" icon
+
+## 3.0.1 - 2026-07-22
+
+* [Feature] Add searchable_fields to models
+
+## 3.0.0 - 2026-07-22
+
+* [BREAKING CHANGE] Replace single filter_field with multiple filter_fields
+
+## 2.0.2 - 2026-07-20
+
+* [Feature] Add "Contract", "Profile", "CRM" icons
+
+## 2.0.1 - 2026-07-13
+
+* [Fix] Improve search bar responsiveness
+
+## 2.0.0 - 2026-07-13
+
+* [BREAKING CHANGE] Restyle table and search field to take advantage of Bootstrap 6
+
+## 1.4.6 - 2026-07-10
+
+* [Feature] Replace "Benches" with "Markets" icons
+
+## 1.4.5 - 2026-06-24
+
+* [Feature] Add "Benches" icons
+
+## 1.4.4 - 2026-06-24
+
+* [Feature] Add "Platforms" icons
+
+## 1.4.3 - 2026-06-24
+
+* [Feature] Add "Brands" icons
+
+## 1.4.2 - 2026-06-24
+
+* [Feature] Add common recourse icons
+* [Feature] Add common acronyms, e.g.: API, CRM, ZIP
+
+## 1.4.1 - 2026-06-23
+
+* [Fix] Remove deprecated LookupContext.find_template!
+
+## 1.4.0 - 2026-06-23
+
+* [Feature] Add navigation_links method
+
+## 1.3.5 - 2026-05-15
+
+* [Feature] Display pagy info with number delimiters
+
+## 1.3.3 - 2026-04-09
+
+* [Fix] Allow for nested resources not defined at the root level
+
+## 1.3.2 - 2026-04-09
+
+* Temporarily disable caching
+
+## 1.3.1 - 2026-04-06
+
+* [Fix] Use a different caching key based on the controller path
+
+Posts could be displayed differently under /users/:id/posts or under /topics/:id/posts
+so they should be cached separately.
+
+## 1.3.0 - 2026-04-03
+
+* [BREAKING CHANGE] Rename `search_placeholder` to `search_prompt`
+
+## 1.2.0 - 2026-03-31
+
+* [BREAKING CHANGE] `RecourseController` is now `RecoursesController`
+* [BREAKING CHANGE] "Add" button is now yield in the `content_for :actions`
+* [BREAKING CHANGE] `recourse_positionable?` is no longer supported
+* [Deprecation] `header:` parameter is no longer required in `column`.
+* [Feature] support for nested resources
+* [Feature] support for ransack searches
+
+## 1.1.0 - 2026-03-24
+
+* [BREAKING CHANGE] `recourses` only accepts one resource if a block is provided
+* [BREAKING CHANGE] `recourses` automatically sets the module for nested resources
+
+Before this change this config/routes.rb was valid:
+
+```ruby
+recourses(:users, :posts) { resources :comments }
+```
+
+and followed Rails `resources` behavior of creating **two** nested resources: `users/comments` and
+`posts/comments`. After this change, each base resource needs to be defined separately:
+
+```ruby
+recourses(:users) { resources :comments }
+recourses(:posts) { resources :comments }
+```
+
+This syntax is more explicit and allows nested resources to be defined under the parent's module.
+In other words, the previous code is equivalent to:
+
+```ruby
+resources(:users) { resources :comments, module: :users }
+resources(:posts) { resources :comments, module: :posts }
+```
+
+which allows developers to have two different controllers/actions to display a user comments
+(/users/:id/comments) or to display a post comments (/posts/:id/comments)
+
+## 1.0.2 - 2026-03-23
+
+* [BUG] Avoid Zeitweirk conflict when loading Active Record
+
+## 1.0.1 - 2026-03-10
+
+* [BUG] Only show search form when search attributes are present
+
+## 1.0.0 - 2026-03-10
+
+* [FEATURE] New `recourses` method that can be invoked inside config/routes.rb
+
+`recourses` is like `resources` on steroids for admin-only routes:
+
+- All the routes are included in `Recourse.resources` to easily display in a navbar
+- Their controllers do not need to define the `index` action: they inherit a predefined one
+- There is also a predefined `index.html` view which displays the resources paginated/searchable.
+- The content of each row can be customized defining a new `_row.html.erb` partial
+
+

data/README.md

@@ -1,33 +1,163 @@
-Recourse
-========
+# Recourse
 
-Provides a new `recourses` method that can be invoked in a Rails app inside config/routes.rb
+Admin screens for a Rails app, drawn from its models. One word in `config/routes.rb`
+serves a resource's seven actions — a paginated, searchable, sortable, filterable index
+table, a record's page, its form and its delete — with no controller, view or partial
+added to the app. What each screen shows is read off the model: its columns, its
+validators, its associations and its indexes.
 
-`recourses` is like `resources` on steroids for admin-only routes:
+Everything a host may call is listed below with a link to its reference on
+[RubyDoc](https://rubydoc.info/gems/recourse). Every default can be overridden by
+defining the same thing in the app.
 
-- All the routes are included in `Recourse.resources` to easily display in a navbar
-- Their controllers do not need to define the `index` action: they inherit a predefined one
-- There is also a predefined `index.html` view which displays the resources paginated/searchable.
-- The content of each row can be customized defining a new `_row.html.erb` partial
+## How to install
 
-How to install
-==============
+```bash
+gem install recourse
+```
 
-1. Add `gem 'recourse'` to the `Gemfile` file of your Rails app.
+```ruby
+# Gemfile
+gem 'recourse', '~> 4.0'
+```
 
-Available methods
-=================
+`~> 4.0` follows Semantic Versioning: `bundle update` takes every 4.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 — Bootstrap and its icons are vendored and served
+by the engine, so a host without an asset pipeline gets the same screens.
 
-In config/routes.rb:
+## In `config/routes.rb`
 
-- `recourses` inside the routes
+[`recourses`](https://rubydoc.info/gems/recourse/Recourse/Routes#recourses-instance_method)
+is `resources` with a controller and views supplied. It takes the same `only:` and
+`except:`, and a block nests children under the parent:
 
-In a resourceful Active Record model:
+```ruby
+scope module: :admin do
+  recourses :providers do
+    recourses :markets, only: :index               # a counted tab on each provider
+    recourses :retrievals, only: :create           # a button on each provider
+  end
+  recourses :searches, only: %i[index show new create]
+end
+```
 
-- `recourse_includes`: the associations to include when fetching the resources
-- `recourse_order`: the SQL to sort the resources by
+- Every resource with an `index` gets a sidebar entry, in routes order, with a keyboard
+  shortcut on its first letter. `only: []` declares a resource with no page of its own.
+- A nested `index` is a tab on the parent's card, counted where a `counter_cache` exists.
+- A nested `create` with no index is a button on the parent's page, named after the
+  route. The host answers it in a controller of its own, or the gem creates the record.
+- Nested controllers are namespaced after the parent (`Admin::Providers::MarketsController`),
+  and a nested index lists only the parent's rows.
+- Do you name a route `exit`? The sidebar ends with a log-out button submitting a
+  `DELETE` to it:
 
-Anywhere:
+  ```ruby
+  resource :session, only: :destroy, as: :exit
+  ```
 
-- `Recourse.resources` to list all the routes
+## In `app/controllers/recourses_controller.rb`
 
+Every controller the gem defines inherits
+[`RecoursesController`](https://rubydoc.info/gems/recourse/Recourse/BaseController),
+which the host defines to put behavior above every screen at once:
+
+```ruby
+class RecoursesController < Recourse::BaseController
+  before_action :authenticate!
+end
+```
+
+A controller the app already defines is left alone.
+
+## In `config/initializers/recourse.rb`
+
+- [`Recourse.color=`](https://rubydoc.info/gems/recourse/Recourse#color%3D-class_method):
+  which Bootstrap family is primary on every page. Readers switch light and dark themselves.
+- [`Recourse.bookmarks=`](https://rubydoc.info/gems/recourse/Recourse#bookmarks%3D-class_method):
+  a Proc answering the viewer's bookmark rows. Every table of a model with a `has_many`
+  at that class then opens with a square to keep a row by, kept rows first.
+
+```ruby
+Recourse.color = :orange
+Recourse.bookmarks = -> { Keepsake.where agent: Current.agent }
+```
+
+## In a model
+
+Every Active Record model answers these; a model overrides one in a
+[`Recoursive`](https://rubydoc.info/gems/recourse/Recourse/Recoursive) concern of its own.
+
+```ruby
+# app/models/market/recoursive.rb
+module Market::Recoursive extend ActiveSupport::Concern
+  class_methods do
+    def recourse_label = :slug                     # what a menu and a cell call one
+    def recourse_hidden = %i[callback_url payload] # off every screen
+    def recourse_displayed = :created_at           # back on the table
+    def recourse_order = { size: :desc }           # how the index sorts
+    def recourse_icon = :question                  # a Unicon concept
+  end
+end
+```
+
+| Hook | Default | Decides |
+| --- | --- | --- |
+| [`recourse_label`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_label-instance_method) | `:name` | the column a combobox shows and a foreign-key cell reads; typed rather than picked where it has a length validator |
+| [`recourse_hidden`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_hidden-instance_method) | `[]` | columns kept off the table, the page, the form and the search |
+| [`recourse_displayed`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_displayed-instance_method) | `[]` | columns a table draws that it would leave off: encrypted ones, the id, timestamps, JSON |
+| [`recourse_order`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_order-instance_method) | `:id` | the index's order, a Symbol or a Hash; rows with nothing in the column come last |
+| [`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 |
+
+What needs no hook, being read off the model:
+
+- The index eager-loads every `belongs_to` the table names, sorts by whatever an index
+  covers, searches through its indexed string columns and the labels behind its foreign
+  keys, marks what it matched, and offers a filter menu per enum, boolean and `belongs_to`.
+- Saving a row refreshes every open index of it.
+- A form field per column, carrying the rules the validators state: a length is a
+  `maxlength`, a format a `pattern`, a numericality a numeric keyboard.
+- An enum is a badge on a page and a menu on a form; a foreign key is a menu of the
+  records it points at, or a field to type the label into where there are too many.
+- Values formatted by kind: delimited integers, money, phone numbers, dates and times in
+  the reader's own time zone, a `<time>` saying how long ago, a URL as a link, a list as
+  a count that opens.
+- An encrypted column stays off the table, arrives masked on the record's page behind a
+  `Show`, and is edited in the clear.
+- The delete button names what goes with the record, counted one association down.
+
+## In `app/views`
+
+Do you want your own cells? Add `app/views/<resources>/_row.html.erb` and build it from
+[`column`](https://rubydoc.info/gems/recourse/Recourse/Helpers/Cells#column-instance_method),
+[`sort_header`](https://rubydoc.info/gems/recourse/Recourse/Helpers/Sorts#sort_header-instance_method)
+and [`search_highlight`](https://rubydoc.info/gems/recourse/Recourse/Helpers/Searches#search_highlight-instance_method):
+
+```erb
+<%# app/views/admin/providers/_row.html.erb %>
+<%# locals: (provider:) -%>
+<%= column header: sort_header(:name) do %>
+  <%= search_highlight provider.name, :name %>
+<% end %>
+<%= column header: 'Phone' do %><%= number_to_phone provider.phone %><% end %>
+```
+
+Any template or partial of the gem's is replaced by defining it in the app, under the
+resource (`app/views/admin/providers/index.html.erb`) or for every resource at once
+(`app/views/recourses/_sidebar.html.erb`). Every string the gem shows is a key under
+`recourse` in `config/locales/recourse.en.yml`, so a host rewords `Add provider` in a
+locale file of its own.
+
+## Development
+
+```bash
+bin/setup            # installs the bundle
+bundle exec rake     # the suite at 100% coverage, RuboCop, and the file-length ceiling
+cd test/dummy && bin/rails server
+```
+
+The dummy app under `test/dummy` runs on SQLite; the gem names no adapter.
+
+## License
+
+[MIT](MIT-LICENSE).

data/app/controllers/bookmarks_controller.rb

@@ -0,0 +1,7 @@
+# The superclass every bookmark controller gets. A host defines this class itself —
+# its `app/controllers` comes first — to write the row its own way, the same way it
+# redefines `RecoursesController` to guard every screen.
+class BookmarksController < Recourse::BookmarksController
+  # Empty on purpose: the behavior is the base class, so a host redefining this one
+  # loses none of it.
+end

data/app/controllers/concerns/recourse/landing.rb

@@ -0,0 +1,49 @@
+module Recourse
+  # Where a write goes once it has landed, and what the page it lands on is told about
+  # it. Apart from the actions that write, because the answer is the routes' rather than
+  # any one action's: three of them ask it, and none of them decides it.
+  module Landing
+  private
+
+    # What a write says once it has landed: the message, and the row it landed on where
+    # one survives, for the page to mark while that message stands.
+    def wrote(message, record = nil)
+      flash.notice = message
+      flash[Recourse::WRITTEN] = Recourse.row_id record if record
+      redirect_to written_url, status: :see_other
+    end
+
+    # What a rejected write does instead: the form again, with the message over it and
+    # the errors beside the fields that earned them.
+    def rejected(record, page, message)
+      return refused record, message unless Recourse.routed? controller_path, page.to_s
+
+      flash.now.alert = message
+      render page, status: :unprocessable_entity
+    end
+
+    # And where a rejection goes when there is no form to send it back to. A bare
+    # action's button stands on a page about something else, so what turned the write
+    # down is the whole of what there is to say, said where the button was.
+    def refused(record, message)
+      flash.alert = record.errors.full_messages.to_sentence.presence || message
+      redirect_to written_url, status: :see_other
+    end
+
+    # And where a write goes: the index, or — where the routes drew none — back to the
+    # record it hangs off, which for a bare action is the page its button stood on.
+    def written_url
+      return url_for action: :index if Recourse.routed? controller_path, 'index'
+
+      parent_url
+    end
+
+    # That record's own page. The path is read back from the routes rather than chopped
+    # off this controller's own: how many segments the nesting added — a `namespace`
+    # among them — is something the routes knew and a path no longer says.
+    def parent_url
+      url_for controller: "/#{Recourse.parent_of controller_path}", action: :show,
+              id: @recourse_parent
+    end
+  end
+end

data/app/controllers/concerns/recourse/list_resolution.rb

@@ -0,0 +1,28 @@
+module Recourse
+  # Resolves a submitted list back to the values it holds, for a column that keeps
+  # several of them where a form can only send one string.
+  module ListResolution
+  private
+
+    # A list is typed one value to a line and arrives as those lines, so it is split
+    # back here — the same place a typed reference is looked up, and for the same
+    # reason: no host model needs a virtual attribute and no host needs a strong
+    # parameter of its own. A line that is only spaces is not a value, and neither is
+    # an empty box: both leave the list empty rather than holding one blank string.
+    def resolve_lists(attributes)
+      list_columns.each do |column|
+        next unless attributes.key? column
+
+        attributes[column] = attributes[column].to_s.lines.filter_map do |line|
+          line.strip.presence
+        end
+      end
+
+      attributes
+    end
+
+    def list_columns
+      resource_class.column_names.select { |column| Recourse.list_column? resource_class, column }
+    end
+  end
+end

data/app/controllers/concerns/recourse/paging.rb

@@ -0,0 +1,17 @@
+module Recourse
+  # How much of a table one page shows: pagy's twenty by default, or whatever the
+  # reader picked from the menu under the table, kept in their own browser.
+  module Paging
+  private
+
+    # Checked against the two we offer rather than taken as read — a cookie is a value
+    # a stranger can write, and an unchecked one is `?limit=100000` by another route.
+    # Which is also why pagy's `max_limit` stays unset: the query string is still not
+    # asked, and this is the one thing that is.
+    def recourse_limit
+      limit = cookies[Recourse::LIMIT_STORAGE].to_i
+
+      Recourse::LIMITS.include?(limit) ? limit : Recourse::LIMITS.first
+    end
+  end
+end

data/app/controllers/concerns/recourse/parent_naming.rb

@@ -0,0 +1,24 @@
+module Recourse
+  # Names the record a nested route sits under, so a host's own view can read it.
+  module ParentNaming
+  private
+
+    # `/providers/5/openings` sets `@provider`, the way a hand-written controller would
+    # -- the contract `ResourceResolution` already keeps for the record a page is about,
+    # kept here for the one above it, and the reason a host needs no scoping concern of
+    # its own to write a form or a row that names the parent.
+    #
+    # Named from the route rather than from the association, because the two need not
+    # meet through a key: a page listing every vertical under a provider is nested by
+    # the path alone, and no `belongs_to` joins the two. What `find_parent` resolved is
+    # what gets the name, and only where it is the record the path names: a bare action
+    # has no model, and a path may name a class that answers no queries.
+    def name_parent
+      path = Recourse.parent_of controller_path
+      model = path && Recourse.model?(path)
+      return unless model && @recourse_parent.is_a?(model)
+
+      instance_variable_set "@#{model.model_name.singular}", @recourse_parent
+    end
+  end
+end

data/app/controllers/concerns/recourse/parent_resolution.rb

@@ -0,0 +1,63 @@
+module Recourse
+  # Finds the record a nested route names, so `/counties/5/zips` lists county 5's
+  # ZIPs, builds ZIPs inside it, and answers 404 when no county 5 exists.
+  module ParentResolution
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :find_parent
+    end
+
+  private
+
+    # The record a key points at where the resource has one, and otherwise the record
+    # the path names: a page nested by the path alone — the memos of a team no memo
+    # belongs to — still sits under something.
+    def find_parent
+      @recourse_parent_association = parent_association
+      @recourse_parent = @recourse_parent_association ? parent_model.find(parent_id) : path_parent
+
+      name_parent
+    end
+
+    # The record the segment above this one names, read off the routes rather than off
+    # a key, or nil where the path names nothing or the name is no model's.
+    def path_parent
+      parent = Recourse.parent_of controller_path
+      model = parent && Recourse.model?(parent)
+      return unless model
+
+      id = request.path_parameters[:"#{model.model_name.singular}_id"]
+      model.find_by id: id if id
+    end
+
+    # What the route settled and every action honours: the index lists rows carrying
+    # these columns, and `new` and `create` build records that do.
+    def parent_columns
+      return {} if @recourse_parent_association.nil?
+
+      { @recourse_parent_association.foreign_key => @recourse_parent.id }
+    end
+
+    # The belongs_to whose record the path names, or nil at the top level. Path
+    # parameters rather than `params`, so a stray `?county_id=` nests nothing.
+    def parent_association
+      own_references.find { |one| path_names? one.name }
+    end
+
+    # A host may serve a page over a verb with no class behind it, whose action the
+    # host answers itself, and a verb answers no question about keys. The routes still
+    # named a parent, and the host still finds it.
+    def own_references
+      resource_model? ? resource_class.recourse_references : []
+    end
+
+    def parent_id
+      request.path_parameters[:"#{@recourse_parent_association.name}_id"]
+    end
+
+    def parent_model = @recourse_parent_association.klass
+
+    def path_names?(name) = request.path_parameters.key?(:"#{name}_id")
+  end
+end