recourse 5.6.3 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83d3a5ce095d609bf7da53c08839eab3bc4924c6e6150f9675d79725c4c9f53f
-  data.tar.gz: d2325213f4e461394adb107d3a3834f6ef668159ce6e90e7fa77aa09d09a8389
+  metadata.gz: 2b7756a87eb7ee1ef4267480a0e8370c1b63e50623a7a22cf0efe6a7a7a46644
+  data.tar.gz: 0e7e84177bc55634878165dd8ba0fe19ad2c9d635c586211477d48431354cb47
 SHA512:
-  metadata.gz: 54d4c8b8075fc497c45caf991fe7f8e5ea04cacb30bf619a12682e137cf962072140b1ff69eaff9ad881658adb018a440bc344fd3bfb3859ec776bdd077ae87b
-  data.tar.gz: 9d8a3e17c0cdb3e05f57381beda1c68b31b5b6924d7104717622c29d5658f6faa198ab33d1c576a81ea8e7adf4ccdee3b9be885c248421302229381536dc7445
+  metadata.gz: 468364cedb2192b3a73d7b4642689d0c6b984b156c0a20b7d6930c7a982e406d5c33132bc4fd8158b1c274eb47a925e299728d5f09530dc0421fdd72d303a243
+  data.tar.gz: d34ed9fd8cbe6f355a0bf9889d7cfa4e4ce9ebd02686ac2f1070fefb3230322173855a0662f720a3380f1d8e10224b0e7d5bf125af13287a41a9f81dbf457f01

data/README.md

@@ -52,6 +52,22 @@ edit page, or on each row of its table where no `edit` is routed:
 
 [image]
 
+`recourse` draws what Rails' `resource` draws, and the gem records it the same way: one
+record reached with no id of its own, at `/locations/5/property`. Rails routes a singular
+resource to a plural controller, so `Locations::PropertiesController` answers it, and the
+gem reads the record off the parent under the name the route gives — `location.property`,
+whether the parent keeps it with a `has_one` or points at one with a `belongs_to`. Where
+the parent has no association of that name the record is still yours to find, with a
+`find_resource` of your own.
+
+What such a nesting earns on the parent's card depends only on what it routes. Routed
+`show`, it earns a tab reading the model's own word in the singular, pointing at that one
+page. Routed `create` or `destroy` and neither `index` nor `new`, it earns a button beside
+the breadcrumb instead — `Add property`, `Delete property` — and which of the two it
+offers is the record's to say: nothing to add where there is already one, nothing to
+delete where there is none. A write has no index to return to, so it lands on the
+record's own page: a singular resource is the collection of one.
+
 Every nested recourse gets namespaced after the parent:
 
 <img width="3824" height="2274" alt="Image" src="https://github.com/user-attachments/assets/9b242335-a25b-4fa8-8023-422538d235b0" />

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

@@ -40,10 +40,13 @@ module Recourse
       redirect_to written_url, status: :see_other
     end
 
-    # And where a write goes: the index, or — where the routes drew none — back to the
-    # record it hangs off, which for a bare action is the page its button stood on.
+    # And where a write goes: the index, or the record's own page where the routes drew none
+    # — a singular resource is the collection of one. A nesting that routed neither has
+    # no page anywhere to land on, so the write goes back to the record it hangs off,
+    # which for a bare action is the page its button stood on.
     def written_url
       return url_for action: :index if Recourse.routed? controller_path, 'index'
+      return url_for action: :show if Recourse.idless_route? controller_path, 'show'
 
       parent_url
     end

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

@@ -4,9 +4,34 @@ module Recourse
   module ResourceResolution
   private
 
-    # The record the id names, under the name Rails would use. `find`, so an id naming
-    # nothing answers 404.
-    def find_resource = assign resource_class.find(params.expect(:id))
+    # A singular resource is reached with no id — `/places/5/memo` names the record by
+    # the path it hangs off rather than by a key of its own — so it is read off the
+    # parent instead, under the name the route already gives it. Where the parent has
+    # no association of that name the record is still the host's to find, in a
+    # controller of its own.
+    def find_resource
+      return assign resource_class.find(params.expect(:id)) if params.key? :id
+      return unless singular_reflection
+
+      record = @recourse_parent.association(singular_reflection.name).reader
+
+      record ? assign(record) : missing_record
+    end
+
+    # The parent's association of this resource's own name, whichever kind it is: a
+    # `has_one` where the parent keeps the record, a `belongs_to` where it points at
+    # one. `reflect_on_association` rather than a rescue, so a name the parent has
+    # never heard of reads as nothing to resolve rather than as an error.
+    def singular_reflection
+      @recourse_parent&.class&.reflect_on_association controller_name.singularize
+    end
+
+    # Nothing found, which for a resource routed `new` means the page that makes one:
+    # a `has_one` nobody has written yet is a form to fill in, not an absence to read.
+    # Where no `new` is drawn, nothing is assigned and the page says so instead.
+    def missing_record
+      redirect_to url_for(action: :new) if Recourse.routed? controller_path, 'new'
+    end
 
     def assign(record)
       @recourse = record
@@ -14,7 +39,7 @@ module Recourse
     end
 
     # Whether there is a model behind this page at all. A bare action has none: it is a
-    # verb the host answers itself — `recourses :sweeps, only: :create` — labelled from the
+    # verb the host answers itself — `recourse :sweep, only: :create` — labelled from the
     # path alone, and still a `RecoursesController`, that being where a host keeps the
     # filters guarding its admin. So what runs on every request asks this first, and the
     # actions the gem serves reach for the model again and raise where it is missing.

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

@@ -1 +1,5 @@
-<p class='fg-2'><%= t 'recourse.none', models: Recourse.downcase(resources_name) %></p>
+<%# locals: (models: nil) -%>
+<%# `models` for a page that stands for one record rather than a list: a singular
+    resource the host found nothing for says `No property.` where an empty index says
+    `No properties.` -%>
+<p class='fg-2'><%= t 'recourse.none', models: models || Recourse.downcase(resources_name) %></p>

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

@@ -4,7 +4,14 @@
     the card is the parent's, so the tabs on it are about the record the path names
     above this one rather than about this one. -%>
 <%= render layout: 'card', locals: { record: resource_parent || resource_record } do %>
-  <div class='row recourse-values'>
-    <%= render 'values', resource_key => resource_record %>
-  </div>
+  <%# Nothing to read out where the host found no record: a singular resource is
+      reached with no id, so the one it stands for is one it may not have yet, and the
+      page says so rather than reading attributes off nothing. -%>
+  <% if resource_record %>
+    <div class='row recourse-values'>
+      <%= render 'values', resource_key => resource_record %>
+    </div>
+  <% else %>
+    <%= render 'none', models: resource_name %>
+  <% end %>
 <% end %>

data/lib/recourse/helpers/actions.rb

@@ -74,14 +74,18 @@ module Recourse
       end
 
       # The icon alone, red for what it does, and the same warning the edit page's button
-      # carries in front of it, which the bundle draws as its dialog.
+      # carries in front of it, which the bundle draws as its dialog. Out of the frame
+      # the table is drawn in, like every other action in the row: what a delete lands on
+      # is a whole page with a message over it, and answering inside the frame would keep
+      # the table and throw the message away.
       def destroy_button(record)
         path = url_for controller: "/#{destroy_action_path}", action: :destroy, id: record
 
         button_to icon_tag(ICONS[:destroy], class: 'fg-danger'), path,
                   method: :delete, class: 'btn btn-sm btn-link btn-icon p-0',
                   aria: { label: t('recourse.delete', model: resource_name) },
-                  form: { data: { turbo_confirm: destroy_warning(record) } }
+                  form: { data: { turbo_frame: '_top',
+                                  turbo_confirm: destroy_warning(record), } }
       end
     end
   end

data/lib/recourse/helpers/buttons.rb

@@ -3,10 +3,14 @@ module Recourse
     # The buttons a record's pages carry: an action the routes drew under it that has
     # no page of its own for a link to sit on.
     module Buttons
+      # What a bare action may be, and the verb each one is asked with. `create`
+      # starts something and `destroy` undoes it; anything else wants a page.
+      BARE_ACTIONS = { create: :post, destroy: :delete }.freeze
+
     private
 
-      # A nested resource routed `create` without an `index` is reached from nowhere, so
-      # its button lives on the record it hangs off — beside the breadcrumbs. Which of
+      # A nested resource routed without an `index` is reached from nowhere, so its
+      # button lives on the record it hangs off — beside the breadcrumbs. Which of
       # that record's pages is the host's business as much as the button is: the
       # routes say where it goes as well as whether it exists.
       def bare_action_buttons(record)
@@ -19,11 +23,14 @@ module Recourse
 
       # Whether this is that page. An index is a page to reach the action from and a
       # `new` is a form to fill in on the way: either one means there is more to this
-      # than a button. A nesting with no page anywhere stands on the record's own page,
-      # since every other page of the record is about something else — a place's memos
-      # are not where a sweep of the place is offered.
+      # than a button. A page of its own is where the button belongs and the only place
+      # it belongs, so a location's card does not offer to fetch one service's answer
+      # while another service's is open. And a nesting with no page anywhere stands on
+      # the record's own page, since every other page of the record is about something
+      # else — a place's ZIP is not where a sweep of the place is offered.
       def bare_action_page?(nested)
         return false if routed?(nested, 'index') || routed?(nested, 'new')
+        return nested == controller.controller_path if idless_route? nested, 'show'
 
         record_page?
       end
@@ -33,12 +40,28 @@ module Recourse
         !resource_parent && controller.action_name == 'show'
       end
 
-      # The `create` the routes drew on the collection, which needs no id: a member
-      # action wants the row it acts on, and a row is what a table is for.
+      # The first of the two the routes drew that needs no id and the record leaves
+      # open: a `create` on the collection, or a singular resource's `destroy`. Both,
+      # where a singular routed each of them has the record to tell them apart. A
+      # member action wants the row it acts on, and a row is what a table is for.
       def bare_action_button(record, nested)
-        return unless routed? nested, 'create'
+        action, method = BARE_ACTIONS.find do |one, _|
+          idless_route?(nested, one) && bare_action_open?(one)
+        end
+        return unless action
+
+        [bare_action_label(nested, action), bare_action_url(record, nested, action), method]
+      end
+
+      # Whether the record leaves it to be done. On a singular resource's own page the
+      # record is what decides, and a `has_one` answers only one of the two: nothing to
+      # create where there is already one, nothing to delete where there is none.
+      # Elsewhere nothing here knows what the action would touch, so the routes stay
+      # the whole check.
+      def bare_action_open?(action)
+        return true unless idless_route? controller.controller_path, 'show'
 
-        [bare_action_label(nested), bare_action_url(record, nested), :post]
+        action == :create ? resource_record.nil? : resource_record.present?
       end
 
       # The resource's own word, which a host renames in a locale like any other
@@ -47,18 +70,19 @@ module Recourse
       # that is the only thing telling two routes to the same model apart — without it
       # a `quick/memos` action and the `memos` beside it both read `Add memo`. The tab
       # for a nested index is named from the same split, so the two agree.
-      def bare_action_label(nested)
+      def bare_action_label(nested, action)
         name, namespace = nested_segments nested, card_path
         model = Recourse.downcase Recourse.known_singular(name)
         lead = namespace_words namespace
 
-        t 'recourse.add', model: [lead.presence, model].compact.join(' ')
+        t "recourse.#{action == :create ? 'add' : 'delete'}",
+          model: [lead.presence, model].compact.join(' ')
       end
 
-      def bare_action_url(record, nested)
+      def bare_action_url(record, nested, action)
         parent = card_path.split('/').last.singularize
 
-        url_for controller: "/#{nested}", action: :create, "#{parent}_id": record.id
+        url_for controller: "/#{nested}", action:, "#{parent}_id": record.id
       end
     end
   end

data/lib/recourse/helpers/cards.rb

@@ -44,21 +44,36 @@ module Recourse
       end
 
       # One tab per resource nested under the record, in the order routes.rb nested
-      # them — the order the sidebar already keeps. The nested index is the whole
-      # requirement: a `has_many` of that name decides how the tab reads, and a counter
-      # cache whether it carries a number, but neither is what puts it there. A nesting
-      # with no index is an action, and its button stands beside the breadcrumbs instead.
+      # them — the order the sidebar already keeps. The nested route is the whole
+      # requirement: an index earns a tab reading its rows, and a singular resource
+      # earns one reading its record. A `has_many` of that name decides how the first
+      # of those reads, and a counter cache whether it carries a number, but neither
+      # is what puts it there.
       def nested_tabs(record, path)
         Recourse.nested_under(path).filter_map do |nested|
-          next unless routed? nested, 'index'
+          action = nested_tab_action nested
+          next unless action
 
           name, namespace = nested_segments nested, path
 
-          [nested_tab_label(record, name, namespace), nested_url(record, path, nested),
-           nested == controller.controller_path,]
+          [nested_tab_label(record, name, namespace, action),
+           nested_url(record, path, nested, action), nested == controller.controller_path,]
         end
       end
 
+      # Which page of the nesting its tab opens, or nil where it has none to open: the
+      # index where one is routed, and otherwise the one record a singular resource
+      # keeps — a `show` the router needs no id for, which is what tells
+      # `recourse :memo` from `recourses :memos` here, since Rails routes both to the
+      # same plural controller. An index wins where a host drew both, being the page
+      # that reads every row rather than one of them. A nesting with neither page is an
+      # action, and its button stands beside the breadcrumbs instead.
+      def nested_tab_action(nested)
+        return :index if routed? nested, 'index'
+
+        :show if idless_route? nested, 'show'
+      end
+
       def tab_label(action)
         word = tag.span t("recourse.#{action}"), class: 'recourse-tab-word'
 

data/lib/recourse/helpers/counters.rb

@@ -28,7 +28,7 @@ module Recourse
         nested = nested_path_of path, association
         return tag.span(counted, **named) unless nested && routed?(nested, 'index')
 
-        turbo_link_to counted, nested_url(resource, path, nested), **named
+        turbo_link_to counted, nested_url(resource, path, nested, :index), **named
       end
 
       # The two forms of one count, of which a stylesheet ever shows one: the bare

data/lib/recourse/helpers/navigation.rb

@@ -10,13 +10,26 @@ module Recourse
         crumbs = parent_breadcrumbs
         leaf = breadcrumb_leaf
         here = controller.controller_path
-        return crumbs << [here, resources_name, nil] unless leaf
+        return crumbs << [here, breadcrumb_name, nil] unless leaf
 
-        crumbs << [here, resources_name, index_url] << [nil, leaf, nil]
+        crumbs << [here, breadcrumb_name, index_url] << [nil, leaf, nil]
       end
 
-      # Where this resource's index is, or nil where it has none, in which case the crumb
-      # naming it is read out rather than linked.
+      # 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

data/lib/recourse/helpers/parents.rb

@@ -22,8 +22,8 @@ module Recourse
       # named after the path the children are nested under rather than after the page
       # being served, since a page nested one level up is served by another controller
       # entirely.
-      def nested_url(record, path, nested)
-        url_for controller: "/#{nested}", action: :index,
+      def nested_url(record, path, nested, action)
+        url_for controller: "/#{nested}", action:,
                 "#{path.split('/').last.singularize}_id": record.id
       end
 

data/lib/recourse/helpers/resources.rb

@@ -44,7 +44,10 @@ module Recourse
       end
 
       # What the record on the page is called, by whatever its model labels it with —
-      # and nothing where there is no record to name.
+      # and nothing where there is no record to name. A singular resource is one the
+      # host finds, since the path carries no id, and a `has_one` it finds nothing for
+      # is still a page: the crumb above it goes unnamed rather than taking the chrome
+      # down with it, and what the body says about the absence is the host's to write.
       def resource_record_label
         return unless resource_record
 

data/lib/recourse/helpers/routing.rb

@@ -23,6 +23,16 @@ module Recourse
 
         @recourse_routed.include? "#{controller_path}##{action}"
       end
+
+      # True where the route needs no id of its own — a collection action, or a
+      # singular resource's. What a button on the parent can reach, in other words:
+      # a member action wants a row, and a row is what a table is for. Asked of
+      # `Recourse` rather than answered here: a write asks the same question of the
+      # same routes, and one of them scanning while the other remembers is two answers
+      # waiting to disagree.
+      def idless_route?(controller_path, action)
+        Recourse.idless_route? controller_path, action
+      end
     end
   end
 end

data/lib/recourse/helpers/tabs.rb

@@ -4,15 +4,17 @@ module Recourse
     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
+      # What a nested resource's tab reads as. For an index, 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. A singular
+      # resource is one record and never a list, so no association is asked for it at
+      # all: a `has_many` of that name would count rows this page is not.
+      def nested_tab_label(record, name, namespace, action)
+        association = nested_association record, name if action == :index
         return association_tab_label record, association, namespace if association
 
-        routed_tab_name name, namespace
+        routed_tab_name name, namespace, action
       end
 
       def nested_association(record, name)
@@ -20,10 +22,14 @@ module Recourse
       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)
+      # the counted tab keeps. Humanized off the path for an index, since nothing else
+      # answers; the model's own singular for one record, since there is a model to ask
+      # and only ever one row of it. That singular is the word the bare action's button
+      # takes, from the same split, so a tab and a button under one record cannot come
+      # to disagree about what the resource is called.
+      def routed_tab_name(name, namespace, action)
         lead = namespace_words namespace
-        title = name.humanize
+        title = action == :show ? Recourse.known_singular(name) : name.humanize
         title = Recourse.downcase title if lead.present?
 
         [lead.presence&.upcase_first, title].compact.join ' '
@@ -80,8 +86,22 @@ module Recourse
         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)
-        model.recourse_counters.find { |_, one| one == association }&.first
+        counter_of(model, association) || counter_of(model, join_of(model, association))
+      end
+
+      def counter_of(model, association)
+        model.recourse_counters.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

data/lib/recourse/routes.rb

@@ -35,6 +35,23 @@ module Recourse
       resources(*names, **options) { draw_within keepable, positionable, block }
     end
 
+    # What `resource` draws, recorded the same way: one record reached without an id,
+    # at `/providers/5/authentication`. Rails routes a singular resource to a plural
+    # controller, so that is the path declared here — and recording it is the whole
+    # point, since an action drawn with no index of its own earns its button on the
+    # parent, and only a recorded nesting is ever looked for there.
+    def recourse(*names, **)
+      refuse_unscoped_nesting names
+
+      names.each do |name|
+        path = [current_module, name.to_s.pluralize].compact.join '/'
+        record_declaration path
+        Controllers.define_missing path
+      end
+
+      resource(*names, **)
+    end
+
   private
 
     # The module is the namespace being drawn in, so a resource is declared and its

data/lib/recourse/routing.rb

@@ -11,6 +11,18 @@ module Recourse
         route.defaults[:controller] == controller_path && route.defaults[:action] == action.to_s
       end
     end
+
+    # True where that route needs no id of its own — a collection action, or a singular
+    # resource's, which is what tells `recourse :memo` from `recourses :memos`: Rails
+    # routes both to the same plural controller, and only the route says which it is.
+    # Nil where no such route is drawn at all, which is a third answer and reads as one.
+    def idless_route?(controller_path, action)
+      route = Rails.application.routes.routes.find do |one|
+        one.defaults[:controller] == controller_path && one.defaults[:action] == action.to_s
+      end
+
+      route&.required_parts&.exclude? :id
+    end
   end
 
   extend Routing

data/lib/recourse/searchable.rb

@@ -10,9 +10,11 @@ module Recourse
   module Searchable
     include Columns, Filters, Terms
 
-    # How many rows a menu may hold before it stops being a menu. Fifty states are a
-    # list to pick from; three thousand counties are a page of HTML nobody reads.
-    MENU_LIMIT = 100
+    # How many rows a menu may hold before it stops being a menu. A couple of hundred
+    # specialties are a list to pick from -- the menu carries a search box, so its length
+    # costs scrolling rather than reading -- and three thousand counties are a page of
+    # HTML nobody reads.
+    MENU_LIMIT = 200
 
     # Attributes Ransack may read: every column that is not encrypted, plus the
     # encrypted ones a search can still match whole — `cont` reads ciphertext and

data/lib/recourse/titles.rb

@@ -38,8 +38,11 @@ module Recourse
       model.respond_to?(:model_name) ? model_title(model) : segment.humanize
     end
 
-    # And the singular of that, for the button a bare action earns: `Add sweep` is one
-    # sweep, and the same split that names the tab beside it.
+    # And the singular of that, for the two places a page stands for one record rather
+    # than a list: the tab a singular resource earns, and the button a bare action
+    # earns. Off `known_title` rather than `model_title(count: 1)`, since a name this
+    # app has no class for is humanized from a plural path segment and needs
+    # singularizing too.
     def known_singular(name)
       known_title(name).singularize
     end

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 = '5.6.3'
+  VERSION = '5.8.0'
 end

data/lib/recourse.rb

@@ -88,8 +88,9 @@ module Recourse
   end
 
   # The same, answering nil where there is no such model rather than raising. A bare
-  # action is a verb — `recourses :sweeps, only: :create` — labelled from the path alone,
-  # so whether a name has a model behind it is a question and not an accusation.
+  # action is a verb — `recourse :sweep, only: :create` — and the gem labels its button
+  # from the path alone, so whether a name has a model behind it has to be a question
+  # and not an accusation.
   def self.model?(name) = model_name(name).safe_constantize
 
   # A namespaced resource is `admin/sources`, and the model it lists is a Source.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recourse
 version: !ruby/object:Gem::Version
-  version: 5.6.3
+  version: 5.8.0
 platform: ruby
 authors:
 - claudiob