recourse 7.8.2 → 7.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03ffa189dd77cb44309f61dc8a42e67fa818673f75daca4ee837aed53fb53a6b
-  data.tar.gz: 32e06a42baacce634ec2a88bc54ee585a0f7e90b740afde1dea4453db1dc737d
+  metadata.gz: '024485f23e83a52580fa55b3d73f858bf737ab1a2fd5e53819f283aaf29a57e3'
+  data.tar.gz: f1aaa536fd9085f5baa7b54cf9590d0387aa79bc65173a9ab97a853ffacbdbe9
 SHA512:
-  metadata.gz: faf5b85e985b30125c1ed657ba37a8912d236b6e1d35cd439b47fb793dd14397de66250325c75d86644b93dc122d4c8251809685cb218f2e3c438e75ec1144e0
-  data.tar.gz: e5667f606d93ec6cb0016707e758ad5aa944cf6b50c3c9a4ade70614242838639813e08b73c4ec460abe71d00e09648eb9eb6476a0825511c44c2ac86e16a017
+  metadata.gz: bbad80f3cda8598fb3773e8caad5b887aa02354a8dd2ba56f289669ae456a4ebca178830d20900cb0ec95a73c641cf95d9d47698c85654a48abd5a5eaa78214e
+  data.tar.gz: 07daefa230e19c573044eb613716eafa6d347cdeceb19e1d72af511696a458abb3e4771fb2d91f5784adb5e8053ef8f172e6f08dab09b3011acab7f6336b933c

data/CHANGELOG.md

@@ -7,6 +7,35 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 7.9.0 - 2026-09-26
+
+* [FEATURE] A pin or an area on a map leads to its row's page
+
+  Each point is sent as `[lat, lng, href, title]` and each place as `[id, href, title]`: the
+  record's own page wherever one is routed, and its label. bh's map controller makes a pin
+  or an area with an `href` clickable, following it through Turbo. Needs the bh that reads
+  these shapes: an older one still draws points, but takes a place's whole triple for its
+  ID and draws nothing, which is why this release requires bh 6.10.
+
+* [FEATURE] A route named `enter` earns the sidebar a way in
+
+  The mirror of `exit`: `get 'session/new', to: 'sessions#new', as: :enter` draws a
+  `Sign in` link beside the toggle, to wherever the host signs people in. A host that
+  signs people in shows one or the other by answering `enter?` and `exit?` itself.
+
+* [FEATURE] A bookmarks Proc answering nil draws no bookmark column
+
+  A visitor who never signed in has nowhere to keep a row, so `Recourse.bookmarks =
+  -> { Current.user&.bookmarks }` leaves them without the squares rather than raising.
+
+## 7.8.3 - 2026-09-21
+
+* [FIX] A delete button in a table row is no taller than the row
+
+  The button kept `.btn`'s minimum height of 2rem, half again the line the other cells
+  read at, so every row of a table with a delete column stood taller than the rows of a
+  table without one.
+
 ## 7.8.2 - 2026-09-20
 
 * [CHANGE] The retrieval button says what it does

data/README.md

@@ -2,6 +2,10 @@
 
 Swap two characters in your `config/routes.rb` and get awesome admin screens for your Rails app.
 
+This README is the tour. The [guides](https://claudiob.github.io/recourse/guides/) are
+where every screen is explained in full, one page each, and the
+[reference](https://rubydoc.info/gems/recourse) is built from the source.
+
 ## How to install
 
 ```bash
@@ -10,10 +14,10 @@ gem install recourse
 
 ```ruby
 # Gemfile
-gem 'recourse', '~> 6.0'
+gem 'recourse', '~> 7.0'
 ```
 
-`~> 6.0` follows Semantic Versioning: `bundle update` takes every 6.x and never a
+`~> 7.0` follows Semantic Versioning: `bundle update` takes every 7.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
@@ -39,7 +43,8 @@ first letter, and a paginated, searchable, sortable, filterable index table:
 <img width="3824" height="2274" alt="Image" src="https://github.com/user-attachments/assets/f952d3e5-c320-464b-b166-77c7ab8f9071" />
 
 Every recourse with `show` gets a detail page where attributes are displayed with the appropriate
-formatting, or masked if sensitive:
+formatting — a boolean as `Yes` or `No`, a date by its name, a key as the label of what it
+points at — or masked if sensitive:
 
 <img width="3824" height="2274" alt="Image" src="https://github.com/user-attachments/assets/515f63c4-8a9b-422e-95c4-88d6647911d8" />
 
@@ -47,73 +52,48 @@ Every recourse with `new` or `edit` gets a form with appropriate browser formatt
 
 <img width="3824" height="1220" alt="Image" src="https://github.com/user-attachments/assets/ebe5108b-bbd1-4cd1-a635-89eef0e6fc50" />
 
-Every recourse with `destroy` gets a button with a detailed confirmation message — on its
-edit page, or on each row of its table where no `edit` is routed:
+Every recourse with `destroy` gets a button with a detailed confirmation message — on the
+record's own page, whichever of `show` and `edit` is open, and on each row of its table
+where no `edit` page would carry it. A row a model will not give up stays, and the page says so
+rather than raising. A model may word its own deletion — `Disconnect` rather than
+`Delete` — by writing `recourse.models.<model>.delete` in its locale:
 
 [image]
 
-`recourse` draws what Rails' `resource` draws, and the gem records it the same way: one
-record reached with no id of its own, at `/locations/5/property`. Rails routes a singular
-resource to a plural controller, so `Locations::PropertiesController` answers it, and the
-gem reads the record off the parent under the name the route gives — `location.property`,
-whether the parent keeps it with a `has_one` or points at one with a `belongs_to`. Where
-the parent has no association of that name the record is still yours to find, with a
-`find_resource` of your own.
-
-What such a nesting earns on the parent's card depends only on what it routes. Routed
-`show`, it earns a tab reading the model's own word in the singular, pointing at that one
-page. Routed `create` or `destroy` and neither `index` nor `new`, it earns a button beside
-the breadcrumb instead — `Add property`, `Delete property` — and which of the two it
-offers is the record's to say: nothing to add where there is already one, nothing to
-delete where there is none. A write has no index to return to, so it lands on the
-record's own page: a singular resource is the collection of one.
-
-Filters are drawn per enum, per boolean and per foreign key. A model adds one the schema
-says nothing about — the type behind a `has_one`, a word reached through another table —
-by naming the words itself, and naming the menu too, since there is no column to head it:
-
-```ruby
-def self.filter_fields
-  super.merge 'integration_type_in' => { label: 'CRM', values: Integration.selectable }
-end
-```
-
-Naming the words is not leave to query through a table, so `ransackable_associations`
-still says how far Ransack may reach.
-
-Every nested recourse gets namespaced after the parent:
+Every nested recourse gets namespaced after the parent, and a tab on the parent's card:
 
 <img width="3824" height="2274" alt="Image" src="https://github.com/user-attachments/assets/9b242335-a25b-4fa8-8023-422538d235b0" />
 
+`recourse` draws what Rails' `resource` draws: one record reached with no id of its own,
+at `/locations/5/property`, read off the parent under the name the route gives —
+`location.property`, whether the parent keeps it with a `has_one` or points at one with
+a `belongs_to`. What such a nesting earns on the parent's card depends only on what it
+routes: a tab where `show` is, and a button beside the breadcrumb — `Add property`,
+`Delete property` — where `create` or `destroy` is routed with no page of its own. A
+singular resource holds at most one, so `new` sends a reader to the record where there
+already is one, and `show` sends them to the form where there is none yet.
+
+Two keywords say what a table may do beyond the seven actions. `positionable: true`
+draws the route a dragged row reports its place to, and `retrievable: true` draws the
+one a `Retrieve` button on the table posts to, for rows that came from somewhere else.
+Both are refused on a resource with no `index`, since there is nowhere for either to
+stand. The [routes guide](https://claudiob.github.io/recourse/guides/routes.html) has
+the rest: namespaces, the defaults a nested resource takes, and the `enter` and `exit`
+routes that earn the sidebar a sign-in link and a log-out button.
 
 ## Step 2. Enhance your models
 
-To change the content displayed in the `index` table of a model, override any of these class methods:
+To change what a model's screens show, override any of these class methods:
 
 | 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`, or the positioned column | the index's order, a Symbol or a Hash; rows with nothing in the column come last |
 | [`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`.
+| [`recourse_includes`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_includes-instance_method) | every `belongs_to` | what the index eager-loads, in any shape `includes` takes |
+| [`recourse_broadcasts?`](https://rubydoc.info/gems/recourse/Recourse/Broadcasting#recourse_broadcasts%3F-instance_method) | `true` | whether saving a record redraws every open index listing it |
 
 For instance, this would yield a more compact `index` than the default configuration:
 
@@ -121,14 +101,35 @@ For instance, this would yield a more compact `index` than the default configura
 class Post < ActiveRecord::Base
   def self.recourse_label = :title                    # Label a post with its title
   def self.recourse_hidden = %i[ip_address]           # Hide the IP address from the views
-  def self.recourse_displayed = :created_at           # Display the created_at in the views
   def self.recourse_order = { published_at: :desc }   # Sort posts by last published first
   def self.recourse_icon = :question                  # Represent Posts with a question icon
 end
-````
+```
 
 [image]
 
+What the schema already says needs nothing declared. 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. An
+enum is a badge on a page, a menu on a form and a filter beside the search box, and so
+is a boolean and every foreign key whose table is short enough to list. An encrypted
+column stays off every table, arrives masked on the record's page and is offered in the
+clear on its form. A `has_one_attached` is a file field and a picture; a
+`has_many_attached :photos` is a page of its own once `recourses :photos` is routed
+under the record.
+
+Filters are drawn per enum, per boolean and per foreign key. A model adds one the schema
+says nothing about — a word reached through another table — by naming the predicate,
+and the gem reads the words off the model behind it:
+
+```ruby
+def self.filter_fields = super + %i[team_name_in]
+```
+
+Naming a filter is not leave to query through a table, so `ransackable_associations`
+still says how far Ransack may reach — and a filter Ransack will not answer is refused
+while the page draws rather than left to narrow nothing.
+
 ## Step 3. Delete your views
 
 If you are happy with the generated HTML files, then be happy to skip this step!
@@ -153,6 +154,12 @@ to define the columns you want:
 
 [image]
 
+A `_fields.html.erb` replaces the fields of a form the same way, and a `show`, `edit` or
+nested `index` template of your own replaces the body of that page and nothing else:
+the card, its tabs, the buttons beside the breadcrumb and the tab's title are the
+layout's, so a page you write is its content alone. A page that wants the width to
+itself assigns `@recourse_card = false`.
+
 ## Step 4. Secure your controllers
 
 Every controller the gem defines inherits
@@ -165,14 +172,15 @@ class RecoursesController < Recourse::BaseController
 end
 ```
 
-A controller the app already defines is left alone.
-
+A controller the app already defines is left alone, and one line of it is usually
+enough: `recourse_relation` puts a scope of your own behind a table the gem draws
+whole, and `find_resource` finds a singular record the parent names no association for.
 
 ## Step 5. Enjoy the extras
 
-The rest of what the gem offers, in four parts. The first two are a line each in
-`config/initializers/recourse.rb`; the last two need nothing beyond what the model
-already declares.
+The rest of what the gem offers. The first two are a line each in
+`config/initializers/recourse.rb`; the others need nothing beyond what the model
+already declares, or one keyword in the routes.
 
 ### Color and theme
 
@@ -189,7 +197,8 @@ Recourse.theme = :nord
 
 The theme is where a reader starts, not where they stay. The moon at the foot of the
 sidebar rotates through every palette, light and dark, and the one they pick stays in
-their browser.
+their browser. Times are drawn in the reader's own zone the same way, reported by their
+browser and never written to the host.
 
 ### Bookmarks
 
@@ -202,151 +211,50 @@ Recourse.bookmarks = -> { Keepsake.where agent: Current.agent }
 
 A Proc rather than a relation, because at boot the viewer is nobody. Every model with a
 `has_many` at that class then opens its table with a square to keep a row by, and kept
-rows come first. A model that cannot hold a bookmark gets no column.
+rows come first. A model that cannot hold a bookmark gets no column, and neither does a
+visitor the Proc answers nil for — somebody who never signed in has nowhere to keep one.
 
 <img width="3824" height="1220" alt="Image" src="https://github.com/user-attachments/assets/d1db4adb-0b5c-4e41-8bb6-cf72a35288f0" />
 
-### Attachments
-
-What a model keeps as files needs nothing declared either. A `has_one_attached :logo` is
-a file field on the form and, on the record's page, the picture Active Storage makes of
-the file — 100 pixels tall, WebP where the browser takes it, opening the whole file in a
-new tab — or the file's name where nothing can be drawn of it.
-
-A `has_many_attached :photos` earns a page of its own, nested under the record:
-
-```ruby
-recourses :photos, only: %i[index destroy]
-```
-
-That page is a table of the files with their pictures, and a Delete on each row that
-takes the file off the record. Files are added on the record's own form, where a chosen
-file joins a shelf and replaces a single one, and a field nobody touched leaves
-everything as it was. `recourse_hidden :photos` keeps a file off every screen the way it
-keeps a column off.
-
-Drawing a picture of an image needs `image_processing`; video and PDF also need the
-host's `ffmpeg` and `poppler`.
-
-### Maps
+### Maps and calendars
 
 A table whose model keeps a `google_place_id`, or a `latitude` and a `longitude`, can be
 read as a Google map of the same page: the footer under it offers `Display as map`, and
 `/counties.map` draws this page's rows in the frame and over the footer the table has, so
-search, sort and pages work the same on either shape.
-
-A point is a pin. A place ID is filled in as an area where the model is a geography
-Google draws boundaries for — a `State`, a `County`, a `City` or a `ZIP`, by name — and
-pinned at the place for any other model.
-
-The key and the map ID are the host's own credentials:
-
-```yaml
-# config/credentials.yml.enc
-google_maps:
-  api_key: AIza…
-  map_id: 4f2a…
-```
-
-The map's style has the matching **Feature layers** turned on in the Cloud console —
-Postal code for ZIPs, Administrative area level 2 for counties. A host with a Content
-Security Policy allows `maps.googleapis.com` for scripts and connections, and Google's
-tile hosts for images.
-
-
-### Calendars
-
-A table whose model keeps a `starts_at` and an `ends_at` can be read as a week of the same
-rows: the footer offers `Display as calendar`, and `/shifts.cal` draws a column a day with
-each row placed by the hours it runs between — rows that overlap in lanes of their own.
-A row says what it is, whoever it points at, and the hours themselves, each led to its own
-page where the routes drew one.
-
-```ruby
-recourses :shifts
-```
-
-A week rather than a page is what a calendar shows, so there is nothing to paginate:
-`?week=2026-09-13` moves to the week holding that day, and `<<`, `<`, `>` and `>>` stand
-where the pages stand under a table — a week either side and four weeks beyond each —
-with the week named between them. The search and the
-filters travel with it — and answer in the shape they were picked in — so a calendar
-narrowed to one person stays a narrowed calendar as the weeks move.
-
-The grid stands as tall as a table's own first page, so the weeks under a calendar sit
-where the pages under a table do. The week opens on Sunday and the hours are the reader's
-own — the same cookie every other
-time on these pages is drawn against — and the scale runs only over the hours that week's
-rows cover, or a working day where it holds none. A row running past midnight is drawn on
-the day it opens, down to the foot of its column.
-
-Both columns have to be datetimes, asked through `type_for_attribute`, so an
-`attribute :starts_at, :datetime` override counts and a column of another kind named
-`starts_at` earns nothing.
+search, sort and pages work the same on either shape. The key and the map ID are the
+host's own credentials, under `google_maps` as `api_key` and `map_id`.
 
+A table whose model keeps a `starts_at` and an `ends_at` can be read as a week of the
+same rows: the footer offers `Display as calendar`, and `/shifts.cal` draws a column a
+day with each row placed by the hours it runs between. `?week=2026-09-13` moves to the
+week holding that day, and the search and the filters travel with it.
 
 ### Positionable tables
 
 A table whose model keeps an integer `position` is one a reader puts in order by hand: a
-grip opens each row, dragging it moves the row, and the place it lands in is written to a
-route drawn under the index. Say where that route belongs, since a page nobody drags needs
-none:
-
-```ruby
-recourses :steps, positionable: true
-```
-
-A table is put in order from its index and from nowhere else, so the keyword is refused on
-a resource that draws none. The column decides the rest — the grips, the callbacks, and
-`recourse_order`, since the order a table is read in and the order somebody put it in are
-one fact.
+grip opens each row, dragging it moves the row, and the place it lands in is written to
+the route `positionable: true` drew under the index. The column decides the rest — the
+grips, the callbacks that keep the numbers running 1, 2, 3, and `recourse_order`, since
+the order a table is read in and the order somebody put it in are one fact. A model
+pointing two ways says which of them its place is counted within:
 
 ```ruby
 class Step < ActiveRecord::Base
   belongs_to :team
   belongs_to :person
 
-  # A step points two ways, so which of them its place is counted within is the model's
-  # to say. One `belongs_to` needs no answer, and a model pointing nowhere is positioned
-  # among the whole table.
   def recourse_siblings = team.steps
 end
 ```
 
-Two things follow the column rather than the routes. A new row lands last among its own
-and the gap closes behind one that goes, whether it was made behind a form or in a
-console: what a drop reports is a row's place on the *page*, which is a position only
-while the numbers run 1, 2, 3 with no holes in them. And a table being positioned is asked
-per page — a position means something under the parent it is counted within, so a flat
-model's own index is positioned and a listing of every row across every parent is not.
-
-The search box and the sorted headings stand down while the grips are drawn, and a `q`
-typed by hand is refused for the same reason: a filter shortens the page, and a drop on a
-shortened page reports a place among the rows that are left.
-
-A host that keeps the order itself writes `def recourse_position = nil`, which takes the
-grips off the table and the two callbacks off the model together. A host with a *second*
-listing of a positioned model — a plan's place among its service's plans, and another
-among every plan of its department — names the second column on the controller instead,
-and owns the write as well as the page:
-
-```ruby
-module Departmental
-  extend ActiveSupport::Concern
-
-private
-
-  def recourse_position = 'ordering'
-end
-
-class Administered::Departments::Plans::PositionsController < Recourse::PositionsController
-  include Departmental
-end
-```
-
-`Recourse::Positioning` is public for exactly that case: `new(relation, column).close` is
-what such a host calls to keep its own column contiguous.
+### Retrievable tables
 
+A table whose rows come from somewhere else — a CRM, a feed — offers to fetch them
+again: `recourses :visits, only: :index, retrievable: true` draws
+`POST /providers/5/visits/retrieval` and the `Retrieve` button that posts to it. Where
+the rows come from is the host's to know, so `Providers::Visits::RetrievalsController`
+is the host's to write, and `recourse_retrievable?` on the listing controller is how a
+page says there is nothing to fetch from.
 
 ## Development
 

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

@@ -51,6 +51,14 @@
     </div>
     <%# Submitted by the browser rather than by Turbo: a log out ends with a redirect to
         wherever the host signs people in, which is another origin a fetch cannot follow. -%>
+    <%# The way in, where the host drew a route named `enter`: a link, since what it
+        leads to is a form rather than a change. -%>
+    <% if enter? %>
+      <%= link_to enter_path, class: 'nav-link border-0 bg-transparent' do %>
+        <i class='bi bi-box-arrow-in-right'></i>
+        <span class='recourse-foot-word'><%= t 'recourse.enter' %></span>
+      <% end %>
+    <% end %>
     <% if exit? %>
       <%= button_to exit_path, method: :delete, class: 'nav-link border-0 bg-transparent',
                     form: { data: { turbo: false } } do %>

data/config/locales/recourse.en.yml

@@ -53,6 +53,7 @@ en:
     deleted_error: "%{model} could not be deleted."
     destroy: Delete
     exit: Exit
+    enter: Sign in
     displaying:
       one: Displaying 1 item
       other: Displaying %{count} items

data/lib/recourse/bookmarks.rb

@@ -17,7 +17,8 @@ module Recourse
   # would run a host's Proc long before there is a request for it to read.
   def self.bookmarks? = !@declared_bookmarks.nil?
 
-  # The viewer's bookmarks, resolved for this request.
+  # The viewer's bookmarks, resolved for this request, or nil where the Proc answered
+  # nil: nobody is looking whose rows could be kept, a visitor who never signed in.
   def self.bookmarks
     bookmarks = @declared_bookmarks
     bookmarks = bookmarks.call if bookmarks.respond_to? :call
@@ -28,10 +29,11 @@ module Recourse
   # How a model's bookmarks point back at it: its own `has_many` at the bookmark
   # class, which is both the opt-in and everything needed to write one. A model that
   # cannot hold a bookmark has not declared one, so it gets no column.
+  # And none for a viewer the Proc named nobody, who has nowhere to keep a row.
   def self.bookmarks_for(model)
     return unless bookmarks?
 
-    klass = bookmarks.klass
+    klass = bookmarks&.klass or return
     model.reflect_on_all_associations(:has_many).find { |one| one.klass == klass }
   end
 

data/lib/recourse/helpers/actions.rb

@@ -73,17 +73,18 @@ module Recourse
         url_for controller: "/#{resource_controller_path}", action: action, id: record
       end
 
-      # The icon alone, red for what it does, and the same warning the edit page's button
-      # carries in front of it, which the bundle draws as its dialog. Out of the frame
-      # the table is drawn in, like every other action in the row: what a delete lands on
-      # is a whole page with a message over it, and answering inside the frame would keep
-      # the table and throw the message away.
+      # The icon alone, red for what it does, no taller than the line the row reads at,
+      # and the same warning the edit page's button carries in front of it, which the
+      # bundle draws as its dialog. Out of the frame the table is drawn in, like every
+      # other action in the row: what a delete lands on is a whole page with a message
+      # over it, and answering inside the frame would keep the table and throw the
+      # message away.
       def destroy_button(record)
         path = url_for controller: "/#{destroy_action_path}", action: :destroy, id: 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',
+                          class: 'btn btn-sm btn-link btn-icon p-0 min-h-0',
                           aria: { label: t('recourse.delete', model: resource_name) },
                           form: { data: { turbo_frame: '_top' } }
       end

data/lib/recourse/helpers/maps.rb

@@ -15,23 +15,38 @@ module Recourse
       end
 
       # The places, with the layer they are areas on — pins where the model is no geography
-      # — or the points, where a model keeps no place.
+      # — or the points, where a model keeps no place. Each carries where its row leads and
+      # what it is called, so a pin or an area is clicked through to the record the way the
+      # row's own link in the table is.
       def map_rows(recourses)
         return { map_points_value: map_points(recourses) } unless Recourse.placed? resource_model
 
         {
           map_boundary_value: Recourse.boundary(resource_model)&.to_s&.upcase,
-          map_places_value: recourses.filter_map { |one| one.attributes[Recourse::PLACE_COLUMN] },
+          map_places_value: map_places(recourses),
         }
       end
 
-      # Only a row with both halves is a point; one with either missing is nowhere.
+      # Each place as `[id, href, title]`, for a row that names one.
+      def map_places(recourses)
+        recourses.filter_map do |one|
+          place = one.attributes[Recourse::PLACE_COLUMN]
+          [place, *map_lead(one)] if place
+        end
+      end
+
+      # Each point as `[lat, lng, href, title]`. Only a row with both halves is a point; one
+      # with either missing is nowhere.
       def map_points(recourses)
         recourses.filter_map do |one|
           point = one.attributes.values_at(*Recourse::POINT_COLUMNS)
-          point.map(&:to_f) if point.all?
+          [*point.map(&:to_f), *map_lead(one)] if point.all?
         end
       end
+
+      # Where a row's pin leads, the record's own page wherever one is routed, and what the
+      # pin says on hover: nothing to lead to where no page is.
+      def map_lead(record) = [resource_action_path(:show, record), Recourse.record_title(record)]
     end
   end
 end

data/lib/recourse/helpers/sidebars.rb

@@ -10,6 +10,13 @@ module Recourse
       # convention, and its helper existing is what the sidebar asks.
       def exit? = respond_to? :exit_path
 
+      # And the way in, its mirror: a route named `enter` — `resource :session, only:
+      # :new, as: :enter`, or a `get` of the host's own — earns a link beside the toggle
+      # to wherever the host signs people in. A link rather than a button, since asking
+      # for a form to sign in with changes nothing. Whether a viewer who already signed
+      # in still sees it is the host's to say, by answering this for them.
+      def enter? = respond_to? :enter_path
+
       # Sidebar entries as [name, title, path, key], in the order routes.rb declares
       # them, `key` being where in the title the letter that reaches it sits.
       def sidebar_resources

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 = '7.8.2'
+  VERSION = '7.9.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recourse
 version: !ruby/object:Gem::Version
-  version: 7.8.2
+  version: 7.9.0
 platform: ruby
 authors:
 - claudiob
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.7'
+        version: '6.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.7'
+        version: '6.10'
 - !ruby/object:Gem::Dependency
   name: pagy
   requirement: !ruby/object:Gem::Requirement