layered-resource-rails 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0429425d0767f40488539bbaef1d13ef629598c52a40592ecc914d9196a6f3e7'
-  data.tar.gz: a45581d887a80412baaeab41ffc0e0310eaaeb1bd495cc11576c12d957424416
+  metadata.gz: 8bc9f9c8cd7248c93dcfe75e5af6c62e73f15e12f7a6a2092b213bbf3c5ffaf3
+  data.tar.gz: bc8992afbc303af01d63f9a0d86e01e3141e5cff9b47b4f6d61db7b7d68c560a
 SHA512:
-  metadata.gz: 7571835a600e4d34659fcfedcd6573c2593a3653fdd23f8c80fa823ea7014b3226078492b8eb217a2247ccbf500d266d77495939f07b65d5178ffed3c53e3196
-  data.tar.gz: 9e980c9c01d37611a40c6172007932e4f62ac1e58702d2a8490c5c902e920985e72a099db7a31d7b890e2a82b779806718a2e416ba32898bccebf7d5679724a0
+  metadata.gz: 91a5a65b3a8b3ac9108046f040e9b38d5ad58e79cd457343cea5d25cedf8c37a16d4077fcaf7d12f5a7da0ecbfa07e293c88169342048f82bc508df47d1606f1
+  data.tar.gz: eaf791793476475fc62b310fe841c186fb23561302aad6e26a06fe0f6f4c975de37e32f1fdc4360af9b3f1eb1ad41a48a34587af9939e5a72603ebed08246ede

data/.claude/skills/layered-resource-rails/SKILL.md

@@ -2,7 +2,7 @@
 name: layered-resource-rails
 description: Installs, configures, and builds with the layered-resource-rails gem - a Rails 8+ engine providing convention-over-configuration CRUD scaffolding with search, sort, and pagination. Use when adding layered-resource-rails to a Rails app, defining resource classes, mounting `layered_resources` routes, ejecting views or controllers, or troubleshooting setup.
 license: Apache-2.0
-compatibility: Requires Ruby on Rails >= 8.0, layered-ui-rails ~> 0.9, ransack ~> 4.0, pagy ~> 43.2
+compatibility: Requires Ruby on Rails >= 8.0, layered-ui-rails ~> 0.27, ransack ~> 4.0, pagy ~> 43.2
 metadata:
   author: layered.ai
   version: "1.0"
@@ -104,7 +104,7 @@ end
 | `model Post` | The ActiveRecord class this resource manages |
 | `columns [...]` | Index table columns. Each entry is `{ attribute:, label:, primary:, link:, render: }` |
 | `fields [...]` | Form fields for new/edit. Omit to disable CRUD forms |
-| `search_fields [...]` | Ransack attributes the index search box matches against. Association-walking entries like `:user_name` (for `belongs_to :user` + `users.name`) join into the association |
+| `search_fields [...]` | Ransack attributes the index search box matches against. Association-walking entries like `:user_name` (for `belongs_to :user` + `users.name`) join into the association. The box searches as the term is typed (debounced, into the index Turbo frame) with a clear button built into the field - no Search or Clear buttons. Typed searches `replace` history rather than pushing; the caret survives the re-render and the result count is announced |
 | `search_placeholder "..."` | Replaces the search box placeholder. Default derives from `search_fields` via `human_attribute_name`, so `activerecord.attributes.<model>.<attr>` i18n renames flow through (association walks resolve each half against its own model) |
 | `filters :a, :b, c: {...}` | Structured filter controls on the index — an "Add filter" popover plus removable tags. Control + Ransack predicate inferred per column; trailing hash overrides per attribute. See [Filters](#filters) |
 | `label_attribute :title` | Attribute a record is labelled by (page titles, row action menus, another resource's picker). Defaults to the `primary:` column, else the first. Falls back through `name`/`title`/`label`/`email`, then the model's own `to_s`, then `"Post #12"` |
@@ -112,6 +112,8 @@ end
 | `per_page n` | Pagination size (default 15) |
 | `root_breadcrumb "Home", "/"` | Static first crumb in the breadcrumb trail (e.g. back to the host app's dashboard). Without it, top-level resources render no trail; nested routes prepend it to the derived parent trail |
 
+The trail always ends with the current page (collection name on `index`, record label on `show`, `New`/`Edit` on the forms), and only that crumb carries `aria-current="page"`. Parent record crumbs link to their show page when the parent resource routes `:show`.
+
 ### Column options
 
 - `as: :type` - pins the cell to a column partial instead of the type-inferred default. Built in: `:text`, `:datetime`, `:badge`, `:boolean`; an unrecognised type raises `ArgumentError` at render time rather than rendering an empty cell. See [Column rendering](#column-rendering)
@@ -161,7 +163,7 @@ Field `as:` follows Rails' `form_with` field helpers - `:text`, `:checkbox`, `:d
 
 ### Filters
 
-`filters` declares structured index controls complementing the single free-text `search_fields` box. The UI: an **Add filter** button opens a popover listing the declared filters; picking one adds it as an unset **tag** at the end of the row (the `f[]` param tracks added tags and their order for as long as they're shown) with its controls popover already open, ready to take a value; pressing the tag's label reopens the popover, and its ✕ removes it. Short single-choice filters apply instantly via links; ranges/text/multi-selects/comboboxes apply via a small GET form. Every filter is a Ransack predicate in the URL, so filters compose with search, sort, and pagination — the search form and each filter form round-trip the other `q` params (and `f[]` entries) as hidden fields (no JavaScript; the one-shot `fo` param marks which tag's popover renders open).
+`filters` declares structured index controls complementing the single free-text `search_fields` box. The UI: an **Add filter** button opens a popover listing the declared filters; picking one adds it as an unset **tag** at the end of the row (the `f[]` param tracks added tags and their order for as long as they're shown) with its controls popover already open, ready to take a value; pressing the tag's label reopens the popover, and its ✕ removes it. Short single-choice filters apply instantly via links; ranges/text/multi-selects/comboboxes apply via a small GET form. Every filter is a Ransack predicate in the URL, so filters compose with search, sort, and pagination — the search form and each filter form round-trip the other `q` params (and `f[]` entries) as hidden fields (the one-shot `fo` param marks which tag's popover renders open). The filter controls are plain links and forms with no JavaScript; only the search box's type-to-search is scripted. Because the filters are hidden fields inside the search form, clearing the term client-side keeps them.
 
 ```ruby
 filters :status,          # enum     -> multi-select of its values  (status_in)
@@ -175,7 +177,7 @@ Inference by column type: `enum`/`belongs_to` -> multi-select (`_in`; `multiple:
 
 **Long option lists switch control.** A select-type filter renders as the plain list (multi-select: checkboxes + Apply; single-choice: instant-apply links) up to `Layered::Resource.filter_combobox_threshold` options (10), and as a type-ahead **combobox** past it — a checkbox list of every user is no way to pick one. A single-choice combobox posts a scalar (no `[]`), so `_eq` gets the value rather than an array. The count is taken per request, after a `collection:` callable resolves, so the control follows the data; the decision lives in `layered_filter_control` (the view helper), not in `resolved_filters`, for exactly that reason. Declaring `as:` pins the control and opts out: `as: :select` keeps the list however long, `as: :combobox` uses the combobox however short.
 
-**Remote options.** `url:` fetches the options from an endpoint as the user types instead of rendering a collection — such a filter is always a combobox (nothing to render or count). Give it as a callable (`-> { user_options_path }`) so it resolves per request in the view, where route helpers exist. The endpoint is an ordinary host-app action including `Layered::Ui::ComboboxOptions` and returning `l_ui_combobox_options(scope, label:, search:)` — the gem never routes it, so it's authorised however any index is. Since the browser has no collection to look a label up in, an active remote filter's values are labelled server-side from the records (same `name`/`title`/`label`/`email` fallbacks), so the tag reads "User: Alice" not "User: 12"; a `url:` over a plain column has no records and its values label themselves. `min_chars:` and `text:` pass through too; the write-side options (`create:`, `create_name:`, `reorder:`) deliberately don't — a filter picks among values that already exist.
+**Remote options.** `url:` fetches the options from an endpoint as the user types instead of rendering a collection — such a filter is always a combobox (nothing to render or count). Give it as a callable (`-> { user_options_path }`) so it resolves per request in the view, where route helpers exist. The endpoint is an ordinary host-app action including `Layered::Ui::ComboboxOptions` and returning `l_ui_combobox_options(scope, label:, search:)` — the gem never routes it, so it's authorised however any index is. Since the browser has no collection to look a label up in, an active remote filter's values are labelled server-side from the records (same `name`/`title`/`label`/`email` fallbacks), so the tag reads "User: Alice" not "User: 12"; a `url:` over a plain column has no records and its values label themselves. The label lookup is confined to records the resource's `scope(controller)` references (via the foreign key), so a hand-edited id outside it - e.g. another tenant's user - labels itself instead of leaking a name; the cost is that an in-scope option with no matching records also shows its raw id. `min_chars:` and `text:` pass through too; the write-side options (`create:`, `create_name:`, `reorder:`) deliberately don't — a filter picks among values that already exist.
 
 **The blank a combobox posts.** `l_ui_combobox` emits a leading blank hidden input so clearing every token submits an empty collection rather than omitting the key. Ransack prunes blanks from an `_in` array itself, and `layered_filter_query_params` prunes them too — an array left with nothing becomes an explicit `""`, the same shape the Clear link writes, so the tag reads as inactive *and* a `default:` doesn't immediately re-apply.
 
@@ -183,7 +185,7 @@ Override per attribute with a trailing hash: `as:` (force control type: `:select
 
 **The predicate set is closed.** Each control type maps to a fixed predicate (`:select`/`:combobox` → `_in`/`_eq`, `:boolean` → `_eq`, `:string` → `_cont`, ranges → `_gteq`+`_lteq`) and there is no `predicate:` option, so predicates Ransack can otherwise express (`_not_null`, `_matches`) aren't reachable through the DSL. In particular a **"is this set / unset" filter on a nullable timestamp** (a `locked_at`-style column) has no inferred control: `as: :boolean` emits `locked_at_eq=true`, which casts against a datetime column and matches nothing. Back the flag with a real boolean column the write path maintains, or eject the filter partials and emit the predicate yourself. Filtered attributes *are* allowlisted, so `q[locked_at_not_null]=1` works hand-typed in the URL — it just has no UI control.
 
-The bar renders inside the index Turbo frame between search box and table, built from `l_ui_popover` and the `_filters`/`_filter_control` partials — eject with `rails g layered:resource:views` to customise.
+The bar renders inside the index Turbo frame between search box and table, built from `l_ui_popover` and the `_filters`/`_filter_control` partials — eject with `rails g layered:resource:views` to customise. The search box is the `_search` partial, which calls `l_ui_search_form` in block mode with `l_ui_search_control`. Both take `live: true` (opt-in in layered-ui-rails 0.27 - it is not inferred from `turbo_frame:`, and the control defaults to `live: false` on its own), and the form passes `count: @pagy&.count` so results are announced.
 
 ## Route DSL
 

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to this project will be documented in this file. This project follows [Semantic Versioning](https://semver.org/).
 
+## [0.3.1] - 2026-10-04
+
+### Security
+
+- A remote (`url:`) `belongs_to` filter no longer labels records outside the resource's `scope`. Its current values come from the query string, and the labels for the tag and combobox tokens were looked up with an unscoped `klass.where(id: ...)`, so hand-editing the id (`?q[user_id_in][]=`) revealed the name or e-mail of any record, including another tenant's. The lookup now only reads records the resource's `scope(controller)` references through the foreign key. Any other value shows its raw id instead.
+
+## [0.3.0] - 2026-09-21
+
+### Changed
+
+- The index search box searches as the term is typed. The **Search** and **Clear** buttons are gone: the box submits into the index Turbo frame as the field changes, debounced so a typed word is one request rather than one per letter, and the field carries its own clear button - shown only once there is something to clear, and reachable by keyboard with Escape clearing the field too. A typed search `replace`s the history entry rather than pushing one, so Back leaves the index instead of replaying the term letter by letter; the term still lives in the URL, so a search stays shareable and survives a reload, and sort links, pagination and filter chips still advance.
+- With no button press to signal a change, the number of results is now announced to screen readers after each search (`count:` is passed from `@pagy`), the caret is preserved across the frame re-render so a word is never interrupted mid-letter, and the box is a labelled `search` landmark. The form still submits on Enter and works without JavaScript.
+- The two search branches on the index - one for resources with `filters`, one without - are now a single `_search.html.erb` partial, ejected by `rails g layered:resource:views` along with the rest. Because the active filters are hidden fields inside the search form, clearing the term keeps them, which is what `layered_search_clear_path` used to compute; that helper is still there for an ejected view that wants the same link.
+- Requires `layered-ui-rails` ~> 0.27, which is where the type-to-search control (`live:`, `count:`, the in-field clear button) landed.
+
+### Fixed
+
+- The breadcrumb trail ends with the page it is on - the collection name on `index`, the record's label on `show`, **New** or **Edit** on the form pages - and only that last crumb is marked `aria-current="page"`. The trail used to stop at the parent record, and because `l_ui_breadcrumb_item` marks any unlinked crumb as the current page, a nested index pointed a screen reader at its parent while `show` marked nothing at all. Crumbs now go through a `layered_breadcrumb_item` helper that lets only the current one through unlinked, and a parent record links to its own show page when its resource routes `:show`, so the middle of a trail is no longer a dead end.
+
 ## [0.2.0] - 2026-09-10
 
 ### Routing and controllers

data/README.md

@@ -45,7 +45,7 @@ curl -fsSL https://raw.githubusercontent.com/layered-ai-public/layered-resource-
 ## Requirements
 
 - Ruby on Rails >= 8.0
-- [layered-ui-rails](https://github.com/layered-ai-public/layered-ui-rails) ~> 0.25 (>= 0.25.1)
+- [layered-ui-rails](https://github.com/layered-ai-public/layered-ui-rails) ~> 0.27
 - Ransack ~> 4.0
 - Pagy ~> 43.2
 
@@ -186,6 +186,8 @@ end
 
 Nested routes prepend it to the derived parent trail (e.g. Home / Users / Alice). Pass `nil` as the path to render unlinked text.
 
+Every trail ends with the page you're on - the collection name on `index`, the record's label on `show`, `New` or `Edit` on the form pages - and that last crumb is the only one marked `aria-current="page"`. Parent crumbs never are, whether or not they link: a parent record links to its own show page when its resource routes `:show`, and renders as plain text when it doesn't.
+
 **Record label:** a record is labelled by its **primary column** (the one marked `primary: true`, else the first) wherever the gem has to name it: the `show` and `edit` page titles, a row's actions menu, and its options in another resource's picker. Declare `label_attribute` when that column isn't the record's name — a `primary:` column rendered by a `render:` proc, say:
 
 ```ruby
@@ -376,6 +378,14 @@ The Ransack allowlists are scoped to the resource: the association and the assoc
 
 A walked search field is also sortable — `q[s]=user_name asc` orders the index by `users.name` — because Ransack derives its sort allowlist from the search allowlist. Associations not declared in `search_fields` stay unsearchable and unsortable.
 
+### How the search box behaves
+
+There is no Search button to press. The box searches as the term is typed, debounced so a typed word is one request rather than one per letter, and the results re-render inside the index's Turbo frame. The field carries its own clear button, which appears once there is something to clear; Escape in the field clears it too.
+
+Each search **replaces** the history entry rather than pushing one, so Back leaves the index instead of replaying the term letter by letter. The term still lives in the URL, so a search remains shareable and survives a reload — and sort links, pagination and filter chips still push history as before.
+
+The parts that matter for accessibility are handled for you: the caret stays put across the re-render, so a word is never interrupted mid-letter; the number of results is announced to screen readers after each search, since with no button press there is otherwise nothing to say the page changed; and the box is a labelled `search` landmark. The form still submits on Enter and works without JavaScript.
+
 ### Search placeholder
 
 The index search box's placeholder is derived from `search_fields` via `human_attribute_name`, so attribute renames declared in the standard Rails i18n location flow through automatically. Given `search_fields [:title, :user_sid]`:
@@ -476,7 +486,7 @@ A counter-cache column reads straight off the parent row, so the index renders i
 
 Where `search_fields` gives a single free-text box, `filters` adds structured controls for narrowing the index by specific attributes. The UI follows the "add filter" pattern: an **Add filter** button opens a popover listing the declared filters; picking one adds it as a **tag** with its controls popover already open, ready to take a value; pressing the tag's label reopens the popover, and its ✕ removes it. Booleans and short single-choice selects apply instantly on click; multi-selects, comboboxes, ranges, and text filters have an Apply button.
 
-Under the hood every filter is a Ransack predicate in the query string, so filters compose with search, sort, and pagination — all coexist in the URL and survive each other's submits (the search form and each filter form round-trip the other params as hidden fields; no JavaScript involved). The lightweight `f[]` param records which tags were added and in what order — new tags join the end of the row (after any pinned ones) and stay put when set; a tag's ✕ removes its entry.
+Under the hood every filter is a Ransack predicate in the query string, so filters compose with search, sort, and pagination — all coexist in the URL and survive each other's submits (the search form and each filter form round-trip the other params as hidden fields). The filter controls themselves are plain links and forms, with no JavaScript involved; only the search box's type-to-search is scripted. The lightweight `f[]` param records which tags were added and in what order — new tags join the end of the row (after any pinned ones) and stay put when set; a tag's ✕ removes its entry.
 
 Declare `filters` with a list of attributes. The control and predicate are inferred from each column:
 
@@ -554,7 +564,7 @@ end
 
 A remote combobox has no collection in the browser to look a label up in, so an active filter's current values are labelled server-side from the records themselves (the same `name`/`title`/`label`/`email` fallbacks) — the tag reads "User: Alice", not "User: 12". A `url:` on a plain column has no records to read, so its values label themselves.
 
-> **Label lookups are not scoped.** Whatever scoping the `url:` endpoint applies covers the options it *serves*; it does not cover the labels. Current values arrive in the query string, and the gem labels them with an unscoped `klass.where(id: ...)` — so hand-editing `?q[user_id_in][]=` to an id outside the endpoint's scope still renders that record's label in the tag and the combobox token. This is the same position a `belongs_to` filter's default `klass.all` options take, and it discloses one label at a time; treat it as a reason not to rely on a filter's option scoping to keep an association's names or e-mail addresses private.
+Current values arrive in the query string, so they can be hand-edited to any id — and the gem can't see whatever scoping the `url:` endpoint applies. Labels are therefore only read for records the resource's own `scope` references (users with a post the viewer can see, say); any other value labels itself. A guessed `?q[user_id_in][]=` for another tenant's user shows "User: 42", not their name. The flip side is that a value from the endpoint with no matching records in scope also shows its id, next to an empty table. (A `belongs_to` filter *without* `url:` renders `klass.all` as its options — pass a scoped `collection:` if those labels are private.)
 
 `min_chars:` and `text:` pass through to `l_ui_combobox` alongside `url:`. The write-side combobox options (`create:`, `create_name:`, `reorder:`) don't: a filter picks among values that already exist.
 
@@ -590,7 +600,7 @@ filters :created_at,
 
 Pinned filters render as tags from the start, so the common ones are one click away instead of two; the **Add filter** button only renders while there are unpinned filters left to add (pin everything and it disappears). A `default:` applies whenever the request carries no state for that filter — the tag shows it as active and every link and form round-trips it explicitly from then on. Clearing a defaulted filter writes an explicit blank (`q[status_eq]=`) rather than dropping the param, so the default doesn't immediately re-apply.
 
-The filter bar renders inside the index's Turbo frame between the search box and the table; eject the views (`rails g layered:resource:views`) to customise placement — the bar is the `_filters` partial, and each control is `_filter_control`.
+The filter bar renders inside the index's Turbo frame between the search box and the table; eject the views (`rails g layered:resource:views`) to customise placement — the search box is the `_search` partial, the bar is `_filters`, and each control is `_filter_control`.
 
 ## Column rendering
 

data/app/controllers/layered/resource/controller.rb

@@ -25,6 +25,7 @@ module Layered
         helper Layered::Ui::PagyHelper
         helper Layered::Ui::BreadcrumbsHelper
         helper Layered::Resource::FiltersHelper
+        helper Layered::Resource::BreadcrumbsHelper
 
         # Hooks the route's `layout:` option in. Returning nil (the common
         # case) falls through to Rails' normal layout resolution, so routes

data/app/controllers/layered/resource/internal/breadcrumbs.rb

@@ -48,32 +48,50 @@ module Layered
 
               crumbs = []
 
-              # Link to the parent's layered index if a route exists
+              # The parent's own ancestors, filled in from the current
+              # request - needed by both of the parent's path helpers.
               if collection_entry
                 rs = collection_entry[:routes] || Rails.application.routes
+                ancestor_args = collection_entry[:parent_params].index_with { |p| params[p] }
+                ancestor_args = nil unless ancestor_args.values.all?(&:present?)
+              end
+
+              # Link to the parent's layered index if a route exists
+              if collection_entry && ancestor_args
                 helper = :"#{collection_key}_path"
                 if rs.url_helpers.method_defined?(helper)
-                  ancestor_args = collection_entry[:parent_params].each_with_object({}) do |p, h|
-                    h[p] = params[p]
-                  end
-                  if ancestor_args.values.all?(&:present?)
-                    path = rs.url_helpers.send(helper, default_url_options.merge(ancestor_args))
-                    crumbs << { label: model_class.model_name.human.pluralize, path: path }
-                  end
+                  path = rs.url_helpers.send(helper, default_url_options.merge(ancestor_args))
+                  crumbs << { label: model_class.model_name.human.pluralize, path: path }
                 end
               end
 
-              # Add the specific record breadcrumb
+              # Add the specific record breadcrumb, linked to its own show
+              # page when the parent resource has one - a crumb that isn't
+              # the current page shouldn't be a dead end.
               record = model_class.find_by(id: params[key])
               if record
                 label = record.try(:name) || record.try(:title) || "#{model_class.model_name.human} ##{record.id}"
-                crumbs << { label: label, path: nil }
+                crumbs << { label: label, path: layered_parent_record_path(collection_entry, collection_key, ancestor_args, record) }
               end
 
               crumbs
             end
           end
         end
+
+        # The parent record's show path, or nil when the parent isn't a
+        # layered resource, doesn't route :show, or can't be addressed
+        # from here.
+        def layered_parent_record_path(collection_entry, collection_key, ancestor_args, record)
+          return nil unless collection_entry && ancestor_args
+          return nil unless collection_entry[:actions].include?(:show)
+
+          rs = collection_entry[:routes] || Rails.application.routes
+          helper = :"#{collection_key.to_s.singularize}_path"
+          return nil unless rs.url_helpers.method_defined?(helper)
+
+          rs.url_helpers.send(helper, default_url_options.merge(ancestor_args).merge(id: record.to_param))
+        end
       end
     end
   end

data/app/helpers/layered/resource/breadcrumbs_helper.rb

@@ -0,0 +1,19 @@
+module Layered
+  module Resource
+    # Renders one crumb of a layered resource's breadcrumb trail.
+    #
+    # `l_ui_breadcrumb_item` marks every unlinked crumb as
+    # aria-current="page", which is only correct for the crumb that *is* the
+    # current page. A derived trail routinely carries unlinked crumbs that
+    # aren't - a parent record with no show route, an unlinked
+    # `root_breadcrumb` - so only the crumb a view flags as `current:` is
+    # passed through unlinked; the rest render as plain, uncurrent text.
+    module BreadcrumbsHelper
+      def layered_breadcrumb_item(label, path = nil, current: false)
+        return l_ui_breadcrumb_item(label, current ? nil : path) if path || current
+
+        tag.li(tag.span(label), class: "l-ui-breadcrumbs__item")
+      end
+    end
+  end
+end

data/app/helpers/layered/resource/filters_helper.rb

@@ -235,8 +235,12 @@ module Layered
         @resource.search_fields.map(&:to_s).join("_or_") + "_cont"
       end
 
-      # Clear link for the search box that drops only the search term,
-      # keeping active filters and sort.
+      # A path that drops only the search term, keeping active filters and sort.
+      #
+      # The search box no longer needs this - it clears client-side by
+      # submitting its own form with an empty field, and the filters are hidden
+      # fields inside that form, so they ride along. Kept for an ejected view or
+      # a host app that wants the same "clear just the term" link.
       def layered_search_clear_path
         layered_filter_path_with(layered_filter_query_params.except(layered_search_field_key))
       end
@@ -282,15 +286,23 @@ module Layered
 
       # Value => label for the filter's currently-set values. A remote filter
       # has no collection to read them from, so an association's are looked up
-      # by id; anything else (a remote filter over a plain column) resolves to
+      # by key; anything else (a remote filter over a plain column) resolves to
       # nothing and the value stands in for its own label.
+      #
+      # The values come straight from the query string, and the gem can't see
+      # whatever scoping the `url:` endpoint applies, so the lookup is confined
+      # to records the resource's own `scope` references: a hand-edited id for,
+      # say, another tenant's user labels itself rather than disclosing that
+      # user's name.
       def layered_filter_option_labels(filter, values)
         if filter[:url].present?
           reflection = filter[:reflection]
           return {} if reflection.nil?
 
-          reflection.klass.where(id: values)
-                    .to_h { |record| [record.id.to_s, layered_filter_record_label(record)] }
+          primary_key = reflection.association_primary_key
+          referenced = @resource.scope(controller).unscope(:order).select(reflection.foreign_key)
+          reflection.klass.where(primary_key => values).where(primary_key => referenced)
+                    .to_h { |record| [record.public_send(primary_key).to_s, layered_filter_record_label(record)] }
         else
           layered_filter_collection(filter).to_h { |label, value| [value, label] }
         end

data/app/views/layered/resource/resources/_search.html.erb

@@ -0,0 +1,24 @@
+<%# The search box. Searching happens as the term is typed (live: true), so
+    there is no Search button to press, and the field carries its own clear
+    button. live: needs the turbo_frame: to land the response in, and count:
+    so the size of the result set is announced once it has.
+
+    Any active filter and sort params ride along as hidden fields, so a search
+    composes with them rather than replacing them - which is also what makes
+    clearing the term client-side keep the filters: an empty term is submitted
+    through this same form. %>
+<div class="l-ui-mt-4">
+  <%= l_ui_search_form(@q,
+        url: layered_collection_path,
+        label: "Search #{@model.model_name.human.pluralize.downcase}",
+        live: true,
+        count: @pagy&.count,
+        turbo_frame: turbo_frame_name) do |f| %>
+    <%= layered_filter_hidden_fields(except: layered_search_field_key) if layered_filters.any? %>
+    <div class="l-ui-search-inline">
+      <%= l_ui_search_control(f, layered_search_field_key,
+            placeholder: @resource.search_placeholder,
+            live: true) %>
+    </div>
+  <% end %>
+</div>

data/app/views/layered/resource/resources/edit.html.erb

@@ -2,9 +2,10 @@
   <div>
     <%= l_ui_breadcrumbs do %>
       <% layered_breadcrumbs.each do |crumb| %>
-        <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+        <%= layered_breadcrumb_item crumb[:label], crumb[:path] %>
       <% end %>
-      <%= l_ui_breadcrumb_item @model.model_name.human.pluralize, layered_collection_path %>
+      <%= layered_breadcrumb_item @model.model_name.human.pluralize, layered_collection_path %>
+      <%= layered_breadcrumb_item "Edit", current: true %>
     <% end %>
 
     <h1 class="l-ui-heading">Edit <%= @model.model_name.human.downcase %></h1>

data/app/views/layered/resource/resources/index.html.erb

@@ -2,11 +2,14 @@
 
 <div class="l-ui-spread">
   <div>
+    <%# The trail ends on this page, so it carries aria-current - the
+        parent crumbs before it never do, linked or not. %>
     <% if layered_breadcrumbs.any? %>
       <%= l_ui_breadcrumbs do %>
         <% layered_breadcrumbs.each do |crumb| %>
-          <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+          <%= layered_breadcrumb_item crumb[:label], crumb[:path] %>
         <% end %>
+        <%= layered_breadcrumb_item @model.model_name.human.pluralize, current: true %>
       <% end %>
     <% end %>
 
@@ -29,32 +32,7 @@
 
 <%= turbo_frame_tag turbo_frame_name, data: { turbo_action: "advance" } do %>
   <% if @resource.search_fields.any? %>
-    <div class="l-ui-mt-4">
-      <% if layered_filters.any? %>
-        <%# With filters declared, the search form must round-trip the active
-            filter and sort q params as hidden fields so its submit composes
-            with them; Clear drops only the search term. %>
-        <%= l_ui_search_form(@q, url: layered_collection_path, turbo_frame: turbo_frame_name) do |f| %>
-          <%= layered_filter_hidden_fields(except: layered_search_field_key) %>
-          <%= f.label layered_search_field_key, "Search", class: "l-ui-sr-only" %>
-          <div class="l-ui-search-inline">
-            <%= f.text_field layered_search_field_key,
-                  class: "l-ui-form__field", placeholder: @resource.search_placeholder %>
-            <%= f.submit "Search", class: "l-ui-button l-ui-button--primary" %>
-            <%= link_to "Clear", layered_search_clear_path,
-                  class: "l-ui-button l-ui-button--outline",
-                  data: { turbo_frame: turbo_frame_name, turbo_action: "advance" } %>
-          </div>
-        <% end %>
-      <% else %>
-        <%= l_ui_search_form(@q,
-              url: layered_collection_path,
-              fields: @resource.search_fields,
-              placeholder: @resource.search_placeholder,
-              clear: true,
-              turbo_frame: turbo_frame_name) %>
-      <% end %>
-    </div>
+    <%= render "search", turbo_frame_name: turbo_frame_name %>
   <% end %>
 
   <% if layered_filters.any? %>

data/app/views/layered/resource/resources/new.html.erb

@@ -2,9 +2,10 @@
   <div>
     <%= l_ui_breadcrumbs do %>
       <% layered_breadcrumbs.each do |crumb| %>
-        <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+        <%= layered_breadcrumb_item crumb[:label], crumb[:path] %>
       <% end %>
-      <%= l_ui_breadcrumb_item @model.model_name.human.pluralize, layered_collection_path %>
+      <%= layered_breadcrumb_item @model.model_name.human.pluralize, layered_collection_path %>
+      <%= layered_breadcrumb_item "New", current: true %>
     <% end %>
 
     <h1 class="l-ui-heading">New <%= @model.model_name.human.downcase %></h1>

data/app/views/layered/resource/resources/show.html.erb

@@ -6,11 +6,12 @@
     <% if layered_breadcrumbs.any? || index_path %>
       <%= l_ui_breadcrumbs do %>
         <% layered_breadcrumbs.each do |crumb| %>
-          <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+          <%= layered_breadcrumb_item crumb[:label], crumb[:path] %>
         <% end %>
         <% if index_path %>
-          <%= l_ui_breadcrumb_item @model.model_name.human.pluralize, index_path %>
+          <%= layered_breadcrumb_item @model.model_name.human.pluralize, index_path %>
         <% end %>
+        <%= layered_breadcrumb_item record_label, current: true %>
       <% end %>
     <% end %>
 

data/lib/generators/layered/resource/views/views_generator.rb

@@ -16,7 +16,7 @@ module Layered
         desc "Copy the gem's view templates into app/views/layered/<name>/ for full customisation."
 
         VIEWS = %w[index.html.erb show.html.erb new.html.erb edit.html.erb
-                   _filters.html.erb _filter_control.html.erb].freeze
+                   _search.html.erb _filters.html.erb _filter_control.html.erb].freeze
 
         def copy_views
           VIEWS.each do |view|

data/lib/layered/resource/version.rb

@@ -1,5 +1,5 @@
 module Layered
   module Resource
-    VERSION = "0.2.0"
+    VERSION = "0.3.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: layered-resource-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - layered.ai
@@ -29,20 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.25.1
+        version: '0.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.25.1
+        version: '0.27'
 - !ruby/object:Gem::Dependency
   name: pagy
   requirement: !ruby/object:Gem::Requirement
@@ -223,6 +217,7 @@ files:
 - app/controllers/layered/resource/internal/columns.rb
 - app/controllers/layered/resource/internal/routing.rb
 - app/controllers/layered/resource/resources_controller.rb
+- app/helpers/layered/resource/breadcrumbs_helper.rb
 - app/helpers/layered/resource/filters_helper.rb
 - app/views/layered/resource/columns/_badge.html.erb
 - app/views/layered/resource/columns/_boolean.html.erb
@@ -230,6 +225,7 @@ files:
 - app/views/layered/resource/columns/_text.html.erb
 - app/views/layered/resource/resources/_filter_control.html.erb
 - app/views/layered/resource/resources/_filters.html.erb
+- app/views/layered/resource/resources/_search.html.erb
 - app/views/layered/resource/resources/edit.html.erb
 - app/views/layered/resource/resources/index.html.erb
 - app/views/layered/resource/resources/new.html.erb
@@ -292,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Convention-over-configuration CRUD for Rails 8+ with Ransack and Pagy built
   in.