recourse 3.0.3 → 4.0.0

data/lib/recourse/helpers/shortcuts.rb

@@ -0,0 +1,30 @@
+module Recourse
+  module Helpers
+    # The letter each sidebar link answers to, and where in its title that letter is.
+    module Shortcuts
+    private
+
+      # The first letter of the title nothing above it has claimed, so `Contacts`
+      # answers to C and `Counties`, declared after it, answers to O. Nil where a
+      # title has no letter left to give, which leaves that entry without a shortcut.
+      def shortcut_index(title, taken)
+        index = title.each_char.find_index do |char|
+          char.match?(/[a-z]/i) && taken.exclude?(char.downcase)
+        end
+        taken << title[index].downcase if index
+
+        index
+      end
+
+      # The title with that one letter marked, for the overlay to reveal. Wrapped in
+      # one element on purpose: `.nav-link` is a flex container with a gap, so a bare
+      # span would leave the letter a flex item of its own and the word would read
+      # `C o unties`. One element is one item, and inside it the word is just a word.
+      def shortcut_title(title, key)
+        marked = tag.span title[key], class: 'recourse-key'
+
+        tag.span safe_join([title[0...key], marked, title[(key + 1)..]])
+      end
+    end
+  end
+end

data/lib/recourse/helpers/sidebars.rb

@@ -0,0 +1,39 @@
+module Recourse
+  module Helpers
+    # The sidebar: one entry per resource the routes declared, in that order, and
+    # the way out where the host drew one.
+    module Sidebars
+    private
+
+      # Whether the host drew a way out. A route named `exit` — `resource :session,
+      # only: :destroy, as: :exit` — is the whole declaration: the name is the
+      # convention, and its helper existing is what the sidebar asks.
+      def exit? = respond_to? :exit_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
+        taken = []
+
+        Recourse.declared.filter_map do |path|
+          next unless routed? path, 'index'
+
+          title = Recourse.title path
+          [
+            path, title, url_for(controller: "/#{path}", action: :index),
+            shortcut_index(title, taken),
+          ]
+        end
+      end
+
+      # True when a sidebar entry names the page being shown, or the parent a nested
+      # page sits under. The whole path, so a namespaced resource and its top-level
+      # twin are not each other.
+      def current_resource?(path)
+        here = controller.controller_path
+
+        path == here || here.start_with?("#{path}/")
+      end
+    end
+  end
+end

data/lib/recourse/helpers/sorts.rb

@@ -0,0 +1,62 @@
+module Recourse
+  module Helpers
+    # The links in a table's headings, and the caret naming the order in force.
+    module Sorts
+      # Caret for the direction a column is sorted by. A column nobody sorted by
+      # gets none: an arrow on every heading says nothing about the order in force.
+      SORT_CARETS = { 'asc' => 'caret-up-fill', 'desc' => 'caret-down-fill' }.freeze
+
+      # A heading for a column: a link that sorts the table by it where the model
+      # allows that, and the plain title everywhere else. Only the header row draws
+      # the link, so the `data-cell` on every other row stays readable text.
+      #
+      # Named apart from Ransack's `sort_link`, which it calls: sharing the name
+      # would take that helper away from every view this gem's controllers render.
+      def sort_header(column, title = nil)
+        title ||= sort_title column
+        return title unless @recourse_headers && sortable_column?(column)
+
+        sort_link resource_search, column.to_sym, hide_indicator: true, page: nil do
+          safe_join [title, sort_caret(column)].compact, ' '
+        end
+      end
+
+    private
+
+      # What the column is called — except a counter's header row, which shows the
+      # counted model's icon: the cells under it are bare figures, and the icon is what
+      # says what they count.
+      #
+      # The column's own name even where a foreign key is typed rather than picked. A
+      # form names the attribute it wants typed, `ZIP code` rather than `ZIP`, because
+      # a box has to say what goes in it; a heading stands over what a record is called
+      # and nobody types anything under it — and `Location address line 1` over a column
+      # of addresses reads as a form's question asked where there is no form.
+      def sort_title(column)
+        counted = resource_model.recourse_counters[column.to_s]
+        return counter_title counted if counted && @recourse_headers
+
+        resource_column_title column.to_s
+      end
+
+      # Whether the model lets a heading sort by this column.
+      def sortable_column?(column) = resource_model.ransortable_attributes.include?(column.to_s)
+
+      def sort_caret(column)
+        sort = resource_search.sorts.find { |one| one.name == column.to_s }
+        icon = SORT_CARETS[sort&.dir]
+        return unless icon
+
+        tag.i class: "bi bi-#{icon}"
+      end
+
+      # Carried through the form as a hidden field, so searching keeps the order a
+      # heading asked for. Ransack's own links write one sort, and write it as a
+      # string; an array from anywhere else is left behind rather than mangled.
+      def sort_param
+        sort = query_params[:s]
+        sort if sort.is_a? String
+      end
+    end
+  end
+end

data/lib/recourse/helpers/tabs.rb

@@ -0,0 +1,82 @@
+module Recourse
+  module Helpers
+    # What a nested index's tab on the parent's card reads as.
+    module Tabs
+    private
+
+      # What a nested index's tab reads as. A `has_many` of that name counts its rows
+      # and lends its icon; a route the parent has no association for is named after the
+      # path instead — a full index reached under a record. There is no model to ask
+      # then, so such a tab carries neither an icon nor a count.
+      def nested_tab_label(record, name, namespace)
+        association = nested_association record, name
+        return association_tab_label record, association, namespace if association
+
+        routed_tab_name name, namespace
+      end
+
+      def nested_association(record, name)
+        record.class.reflect_on_all_associations(:has_many).find { |one| one.name.to_s == name }
+      end
+
+      # `Messages`, and `Booked messages` where a namespace leads — the same shape
+      # the counted tab keeps. Humanized off the path, since nothing else answers.
+      def routed_tab_name(name, namespace)
+        lead = namespace_words namespace
+        title = name.humanize
+        title = Recourse.downcase title if lead.present?
+
+        [lead.presence&.upcase_first, title].compact.join ' '
+      end
+
+      # The icon is the counted model's own, whatever leads the words beside it.
+      def association_tab_label(record, association, namespace)
+        icon = Recourse.known_model_icon association.klass
+
+        words = [icon && tag.i(class: "bi bi-#{icon}"), tab_name(record, association, namespace)]
+
+        safe_join words.compact, ' '
+      end
+
+      # `8 ZIPs` where the record keeps a count — read off the record itself, no
+      # query, like the column — and the bare `ZIPs` where it keeps none. A namespace
+      # the routes drew leads either of those, so two nestings of one model read
+      # apart: `10 visited places` beside `4 booked places`, `Visited places` beside
+      # `Booked places`. Whatever leads earns the downcase, and a title that leads
+      # keeps its capital — which is what puts these beside Show and Edit.
+      def tab_name(record, association, namespace)
+        count = tab_count record, association
+        lead = [count, namespace_words(namespace)].compact_blank.join ' '
+        title = Recourse.model_title association.klass, count: count, lower: lead.present?
+
+        [lead.presence&.upcase_first, title].compact.join ' '
+      end
+
+      def tab_count(record, association)
+        column = counter_column_of record.class, association
+
+        record.attributes[column] if column
+      end
+
+      # `on_hold` reads as `on hold`, and an acronym among them keeps its capitals.
+      # A nested path split where the parent's ends: whatever the routes drew between
+      # the two — a `namespace`, usually nothing — and then the resource's own name.
+      # `admin/people/quick/memos` under `admin/people` is `memos`, led by `quick`.
+      # Both the tab and the button that stand for that route read it from here, so
+      # the two cannot disagree about which words belong to the namespace.
+      def nested_segments(nested, path)
+        namespace = nested.delete_prefix("#{path}/").split '/'
+
+        [namespace.pop, namespace]
+      end
+
+      def namespace_words(namespace)
+        namespace.map { |segment| Recourse.downcase segment.humanize }.join ' '
+      end
+
+      def counter_column_of(model, association)
+        model.recourse_counters.find { |_, one| one == association }&.first
+      end
+    end
+  end
+end

data/lib/recourse/helpers/times.rb

@@ -0,0 +1,43 @@
+module Recourse
+  module Helpers
+    # A date or a time on a page that only reads it, drawn against the reader's own
+    # clock — which is `Time.zone` here, because `Zoning` put it there.
+    module Times
+    private
+
+      # In words and in the attribute a machine reads. `l` picks the date format or the
+      # time one by what it is handed, so nothing here has to ask which it has — and a
+      # `DateTime`, which is both, still keeps its time.
+      def localized(kind, value)
+        time_tag value, l(value, format: :recourse), **relative_naming(kind, value)
+      end
+
+      # Only an instant is told how far off it is. A date is a day and a time is a time
+      # of day, and neither is a moment for `in 9 years` to count against. Beside the
+      # value rather than above it, unlike the icons that head a column: a timestamp
+      # has a row of the table above it and a value of its own page, and either is
+      # something a reader may be comparing this one against.
+      def relative_naming(kind, value)
+        return {} unless kind == :datetime
+
+        {
+          data: {
+            controller: 'relative-time tooltip', bs_placement: 'left',
+            bs_title: relative_words(value),
+          },
+        }
+      end
+
+      # Rails says how far off, never which way, so the direction is supplied here — in
+      # the wording `Intl.RelativeTimeFormat` uses, since the browser says these words
+      # again on the way to the tooltip and two spellings of one phrase read as two.
+      # It has to say them again: these are true when the page is drawn, and the page
+      # may be cached for a day.
+      def relative_words(value)
+        key = value.past? ? 'recourse.ago' : 'recourse.from_now'
+
+        t key, distance: distance_of_time_in_words_to_now(value)
+      end
+    end
+  end
+end

data/lib/recourse/helpers/values.rb

@@ -0,0 +1,64 @@
+module Recourse
+  module Helpers
+    # What one record reads as, laid out where its form's fields would be.
+    module Values
+    private
+
+      # One labelled value in the show page's grid: the heading the table gives the
+      # column, and under it what the record says, formatted the way the table's cell
+      # for the same column is — this page reads a record out, so it names its columns
+      # the way the page of every record does. `label:` overrides the heading.
+      def value(name, **options)
+        column = name.to_s
+        label = options.fetch :label, resource_column_title(column)
+
+        tag.div class: ROW do
+          safe_join [tag.div(label, class: 'form-label'), value_control(column)]
+        end
+      end
+
+      # What the record says for one column, or a dash where it says nothing. A
+      # boolean says something either way, and an icon says it, so only a value that
+      # formats to nothing at all reads as nothing.
+      def resource_value(column)
+        value = formatted_value column
+
+        value.to_s.empty? ? t('recourse.blank') : value
+      end
+
+      # Nothing to disclose is nothing to mask: an encrypted column the record has no
+      # value for reads as the dash, rather than as one asterisk hiding one.
+      def value_control(column)
+        return masked_value formatted_value(column) if masked? column
+
+        tag.div resource_value(column), class: 'form-control-plaintext'
+      end
+
+      def masked?(column)
+        encrypted_column?(column) && resource_record.attributes[column].present?
+      end
+
+      # PII is a page's to show and nobody's to leak by accident, so it arrives as one
+      # asterisk per character with the plaintext in an attribute the reveal reads: a
+      # screenshot of the page discloses nothing, and reading one value takes a click.
+      def masked_value(value)
+        options = {
+          class: 'form-control-plaintext d-flex gap-2 align-items-end',
+          data: { controller: 'reveal', reveal_plain_value: value },
+        }
+
+        tag.div(**options) { safe_join [masked_span(value), reveal_button] }
+      end
+
+      def masked_span(value)
+        tag.span '*' * value.length, data: { reveal_target: 'mask' }
+      end
+
+      def reveal_button
+        tag.button t('recourse.reveal'), type: :button,
+                                         class: 'btn btn-link btn-sm p-0',
+                                         data: { action: 'reveal#show', reveal_target: 'button' }
+      end
+    end
+  end
+end

data/lib/recourse/helpers/zones.rb

@@ -0,0 +1,38 @@
+module Recourse
+  module Helpers
+    # The menu a time zone is picked from, and the short list it opens on.
+    module Zones
+    private
+
+      # Every zone Rails knows, or the narrower list a host's own type nominates: an app
+      # serving one country has no use for the other hundred and twenty, and the type is
+      # already what the gem asks whether a column holds a zone at all.
+      #
+      # It opens on the few that type calls common, and the rest arrive behind
+      # `All time zones` the way a filter's unused options do: forty of them is a page to
+      # read, and four answer for most records.
+      def zone_combobox(form, column)
+        type = resource_model.type_for_attribute column
+        values = zone_names type, :values, ActiveSupport::TimeZone.all.map(&:name)
+        shown = zone_names type, :common, values
+
+        render 'recourses/combobox', **combobox_locals(form, column),
+                                     values: values, shown: shown,
+                                     all: zone_reveal(column, values, shown)
+      end
+
+      # What the type says, where it says anything: neither list is a question every type
+      # has an answer to, and what Rails knows is the answer when one has none.
+      def zone_names(type, name, fallback)
+        type.respond_to?(name) ? Array(type.public_send(name)) : fallback
+      end
+
+      # The line that asks for the rest of them, and nothing where there is no rest.
+      def zone_reveal(column, values, shown)
+        return unless shown.size < values.size
+
+        t 'recourse.all', models: Recourse.downcase(resource_column_title(column).pluralize)
+      end
+    end
+  end
+end

data/lib/recourse/helpers.rb

@@ -0,0 +1,81 @@
+require_relative 'helpers/actions'
+require_relative 'helpers/bookmarks'
+require_relative 'helpers/buttons'
+require_relative 'helpers/cards'
+require_relative 'helpers/cells'
+require_relative 'helpers/choices'
+require_relative 'helpers/colors'
+require_relative 'helpers/comboboxes'
+require_relative 'helpers/constraints'
+require_relative 'helpers/counters'
+require_relative 'helpers/deletions'
+require_relative 'helpers/details'
+require_relative 'helpers/examples'
+require_relative 'helpers/fields'
+require_relative 'helpers/filters'
+require_relative 'helpers/formats'
+require_relative 'helpers/inputs'
+require_relative 'helpers/kinds'
+require_relative 'helpers/limits'
+require_relative 'helpers/names'
+require_relative 'helpers/navigation'
+require_relative 'helpers/parents'
+require_relative 'helpers/pictures'
+require_relative 'helpers/references'
+require_relative 'helpers/resources'
+require_relative 'helpers/refreshes'
+require_relative 'helpers/routing'
+require_relative 'helpers/rows'
+require_relative 'helpers/schemes'
+require_relative 'helpers/searches'
+require_relative 'helpers/shortcuts'
+require_relative 'helpers/sidebars'
+require_relative 'helpers/sorts'
+require_relative 'helpers/tabs'
+require_relative 'helpers/times'
+require_relative 'helpers/values'
+require_relative 'helpers/zones'
+
+module Recourse
+  # View helpers for the pages the gem renders, and what the parts share.
+  module Helpers
+    include Actions, Bookmarks, Buttons, Cards,
+            Cells, Choices, Colors, Comboboxes, Constraints, Counters, Deletions,
+            Details,
+            Examples, Fields, Filters, Formats, Inputs, Kinds, Limits,
+            Names, Navigation, Parents, Pictures, References, Refreshes,
+            Routing,
+            Resources, Rows, Schemes, Searches, Shortcuts, Sidebars, Sorts, Tabs,
+            Times, Values, Zones
+
+    # The grid a record's own two pages lay an attribute out in: two columns on a large
+    # viewport, and the same padding on both, so a value and the field that edits it sit
+    # at the same height whichever page is open. The rule between rows belongs to the
+    # show page alone — `.recourse-values` in the layout draws it.
+    ROW = 'recourse-row pb-2 mb-3 lg:col-6'
+
+    # Bootstrap theme for each flash key, so a notice and an alert read apart.
+    FLASH_THEMES = { 'notice' => 'theme-success', 'alert' => 'theme-danger' }
+
+    # Theme for one flash entry, falling back to a neutral one for a host's key.
+    def flash_theme(key)
+      FLASH_THEMES.fetch key.to_s, 'theme-primary'
+    end
+
+  private
+
+    # What marks the row a write just landed on, and nothing at all on a page no write
+    # brought about — which is every page but the one after a create or an update.
+    def written_data
+      row = flash[Recourse::WRITTEN]
+
+      { controller: 'written', written_row_value: row } if row.present?
+    end
+
+    # `?q=anything` arrives as a String, which has no parameters to read — the
+    # same test `Recourse::Search` makes, spelled the same way.
+    def query_params
+      params[:q].is_a?(ActionController::Parameters) ? params[:q] : {}
+    end
+  end
+end

data/lib/recourse/icons.rb

@@ -0,0 +1,21 @@
+# Reopened for the one thing a drawn resource cannot answer alone: which picture it
+# is shown with, which its model names and Unicon translates.
+module Recourse
+  # What a resource is drawn with, by the name of the class a route resolves to, and
+  # nil where there is no such class -- a bare action is drawn under a word this app
+  # has no class for, and an icon is not worth raising over.
+  def self.known_icon(name)
+    model = name.to_s.split('/').last.classify.safe_constantize
+
+    known_model_icon model if model
+  end
+
+  # And for a model in hand. Nil rather than Unicon's circle where it has never heard
+  # the concept: a crumb or a tab then draws no picture at all, since the circle
+  # pictures nothing.
+  def self.known_model_icon(model)
+    concept = model.recourse_icon
+
+    Unicon[concept][:bootstrap] if Unicon.names.include? concept
+  end
+end

data/lib/recourse/limits.rb

@@ -0,0 +1,12 @@
+# Reopened for how much of a table a page shows at once.
+module Recourse
+  # Rows to a page, in the order the menu offers them: pagy's own default, and the one
+  # step up for a reader scanning a table rather than reading it. Named once — the
+  # controller checks a cookie against this list, and the menu is drawn from it.
+  LIMITS = [20, 100].freeze
+
+  # Where a reader's chosen page size is kept in their browser. A cookie rather than
+  # local storage, which the scheme is kept in: pagy runs on the server, and a cookie
+  # is the only storage the server is sent.
+  LIMIT_STORAGE = 'recourse-limit'
+end

data/lib/recourse/recoursive.rb

@@ -1,33 +1,80 @@
-# A module to manage administered resources.
+require 'active_support'
+
 module Recourse
-  # Ensures every Active Record object is compatible with recourse.
+  # Extends every Active Record model, so each one says how it is labelled, which
+  # of its columns a screen draws, what its index eager-loads and how it is sorted.
   module Recoursive
-    # Return the associations to .include when loading all the resources.
-    def recourse_includes
-      %i[]
-    end
+    # Column a combobox shows for a record, and selects alongside its id.
+    def recourse_label = :name
 
-    # Return the fields to .order when loading all the models.
-    def recourse_order
-    end
+    # The concept a resource is drawn with, which Unicon names in each icon set it
+    # knows. A model's own name by default — `contact` draws a rolodex, `job` a hammer
+    # — and Unicon answers with a circle for a name it has never heard of.
+    def recourse_icon = model_name.singular.to_sym
+
+    # Columns the model keeps off its screens — the table, the show page, the
+    # form and the search box — none by default. One name or a list:
+    # `def recourse_hidden = :name` reads as well as `%i[name title]`.
+    def recourse_hidden = []
+
+    # And the columns a table draws whatever would otherwise keep them off it —
+    # ciphertext, the id, the inheritance column, and the two
+    # timestamps. Every one of those is a default the gem picks, and a host is what
+    # answers for its own screens: `def recourse_displayed = :phone` puts a number
+    # back on a table that recognises its rows by nothing else, and
+    # `%i[created_at updated_at]` asks for the two Rails keeps rather than the two
+    # a record is about. A timestamp named here still lands last, and in that order,
+    # whichever way round it was written.
+    def recourse_displayed = []
 
-    # Return whether the content to display all the models can be cached.
-    def recourse_cachable?
-      true
+    # Columns holding a counter cache, each mapped to the association it counts. Read
+    # from the `belongs_to` on the other side, which is where `counter_cache` is
+    # declared: a column merely named `quote_count` is not one of these. Worked out
+    # once per class, the way `recourse_listable?` is: associations are declared at
+    # load and a reloaded class is a new one, with a memo of its own.
+    def recourse_counters
+      @recourse_counters ||= reflect_on_all_associations(:has_many).filter_map do |association|
+        column = association.inverse_of&.counter_cache_column
+        [column, association] if column
+      end.to_h
     end
 
-    # @return [Boolean] whether Ransack search attributes are defined on the resource.
-    def recourse_searchable?
-      ransackable_attributes.any? || ransackable_associations.any?
+    # `ZIP code`: what to call a foreign key pointing here. A form's label, a table's
+    # heading and a search prompt all name the same thing, so they name it once.
+    def recourse_reference_name
+      attribute = Recourse.downcase human_attribute_name(recourse_label)
+
+      I18n.t 'recourse.reference', model: model_name.human, attribute: attribute
     end
 
-    # @return [Boolean] whether Ransack sort attributes are defined on the resource.
-    def recourse_sortable?
-      ransortable_attributes.any?
+    # True when the label has a length, so it is short enough to be typed and a
+    # form can ask for the value instead of listing every record to pick from.
+    def recourse_typed_label?
+      validators_on(recourse_label).any? ActiveModel::Validations::LengthValidator
     end
+
+    # The belongs_to associations this gem can follow. A polymorphic key names no
+    # one table, so nothing can label it, list it, filter by it or search through
+    # it — its column reads and edits as the number it holds, like any other.
+    def recourse_references = reflect_on_all_associations(:belongs_to).reject(&:polymorphic?)
+
+    # Associations the index eager-loads, in any shape `includes` accepts. Every
+    # belongs_to it can follow, since each cell naming one would be a query of its own.
+    def recourse_includes = recourse_references.map(&:name)
+
+    # How the index sorts its rows, in any shape `order` accepts. By id by default,
+    # which is the one column every table has and the order rows were created in.
+    def recourse_order = :id
+
+    # What a column is for, said where the table itself documents it — a form draws it
+    # under the field that sets it. Read from the schema, which is the one thing here no
+    # validator can answer: a comment has nothing to disagree with. Nil where the schema
+    # says nothing, and nil on every adapter that keeps no comments at all — SQLite is
+    # one — which is why a host may answer it instead.
+    def recourse_comment(column) = columns_hash[column]&.comment
   end
 end
 
-ActiveSupport.on_load(:active_record) do
+ActiveSupport.on_load :active_record do
   extend Recourse::Recoursive
 end

data/lib/recourse/registry.rb

@@ -0,0 +1,36 @@
+# Reopened for what the routes file said, which several helpers each need read back.
+module Recourse
+  # What the routes file said, remembered: which resources were drawn, and which were
+  # nested under which.
+  # Extended onto `Recourse`, so every one of these is `Recourse.something` wherever
+  # it is called from, and every ivar below is that module's own.
+  module Registry
+    # Records a resource as declared, keeping order and ignoring a repeated draw.
+    def declare(name)
+      @declared << name.to_s unless @declared.include? name.to_s
+    end
+
+    # Records a resource nested under a parent, in routes.rb order like the sidebar's
+    # — which is what the parent record's tabs follow. Both sides are whole controller
+    # paths, so a `namespace` drawn between the two is carried rather than guessed at.
+    def nest(parent, child)
+      children = @nested[parent.to_s] ||= []
+      children << child.to_s unless children.include? child.to_s
+      @parents[child.to_s] = parent.to_s
+    end
+
+    # The resources nested under one parent path, in the order they were drawn.
+    def nested_under(parent)
+      @nested.fetch parent.to_s, []
+    end
+
+    # The path a nested resource hangs off, or nil where it hangs off nothing. Read
+    # back rather than chopped off the controller's own path: how many segments a
+    # nesting added is something the routes knew and a path no longer says.
+    def parent_of(child)
+      @parents[child.to_s]
+    end
+  end
+
+  extend Registry
+end

data/lib/recourse/routes/nested.rb

@@ -0,0 +1,36 @@
+module Recourse
+  module Routes
+    # What a `recourses` block draws around whatever the host wrote inside it: the
+    # square that keeps one of its rows.
+    module Nested
+    private
+
+      # What a resource holds: the square that keeps one of its rows, and whatever the
+      # host's own block declared — each under the resource's own module, which is what
+      # every nested page relies on.
+      def draw_within(keepable, block)
+        scope module: parent_resource.name do
+          draw_bookmark if keepable && addressable_rows?
+          instance_exec(&block) if block
+        end
+      end
+
+      # Whether this resource has rows to address one at a time. A bookmark names one
+      # row, which means nothing for a name with no class behind it at all — and one was
+      # drawn anyway, at `/placeholders/:placeholder_id/bookmark`, where nothing linked
+      # to it and anything reaching it raised.
+      def addressable_rows? = Recourse.model?(parent_resource.name).present?
+
+      # The row a table's bookmark square writes: one record kept by whoever is looking,
+      # at `/places/5/bookmark`. Deliberately not recorded through `Recourse.nest` — it
+      # would sit directly under the resource, where a tab and a bare-action button both
+      # look, and this is neither. Nothing has to remember where it hangs off either,
+      # since the gem drew it: one segment under the resource, always.
+      def draw_bookmark
+        path = [current_module, 'bookmarks'].compact.join '/'
+        Controllers.define_missing path, ::BookmarksController
+        resource :bookmark, only: %i[create destroy]
+      end
+    end
+  end
+end