plutonium 0.62.2 → 0.63.0

data/lib/plutonium/interaction/concerns/scoping.rb

@@ -11,6 +11,16 @@ module Plutonium
       #
       # The `scoped_record_of_type` method checks both contexts and ensures type safety.
       #
+      # == Precondition
+      #
+      # These methods read the controller the interaction is rendering in, so
+      # they require a Plutonium controller: `current_scoped_entity` needs
+      # Core::Controllers::EntityScoping (which Plutonium::Core::Controller
+      # includes, portal or not), and `current_parent` needs
+      # Plutonium::Resource::Controller. Called anywhere else they raise
+      # NoMethodError, deliberately — see #current_parent. An interaction that
+      # can run outside a resource controller must not ask for a parent.
+      #
       # @example Using in an interaction
       #   class MyInteraction < Plutonium::Resource::Interaction
       #     include Plutonium::Interaction::Concerns::Scoping
@@ -33,26 +43,77 @@ module Plutonium
         #
         # @param klass [Class] the expected model class
         # @return [Object, nil] the scoped record if found and type matches, nil otherwise
+        # Asks for the parent only if the entity did not already answer.
+        #
+        # "Prefers entity over parent" has to mean the parent is not consulted at
+        # all when the entity matches, or the preference is only about which
+        # answer wins rather than which questions get asked. The array form
+        # evaluated both before looking at either, so a caller that wanted the
+        # TENANT still walked view_context.controller.helpers for a parent whose
+        # answer it then discarded.
+        #
+        # It also keeps the precondition above honest. #current_parent no longer
+        # rescues, so it raises wherever Plutonium::Resource::Controller is not
+        # in play — and every caller today is an interaction, which always runs
+        # under one. Nothing reaches that raise now; asking lazily is what stops
+        # a tenant-only caller from being the one that finds it.
         def scoped_record_of_type(klass)
-          [current_scoped_entity, current_parent].find { |record| record.is_a?(klass) }
+          entity = current_scoped_entity
+          return entity if entity.is_a?(klass)
+
+          parent = current_parent
+          parent if parent.is_a?(klass)
         end
 
         # Returns the parent record from the controller (nested routes).
         #
-        # @return [Object, nil] the current parent or nil
+        # Reached through +helpers+, not off the controller: both readers are
+        # PRIVATE controller methods published with +helper_method+ (see
+        # Plutonium::Resource::Controller and Core::Controllers::EntityScoping),
+        # so calling them on the controller raises NoMethodError.
+        #
+        # Which is exactly what it should do. Neither reader rescues, because the
+        # two answers must never collapse: "there is no parent" and "I could not
+        # determine the parent" look identical as nil, and for the tenant below
+        # that identity is a fail-OPEN — a nil tenant drops the entity filter
+        # rather than narrowing to one. A rescue here bought silence about a
+        # broken call for as long as it shipped; the next visibility change or
+        # typo would buy the same silence again.
+        #
+        # nil here means the route is not nested, which is the controller
+        # answering rather than an error being swallowed.
+        #
+        # @return [Object, nil] the current parent, or nil on a non-nested route
         def current_parent
-          view_context.controller.current_parent
-        rescue NoMethodError
-          nil
+          view_context.controller.helpers.current_parent
+        end
+
+        # The association a nested child hangs off its parent, e.g. :comments for
+        # /posts/5/comments.
+        #
+        # Reached through +helpers+ and unrescued for the same reasons as
+        # #current_parent above, and always answered together with it: a policy
+        # needs both halves or neither (Policy#default_relation_scope raises on
+        # one alone).
+        #
+        # @return [Symbol, nil] nil on a non-nested route
+        def current_nested_association
+          view_context.controller.helpers.current_nested_association
         end
 
         # Returns the entity record from the controller (portal multi-tenancy).
         #
-        # @return [Object, nil] the current scoped entity or nil
+        # nil means the portal has NO tenant, never that one could not be found.
+        #
+        # @return [Object, nil] the current scoped entity, or nil in an un-scoped portal
         def current_scoped_entity
-          view_context.controller.current_scoped_entity
-        rescue NoMethodError
-          nil
+          controller = view_context.controller
+          # Asking an un-scoped portal for its entity raises NotImplementedError
+          # by design; "there is no tenant" is the honest answer for a caller
+          # that only wants to know which one it is in.
+          return nil unless controller.scoped_to_entity?
+
+          controller.helpers.current_scoped_entity
         end
 
         # Returns the appropriate parent for URL generation.

data/lib/plutonium/interaction/response/redirect.rb

@@ -17,15 +17,23 @@ module Plutonium
           redirect_options = @options
 
           controller.instance_eval do
-            # Preserve the request format unless explicitly specified
+            # Preserve the request format unless explicitly specified.
+            #
+            # Skipped for a target that is ALREADY A URL. There is nothing to
+            # merge a format into, and url_for takes exactly one argument — so
+            # appending the options hash raises ArgumentError rather than
+            # producing a formatted URL. A caller handing over a complete URL has
+            # already decided what it points at.
+            fully_formed_url = redirect_args.size == 1 && redirect_args.first.is_a?(String)
+
             url_options = redirect_args.last.is_a?(Hash) ? redirect_args.last : {}
-            if !url_options.key?(:format) && request.format.symbol != :html
+            if !fully_formed_url && !url_options.key?(:format) && request.format.symbol != :html
               url_options = url_options.merge(format: request.format.symbol)
               redirect_args = [*redirect_args[0...-1], url_options] if redirect_args.last.is_a?(Hash)
               redirect_args = [*redirect_args, url_options] unless redirect_args.last.is_a?(Hash)
             end
 
-            url = url_for(*redirect_args)
+            url = fully_formed_url ? redirect_args.first : url_for(*redirect_args)
 
             respond_to do |format|
               format.turbo_stream do

data/lib/plutonium/kanban/board.rb

@@ -35,6 +35,20 @@ module Plutonium
       # Resolves the board's effective show_in, falling back to the definition's
       # `show_in` when the board doesn't override it. Pass the resource definition.
       def show_in_for(definition) = @show_in || definition.show_in
+
+      # The board's positioning strategy: its own `position_on` if the block
+      # declared one, else the definition's, else the historic default.
+      #
+      # Resolved LAZILY, not at build time: `kanban` eagerly compiles the board
+      # at class-load (definition/index_views.rb), so a board built before a
+      # later `position_on` line would silently miss it — making the declaration
+      # order-dependent in the class body.
+      #
+      # Takes the resource definition, exactly like #show_in_for above.
+      def position_config_for(definition)
+        @position_config || definition.defined_position_config ||
+          Plutonium::Positioning::Config.default
+      end
     end
   end
 end

data/lib/plutonium/kanban/column.rb

@@ -32,8 +32,10 @@ module Plutonium
         # `resource` attribute), never collection/bulk-shaped (`resources`). Reject
         # anything else at definition time so a mis-shaped interaction can't (a) blow
         # up at drop time on the `resource=` assignment, or (b) get auto-classified
-        # by Action::Interactive::Factory as a bulk action and leak into the
-        # bulk-actions bar (which does not filter kanban_drop actions).
+        # by Action::Interactive::Factory as a bulk action. The bulk bars now
+        # filter `hidden?` themselves, so (b) is defence-in-depth — but keep the
+        # guard: failing at definition time with a message that names the fix
+        # beats failing at drop time on the `resource=` assignment.
         if enter_interaction && !enter_interaction.attribute_names.map(&:to_sym).include?(:resource)
           raise ArgumentError, "enter_interaction: #{enter_interaction} must operate on a single record (declare `attribute :resource`); collection/bulk interactions cannot be used as an enter_interaction."
         end

data/lib/plutonium/kanban/dsl.rb

@@ -15,7 +15,10 @@ module Plutonium
         @card_fields = nil
         @per_column = nil
         @realtime = false
-        @position_config = Positioning::Config.default
+        # nil means "not declared" so the board can inherit the definition's
+        # position_on. Resolution — including the historic Config.default
+        # fallback — moves to Board#position_config_for.
+        @position_config = nil
         @lazy = true
         @show_in = nil
       end

data/lib/plutonium/kanban/grouping.rb

@@ -2,33 +2,20 @@
 
 module Plutonium
   module Kanban
-    # Groups an already-authorized, query-applied, UN-paginated relation into
-    # ordered, per_column-capped column entries.
+    # The two primitives every kanban rendering path shares: which columns a
+    # board has, and how a column's scope narrows a relation.
+    #
+    # There is deliberately no `call` that groups a whole relation in one go.
+    # One existed and had no callers: KanbanActions renders columns
+    # independently — each is its own lazy turbo-frame with its own per_column
+    # cap and count — so a whole-board grouper only ever duplicated that logic
+    # while quietly counting and limiting every column on every request.
     module Grouping
       module_function
 
-      # Returns [{column:, cards: [records], total: Integer}, ...] in column order.
-      def call(board:, relation:, context:)
-        columns = resolve_columns(board, context)
-        pos = board.position_config
-        columns.map do |col|
-          scoped = apply_scope(relation, col.scope)
-          ordered = pos.order(scoped)
-          if board.per_column
-            total = ordered.count
-            cards = ordered.limit(board.per_column).to_a
-          else
-            cards = ordered.to_a
-            total = cards.size
-          end
-          {column: col, cards: cards, total: total}
-        end
-      end
-
       # Resolves the column list from a board. For dynamic boards, evaluates
       # the columns_block against the context (which exposes current_user,
-      # params, etc. via delegation to view_context). Public so Task 7 (move
-      # handler) can call Grouping.resolve_columns(board, context) directly.
+      # params, etc. via delegation to view_context).
       def resolve_columns(board, context)
         return board.columns unless board.dynamic?
         Array(context.instance_exec(&board.columns_block)).flatten

data/lib/plutonium/kanban/positioning.rb

@@ -4,72 +4,12 @@ require "plutonium/positioning"
 
 module Plutonium
   module Kanban
+    # Kanban's positioning strategy is the framework-wide one — see
+    # Plutonium::Positioning::Config. This alias preserves the original
+    # namespace so `position_on` and every existing reference keep working.
     module Positioning
-      # Value object passed to Mode B blocks, carrying the full drop context.
-      Move = Data.define(:record, :column, :prev, :next, :index)
-
-      # Strategy configuration object created by the `position_on` DSL.
-      #
-      # Three modes:
-      #   Mode A (:delegate) — delegate reposition! to Plutonium::Positioning concern
-      #   Mode B (:block)    — call a user-supplied block with a Move
-      #   Mode C (:disabled) — no ordering; relation returned unchanged
-      class Config
-        # Mode A, default attribute :position
-        def self.default
-          new(:delegate, :position, nil)
-        end
-
-        # Mode A, custom attribute
-        def self.attribute(attr)
-          new(:delegate, attr.to_sym, nil)
-        end
-
-        # Mode B — orders by attr, write delegated to block
-        def self.with_block(attr, block)
-          new(:block, attr.to_sym, block)
-        end
-
-        # Mode C — disabled
-        def self.disabled
-          new(:disabled, nil, nil)
-        end
-
-        attr_reader :attribute
-
-        def initialize(mode, attribute, block)
-          @mode = mode
-          @attribute = attribute
-          @block = block
-        end
-
-        def disabled?
-          @mode == :disabled
-        end
-
-        # Apply positional ordering to a relation.
-        # Mode A/B: relation.reorder(attribute)
-        # Mode C:   return relation unchanged
-        def order(relation)
-          return relation if disabled?
-          relation.reorder(@attribute)
-        end
-
-        # Persist the new position for a dropped record.
-        # Mode A: delegate to record.reposition!(prev_record:, next_record:)
-        # Mode B: call the user block with a Move
-        # Mode C: no-op
-        def reposition!(record:, column:, prev_record:, next_record:, index:)
-          case @mode
-          when :delegate
-            record.reposition!(prev_record:, next_record:)
-          when :block
-            @block.call(Move.new(record:, column:, prev: prev_record, next: next_record, index:))
-          when :disabled
-            nil
-          end
-        end
-      end
+      Config = Plutonium::Positioning::Config
+      Move = Plutonium::Positioning::Move
     end
   end
 end

data/lib/plutonium/positioning/config.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Plutonium
+  # This file is deliberately dependency-free — no ActiveSupport, no
+  # ActiveRecord, not even the rest of Plutonium::Positioning. A controller,
+  # a definition DSL and a view component all need to name a strategy, and
+  # none of them should have to drag the model concern in to do it.
+  module Positioning
+    # Value object passed to Mode B blocks, carrying the full drop context.
+    Move = Data.define(:record, :column, :prev, :next, :index)
+
+    # Strategy configuration object created by the `position_on` DSL.
+    #
+    # Three modes:
+    #   Mode A (:delegate) — delegate reposition! to Plutonium::Positioning::Model
+    #   Mode B (:block)    — call a user-supplied block with a Move
+    #   Mode C (:disabled) — no ordering; relation returned unchanged
+    class Config
+      # Mode A, default attribute :position
+      def self.default
+        new(:delegate, :position, nil)
+      end
+
+      # Mode A, custom attribute
+      def self.attribute(attr)
+        new(:delegate, attr.to_sym, nil)
+      end
+
+      # Mode B — orders by attr, write delegated to block
+      def self.with_block(attr, block)
+        new(:block, attr.to_sym, block)
+      end
+
+      # Mode C — disabled
+      def self.disabled
+        new(:disabled, nil, nil)
+      end
+
+      attr_reader :attribute
+
+      def initialize(mode, attribute, block)
+        @mode = mode
+        @attribute = attribute
+        @block = block
+      end
+
+      def disabled?
+        @mode == :disabled
+      end
+
+      # Mode A — the framework owns the write, via Positioning::Model. Callers
+      # ask because Mode A is the only mode whose storage they may reason about:
+      # a fractional position between two neighbours, in a known scope group. A
+      # Mode B block owns both the storage and its own notion of neighbours, so
+      # nothing outside it may second-guess the drop it is handed.
+      def delegate?
+        @mode == :delegate
+      end
+
+      # Apply positional ordering to a relation.
+      # Mode A/B: relation.reorder(attribute)
+      # Mode C:   return relation unchanged
+      def order(relation)
+        return relation if disabled?
+        relation.reorder(@attribute)
+      end
+
+      # Persist the new position for a dropped record. Returns true when the
+      # caller must reconcile its view of the list because positions other than
+      # this record's may have changed.
+      #
+      # Mode A: delegate to record.reposition!(prev_record:, next_record:), and
+      #         report whether it had to rebalance the scope group.
+      # Mode B: call the user block with a Move; always true — the block is an
+      #         opaque write, and gems in this space routinely renumber the whole
+      #         group (acts_as_list does).
+      # Mode C: no-op; always false — nothing was written.
+      #
+      # `column` is the kanban column key on a board, and nil on every other
+      # surface (index tables, nested tables, grids) — those have no columns.
+      def reposition!(record:, prev_record:, next_record:, index:, column: nil)
+        case @mode
+        when :delegate
+          record.reposition!(prev_record:, next_record:).rebalanced?
+        when :block
+          @block.call(Move.new(record:, column:, prev: prev_record, next: next_record, index:))
+          true
+        when :disabled
+          false
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/positioning/model.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Positioning
+    # Standalone decimal/fractional ordering. Kanban-independent.
+    #
+    # Including this concern and calling `positioned_on` gives a model:
+    # - automatic position assignment on create (appends to the end of its scope group)
+    # - `reposition!(prev_record:, next_record:)` for drag-and-drop reordering
+    # - `backfill_positions!` class method to number existing rows
+    #
+    # This lives one level below Plutonium::Positioning on purpose. A concern is
+    # mixed into user models, and every constant nested in the included module
+    # joins that model's constant lookup — so a concern named Positioning would
+    # make a bare `Config` inside the model resolve to
+    # Plutonium::Positioning::Config, silently shadowing the app's own ::Config.
+    # Keeping the namespace and the mixin separate stops the leak.
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :positioning_column, instance_accessor: false, default: :position
+        class_attribute :positioning_scope_attr, instance_accessor: false, default: nil
+        # Separate from positioning_column, which has a default and so cannot
+        # answer "did this model actually call positioned_on?". Including the
+        # concern without calling it skips `before_create :assign_initial_position`
+        # entirely — every row keeps a nil position and the order is arbitrary —
+        # so the definition DSL checks this flag, not mere inclusion.
+        class_attribute :positioning_declared, instance_accessor: false, default: false
+      end
+
+      class_methods do
+        # Opt in to positional ordering.
+        #
+        #   positioned_on :position, scope: :status
+        #
+        # @param column [Symbol] the decimal column that stores positions
+        # @param scope  [Symbol, nil] group rows by this column; nil = single global group
+        def positioned_on(column = :position, scope: nil)
+          self.positioning_column = column
+          self.positioning_scope_attr = scope
+          self.positioning_declared = true
+          before_create :assign_initial_position
+        end
+
+        # Number every row in the table per scope group as 1.0, 2.0, … in
+        # +order+ order. Safe to call on an empty table.
+        #
+        # @param order [Symbol] column to sort by when assigning positions
+        def backfill_positions!(order: :created_at)
+          groups = positioning_scope_attr ? all.group_by(&positioning_scope_attr) : {nil => all.to_a}
+          groups.each_value do |rows|
+            # `transaction` on THIS class, never ActiveRecord::Base.transaction.
+            # A transaction is opened on the receiver's connection pool; the
+            # UPDATEs below go out on this model's pool (update_column →
+            # self.class._update_record). For a model on a secondary database
+            # those are two different connections: ActiveRecord::Base would BEGIN
+            # on primary and do nothing else with it while every UPDATE
+            # autocommits on the model's own connection — a crash halfway leaves
+            # the group partly renumbered, with duplicate/gapped positions and
+            # nothing to roll back. Do not "simplify" this back.
+            transaction do
+              rows.sort_by { |r| r.public_send(order) }.each_with_index do |row, i|
+                row.update_column(positioning_column, (i + 1).to_f)
+              end
+            end
+          end
+        end
+      end
+
+      # Move this record so it sits between +prev_record+ and +next_record+
+      # within its scope group. Pass nil for either neighbor to move to an end.
+      #
+      # If the gap between the two neighbors is exhausted (too small to split)
+      # the scope group is rebalanced first so that fresh integer positions are
+      # available, then the record is positioned between the reloaded neighbors.
+      #
+      # @param prev_record [ActiveRecord::Base, nil]
+      # @param next_record [ActiveRecord::Base, nil]
+      # @return [Plutonium::Positioning::Result] whose `rebalanced?` tells the
+      #   caller whether rows OTHER than this one moved — a drag-and-drop client
+      #   that optimistically reordered its own view needs to re-sync when so.
+      def reposition!(prev_record:, next_record:)
+        col = self.class.positioning_column
+        prev_val = prev_record&.public_send(col)
+        next_val = next_record&.public_send(col)
+        rebalanced = Plutonium::Positioning.gap_exhausted?(prev_val, next_val)
+        if rebalanced
+          rebalance_scope_group!
+          prev_val = prev_record&.reload&.public_send(col)
+          next_val = next_record&.reload&.public_send(col)
+        end
+        update!(col => Plutonium::Positioning.position_between(prev_val, next_val))
+        Plutonium::Positioning::Result.new(rebalanced:)
+      end
+
+      private
+
+      def assign_initial_position
+        col = self.class.positioning_column
+        return if public_send(col).present?
+        max = positioning_group_relation.maximum(col) || 0.0
+        public_send(:"#{col}=", max + 1)
+      end
+
+      def positioning_group_relation
+        rel = self.class.all
+        attr = self.class.positioning_scope_attr
+        attr ? rel.where(attr => public_send(attr)) : rel
+      end
+
+      def rebalance_scope_group!
+        col = self.class.positioning_column
+        # self.class.transaction, never ActiveRecord::Base.transaction — the
+        # BEGIN must land on the connection the UPDATEs below actually use. See
+        # the note in backfill_positions!: on a secondary-database model the
+        # ActiveRecord::Base form opens an empty transaction on primary and every
+        # renumbering UPDATE autocommits unprotected, so a failure mid-rebalance
+        # is unrecoverable. Rebalancing is exactly where that matters.
+        self.class.transaction do
+          positioning_group_relation.order(col).each_with_index do |row, i|
+            row.update_column(col, (i + 1).to_f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/positioning.rb

@@ -1,22 +1,40 @@
 # frozen_string_literal: true
 
+# require_relative, not require: test/positioning_postgres_check.rb loads this
+# file directly with require_relative and no $LOAD_PATH setup — it is
+# deliberately framework-free, needing only activerecord + pg. A plain `require`
+# resolves against $LOAD_PATH and so fails there. Matches how lib/plutonium.rb
+# pulls in its own files.
+require_relative "positioning/config"
+require_relative "positioning/model"
+
 module Plutonium
-  # Standalone decimal/fractional ordering. Kanban-independent.
+  # Namespace for decimal/fractional ordering. Kanban-independent.
   #
-  # Including this concern and calling `positioned_on` gives a model:
-  # - automatic position assignment on create (appends to the end of its scope group)
-  # - `reposition!(prev_record:, next_record:)` for drag-and-drop reordering
-  # - `backfill_positions!` class method to number existing rows
+  # This module is a pure namespace — it is never included into a model. The
+  # AR mixin is Plutonium::Positioning::Model and the drag strategy object is
+  # Plutonium::Positioning::Config.
   #
   # Pure math helpers are exposed as module-level methods so they can be
   # called without an AR instance:
   #   Plutonium::Positioning.position_between(1.0, 3.0)  # => 2.0
   #   Plutonium::Positioning.gap_exhausted?(1.0, 1.0)    # => true
   module Positioning
-    extend ActiveSupport::Concern
-
     EPSILON = 1e-6
 
+    # Outcome of a Model#reposition! call. `rebalanced?` is true when the gap
+    # between the neighbours was exhausted and the whole scope group had to be
+    # renumbered — the caller needs to know because every other row's position
+    # changed, so any cached client-side view of the list is stale.
+    #
+    # It lives on the namespace, NOT inside Model, for the same reason the
+    # concern was split out of the namespace in the first place: Model is
+    # included into user models, so anything nested in it joins their constant
+    # lookup and can shadow their own constants (see the comment in model.rb).
+    Result = Data.define(:rebalanced) do
+      def rebalanced? = rebalanced
+    end
+
     # Returns the position that sits between +prev_val+ and +next_val+.
     #
     # Rules:
@@ -38,85 +56,6 @@ module Plutonium
       (next_val - prev_val).abs < EPSILON
     end
 
-    included do
-      class_attribute :positioning_column, instance_accessor: false, default: :position
-      class_attribute :positioning_scope_attr, instance_accessor: false, default: nil
-    end
-
-    class_methods do
-      # Opt in to positional ordering.
-      #
-      #   positioned_on :position, scope: :status
-      #
-      # @param column [Symbol] the decimal column that stores positions
-      # @param scope  [Symbol, nil] group rows by this column; nil = single global group
-      def positioned_on(column = :position, scope: nil)
-        self.positioning_column = column
-        self.positioning_scope_attr = scope
-        before_create :assign_initial_position
-      end
-
-      # Number every row in the table per scope group as 1.0, 2.0, … in
-      # +order+ order. Safe to call on an empty table.
-      #
-      # @param order [Symbol] column to sort by when assigning positions
-      def backfill_positions!(order: :created_at)
-        groups = positioning_scope_attr ? all.group_by(&positioning_scope_attr) : {nil => all.to_a}
-        groups.each_value do |rows|
-          ActiveRecord::Base.transaction do
-            rows.sort_by { |r| r.public_send(order) }.each_with_index do |row, i|
-              row.update_column(positioning_column, (i + 1).to_f)
-            end
-          end
-        end
-      end
-    end
-
-    # Move this record so it sits between +prev_record+ and +next_record+
-    # within its scope group. Pass nil for either neighbor to move to an end.
-    #
-    # If the gap between the two neighbors is exhausted (too small to split)
-    # the scope group is rebalanced first so that fresh integer positions are
-    # available, then the record is positioned between the reloaded neighbors.
-    #
-    # @param prev_record [ActiveRecord::Base, nil]
-    # @param next_record [ActiveRecord::Base, nil]
-    def reposition!(prev_record:, next_record:)
-      col = self.class.positioning_column
-      prev_val = prev_record&.public_send(col)
-      next_val = next_record&.public_send(col)
-      if Plutonium::Positioning.gap_exhausted?(prev_val, next_val)
-        rebalance_scope_group!
-        prev_val = prev_record&.reload&.public_send(col)
-        next_val = next_record&.reload&.public_send(col)
-      end
-      update!(col => Plutonium::Positioning.position_between(prev_val, next_val))
-    end
-
-    private
-
-    def assign_initial_position
-      col = self.class.positioning_column
-      return if public_send(col).present?
-      max = positioning_group_relation.maximum(col) || 0.0
-      public_send(:"#{col}=", max + 1)
-    end
-
-    def positioning_group_relation
-      rel = self.class.all
-      attr = self.class.positioning_scope_attr
-      attr ? rel.where(attr => public_send(attr)) : rel
-    end
-
-    def rebalance_scope_group!
-      col = self.class.positioning_column
-      ActiveRecord::Base.transaction do
-        positioning_group_relation.order(col).each_with_index do |row, i|
-          row.update_column(col, (i + 1).to_f)
-        end
-      end
-    end
-
     # Migration helper that adds a position column pre-tuned for fractional
     # ordering. Mixed into ActiveRecord's table-definition classes by the
     # railtie, so it is available in both create_table and change_table:

data/lib/plutonium/railtie.rb

@@ -41,6 +41,7 @@ module Plutonium
 
     initializer "plutonium.register_migrations" do
       Plutonium::Migrations.register(:wizards, Plutonium.root.join("db/migrate/wizard").to_s)
+      Plutonium::Migrations.register(:async_interactions, Plutonium.root.join("db/migrate/async_interactions").to_s)
     end
 
     # Runs after the host's config/initializers/plutonium.rb (load_config_initializers)