recourse 7.3.0 → 7.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f6b6c7f06985a9e98ef9544e3f7494dca418d4a962fe9c1690d20e05b057104
-  data.tar.gz: 9ea935c4fb5c7b1ad8d37f4d0001dc3c0d59e0f5b50b8d383bfa49c9441db7d1
+  metadata.gz: 28a482b8977d87fe680f8b1bff7502998e09202d1c5e95364746cc01b9c92596
+  data.tar.gz: a8fdb47ce0906854dd0164ac638d8d43155ca9d5561b3f47641c100b326113bf
 SHA512:
-  metadata.gz: a146580b87daa86917b16a3fab8c2029f0d72d2ccf40a877550537b1c058e87caa294f6d66996909a0398585191e3d70e70a835e4dd606eca08d14afea1c5803
-  data.tar.gz: 37a1dcaa862e424001eddfccf0018951bb62ccf6762c7c2d19995946f1fb72fca99ce7047c82f586b4154a9af080aa167e5a38edb9b4641902011b6dd12d1fa2
+  metadata.gz: b03910594792d293f48c138e3ebc186527fa8e08b4784a8c45924479290342ff83776775d508222b7b127b4d7dad5d19f24c5d6b08e9ad46df8be6aff418bfc3
+  data.tar.gz: e6951d50584a7d913f575caeaa4e141d842e990902abee2326e65080b382587ec416cdedc73bf136265a3d5902374b3b5250546c1cdddd7d0513b5b4a16bdd86

data/CHANGELOG.md

@@ -7,6 +7,33 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 7.5.0 - 2026-09-20
+
+* [FEATURE] A model may word its own deletion
+
+  Deleting is not what every model does when a row goes: an account is disconnected, a
+  note is withdrawn. Both the button and the heading over the dialog now read
+  `recourse.models.<model>.delete` and `recourse.models.<model>.deletion_title` where a
+  host wrote them, and the one word the gem has where nobody did. Keyed off the record's
+  own class, so a subclass words it apart from its siblings — and a slash in an i18n key
+  is a nesting, so `integration/jobber` sits under `integration` in the locale.
+
+## 7.4.0 - 2026-09-20
+
+* [CHANGE] A singular resource that has its record reads it rather than offering a form
+
+  `new` drew a form for a second record where the parent already kept one. At most one is
+  what singular means, so the reader is sent to the page that reads it — the mirror of the
+  redirect that already sent them to `new` when there was none yet. Before the action
+  rather than inside it, so a host writing its own `new` gets it too.
+
+* [FIX] Every file in the gem is under a hundred lines again
+
+  Seven of them had grown past it. Each split along a seam it already had: web addresses
+  out of `Formats`, the trail out of `Navigation`, the counter lookups into `Counters`,
+  what a form sent into `ParameterResolution`, and which columns a screen uses apart from
+  what order they read in.
+
 ## 7.3.0 - 2026-09-20
 
 * [CHANGE] A boolean reads as the word a reader answers with

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

@@ -0,0 +1,31 @@
+module Recourse
+  # Resolves what a form sent: the attributes a record may be written with, read back
+  # from what the route names and what the model lets a screen set.
+  module ParameterResolution
+  private
+
+    # What a form may submit: every column a user may set, less the ones the model
+    # keeps off its screens. The other thing a host overrides, and for the same
+    # reason as `recourse_relation` — a form of its own asks for what it asks for,
+    # which may be a hidden column or an attribute that is no column at all:
+    # `def resource_params = params.expect(provider: %i[name cid])`.
+    def resource_params
+      # The parent is merged after resolving, so the one the route names is never
+      # mistaken for a label; the files go no further than the permit that let them
+      # through, being attached rather than assigned.
+      submitted_attributes.except(*Recourse.attachment_names(resource_class))
+                          .merge parent_columns
+    end
+
+    # What the form sent, with a typed reference read back as the id it names. A bare
+    # `Create` submits no attributes at all, so the key may be absent: the parent a
+    # nested route names is everything such a record starts from.
+    def submitted_attributes
+      permitted = Recourse.editable_columns(resource_class) + attachment_filters
+      key = controller_name.singularize.to_sym
+      return {} unless params.key? key
+
+      resolve_lists resolve_references(params.expect(key => permitted))
+    end
+  end
+end

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

@@ -33,6 +33,18 @@ module Recourse
       redirect_to url_for(action: :new) if Recourse.routed? controller_path, 'new'
     end
 
+    # And the other way, before a form is drawn: a singular resource holds at most one,
+    # so where the parent already keeps it there is nothing for `new` to make and the
+    # page that reads it answers instead. The mirror of `missing_record`, which sends a
+    # reader here when there is none yet. Where no `show` is drawn the form stands, that
+    # being the only page the routes gave this record.
+    def redirect_to_existing_record
+      return unless singular_reflection && Recourse.routed?(controller_path, 'show')
+      return unless @recourse_parent.association(singular_reflection.name).reader
+
+      redirect_to url_for(action: :show)
+    end
+
     def assign(record)
       @recourse = record
       instance_variable_set "@#{controller_name.singularize}", record
@@ -76,29 +88,5 @@ module Recourse
 
       resource_class.model_name.human
     end
-
-    # What a form may submit: every column a user may set, less the ones the model
-    # keeps off its screens. The other thing a host overrides, and for the same
-    # reason as `recourse_relation` — a form of its own asks for what it asks for,
-    # which may be a hidden column or an attribute that is no column at all:
-    # `def resource_params = params.expect(provider: %i[name cid])`.
-    def resource_params
-      # The parent is merged after resolving, so the one the route names is never
-      # mistaken for a label; the files go no further than the permit that let them
-      # through, being attached rather than assigned.
-      submitted_attributes.except(*Recourse.attachment_names(resource_class))
-                          .merge parent_columns
-    end
-
-    # What the form sent, with a typed reference read back as the id it names. A bare
-    # `Create` submits no attributes at all, so the key may be absent: the parent a
-    # nested route names is everything such a record starts from.
-    def submitted_attributes
-      permitted = Recourse.editable_columns(resource_class) + attachment_filters
-      key = controller_name.singularize.to_sym
-      return {} unless params.key? key
-
-      resolve_lists resolve_references(params.expect(key => permitted))
-    end
   end
 end

data/app/controllers/recourse/base_controller.rb

@@ -4,7 +4,7 @@ module Recourse
   # with a `before_action :authenticate!` guards every screen the gem serves.
   class BaseController < ApplicationController
     include Pagy::Method, Positioned, AttachmentResolution, AttachmentWriting,
-            Landing, Paging, ListResolution, ParentNaming,
+            Landing, Paging, ListResolution, ParameterResolution, ParentNaming,
             ParentResolution, ReferenceResolution, ResourceResolution,
             Weeks, Zoning
 
@@ -13,6 +13,10 @@ module Recourse
     # `find` raises RecordNotFound, so an id that names nothing answers 404.
     before_action :find_resource, only: %i[show edit update destroy]
 
+    # Before the form rather than inside `new`, so a host that writes its own still
+    # sends a reader to the record a singular resource already has.
+    before_action :redirect_to_existing_record, only: :new
+
     # The model behind the page, assigned once, and only where the route names one.
     before_action { @recourse_model = resource_class if resource_model? }
 

data/lib/recourse/bands.rb

@@ -0,0 +1,80 @@
+# Reopened for the order a row reads in, which a table, a show page and a form all ask
+# for the same way.
+module Recourse
+  # Which part of a row a column belongs to. What a column holds is the gem's to know
+  # and where the schema put it is the host's, so both have a say: the kind picks the
+  # band, and the order inside the band is the one the table already has. Extended onto
+  # `Recourse`, so this is `Recourse.ordered` wherever it is called from.
+  module Bands
+    # The bands, in the order a row reads. What kind of row this is and what state it is
+    # in, whose it is, what it says, its flags, the long values a narrow column suits
+    # least, when it happened, the two Rails keeps — and last of all the counts, which
+    # say nothing about the row itself, only how much hangs off it. So they close the
+    # row at the far edge rather than opening it beside the buttons they resemble.
+    #
+    # A flag follows what the row says rather than leading it. A yes or a no is narrow
+    # enough to have led on width alone, but it reads as a note *about* the row, and a
+    # reader scanning a table is looking for the name it belongs to first.
+    BANDS = %i[state reference scalar boolean long date timestamp counter].freeze
+
+    # Values that are paragraphs rather than words, under every name an adapter has for
+    # them: PostgreSQL reports `jsonb` where SQLite and MySQL report `json`.
+    LONG_KINDS = %i[text json jsonb].freeze
+
+    # And the ones that are a point in time, whichever part of one they keep.
+    DATE_KINDS = %i[date datetime time].freeze
+
+    # Whether a column holds a list of values rather than one. A PostgreSQL array
+    # reports a type wrapping a subtype, and so does a `serialize` of an Array; asked
+    # that way rather than by an adapter's own class, which only exists where that
+    # adapter is loaded. But wrapping a subtype is not enough on its own: an enum and a
+    # range always answered the same way, and since Rails 8.2 so does every decorator
+    # a column may wear — time zone conversion on a timestamp, `normalizes`, a lock. What
+    # sets a list apart is that its value is changed in place, which `Mutable` marks and
+    # none of those are.
+    def list_column?(model, column)
+      type = model.type_for_attribute column
+
+      type.respond_to?(:subtype) && type.is_a?(ActiveModel::Type::Helpers::Mutable)
+    end
+
+    # The columns of a model in the order a row reads them, given whichever of them the
+    # caller is drawing. Grouped rather than sorted: `group_by` keeps the order it was
+    # given inside each group, which is what leaves an order the schema already carries
+    # standing, and `sort_by` would not — Ruby's sort is not stable.
+    def ordered(model, names)
+      keys = reference_keys model
+
+      names.group_by { |name| BANDS.index band(model, name, keys) }.sort.flat_map(&:last)
+    end
+
+  private
+
+    # Asked in the order that settles it. A counter is one whatever it is stored as; the
+    # column Rails keeps a subclass in says what kind of row this is, as an enum says
+    # what state it is in; and a key is an integer, so it has to be recognised as a key
+    # before its type is asked about at all.
+    def band(model, name, keys)
+      return :counter if Recourse.counters(model).key? name
+      return :state if name == model.inheritance_column || model.defined_enums.key?(name)
+      return :timestamp if TIMESTAMPS.include? name
+      return :reference if keys.include? name
+
+      band_of model.type_for_attribute(name).type
+    end
+
+    def band_of(kind)
+      return :boolean if kind == :boolean
+      return :long if LONG_KINDS.include? kind
+      return :date if DATE_KINDS.include? kind
+
+      :scalar
+    end
+
+    def reference_keys(model)
+      model.recourse_references.map { |reference| reference.foreign_key.to_s }
+    end
+  end
+
+  extend Bands
+end

data/lib/recourse/columns.rb

@@ -1,5 +1,5 @@
-# Reopened for the order a row reads in, which a table, a show page and a form all ask
-# for the same way.
+# Reopened for which columns a screen uses at all, which the table, the show page and
+# the form each ask before they ask what order to read them in.
 module Recourse
   # Columns the database writes itself out of the others, which a form never offers: a
   # stored generated column takes no value, and Postgres refuses the one a form would send.
@@ -9,80 +9,30 @@ module Recourse
     model.columns.select(&:virtual?).map(&:name)
   end
 
-  # Which part of a row a column belongs to. What a column holds is the gem's to know
-  # and where the schema put it is the host's, so both have a say: the kind picks the
-  # band, and the order inside the band is the one the table already has. Extended onto
-  # `Recourse`, so this is `Recourse.ordered` wherever it is called from.
-  module Columns
-    # The bands, in the order a row reads. What kind of row this is and what state it is
-    # in, whose it is, what it says, its flags, the long values a narrow column suits
-    # least, when it happened, the two Rails keeps — and last of all the counts, which
-    # say nothing about the row itself, only how much hangs off it. So they close the
-    # row at the far edge rather than opening it beside the buttons they resemble.
-    #
-    # A flag follows what the row says rather than leading it. A yes or a no is narrow
-    # enough to have led on width alone, but it reads as a note *about* the row, and a
-    # reader scanning a table is looking for the name it belongs to first.
-    BANDS = %i[state reference scalar boolean long date timestamp counter].freeze
-
-    # Values that are paragraphs rather than words, under every name an adapter has for
-    # them: PostgreSQL reports `jsonb` where SQLite and MySQL report `json`.
-    LONG_KINDS = %i[text json jsonb].freeze
-
-    # And the ones that are a point in time, whichever part of one they keep.
-    DATE_KINDS = %i[date datetime time].freeze
-
-    # Whether a column holds a list of values rather than one. A PostgreSQL array
-    # reports a type wrapping a subtype, and so does a `serialize` of an Array; asked
-    # that way rather than by an adapter's own class, which only exists where that
-    # adapter is loaded. But wrapping a subtype is not enough on its own: an enum and a
-    # range always answered the same way, and since Rails 8.2 so does every decorator
-    # a column may wear — time zone conversion on a timestamp, `normalizes`, a lock. What
-    # sets a list apart is that its value is changed in place, which `Mutable` marks and
-    # none of those are.
-    def list_column?(model, column)
-      type = model.type_for_attribute column
-
-      type.respond_to?(:subtype) && type.is_a?(ActiveModel::Type::Helpers::Mutable)
-    end
-
-    # The columns of a model in the order a row reads them, given whichever of them the
-    # caller is drawing. Grouped rather than sorted: `group_by` keeps the order it was
-    # given inside each group, which is what leaves an order the schema already carries
-    # standing, and `sort_by` would not — Ruby's sort is not stable.
-    def ordered(model, names)
-      keys = reference_keys model
-
-      names.group_by { |name| BANDS.index band(model, name, keys) }.sort.flat_map(&:last)
-    end
-
-  private
-
-    # Asked in the order that settles it. A counter is one whatever it is stored as; the
-    # column Rails keeps a subclass in says what kind of row this is, as an enum says
-    # what state it is in; and a key is an integer, so it has to be recognised as a key
-    # before its type is asked about at all.
-    def band(model, name, keys)
-      return :counter if Recourse.counters(model).key? name
-      return :state if name == model.inheritance_column || model.defined_enums.key?(name)
-      return :timestamp if TIMESTAMPS.include? name
-      return :reference if keys.include? name
-
-      band_of model.type_for_attribute(name).type
-    end
-
-    def band_of(kind)
-      return :boolean if kind == :boolean
-      return :long if LONG_KINDS.include? kind
-      return :date if DATE_KINDS.include? kind
-
-      :scalar
-    end
+  # Columns a user may set: the form offers these, the show page reads these out, and
+  # `create` permits these. A counter cache is none of a user's business — Rails keeps
+  # it, so a form that offered one would let it be typed over, and neither is a column
+  # the database generates: it takes no value at all.
+  def self.editable_columns(model)
+    ordered model, model.column_names - ['id', *TIMESTAMPS] - counters(model).keys -
+                   hidden_columns(model) - virtual_columns(model)
+  end
 
-    def reference_keys(model)
-      model.recourse_references.map { |reference| reference.foreign_key.to_s }
-    end
+  # Columns no screen shows: whatever the model asked to hide through `recourse_hidden`
+  # — one name or a list, taken either way — the column Rails reserves for single table
+  # inheritance, and the place a row holds where somebody positioned the table. A class
+  # name is machinery rather than something to read out, and a position is set by
+  # dragging the row rather than typed beside it.
+  def self.hidden_columns(model)
+    Array(model.recourse_hidden).map(&:to_s) +
+      [model.inheritance_column, *position_columns(model)]
   end
 
-  extend Columns
+  # The names a column is validated under: its own, and — where it is a foreign key
+  # — the association's, since `belongs_to` validates the record it points at rather
+  # than the number pointing there. Two questions where a column is a key, one
+  # everywhere else.
+  def self.validated_names(column)
+    [column, column.delete_suffix('_id')].uniq
+  end
 end

data/lib/recourse/helpers/breadcrumbs.rb

@@ -0,0 +1,58 @@
+module Recourse
+  module Helpers
+    # The trail across the navbar: what each crumb reads, and which of them lead
+    # anywhere.
+    module Breadcrumbs
+    private
+
+      # Trail to the current page as [resource, title, path] triples, opening with
+      # the parent a nested page sits under; a nil path is not a link.
+      def resource_breadcrumbs
+        crumbs = parent_breadcrumbs
+        leaf = breadcrumb_leaf
+        here = controller.controller_path
+        return crumbs << [here, breadcrumb_name, nil] unless leaf
+
+        crumbs << [here, breadcrumb_name, index_url] << [nil, leaf, nil]
+      end
+
+      # What the crumb naming this resource reads: its plural, or its singular where
+      # the routes drew one record rather than a list. Rails routes a singular resource
+      # to a plural controller, so the path says `properties` for the one property a
+      # location keeps -- and the crumb over it would read `HouseCanaries` for a page
+      # there is only ever one of. The same word the tab leading here took, from the
+      # same place, since the two stand for one page.
+      def breadcrumb_name
+        return resources_name unless idless_route? controller.controller_path, 'show'
+
+        Recourse.known_singular controller.controller_name
+      end
+
+      # Where this resource's index is, or nil where it has none: a singular resource
+      # is one record reached with no id, so there is no list of it to go back to and
+      # the crumb naming it is read out rather than linked.
+      def index_url
+        url_for action: :index if routed_action? 'index'
+      end
+
+      # A crumb's words, which a phone drops where the icon stands for them: the row at
+      # the top has a search box and a button to fit beside the trail.
+      def crumb_label(resource, title)
+        icon = Recourse.known_icon resource
+        return title unless icon
+
+        word = tag.span title, class: 'recourse-crumb-word'
+
+        safe_join [tag.i(class: "bi bi-#{icon}"), word], ' '
+      end
+
+      # Only a page beneath the index names itself, and names what it is showing.
+      def breadcrumb_leaf
+        case controller.action_name
+        when 'new', 'create' then t 'recourse.new', model: resource_name
+        when 'show', 'edit', 'update' then resource_record_label
+        end
+      end
+    end
+  end
+end

data/lib/recourse/helpers/cells.rb

@@ -68,7 +68,7 @@ module Recourse
       # `Created`, not `Created at`, since when it happened is what the column holds.
       def dated_title(column)
         title = resource_model.human_attribute_name column
-        dated = column.end_with?('_at', '_on') && Columns::DATE_KINDS.include?(attribute_type(column))
+        dated = column.end_with?('_at', '_on') && Bands::DATE_KINDS.include?(attribute_type(column))
 
         dated ? title.sub(/ (at|on)\z/, '') : title
       end

data/lib/recourse/helpers/counters.rb

@@ -74,6 +74,24 @@ module Recourse
 
         safe_join [icon, tag.span(title, class: 'recourse-counter-word')]
       end
+
+      # The counter a tab reads. A `has_many through:` keeps none of its own, and the
+      # join it goes through usually does: a market's ZIPs are reached through its
+      # territories, and `territories_count` is the number of them it holds. The figure
+      # is of the join rows, which is what the record actually keeps a count of.
+      def counter_column_of(model, association)
+        counter_of(model, association) || counter_of(model, join_of(model, association))
+      end
+
+      def counter_of(model, association)
+        Recourse.counters(model).find { |_, one| one == association }&.first if association
+      end
+
+      def join_of(model, association)
+        name = association.options[:through]
+
+        model.reflect_on_association name if name
+      end
     end
   end
 end

data/lib/recourse/helpers/deletions.rb

@@ -3,13 +3,6 @@ module Recourse
     # The button that deletes the record a form is showing, and the warning it puts
     # in front of whoever clicked it.
     module Deletions
-      # `dependent:` values that take the children with the parent.
-      DESTROYED = %i[destroy destroy_async].freeze
-
-      # And the one that keeps them, holding the key open. Anything else — a bare
-      # `has_many`, a `:restrict` — is left unsaid rather than guessed at.
-      NULLIFIED = %i[nullify].freeze
-
     private
 
       # The record a page may delete: the one it is about, on its own look or its own
@@ -26,68 +19,37 @@ module Recourse
         path = record && destroy_resource_path(record)
         return unless path
 
-        confirm_button_to t('recourse.delete', model: resource_name), path,
+        confirm_button_to destroy_label(record), path,
                           confirm: destroy_warning(record), method: :delete,
                           class: 'btn btn-sm btn-solid theme-danger ms-3',
                           form_class: 'd-inline-block'
       end
 
-      # @api private
-      # What deleting this record takes with it, counted a level down and no further:
-      # a state reaches counties, then ZIPs, then locations, and counting that far
-      # would join 40,965 rows to draw one page.
-      def destroy_warning(record)
-        lines = [t('recourse.deletion.title', record: destroy_title(record)), nil]
-
-        [*lines, *dependent_lines(record), nil, t('recourse.deletion.undone')].join "\n"
-      end
-
-      def destroy_resource_path(record)
-        return unless routed_action? 'destroy'
-
-        url_for action: :destroy, id: record
-      end
-
-      # The middle of the warning, in the order it reads: what goes, what stays, and
-      # only then what is under what goes — the levels this stops short of counting.
-      def dependent_lines(record)
-        going = dependents record, DESTROYED
-        staying = dependents record, NULLIFIED
-        lines = []
-        lines << t('recourse.deletion.going', list: going.to_sentence) if going.any?
-        lines << staying_line(staying) if staying.any?
-        lines << t('recourse.deletion.under') if going.any?
-
-        lines
+      # The word on the button, and below it the word over the dialog. A model that
+      # undoes something rather than deleting it says so under its own name, and every
+      # other model falls through to the one word the gem has. Keyed off the record's
+      # class rather than the resource's, so a subclass words it apart from its
+      # siblings: an integration a provider authorized is disconnected where the one an
+      # admin picked is given up.
+      def destroy_label(record)
+        t worded(record, :delete), model: resource_name, default: :'recourse.delete'
       end
 
-      def staying_line(staying)
-        t 'recourse.deletion.staying', list: staying.to_sentence, model: resource_name
+      def destroy_heading(record)
+        t worded(record, :deletion_title), record: destroy_title(record),
+                                           default: :'recourse.deletion.title'
       end
 
-      def dependents(record, kinds)
-        record.class.reflect_on_all_associations(:has_many).filter_map do |association|
-          next if association.through_reflection || kinds.exclude?(association.options[:dependent])
-
-          dependent_count record, association
-        end
+      # A slash in the key is a nesting to i18n, which is what lets a subclass sit
+      # under the model it inherits from rather than beside it.
+      def worded(record, name)
+        :"recourse.models.#{record.model_name.i18n_key}.#{name}"
       end
 
-      # `association.reader` rather than a method named at runtime, and `count` rather
-      # than loading them: the warning needs how many, never which.
-      def dependent_count(record, association)
-        count = record.association(association.name).reader.count
-        return if count.zero?
-
-        name = Recourse.downcase association.klass.model_name.human
-
-        "#{number_with_delimiter count} #{name.pluralize count}"
-      end
+      def destroy_resource_path(record)
+        return unless routed_action? 'destroy'
 
-      # What the record is called, or what it is, for one that answers to no label.
-      def destroy_title(record)
-        record.attributes[record.class.recourse_label.to_s].presence ||
-          record.class.model_name.human
+        url_for action: :destroy, id: record
       end
     end
   end

data/lib/recourse/helpers/formats.rb

@@ -2,11 +2,6 @@ module Recourse
   module Helpers
     # How one attribute reads on a page that only reads it.
     module Formats
-      # One absolute web address and nothing else: a value to follow, not to read.
-      # Anything around it — words, a second address — reads as text instead. What it
-      # captures is what a link says: the host, less any `www.`, and whatever follows.
-      WEB_URL = %r{\Ahttps?://(?:www\.)?([^/?#\s]+)(\S*)\z}
-
     private
 
       # What the record says for one column, formatted by what the column holds.
@@ -85,25 +80,6 @@ module Recourse
       def phone_span(value) = value && tag.span(value, data: { controller: 'phone' })
 
       def enum_badge(value) = tag.span(value, class: 'badge')
-
-      def web_url?(value) = value.is_a?(String) && value.match?(WEB_URL)
-
-      # The words lead where the value points, in this tab, the way any link does; the
-      # arrow after them — Bootstrap's icon link, stepping under the cursor — opens the
-      # same address in a new tab. Either reads as the host, and an ellipsis where the
-      # address goes further: a path is how a machine finds the page, and the href has it.
-      def url_link(value)
-        host, rest = value.match(WEB_URL).captures
-        said = rest.delete_suffix('/').empty? ? host : "#{host}/…"
-
-        safe_join [tag.a(said, href: value), new_tab_arrow(value)], ' '
-      end
-
-      def new_tab_arrow(value)
-        tag.a icon_tag(:point_right), href: value, target: '_blank', rel: 'noopener',
-                                      class: 'icon-link icon-link-hover',
-                                      aria: { label: t('recourse.new_tab') }
-      end
     end
   end
 end

data/lib/recourse/helpers/links.rb

@@ -0,0 +1,33 @@
+module Recourse
+  module Helpers
+    # A value that is a web address rather than words: how one is recognised, and how
+    # it reads once it is.
+    module Links
+      # One absolute web address and nothing else: a value to follow, not to read.
+      # Anything around it — words, a second address — reads as text instead. What it
+      # captures is what a link says: the host, less any `www.`, and whatever follows.
+      WEB_URL = %r{\Ahttps?://(?:www\.)?([^/?#\s]+)(\S*)\z}
+
+    private
+
+      def web_url?(value) = value.is_a?(String) && value.match?(WEB_URL)
+
+      # The words lead where the value points, in this tab, the way any link does; the
+      # arrow after them — Bootstrap's icon link, stepping under the cursor — opens the
+      # same address in a new tab. Either reads as the host, and an ellipsis where the
+      # address goes further: a path is how a machine finds the page, and the href has it.
+      def url_link(value)
+        host, rest = value.match(WEB_URL).captures
+        said = rest.delete_suffix('/').empty? ? host : "#{host}/…"
+
+        safe_join [tag.a(said, href: value), new_tab_arrow(value)], ' '
+      end
+
+      def new_tab_arrow(value)
+        tag.a icon_tag(:point_right), href: value, target: '_blank', rel: 'noopener',
+                                      class: 'icon-link icon-link-hover',
+                                      aria: { label: t('recourse.new_tab') }
+      end
+    end
+  end
+end

data/lib/recourse/helpers/navigation.rb

@@ -1,39 +1,9 @@
 module Recourse
   module Helpers
-    # Helpers for the navbar: the trail across it, and the links and forms it draws.
+    # The links and forms the navbar draws, and where each of them goes.
     module Navigation
     private
 
-      # Trail to the current page as [resource, title, path] triples, opening with
-      # the parent a nested page sits under; a nil path is not a link.
-      def resource_breadcrumbs
-        crumbs = parent_breadcrumbs
-        leaf = breadcrumb_leaf
-        here = controller.controller_path
-        return crumbs << [here, breadcrumb_name, nil] unless leaf
-
-        crumbs << [here, breadcrumb_name, index_url] << [nil, leaf, nil]
-      end
-
-      # What the crumb naming this resource reads: its plural, or its singular where
-      # the routes drew one record rather than a list. Rails routes a singular resource
-      # to a plural controller, so the path says `properties` for the one property a
-      # location keeps -- and the crumb over it would read `HouseCanaries` for a page
-      # there is only ever one of. The same word the tab leading here took, from the
-      # same place, since the two stand for one page.
-      def breadcrumb_name
-        return resources_name unless idless_route? controller.controller_path, 'show'
-
-        Recourse.known_singular controller.controller_name
-      end
-
-      # Where this resource's index is, or nil where it has none: a singular resource
-      # is one record reached with no id, so there is no list of it to go back to and
-      # the crumb naming it is read out rather than linked.
-      def index_url
-        url_for action: :index if routed_action? 'index'
-      end
-
       # A link out of a table. Every cell is inside the results frame, and the page a
       # cell links to has no frame of that name, so Turbo would replace the table with
       # `Content missing` rather than leaving the page. `_top` is what leaves it.
@@ -77,25 +47,6 @@ module Recourse
 
         safe_join [tag.i(class: "bi bi-#{icon}"), tag.span(name, class: 'recourse-nav-word')], ' '
       end
-
-      # The same for a crumb, whose words a phone drops where the icon stands for them:
-      # the row at the top has a search box and a button to fit beside the trail.
-      def crumb_label(resource, title)
-        icon = Recourse.known_icon resource
-        return title unless icon
-
-        word = tag.span title, class: 'recourse-crumb-word'
-
-        safe_join [tag.i(class: "bi bi-#{icon}"), word], ' '
-      end
-
-      # Only a page beneath the index names itself, and names what it is showing.
-      def breadcrumb_leaf
-        case controller.action_name
-        when 'new', 'create' then t 'recourse.new', model: resource_name
-        when 'show', 'edit', 'update' then resource_record_label
-        end
-      end
     end
   end
 end

data/lib/recourse/helpers/tabs.rb

@@ -90,24 +90,6 @@ module Recourse
       def namespace_words(namespace)
         namespace.map { |segment| Recourse.downcase segment.humanize }.join ' '
       end
-
-      # The counter a tab reads. A `has_many through:` keeps none of its own, and the
-      # join it goes through usually does: a market's ZIPs are reached through its
-      # territories, and `territories_count` is the number of them it holds. The figure
-      # is of the join rows, which is what the record actually keeps a count of.
-      def counter_column_of(model, association)
-        counter_of(model, association) || counter_of(model, join_of(model, association))
-      end
-
-      def counter_of(model, association)
-        Recourse.counters(model).find { |_, one| one == association }&.first if association
-      end
-
-      def join_of(model, association)
-        name = association.options[:through]
-
-        model.reflect_on_association name if name
-      end
     end
   end
 end

data/lib/recourse/helpers/warnings.rb

@@ -0,0 +1,68 @@
+module Recourse
+  module Helpers
+    # What a deletion is said to cost before it is made: the heading over the dialog,
+    # and what the row takes with it or leaves behind.
+    module Warnings
+      # `dependent:` values that take the children with the parent.
+      DESTROYED = %i[destroy destroy_async].freeze
+
+      # And the one that keeps them, holding the key open. Anything else — a bare
+      # `has_many`, a `:restrict` — is left unsaid rather than guessed at.
+      NULLIFIED = %i[nullify].freeze
+
+    private
+
+      # @api private
+      # What deleting this record takes with it, counted a level down and no further:
+      # a state reaches counties, then ZIPs, then locations, and counting that far
+      # would join 40,965 rows to draw one page.
+      def destroy_warning(record)
+        lines = [destroy_heading(record), nil]
+
+        [*lines, *dependent_lines(record), nil, t('recourse.deletion.undone')].join "\n"
+      end
+
+      # The middle of the warning, in the order it reads: what goes, what stays, and
+      # only then what is under what goes — the levels this stops short of counting.
+      def dependent_lines(record)
+        going = dependents record, DESTROYED
+        staying = dependents record, NULLIFIED
+        lines = []
+        lines << t('recourse.deletion.going', list: going.to_sentence) if going.any?
+        lines << staying_line(staying) if staying.any?
+        lines << t('recourse.deletion.under') if going.any?
+
+        lines
+      end
+
+      def staying_line(staying)
+        t 'recourse.deletion.staying', list: staying.to_sentence, model: resource_name
+      end
+
+      def dependents(record, kinds)
+        record.class.reflect_on_all_associations(:has_many).filter_map do |association|
+          next if association.through_reflection || kinds.exclude?(association.options[:dependent])
+
+          dependent_count record, association
+        end
+      end
+
+      # `association.reader` rather than a method named at runtime, and `count` rather
+      # than loading them: the warning needs how many, never which.
+      def dependent_count(record, association)
+        count = record.association(association.name).reader.count
+        return if count.zero?
+
+        name = Recourse.downcase association.klass.model_name.human
+
+        "#{number_with_delimiter count} #{name.pluralize count}"
+      end
+
+      # What the record is called, or what it is, for one that answers to no label.
+      def destroy_title(record)
+        record.attributes[record.class.recourse_label.to_s].presence ||
+          record.class.model_name.human
+      end
+    end
+  end
+end

data/lib/recourse/helpers.rb

@@ -3,6 +3,7 @@ require_relative 'helpers/positions'
 require_relative 'helpers/attachments'
 require_relative 'helpers/blobs'
 require_relative 'helpers/bookmarks'
+require_relative 'helpers/breadcrumbs'
 require_relative 'helpers/buttons'
 require_relative 'helpers/calendars'
 require_relative 'helpers/cards'
@@ -24,6 +25,7 @@ require_relative 'helpers/formats'
 require_relative 'helpers/inputs'
 require_relative 'helpers/kinds'
 require_relative 'helpers/limits'
+require_relative 'helpers/links'
 require_relative 'helpers/maps'
 require_relative 'helpers/names'
 require_relative 'helpers/navigation'
@@ -45,20 +47,20 @@ require_relative 'helpers/spans'
 require_relative 'helpers/tabs'
 require_relative 'helpers/times'
 require_relative 'helpers/values'
+require_relative 'helpers/warnings'
 require_relative 'helpers/weeks'
 require_relative 'helpers/zones'
 
 module Recourse
   # View helpers for the pages the gem renders, and what the parts share.
   module Helpers
-    include Actions, Positions, Attachments, Blobs, Bookmarks, Buttons, Calendars, Cards,
-            Cells, Choices, Colors, Comboboxes, Constraints, Counters, Deletions, Densities,
-            Details,
-            Events, Examples, Fields, Filters, Flashes, Formats, Inputs, Kinds, Limits, Maps,
-            Names, Navigation, Parents, Pictures, Previews, References, Refreshes,
-            Routing,
-            Resources, Rows, Searches, Shapes, Shortcuts, Sidebars, Sorts, Spans, Tabs,
-            Themes, Times, Values, Weeks, Zones
+    include Actions, Positions, Attachments, Blobs, Bookmarks, Breadcrumbs, Buttons,
+            Calendars, Cards, Cells, Choices, Colors, Comboboxes, Constraints, Counters,
+            Deletions, Densities, Details, Events, Examples, Fields, Filters, Flashes,
+            Formats, Inputs, Kinds, Limits, Links, Maps, Names, Navigation, Parents,
+            Pictures, Previews, References, Refreshes, Routing, Resources, Rows, Searches,
+            Shapes, Shortcuts, Sidebars, Sorts, Spans, Tabs, Themes, Times, Values,
+            Warnings, Weeks, 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

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.3.0'
+  VERSION = '7.5.0'
 end

data/lib/recourse.rb

@@ -11,6 +11,7 @@ require_relative 'recourse/blobs'
 require_relative 'recourse/bookmarks'
 require_relative 'recourse/calendars'
 require_relative 'recourse/colors'
+require_relative 'recourse/bands'
 require_relative 'recourse/columns'
 require_relative 'recourse/counters'
 require_relative 'recourse/searches'
@@ -57,33 +58,6 @@ module Recourse
   @parents = {}
   @declared_bookmarks = nil
 
-  # Columns a user may set: the form offers these, the show page reads these out, and
-  # `create` permits these. A counter cache is none of a user's business — Rails keeps
-  # it, so a form that offered one would let it be typed over, and neither is a column
-  # the database generates: it takes no value at all.
-  def self.editable_columns(model)
-    ordered model, model.column_names - ['id', *TIMESTAMPS] - counters(model).keys -
-                   hidden_columns(model) - virtual_columns(model)
-  end
-
-  # Columns no screen shows: whatever the model asked to hide through `recourse_hidden`
-  # — one name or a list, taken either way — the column Rails reserves for single table
-  # inheritance, and the place a row holds where somebody positioned the table. A class
-  # name is machinery rather than something to read out, and a position is set by
-  # dragging the row rather than typed beside it.
-  def self.hidden_columns(model)
-    Array(model.recourse_hidden).map(&:to_s) +
-      [model.inheritance_column, *position_columns(model)]
-  end
-
-  # The names a column is validated under: its own, and — where it is a foreign key
-  # — the association's, since `belongs_to` validates the record it points at rather
-  # than the number pointing there. Two questions where a column is a key, one
-  # everywhere else.
-  def self.validated_names(column)
-    [column, column.delete_suffix('_id')].uniq
-  end
-
   # The model a resource is named after. A controller the gem defined has nothing else
   # to go on, so a name resolving to no model is a routes file to fix rather than a
   # `NameError` from somewhere inside a view.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recourse
 version: !ruby/object:Gem::Version
-  version: 7.3.0
+  version: 7.5.0
 platform: ruby
 authors:
 - claudiob
@@ -140,6 +140,7 @@ files:
 - app/controllers/concerns/recourse/landing.rb
 - app/controllers/concerns/recourse/list_resolution.rb
 - app/controllers/concerns/recourse/paging.rb
+- app/controllers/concerns/recourse/parameter_resolution.rb
 - app/controllers/concerns/recourse/parent_naming.rb
 - app/controllers/concerns/recourse/parent_resolution.rb
 - app/controllers/concerns/recourse/positioned.rb
@@ -178,6 +179,7 @@ files:
 - lib/recourse.rb
 - lib/recourse/assets.rb
 - lib/recourse/attachments.rb
+- lib/recourse/bands.rb
 - lib/recourse/blobs.rb
 - lib/recourse/bookmarks.rb
 - lib/recourse/broadcasting.rb
@@ -193,6 +195,7 @@ files:
 - lib/recourse/helpers/attachments.rb
 - lib/recourse/helpers/blobs.rb
 - lib/recourse/helpers/bookmarks.rb
+- lib/recourse/helpers/breadcrumbs.rb
 - lib/recourse/helpers/buttons.rb
 - lib/recourse/helpers/calendars.rb
 - lib/recourse/helpers/cards.rb
@@ -214,6 +217,7 @@ files:
 - lib/recourse/helpers/inputs.rb
 - lib/recourse/helpers/kinds.rb
 - lib/recourse/helpers/limits.rb
+- lib/recourse/helpers/links.rb
 - lib/recourse/helpers/maps.rb
 - lib/recourse/helpers/names.rb
 - lib/recourse/helpers/navigation.rb
@@ -236,6 +240,7 @@ files:
 - lib/recourse/helpers/themes.rb
 - lib/recourse/helpers/times.rb
 - lib/recourse/helpers/values.rb
+- lib/recourse/helpers/warnings.rb
 - lib/recourse/helpers/weeks.rb
 - lib/recourse/helpers/zones.rb
 - lib/recourse/icons.rb