recourse 7.2.1 → 7.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5902f16def7afce17cc0aec2d67eb1255ffc504af58cbd766146a4f3e7f3077
-  data.tar.gz: 3e917516c8a76bdc0fe30497e02d7181a886d96f500cd765dfbe6202f4785452
+  metadata.gz: da821317fa8c02a37911dd03b62aaeb072bb3cacbc40cfb15c29eb51c3ffbd8b
+  data.tar.gz: 276e8d9570b080d81dbefc6b304ba6d4a169e783191587cbe534059a2ccd3c0b
 SHA512:
-  metadata.gz: d1a6d35fa1bd005290644f5f8981ac7a7837fda2f6bb9919b3225518ab41bacdf497d261827116b43928b1cf1f918eea3b5030de38faed3bd195aa257db6f798
-  data.tar.gz: e242d7c656755f01f53c1e2f3c1f9b75c89bbc5654b50a3dc44e6bb7f768c64321572c024e7d52fe036dcfc9c65bed2eaee7464815617e2294bfcbecc64350dc
+  metadata.gz: 172bd06e4fc69264846c29ed4c12123290aab2532c98033076c1fce4f0ab7829931cfeac6d16e16765c7d25117eec969f624b2fd3a66120878d85fc3f56f57ee
+  data.tar.gz: f7ab6fd22033642867259dc840ec3da125c9914c08af2a9617a72ebf67fa4cf7e70c7b5930f928ef8bac45855449111621ef4565b323da2631958e5a9af70392

data/CHANGELOG.md

@@ -7,6 +7,31 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 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
+
+  A cell and a value read `true` and `false`, which is what the database keeps and not
+  what anybody asked. Both now read `Yes` and `No` — the two the filter menu beside the
+  column already offered — and a nullable column nobody answered reads as the dash every
+  other empty value reads as, rather than as a no.
+
 ## 7.2.1 - 2026-09-20
 
 * [FIX] A refused change keeps the card it was made in

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/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.
@@ -18,12 +13,13 @@ module Recourse
       end
 
       # One value, formatted by the kind its column holds — the one ladder a table
-      # cell and a show page's value both come down, so a boolean is the same icon
+      # cell and a show page's value both come down, so a boolean is the same word
       # and an enum the same badge on either. A block, where the caller has one,
       # marks the search terms inside whichever arm ends up as words.
       def formatted_attribute(column, value, &)
         kind = attribute_kind column
         return listed Array(value) if kind == :list
+        return affirmed value if kind == :boolean
         return formatted_number kind, column, value if numeric_kind? kind
 
         formatted_text kind, value, &
@@ -51,6 +47,15 @@ module Recourse
         end
       end
 
+      # The word a reader answers with, which is the word the filter beside the column
+      # already offers. A column that was never answered holds neither, so it reads as
+      # the dash every other empty value does rather than as a no.
+      def affirmed(value)
+        return if value.nil?
+
+        t value ? 'recourse.affirmative' : 'recourse.negative'
+      end
+
       # One whole web address is a value to follow rather than to read, and anything
       # else is words — which the caller may have marking of its own for.
       def linked_or_marked(value, &)
@@ -75,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/values.rb

@@ -18,7 +18,7 @@ module Recourse
       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
+      # boolean says something either way, and a word says it, so only a value that
       # formats to nothing at all reads as nothing.
       def resource_value(column)
         value = formatted_value column

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'
@@ -51,14 +53,13 @@ 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, 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.2.1'
+  VERSION = '7.4.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.2.1
+  version: 7.4.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