recourse 5.5.0 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90b3afa1fb3432ce14d6b23b67dfbd972c9887db8077b03eef5a58e43359d079
-  data.tar.gz: 69c7047b6f440ca4228d19fc2418deb769a51a63890b0c98cf1289059a80195c
+  metadata.gz: 8d2b5251cca5129bfd2c634cb82e8cb8951e9363507762ec1efab7263bce419f
+  data.tar.gz: 25630ad43f83b9a650e8a4d52fc01628a0032e087d23f7285f420d683db4895c
 SHA512:
-  metadata.gz: 1c72dd551e37c712fdf67f2beb4dd0cbcb3c44c234bec7cf8423ddd30a510efbb1ff00151f3820709b58d9a00e59efaf7759ed32cd15b5cc16d22cc46169192d
-  data.tar.gz: 8528213a6a673cabc608d45be06311439f317d6eb56f90f5d9e36b4b25298bd7e0d29acfa8a6d28dd38c9b0cd61b40c6e5cd4e4e5436c864eeac7da308aa1665
+  metadata.gz: 8fa002c794c334526bdc692ba5bcc5cc47f40521501c2dd945f9aa04638013a6af5d5fcae20b57960ab06fdb34adb77cf63dfb7bd8dae4e4908bf369b8d86d56
+  data.tar.gz: 8dc080edb46c2273cf4685a5a98c1bf82c58411acec408c1a9cf030ed9c09ff9219a55741df512028f9065f0b09b0f27983dcf58c7dd5dcf7b93e8f72546d5a2

data/CHANGELOG.md

@@ -7,6 +7,70 @@ For more information about changelogs, check [Keep a Changelog](http://keepachan
 
 ## [Unreleased]
 
+## 5.6.0 - 2026-09-18
+
+* [Feature] A table can be dragged into an order
+
+  Back from the 4.0.0 development tree, and opting in the way the map and the calendar do:
+  a model keeping an integer `position` is one a reader positions by hand. A grip opens each
+  row, dragging it moves the row, and `resource :position, only: :update` is where the place
+  it landed is written. That route is drawn where the host asks for it —
+  `recourses :steps, positionable: true` — and nowhere else: a table is put in order from
+  its index, so the keyword is refused on a resource that draws none. The column still
+  decides everything else, `recourse_order` among it, because the order a table is read in
+  and the order somebody put it in are one fact.
+
+  The type is load-bearing rather than belt-and-braces, and asked through
+  `type_for_attribute` as a calendar asks about its two ends: `contacts.position` holding a
+  job title is a word about the row, not a place among rows. A map and a calendar only
+  read, so a column mistaken for one costs a link; this writes, and writes at the first
+  save.
+
+  Two things follow the column rather than the routes. `Recourse::Positionable` fills the
+  column on create and closes the gap on destroy, so a row made in a console is numbered
+  like one made behind a form — what a drop reports is a row's place on the *page*, which
+  is a position only while the numbers run 1, 2, 3 with no holes in them. A model pointing
+  several ways answers `recourse_siblings` with the rows one of its own is counted among;
+  one pointing a single way needs no answer, and one pointing nowhere is positioned among
+  the whole table.
+
+  Whether a page is positioned is asked per page, not per model: a place means something
+  under the parent it is counted within, so a flat model's own index is positioned and a
+  listing of every row across every parent — where the positions run 1, 2, 3, 1, 2, 3 side
+  by side — is not. And the search box and the sorted headings stand down while the grips
+  are drawn, a `q` typed by hand refused with them: a filter shortens the page, and a drop
+  on a shortened page reports a place among the rows that are left.
+
+  A host keeping the order itself writes `def recourse_position = nil`. A host with a
+  second listing of a positioned model names the second column on its own controller, which
+  then owns the write as well as the page — `Recourse::PositionsController` is public to
+  subclass, and `Recourse::Positioning` is public for the column such a host maintains.
+
+* [Fix] A word that names a class which is not a model
+
+  `known_title` guarded against a name resolving to nothing — `pause` is a verb no app
+  makes a class for — but not against one resolving to a class with no `model_name`. A
+  host may keep a plain `Message` that gathers rows rather than a table of them, and a
+  breadcrumb over such a page raised instead of reading. It asks whether what it found
+  answers `model_name`, the way `known_icon` beside it already does.
+
+* [Feature] `Recourse.assets` says where the house bundle is served from
+
+  The stylesheet, the script and the palettes were three URLs carrying one pinned version,
+  moved together by hand every release — the 5.5.0 entry below says as much. They are one
+  line now: `Recourse::BUNDLE` is which release, `Recourse.assets` is where it is read
+  from, and jsdelivr's copy of the published package stays the default.
+
+  A host that sets `Recourse.assets = ''` serves the bundle itself, out of the
+  `houseaccount` gem mounted by path: its engine answers `/css`, `/js` and `/theme` from
+  its own `public/`. That is how a stylesheet or a controller gets tried on a real page
+  before the version carrying it is published, which is what this release needed.
+
+* [Change] The pinned bundle is `houseaccount@0.14.0`
+
+  What carries the `sortable` controller the feature above names, and the two rules beside
+  it: the grip's cursor, and the tint on the space a dragged row will land in.
+
 ## 5.5.0 - 2026-09-17
 
 * [Fix] A sorted heading has a mark again

data/README.md

@@ -66,7 +66,8 @@ To change the content displayed in the `index` table of a model, override any of
 | [`recourse_label`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_label-instance_method) | `:name` | the column a combobox shows and a foreign-key cell reads; typed rather than picked where it has a length validator |
 | [`recourse_hidden`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_hidden-instance_method) | `[]` | columns kept off the table, the page, the form and the search |
 | [`recourse_displayed`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_displayed-instance_method) | `[]` | columns a table draws that it would leave off: encrypted ones, the id, timestamps, JSON |
-| [`recourse_order`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_order-instance_method) | `:id` | the index's order, a Symbol or a Hash; rows with nothing in the column come last |
+| [`recourse_order`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_order-instance_method) | `:id`, or the positioned column | the index's order, a Symbol or a Hash; rows with nothing in the column come last |
+| [`recourse_position`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_position-instance_method) | `'position'` where the model keeps an integer one | the column a reader drags the rows into order by, or `nil` for a table nobody positions |
 | [`recourse_icon`](https://rubydoc.info/gems/recourse/Recourse/Recoursive#recourse_icon-instance_method) | the model's name | the icon on the sidebar, the crumbs and the tabs |
 
 For instance, this would yield a more compact `index` than the default configuration:
@@ -239,6 +240,69 @@ Both columns have to be datetimes, asked through `type_for_attribute`, so an
 `starts_at` earns nothing.
 
 
+### Positionable tables
+
+A table whose model keeps an integer `position` is one a reader puts in order by hand: a
+grip opens each row, dragging it moves the row, and the place it lands in is written to a
+route drawn under the index. Say where that route belongs, since a page nobody drags needs
+none:
+
+```ruby
+recourses :steps, positionable: true
+```
+
+A table is put in order from its index and from nowhere else, so the keyword is refused on
+a resource that draws none. The column decides the rest — the grips, the callbacks, and
+`recourse_order`, since the order a table is read in and the order somebody put it in are
+one fact.
+
+```ruby
+class Step < ActiveRecord::Base
+  belongs_to :team
+  belongs_to :person
+
+  # A step points two ways, so which of them its place is counted within is the model's
+  # to say. One `belongs_to` needs no answer, and a model pointing nowhere is positioned
+  # among the whole table.
+  def recourse_siblings = team.steps
+end
+```
+
+Two things follow the column rather than the routes. A new row lands last among its own
+and the gap closes behind one that goes, whether it was made behind a form or in a
+console: what a drop reports is a row's place on the *page*, which is a position only
+while the numbers run 1, 2, 3 with no holes in them. And a table being positioned is asked
+per page — a position means something under the parent it is counted within, so a flat
+model's own index is positioned and a listing of every row across every parent is not.
+
+The search box and the sorted headings stand down while the grips are drawn, and a `q`
+typed by hand is refused for the same reason: a filter shortens the page, and a drop on a
+shortened page reports a place among the rows that are left.
+
+A host that keeps the order itself writes `def recourse_position = nil`, which takes the
+grips off the table and the two callbacks off the model together. A host with a *second*
+listing of a positioned model — a plan's place among its service's plans, and another
+among every plan of its department — names the second column on the controller instead,
+and owns the write as well as the page:
+
+```ruby
+module Departmental
+  extend ActiveSupport::Concern
+
+private
+
+  def recourse_position = 'ordering'
+end
+
+class Administered::Departments::Plans::PositionsController < Recourse::PositionsController
+  include Departmental
+end
+```
+
+`Recourse::Positioning` is public for exactly that case: `new(relation, column).close` is
+what such a host calls to keep its own column contiguous.
+
+
 ## Development
 
 ```bash
@@ -249,6 +313,23 @@ cd test/dummy && bin/rails server
 
 The dummy app under `test/dummy` runs on SQLite; the gem names no adapter.
 
+### Reading an unpublished bundle
+
+The pages link `houseaccount` from a CDN, pinned to `Recourse::BUNDLE`, so a stylesheet or
+a Stimulus controller that is not published yet cannot be read on a page. Two lines change
+that — one in this Gemfile, kept out of it because CI checks out this repo alone:
+
+```bash
+echo "gem 'houseaccount', path: '../design'" >> Gemfile && bundle install
+cd test/dummy && bin/rails db:migrate && HOUSE_ASSETS=1 bin/rails server
+```
+
+`HOUSE_ASSETS` is what loads that gem and sets `Recourse.assets = ''`, so the page asks
+this app for `/css`, `/js` and `/theme` and the gem's engine answers them out of its own
+`public/`. Behind a variable because what a deployed app links is what the suite asserts,
+and because the dummy is also the stand-in for a host with no such gem at all. The dummy's
+development database is migrated on its own, which the line above is why.
+
 ## License
 
 [MIT](MIT-LICENSE).

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

@@ -0,0 +1,40 @@
+module Recourse
+  # Which column a listing is dragged into order by, and so whether it is positioned at
+  # all. Two questions with one answer, asked by the table that draws the grips, by the
+  # search and the headings that stand down where they are drawn, and by the write a
+  # drop lands on.
+  module Positioned
+    extend ActiveSupport::Concern
+
+    included do
+      # After the parent is found, which is what the default turns on.
+      before_action { @recourse_position = recourse_position }
+    end
+
+  private
+
+    # The model's own column by default — the `position` it keeps — and only on a page
+    # where a place among rows means something: the rows one is counted within are the
+    # rows the page lists, which the parent above it settles.
+    #
+    # A host overrides it where a listing is positioned by an order the model does not
+    # keep. A plan holds a place among its service's plans and another among every plan
+    # of its department, and which of the two a page is in is the page's answer rather
+    # than the model's: a model keeps one column, and a second listing is a second
+    # column that only its own controller knows about.
+    #
+    # Such a host owns the write as well as the listing. The gem draws a positions
+    # controller under every index, and that one has to be told the same two things —
+    # this column, and the rows to renumber — or a drop would move a row among rows the
+    # page never showed.
+    def recourse_position
+      return unless resource_model?
+      return unless Recourse.positioned? resource_class, @recourse_parent_association
+
+      Recourse.position_column resource_class
+    end
+
+    # Whether these rows are ones a reader positions, which is the same question again.
+    def positioned? = @recourse_position.present?
+  end
+end

data/app/controllers/recourse/base_controller.rb

@@ -3,7 +3,7 @@ module Recourse
   # its own behavior above it — `class RecoursesController < Recourse::BaseController`
   # with a `before_action :authenticate!` guards every screen the gem serves.
   class BaseController < ApplicationController
-    include Pagy::Method, AttachmentResolution, AttachmentWriting,
+    include Pagy::Method, Positioned, AttachmentResolution, AttachmentWriting,
             Landing, Paging, ListResolution, ParentNaming,
             ParentResolution, ReferenceResolution, ResourceResolution,
             Weeks, Zoning
@@ -22,7 +22,7 @@ module Recourse
     # Lists one page of the model the route is named after, or one week of it where the
     # calendar was asked for — a week is how much that shape shows. `@q` is Ransack's own.
     def index
-      search = Search.new recourse_relation, params[:q]
+      search = Search.new recourse_relation, params[:q], positioned: @recourse_position
       @q = search.query
 
       @pagy, @resources = week_or_page search.scope

data/app/controllers/recourse/positions_controller.rb

@@ -0,0 +1,43 @@
+module Recourse
+  # The place one row holds in a table somebody positioned: written by a drag, and never
+  # read back here. The path names the row and the route names the rows it is counted
+  # among, so a position is all there is to submit.
+  class PositionsController < ::RecoursesController
+    # `update` is a member action everywhere else, so the inherited callback would
+    # look for an `:id` a singular resource never carries.
+    skip_before_action :find_resource
+
+    # Puts the row the path names where the request says, among the rows the route
+    # named, and answers with as little as the caller can do with: a drag is answered
+    # with nothing at all, the row being already where it was dropped, and redrawing
+    # the table under the cursor that dropped it is what this avoids.
+    def update
+      positioning = Positioning.new recourse_relation, positioned_column
+      positioning.move moved_record, params.expect(:position)
+
+      head :no_content
+    end
+
+  private
+
+    # The model this positions, read off the listing the route was nested under rather
+    # than off this controller's own name, which is always `positions`.
+    def recourse_model = Recourse.model(listing_path)
+
+    def moved_record = resource_class.find(params.expect(:"#{listing_name}_id"))
+
+    # A table nobody positions draws no handle, so the only way here is by hand — which
+    # earns a 404 rather than a 500 from somewhere below.
+    def positioned_column
+      raise ActiveRecord::RecordNotFound unless positioned?
+
+      @recourse_position
+    end
+
+    # One segment up, which is where the routes drew it — the gem draws this path
+    # itself, so unlike a host's nesting there is nothing to look up.
+    def listing_path = controller_path.rpartition('/').first
+
+    def listing_name = listing_path.split('/').last.singularize
+  end
+end

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

@@ -18,15 +18,16 @@
 
     <%# Everything the page is styled by, from the one place every HouseAccount app draws
         on: Bootstrap 6, its icons and the house's own rules for this gem's markup. Served
-        from the `houseaccount` package on a CDN, pinned to a version, so a change there
-        reaches these pages when somebody moves the pin here and not before; the same
-        version stands in the script below and in `Recourse::THEMES_PATH`. A published
-        version is never written again, so the bytes behind that URL cannot move under us.
-        Two connections opened before the parser finds either tag: the stylesheet's plain
-        one and the CORS one a module script and a font are fetched over. -%>
+        from the `houseaccount` package on a CDN, pinned to a version — `Recourse.assets`
+        is where, and `Recourse::BUNDLE` is which — so a change there reaches these pages
+        when somebody moves that line and not before. Two connections opened before the
+        parser finds either tag: the stylesheet's plain one and the CORS one a module
+        script and a font are fetched over. They name the CDN outright, being a hint
+        about it and nothing more, so a host serving the bundle itself simply never uses
+        them. -%>
     <link rel='preconnect' href='https://cdn.jsdelivr.net'>
     <link rel='preconnect' href='https://cdn.jsdelivr.net' crossorigin>
-    <link rel='stylesheet' href='https://cdn.jsdelivr.net/npm/houseaccount@0.13.0/public/css/houseaccount.css'>
+    <link rel='stylesheet' href='<%= Recourse.asset 'css/houseaccount.css' %>'>
     <%# The one thing these screens set that the house's stylesheet does not: system faces
         at a compact size, for pages dense with figures. 14px as rem, so a browser's own
         text-size setting still scales it. After the stylesheet, since both are `:root`. -%>
@@ -50,7 +51,7 @@
     <%# Turbo, Bootstrap and a Stimulus application with every controller this markup
         names, started once under `window.Stimulus`. In the head, so a controller exists
         before the body's first `data-controller`. -%>
-    <script type='module' src='https://cdn.jsdelivr.net/npm/houseaccount@0.13.0/public/js/houseaccount.js'></script>
+    <script type='module' src='<%= Recourse.asset 'js/houseaccount.js' %>'></script>
   </head>
 
   <%# The reader's zone is told to the server here rather than from a page of its

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

@@ -23,6 +23,6 @@
       link.dataset.recourseTheme = ''
       document.head.appendChild(link)
     }
-    link.href = '<%= Recourse::THEMES_PATH %>/' + stored.theme + '.css'
+    link.href = '<%= Recourse.themes_path %>/' + stored.theme + '.css'
   })()
 </script>

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

@@ -17,11 +17,16 @@
           bookmark_digest, Time.zone.name] -%>
 <% cache_if cacheable_table?, key do %>
   <% actions = resource_actions %>
+  <%# Read once for the whole table: every row of it is positioned or none is. -%>
+  <% positioned = positioned? %>
   <div class='table-responsive'>
     <table class='table caption-top table-hover align-middle sm:table-stacked'>
       <thead>
         <tr>
           <% @recourse_headers = true %>
+          <%# The grip leads, because dragging it moves the whole row: what a reader
+              takes hold of belongs at the edge they reach for it from. -%>
+          <%= column header: position_header, class: 'recourse-actions' if positioned %>
           <%# The square a row is kept by opens the table, ahead of the pages it
               leads to: whether this row is one of mine, before what to do with it. -%>
           <%= column header: bookmark_header, class: 'recourse-actions' if resource_bookmarks %>
@@ -31,10 +36,15 @@
           <%= render 'row', resource_key => nil %>
         </tr>
       </thead>
-      <tbody>
+      <tbody <%= tag.attributes data: position_data(pagy) if positioned %>>
         <% @recourse_headers = false %>
         <% recourses.each do |recourse| %>
-          <tr <%= tag.attributes id: Recourse.row_id(recourse), class: bookmark_row_class(recourse) %>>
+          <tr <%= tag.attributes id: Recourse.row_id(recourse),
+                                 class: bookmark_row_class(recourse),
+                                 data: ({ sortable_update_url: position_url(recourse) } if positioned) %>>
+            <% if positioned -%>
+              <%= column header: position_header, class: 'recourse-actions recourse-handle' do %><%= position_handle %><% end %>
+            <% end -%>
             <% if resource_bookmarks -%>
               <%= column header: bookmark_header, class: 'recourse-actions' do %><%= bookmark_button recourse %><% end %>
             <% end -%>

data/config/locales/recourse.en.yml

@@ -18,6 +18,11 @@ en:
     ago: "%{distance} ago"
     all: All %{models}
     all_values: All
+    # Why a model pointing several ways cannot be positioned without a word from it.
+    ambiguous_position: "%{model} points several ways, so which of them its position is
+      counted within is not the gem's to guess. Answer `recourse_siblings` with the rows
+      one of these is positioned among."
+    position: Reorder
     as_calendar: Display as calendar
     as_map: Display as map
     as_table: Display as table
@@ -62,6 +67,9 @@ en:
       has no %{model} model.
     nested: You nested `recourses %{names}` inside `resources :%{parent}`, which does
       not namespace what it holds. Nest it under `recourses :%{parent}` instead.
+    unindexed: "You asked for `recourses %{names}, positionable: true`, which draws no
+      index to put in order. A row is dragged from the table that lists it, so there is
+      nowhere for a drop to be reported from."
     # What a menu with several picks reads as, the first named and the rest counted.
     more: "%{first} + %{count} more"
     new: New %{model}
@@ -72,6 +80,7 @@ en:
     none: "No %{models}."
     optional: Optional
     per_page: "%{limit} per page"
+    position_updated: Position updated
     preview: Preview
     previous_week: Previous week
     previous_weeks: Previous four weeks

data/lib/recourse/assets.rb

@@ -0,0 +1,32 @@
+# Reopened for where the house bundle these pages are drawn from is served from.
+module Recourse
+  # The release of `houseaccount` they are drawn from, named once — the layout links its
+  # stylesheet and its script, and the sidebar's toggle swaps a palette out of the same
+  # release. A published version is never written again, so the bytes behind these URLs
+  # cannot move under us, and a change to the bundle reaches these pages when somebody
+  # moves this line and not before.
+  BUNDLE = '0.14.0'
+
+  class << self
+    # Where that release is served from, with no trailing slash. jsdelivr's copy of the
+    # published package by default, which is what every deployed app reads and the one
+    # place all five of them draw from.
+    #
+    # A host that sets it to `''` serves the bundle itself, out of the `houseaccount`
+    # gem: its engine answers `/css`, `/js` and `/theme` from its own `public/`. That is
+    # how the bundle is worked on — a stylesheet or a controller can be tried on a real
+    # page before the version carrying it is published — and it is the whole of what
+    # such a host writes.
+    attr_accessor :assets
+  end
+
+  @assets = "https://cdn.jsdelivr.net/npm/houseaccount@#{BUNDLE}/public"
+
+  # One file of the bundle.
+  def self.asset(path) = "#{assets}/#{path}"
+
+  # And the folder one palette is read from, which three places ask for: the layout
+  # links the one a host named, the sidebar's toggle rotates through the rest, and the
+  # layout's own script puts back whichever the reader chose last time.
+  def self.themes_path = asset('theme')
+end

data/lib/recourse/helpers/cells.rb

@@ -21,22 +21,22 @@ module Recourse
         Recourse.ordered resource_model, resource_model.column_names - hidden_columns
       end
 
-      # What no table shows, less whatever the model asked to draw anyway. Each of
-      # the four below is a default the gem picks, and a host is what answers for
-      # its own screens — so naming one overrules it.
+      # What no table shows, less whatever the model asked to draw anyway. Each below
+      # is a default the gem picks, and a host answers for its own screens.
       def hidden_columns
         columns_hidden_by_default - Array(resource_model.recourse_displayed).map(&:to_s)
       end
 
       # Ciphertext, the id that addresses the row, the parent a nested route already
       # names, the timestamps and every JSON payload — what a machine keeps rather than
-      # what a row is about — and whatever the model asked to hide, the one of these a
-      # host decides without the override above.
+      # what a row is about — whatever the model asked to hide, the one of these a host
+      # decides without the override above, and the column *this page* is dragged into
+      # order by, where a host positioned a second listing by one the model never keeps.
       def columns_hidden_by_default
         [
           resource_model.recourse_encrypted_names, resource_model.primary_key, TIMESTAMPS,
           resource_parent_association&.foreign_key, json_columns,
-          Recourse.hidden_columns(resource_model),
+          Recourse.hidden_columns(resource_model), position_column,
         ].flatten.compact
       end
 

data/lib/recourse/helpers/positions.rb

@@ -0,0 +1,54 @@
+module Recourse
+  module Helpers
+    # What a table somebody positions by hand draws, and what it stops drawing.
+    module Positions
+      # The concept the grip beside each row is drawn as, named for an icon set to
+      # answer for rather than spelled as one set's own class: Bootstrap draws it
+      # `grip-vertical`, iOS as the three bars it has used for a reorder grabber
+      # since the first table view, and Material as `drag_indicator`.
+      HANDLE = :drag
+
+    private
+
+      # The column these rows are dragged into order by, which the controller settled
+      # before the page began: a listing may be positioned by a column the model never
+      # nominated, and only the controller knows which.
+      def position_column = controller_assign('recourse_position')
+
+      # Whether these rows are ones a reader positions, which is the same question.
+      def positioned? = position_column.present?
+
+      # The grip's heading: the icon on the header row, since the column is as narrow
+      # as what sits in it, and the word in every other for the `data-cell` a stacked
+      # table labels itself with.
+      def position_header
+        label = t 'recourse.position'
+        return label unless @recourse_headers
+
+        icon_heading HANDLE, label
+      end
+
+      # The grip itself. A method rather than the constant, so a template reaches for
+      # nothing a view context cannot resolve.
+      def position_handle = icon_tag(HANDLE)
+
+      # What the body carries so a drop knows what it is counting from: the rows are a
+      # page rather than the table, so the index a drag reports is short by whatever
+      # the pages before it hold.
+      def position_data(pagy)
+        {
+          controller: 'sortable', sortable_offset_value: pagy&.offset.to_i,
+          sortable_message_value: t('recourse.position_updated'),
+        }
+      end
+
+      # And what each row carries: where to write the place it ends up. One URL per
+      # row rather than one template on the body, so a host's own row partial and a
+      # nested table alike are addressed by the routes rather than by string-building.
+      def position_url(record)
+        url_for controller: "/#{controller.controller_path}/positions", action: :update,
+                "#{resource_key}_id": record
+      end
+    end
+  end
+end

data/lib/recourse/helpers/searches.rb

@@ -20,6 +20,11 @@ module Recourse
       # earns it — a table with nothing worth searching may still be worth filtering,
       # and a model whose only columns are an enum and a foreign key is the case.
       def search_form
+        # Nor on a table somebody positions, for the reason a heading stands down: a
+        # search or a filter shortens the page, and a drop on a shortened one reports
+        # a place among the rows that are left rather than a position in the table.
+        return if positioned?
+
         field = resource_search_field
         filters = resource_filter_fields
         return if field.blank? && filters.empty?

data/lib/recourse/helpers/sorts.rb

@@ -43,8 +43,16 @@ module Recourse
         resource_column_title column.to_s
       end
 
-      # Whether the model lets a heading sort by this column.
-      def sortable_column?(column) = resource_model.ransortable_attributes.include?(column.to_s)
+      # Whether the model lets a heading sort by this column — and whether this table
+      # is one a heading may re-sort at all. A positioned table is read in the order
+      # somebody put it in: a drop reports a row's place on the page, which is a
+      # position only while the page runs 1, 2, 3, so a heading that re-sorted it would
+      # leave the next drag renumbering by the wrong index.
+      def sortable_column?(column)
+        return false if positioned?
+
+        resource_model.ransortable_attributes.include? column.to_s
+      end
 
       def sort_mark(column)
         sort = resource_search.sorts.find { |one| one.name == column.to_s }

data/lib/recourse/helpers/themes.rb

@@ -19,7 +19,7 @@ module Recourse
       end
 
       # Where one palette is served from.
-      def theme_stylesheet_path(theme) = "#{Recourse::THEMES_PATH}/#{theme}.css"
+      def theme_stylesheet_path(theme) = "#{Recourse.themes_path}/#{theme}.css"
 
       # What the sidebar's toggle needs to rotate: every palette there is, where they
       # are served from, and where to keep what the reader picked.
@@ -27,7 +27,7 @@ module Recourse
         {
           controller: 'scheme', action: 'scheme#rotate',
           scheme_themes_value: Recourse::THEMES.keys.to_json,
-          scheme_path_value: Recourse::THEMES_PATH,
+          scheme_path_value: Recourse.themes_path,
           scheme_storage_value: Recourse::SCHEME_STORAGE,
         }
       end

data/lib/recourse/helpers.rb

@@ -1,4 +1,5 @@
 require_relative 'helpers/actions'
+require_relative 'helpers/positions'
 require_relative 'helpers/attachments'
 require_relative 'helpers/blobs'
 require_relative 'helpers/bookmarks'
@@ -50,7 +51,7 @@ require_relative 'helpers/zones'
 module Recourse
   # View helpers for the pages the gem renders, and what the parts share.
   module Helpers
-    include Actions, Attachments, Blobs, Bookmarks, Buttons, Calendars, Cards,
+    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,

data/lib/recourse/positionable.rb

@@ -0,0 +1,75 @@
+require 'active_support'
+
+module Recourse
+  # Keeps a positioned table numbered 1, 2, 3: a new row lands last among its own, and
+  # the gap closes behind one that goes. Both are the gem's own screens' business. The
+  # form it draws never asks for a position — a reader sets one by dragging a row, and
+  # a box beside the handle would be a second way to say a thing already said — so a
+  # column the schema insists on has to be filled from somewhere. And what a drop
+  # reports is a row's place on the page, which means a position only while the two run
+  # together: leave a hole and every later drag lands beside where it was aimed.
+  #
+  # Every model carries this, and it acts on the ones that keep a `position`. Nothing
+  # to include and nothing to remember: the column is the declaration, so a table with
+  # one is numbered whether its rows are ever dragged or only ever made in a console.
+  # A host maintaining its own order says `def recourse_position = nil` and gets
+  # neither callback. What it writes otherwise is `recourse_siblings`, and only where
+  # more than one key could be the parent.
+  module Positionable
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :recourse_place_last, on: :create
+      after_destroy :recourse_close_gap
+    end
+
+    # The rows this one's position is counted among: those under the same parent, or
+    # the whole table where the model points nowhere. The parent is named rather than
+    # its key, so a key that names no one table is answered by the record it holds and
+    # the two halves are matched together.
+    #
+    # Override where two keys could be the parent and only one is: a picture belongs to
+    # a department and to the file it shows, and its place is among the department's.
+    def recourse_siblings
+      name = recourse_position_reference
+      return self.class.all unless name
+
+      self.class.where name => public_send(name)
+    end
+
+  private
+
+    # A model pointing one way is positioned within what it points at, and one pointing
+    # nowhere is a whole table in one order. Which of several is the parent is the
+    # model's to say: guessing would number a picture among every picture there is,
+    # quietly and at the first write.
+    def recourse_position_reference
+      references = self.class.reflect_on_all_associations :belongs_to
+      return if references.empty?
+      raise Error, I18n.t('recourse.ambiguous_position', model: self.class.name) unless
+        references.one?
+
+      references.first.name
+    end
+
+    def recourse_place_last
+      column = Recourse.position_column self.class
+      return unless column && self[column].nil?
+
+      self[column] = recourse_siblings.maximum(column).to_i + 1
+    end
+
+    def recourse_close_gap
+      column = Recourse.position_column self.class
+      return unless column
+
+      Positioning.new(recourse_siblings, column).close self[column]
+    end
+  end
+end
+
+# Beside `Recoursive`'s own: a model is positioned by keeping the column, and there is no
+# second place to say it again.
+ActiveSupport.on_load :active_record do
+  include Recourse::Positionable
+end

data/lib/recourse/positioning.rb

@@ -0,0 +1,60 @@
+module Recourse
+  # Moves one row of a positioned table to a place in it, and closes the gap it leaves
+  # by shifting whatever it displaced one step the other way.
+  class Positioning
+    # The rows a position is counted within, and the column it is counted in. A
+    # relation rather than a model, because which rows those are is the route's answer
+    # on a drag and the record's on a delete, and each caller has already asked.
+    def initialize(relation, column)
+      @relation = relation
+      @column = column
+    end
+
+    # Puts the record at `position`, counting from one and never past the end — a drag
+    # reports where a row was dropped, and a page is not the whole table. That the two
+    # agree at all is what `Positionable` is for: a drop names a row's place on the page,
+    # which is a position only while the table runs 1, 2, 3 with no gaps in it.
+    def move(record, position)
+      target = position.to_i.clamp 1, @relation.count
+      current = record[@column]
+      return if target == current
+
+      @relation.transaction do
+        displace record, current, target
+        record.update! @column => target
+      end
+    end
+
+    # Closes the gap a row left behind it: whatever stood after it moves one step up.
+    # The row itself is already gone, so the block starts where it was standing.
+    def close(from)
+      @relation.where(@column => from..).update_all shift(-1)
+    end
+
+  private
+
+    # Everything between where the row was and where it is going moves one step
+    # towards the space it left: moving up, the block beneath it shifts down; moving
+    # down, the block above it shifts up. That is what the two ranges say, the
+    # half-open one compensating for the row itself being left out of the count.
+    def displace(record, current, target)
+      delta = current <=> target
+      between = delta.positive? ? target...current : current..target
+
+      @relation.excluding(record).where(@column => between).update_all shift(delta)
+    end
+
+    # One statement however many rows it moves, and it touches them in the same
+    # breath: `update_all` runs no callbacks, so nothing else would tell the relation
+    # a table caches on that its version has changed, and the old order would be
+    # served straight back.
+    def shift(delta)
+      column = @relation.klass.connection.quote_column_name @column
+      moved = "#{column} = #{column} + ?"
+
+      return [moved, delta] unless @relation.klass.column_names.include? 'updated_at'
+
+      ["#{moved}, updated_at = ?", delta, Time.current]
+    end
+  end
+end

data/lib/recourse/positions.rb

@@ -0,0 +1,50 @@
+# Reopened for the order somebody put a table's rows in, which is neither the order
+# they were made in nor one a heading sorts them into.
+module Recourse
+  # The column that order is kept in. The whole of the opt-in, the way a
+  # `google_place_id` is the whole of a map's: a table keeping a place in each row has
+  # said its rows are in an order, and there is nothing else for a model to declare.
+  POSITION_COLUMN = 'position'
+
+  # Whether a model's rows are positioned by hand. Asked of the type the model reports,
+  # as a calendar asks about the two ends of its events — a `position` holding a job
+  # title is a word about the row rather than a place among rows, and a table of those
+  # is one this must leave alone.
+  #
+  # The guard earns more here than it does there. A map and a calendar only read, so a
+  # column mistaken for one costs a link nobody follows; positioning writes, and it
+  # writes at the first save — a new row takes a number and a deleted one closes the
+  # gap behind it — so a wrong guess here is a column overwritten rather than a page
+  # drawn wrong.
+  def self.positionable?(model)
+    model.column_names.include?(POSITION_COLUMN) &&
+      model.type_for_attribute(POSITION_COLUMN).type == :integer
+  end
+
+  # The column a model is positioned by, or nil where nobody positions it. The model's
+  # own word rather than the convention, since that is what a host overrides — and nil
+  # for a page whose rows answer no model at all.
+  def self.position_column(model)
+    model.recourse_position&.to_s if model.respond_to? :recourse_position
+  end
+
+  # The same as a list, for a caller subtracting it from a set of column names: a
+  # position is nobody's to type and no table's to draw, since the row's own place in
+  # the table already says it.
+  def self.position_columns(model) = Array(position_column(model))
+
+  # Whether *this* page is one the positioning means anything on, which is the same
+  # question as whether the rows it lists are the rows a position is counted within.
+  #
+  # The association rather than the record it found: a key is what makes every row on
+  # the page share the parent, and `parent_columns` narrows the relation by the same
+  # one. A model nothing points away from — a flat list — is its own whole table, so
+  # its index is that level too. What is neither is a page listing every row across
+  # every parent, where the positions run 1, 2, 3, 1, 2, 3 and mean nothing side by
+  # side: that page sorts and searches like any other, and offers no handle.
+  def self.positioned?(model, association)
+    return false unless position_column model
+
+    association.present? || model.recourse_references.empty?
+  end
+end

data/lib/recourse/recoursive.rb

@@ -62,9 +62,25 @@ module Recourse
     # belongs_to it can follow, since each cell naming one would be a query of its own.
     def recourse_includes = recourse_references.map(&:name)
 
-    # How the index sorts its rows, in any shape `order` accepts. By id by default,
-    # which is the one column every table has and the order rows were created in.
-    def recourse_order = :id
+    # The column this model's rows are positioned by — dragged into an order somebody
+    # chose rather than sorted into one — or nil for a table nobody positions. The
+    # column is the whole of the declaration, so a model keeping a `position` has said
+    # this already and says nothing here.
+    #
+    # Overridden two ways. `def recourse_position = :ordering` where the column is
+    # named otherwise, and `def recourse_position = nil` where a host keeps the order
+    # itself: that one is the way out of the convention, and it takes the handle off
+    # the table and both callbacks off the model together.
+    def recourse_position
+      Recourse::POSITION_COLUMN if Recourse.positionable? self
+    end
+
+    # How the index sorts its rows, in any shape `order` accepts. The column it is
+    # positioned by where there is one — the order a table is read in and the order
+    # somebody put it in are one fact, and a table read in another order would have a
+    # drop reporting a place that is no position at all — and by id otherwise, which is
+    # the one column every table has and the order rows were created in.
+    def recourse_order = recourse_position&.to_sym || :id
 
     # What a column is for, said where the table itself documents it — a form draws it
     # under the field that sets it. Read from the schema, which is the one thing here no

data/lib/recourse/routes/nested.rb

@@ -1,27 +1,42 @@
 module Recourse
   module Routes
     # What a `recourses` block draws around whatever the host wrote inside it: the
-    # square that keeps one of its rows.
+    # square that keeps one of its rows, and the place one of them holds.
     module Nested
     private
 
-      # What a resource holds: the square that keeps one of its rows, and whatever the
-      # host's own block declared — each under the resource's own module, which is what
-      # every nested page relies on.
-      def draw_within(keepable, block)
+      # What a resource holds: the square that keeps one of its rows, the place a row
+      # holds in a table somebody positioned, and whatever the host's own block declared —
+      # each under the resource's own module, which is what every nested page relies on.
+      def draw_within(keepable, positionable, block)
+        addressable = addressable_rows?
+
         scope module: parent_resource.name do
-          draw_bookmark if keepable && addressable_rows?
+          draw_bookmark if keepable && addressable
+          draw_position if positionable && addressable
           instance_exec(&block) if block
         end
       end
 
       # Whether this resource has rows to address one at a time. A bookmark names one
-      # row, which means nothing for a name with no class behind it at all — and one was
-      # drawn anyway, at `/placeholders/:placeholder_id/bookmark`, where nothing linked
-      # to it and anything reaching it raised. Asked of the constant rather than the
-      # class: loading a model while the routes draw is what Rails 8.2 warns about.
+      # row and a position names one row, so neither means anything for a name with no
+      # class behind it at all — and one was drawn anyway, at
+      # `/placeholders/:placeholder_id/bookmark`, where nothing linked to it and
+      # anything reaching it raised. Asked of the constant rather than the class:
+      # loading a model while the routes draw is what Rails 8.2 warns about.
       def addressable_rows? = Object.const_defined? Recourse.model_name(parent_resource.name)
 
+      # The place a row of a positioned table holds, at `/teams/5/position`. Recorded
+      # nowhere, for the reason the bookmark gives: a tab and a bare-action button both
+      # look under a resource, and this is neither. Drawn wherever an index is —
+      # whether a model keeps a position column is a question for a request, and asking
+      # it here would reach for a database before the routes are even finished.
+      def draw_position
+        path = [current_module, 'positions'].compact.join '/'
+        Controllers.define_missing(path) { PositionsController }
+        resource :position, only: :update
+      end
+
       # The row a table's bookmark square writes: one record kept by whoever is looking,
       # at `/places/5/bookmark`. Deliberately not recorded through `Recourse.nest` — it
       # would sit directly under the resource, where a tab and a bare-action button both

data/lib/recourse/routes.rb

@@ -24,10 +24,15 @@ module Recourse
       keepable = Recourse.bookmarks? && parent_resource.nil?
 
       names.each { |name| declare_resource name }
+      # The host's word, and taken out before Rails sees the rest: `resources` would
+      # refuse a keyword it does not know.
+      positionable = options.delete(:positionable) { false }
       options = default_nested_actions options
-      return resources(*names, **options) unless block || keepable
+      refuse_unindexed_positioning names, positionable, options
 
-      resources(*names, **options) { draw_within keepable, block }
+      return resources(*names, **options) unless block || keepable || positionable
+
+      resources(*names, **options) { draw_within keepable, positionable, block }
     end
 
   private
@@ -40,6 +45,23 @@ module Recourse
       Controllers.define_missing path
     end
 
+    # A table is put in order from its index and from nowhere else, so asking for the
+    # route without drawing one is a host saying two things that cannot both hold.
+    def refuse_unindexed_positioning(names, positionable, options)
+      return unless positionable && !indexed?(options)
+
+      raise Error, I18n.t('recourse.unindexed', names: names.map(&:inspect).join(', '))
+    end
+
+    # Whether `index` survived the `only:` or `except:` the host wrote. Neither of
+    # them is the common case, and both name the action plainly.
+    def indexed?(options)
+      return Array(options[:except]).map(&:to_sym).exclude?(:index) if options.key? :except
+      return Array(options[:only]).map(&:to_sym).include?(:index) if options.key? :only
+
+      true
+    end
+
     def default_nested_actions(options)
       return options if !parent_resource || options.key?(:only) || options.key?(:except)
 

data/lib/recourse/search.rb

@@ -14,8 +14,14 @@ module Recourse
     # it narrowed to rather than around it — the model is still what answers for the
     # order, the eager loads and the allowlist, and a relation knows its own.
     #
-    def initialize(relation, params)
+    # `positioned` is the column this page is dragged into order by, or nil where it is
+    # no such page. The controller's word rather than a question asked here: whether a
+    # place among rows means anything depends on the level the page was reached at,
+    # which the route knows and a relation does not — and a listing may be positioned by
+    # a column the model never keeps, which only its own controller knows.
+    def initialize(relation, params, positioned: nil)
       @model = relation.klass
+      @positioned = positioned
       @query = relation.ransack conditions(params)
     end
 
@@ -33,19 +39,27 @@ module Recourse
     # A heading's sort or the model's own order, each column with its empty rows last.
     # Ransack has ordered the relation already where a heading asked, but as the bare
     # column; the same sort is written again here so it ends the way every order does.
+    #
+    # And on a page somebody positions, the column they positioned it by — which is the
+    # model's own order for a table positioned by the column it keeps, and is not for the
+    # second listing of one, where a host named another. The order a table is read in
+    # and the order somebody put it in have to be the same order, or a drop reports a
+    # place that is no position at all.
     def ordering
       sorts = @query.sorts.map { |sort| sort.attr.public_send(sort.dir).nulls_last }
       return sorts if sorts.any?
 
-      kept_first + Recourse.nulls_last(@model, @model.recourse_order)
+      kept_first + Recourse.nulls_last(@model, @positioned&.to_sym || @model.recourse_order)
     end
 
     # The rows this viewer has kept, ahead of whatever the model orders by — but only
     # where nobody clicked a heading, which is the same word `recourse_order` answers
     # to. A semi-join rather than an outer one: it cannot multiply a row, and it
-    # leaves the count pagy runs over this relation well-formed.
+    # leaves the count pagy runs over this relation well-formed. Never on a positioned
+    # table, where it would put one reader's kept rows ahead of the order everybody
+    # else set by hand — and leave the numbers no longer running 1, 2, 3 down the page.
     def kept_first
-      reflection = Recourse.bookmarks_for @model
+      reflection = Recourse.bookmarks_for @model unless @positioned
       return [] unless reflection
 
       kept = Recourse.bookmarks_of(reflection).select reflection.foreign_key
@@ -60,8 +74,12 @@ module Recourse
     # is dropped, since `IN ()` would match no row rather than every one.
     def conditions(params)
       # `?q=anything` reaches here as a String rather than as parameters of its own,
-      # and a search nobody asked for reaches here as nil. Neither is a condition.
-      return {} unless params.is_a? ActionController::Parameters
+      # and a search nobody asked for reaches here as nil. Neither is a condition — and
+      # neither is anything at all where the table is positioned by hand, since a search
+      # or a filter shortens the page and a drop on a shortened one reports a place
+      # among the rows that are left. Refused here rather than by leaving the form off
+      # the page, because an address is typed as readily as it is clicked.
+      return {} if @positioned || !params.is_a?(ActionController::Parameters)
 
       params.to_unsafe_h.filter_map do |key, value|
         value = list_values value if key.match? LIST_PREDICATES

data/lib/recourse/themes.rb

@@ -22,11 +22,6 @@ module Recourse
     tokyo_night: %i[blue brown cyan gray green orange pink purple red yellow],
   }.freeze
 
-  # Where the palettes are served from, named once: the layout links one, the layout's
-  # own script puts back the one a reader chose, and the sidebar's controller swaps it.
-  # The version is the one the layout links its stylesheet and script at.
-  THEMES_PATH = 'https://cdn.jsdelivr.net/npm/houseaccount@0.13.0/public/theme'
-
   # Where a reader's chosen palette and mode are kept in their browser. Named once for
   # the same reason: the sidebar's controller writes it and the layout reads it back.
   SCHEME_STORAGE = 'recourse-scheme'

data/lib/recourse/titles.rb

@@ -26,14 +26,16 @@ module Recourse
       model_title model(name)
     end
 
-    # The same for a name that may resolve to no model at all: an action drawn under
-    # a record still needs a word for its button, and `pause` is a verb this app never
-    # made a class for.
+    # The same for a name that may name no model at all: an action drawn under a record
+    # still needs a word for its button, and `pause` is a verb this app never made a
+    # class for. A word that does resolve is not a model either where what it found has
+    # no `model_name` — `Message` may be a host's own class for gathering rows rather
+    # than a table of them, and asking it would raise rather than read.
     def known_title(name)
       segment = name.to_s.split('/').last
       model = segment.classify.safe_constantize
 
-      model ? model_title(model) : segment.humanize
+      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

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.5.0'
+  VERSION = '5.6.0'
 end

data/lib/recourse.rb

@@ -4,6 +4,7 @@ require 'ransack'
 require 'unicon'
 
 require_relative 'recourse/version'
+require_relative 'recourse/assets'
 require_relative 'recourse/attachments'
 require_relative 'recourse/blobs'
 require_relative 'recourse/bookmarks'
@@ -18,8 +19,11 @@ require_relative 'recourse/helpers'
 require_relative 'recourse/limits'
 require_relative 'recourse/maps'
 require_relative 'recourse/orders'
+require_relative 'recourse/positions'
+require_relative 'recourse/positioning'
 require_relative 'recourse/writes'
 require_relative 'recourse/zones'
+require_relative 'recourse/positionable'
 require_relative 'recourse/broadcasting'
 require_relative 'recourse/recoursive'
 require_relative 'recourse/registry'
@@ -36,9 +40,8 @@ module Recourse
   # them. Named once: three places ask which columns these are.
   TIMESTAMPS = %w[created_at updated_at].freeze
 
-  # The shapes a page of rows takes besides the table, by the format each is asked
-  # for. Every one of them is the same HTML drawn another way, which is why none has
-  # a template of its own and all three answer to one controller action.
+  # The shapes a page of rows takes besides the table, by the format each is asked for.
+  # Both are the same HTML drawn another way: no template of their own, and one action.
   SHAPES = %i[map cal].freeze
 
   class << self
@@ -59,12 +62,14 @@ module Recourse
                    hidden_columns(model)
   end
 
-  # Columns no screen shows: whatever the model asked to hide through
-  # `recourse_hidden` — one name or a list, taken either way — and the column Rails
-  # reserves for single table inheritance. A class name is machinery, not something
-  # to read out or type over.
+  # 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]
+    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
@@ -75,17 +80,16 @@ module Recourse
     [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 that resolves to no model is a routes file to fix
-  # rather than a `NameError` from somewhere inside a view.
+  # 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.
   def self.model(name)
     model?(name) || raise(Error, I18n.t('recourse.missing_model', name:, model: model_name(name)))
   end
 
   # The same, answering nil where there is no such model rather than raising. A bare
-  # action is a verb — `recourses :sweeps, 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.
+  # 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.
   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.5.0
+  version: 5.6.0
 platform: ruby
 authors:
 - claudiob
@@ -128,12 +128,14 @@ files:
 - app/controllers/concerns/recourse/paging.rb
 - app/controllers/concerns/recourse/parent_naming.rb
 - app/controllers/concerns/recourse/parent_resolution.rb
+- app/controllers/concerns/recourse/positioned.rb
 - app/controllers/concerns/recourse/reference_resolution.rb
 - app/controllers/concerns/recourse/resource_resolution.rb
 - app/controllers/concerns/recourse/weeks.rb
 - app/controllers/concerns/recourse/zoning.rb
 - app/controllers/recourse/base_controller.rb
 - app/controllers/recourse/bookmarks_controller.rb
+- app/controllers/recourse/positions_controller.rb
 - app/controllers/recourses_controller.rb
 - app/views/layouts/recourses.html.erb
 - app/views/recourses/_breadcrumb.html.erb
@@ -161,6 +163,7 @@ files:
 - app/views/recourses/show.html.erb
 - config/locales/recourse.en.yml
 - lib/recourse.rb
+- lib/recourse/assets.rb
 - lib/recourse/attachments.rb
 - lib/recourse/blobs.rb
 - lib/recourse/bookmarks.rb
@@ -202,6 +205,7 @@ files:
 - lib/recourse/helpers/navigation.rb
 - lib/recourse/helpers/parents.rb
 - lib/recourse/helpers/pictures.rb
+- lib/recourse/helpers/positions.rb
 - lib/recourse/helpers/previews.rb
 - lib/recourse/helpers/references.rb
 - lib/recourse/helpers/refreshes.rb
@@ -224,6 +228,9 @@ files:
 - lib/recourse/limits.rb
 - lib/recourse/maps.rb
 - lib/recourse/orders.rb
+- lib/recourse/positionable.rb
+- lib/recourse/positioning.rb
+- lib/recourse/positions.rb
 - lib/recourse/recoursive.rb
 - lib/recourse/registry.rb
 - lib/recourse/routes.rb