plutonium 0.60.5 → 0.62.0

data/lib/plutonium/kanban/column.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Kanban
+    class Column
+      ROLE_PRESETS = {
+        backlog: {add: true},
+        # Terminal columns: collapsed by default, colour signals the outcome.
+        # :done is the positive close (green); :lost is the negative close
+        # (red) — the natural pair for won/lost pipelines (leads, deals, tickets).
+        done: {color: :green, collapsed: true},
+        lost: {color: :red, collapsed: true}
+      }.freeze
+
+      attr_reader :key, :label, :color, :wip, :scope, :on_enter, :on_exit, :accepts, :actions, :enter_interaction
+
+      def initialize(key, label: nil, color: nil, wip: nil, scope: nil, on_enter: nil, on_exit: nil, on_drop: nil,
+        collapsed: nil, add: nil, accepts: nil, locked: nil, role: nil, enter_interaction: nil, drop_interaction: nil)
+        # on_drop:/drop_interaction: were renamed to on_enter:/enter_interaction:.
+        # Resolve the deprecated aliases first (dev/test raise; deployed envs warn
+        # and map — see resolve_renamed_option) so the rest of initialize only
+        # ever sees the new names.
+        on_enter = resolve_renamed_option(:on_drop, on_drop, :on_enter, on_enter)
+        enter_interaction = resolve_renamed_option(:drop_interaction, drop_interaction, :enter_interaction, enter_interaction)
+
+        preset = role ? ROLE_PRESETS.fetch(role) { raise ArgumentError, "Unknown column role: #{role.inspect}. Valid: #{ROLE_PRESETS.keys.inspect}" } : {}
+        if enter_interaction && !(enter_interaction.is_a?(Class) && enter_interaction < Plutonium::Resource::Interaction)
+          raise ArgumentError, "enter_interaction: must be a Plutonium::Resource::Interaction subclass, got #{enter_interaction.inspect}"
+        end
+        # An enter_interaction acts on the SINGLE dropped card — the move handler
+        # binds it as `resource:`. It must therefore be record-shaped (declare a
+        # `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).
+        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
+        # accepts: is purely structural (topology + client drop hints): true/false
+        # or an Array of source keys. The Proc form was removed — record/user
+        # conditions belong in the kanban_move? policy, which sees the record and
+        # the from/to columns. Fail loud rather than silently treating a stale Proc
+        # as permissive (which would OPEN UP a column that used to restrict drops).
+        if accepts.is_a?(Proc)
+          raise ArgumentError, "kanban column `accepts:` no longer accepts a Proc; use true/false or an Array of source keys, and put record/user conditions in the kanban_move? policy."
+        end
+        @key = key.to_sym
+        @label = label || key.to_s.titleize
+        @color = color.nil? ? preset[:color] : color
+        @wip = wip
+        @scope = scope
+        @on_enter = on_enter
+        @on_exit = on_exit
+        @collapsed = collapsed.nil? ? preset[:collapsed] : collapsed
+        @add = add.nil? ? preset[:add] : add
+        @accepts = accepts.nil? || accepts
+        @locked = locked || false
+        @enter_interaction = enter_interaction
+        @actions = []
+      end
+
+      # A column may run an input-collecting Interaction when a card ENTERS it
+      # (e.g. "mark lead as lost with a reason"). When set, the drop opens the
+      # interaction's form as a modal before the move is committed.
+      def enter_interaction? = !!@enter_interaction
+
+      # Internal action-registration key for the enter interaction, scoped to the
+      # column: :blocked → :blocked_enter_interaction. Nil when unset.
+      #
+      # Column-scoped (not class-name-derived) so it is unique by construction — a
+      # column has at most one enter_interaction, so two columns can never collide
+      # even if they reuse the same interaction class. This key is ONLY an internal
+      # form/param routing handle; it is NOT an authorization name. The move (and
+      # therefore the interaction) is authorized solely by kanban_move? — the
+      # interaction has no policy method of its own.
+      def enter_interaction_key
+        return nil unless @enter_interaction
+        :"#{key}_enter_interaction"
+      end
+
+      def action(key, interaction:, on: :all, label: nil, icon: nil, confirmation: nil)
+        @actions << Action.new(key: key.to_sym, interaction:, on:, label:, icon:, confirmation:)
+      end
+
+      def collapsed? = !!@collapsed
+      def add? = !!@add
+      def locked? = @locked
+
+      # Whether a card from `source_key` may be dropped into this column. Purely
+      # structural — @accepts is normalized to true/false or an Array of source
+      # keys (the constructor rejects a Proc). Drives both the server-side gate in
+      # the move handler and the client-side drop hint (data-kanban-accepts).
+      def accepts?(source_key)
+        case @accepts
+        when Array then @accepts.include?(source_key)
+        else @accepts # true or false
+        end
+      end
+
+      private
+
+      # Bridge a renamed column option. `on_drop:`/`drop_interaction:` became
+      # `on_enter:`/`enter_interaction:`. To avoid breaking live deployments on
+      # upgrade we DON'T hard-fail in deployed envs — we log a deprecation and map
+      # the old value onto the new name. But local envs (development/test) raise,
+      # so the rename is caught during development and can't silently ship. If
+      # both the old and new names are given, the new one wins.
+      def resolve_renamed_option(old_name, old_value, new_name, new_value)
+        return new_value if old_value.nil?
+
+        if Rails.env.local?
+          raise ArgumentError,
+            "kanban column `#{old_name}:` has been renamed to `#{new_name}:` — update your definition."
+        end
+
+        Rails.logger.warn { "[plutonium] kanban column `#{old_name}:` is deprecated; rename it to `#{new_name}:`." }
+        new_value.nil? ? old_value : new_value
+      end
+    end
+  end
+end

data/lib/plutonium/kanban/context.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Plutonium
+  module Kanban
+    # Evaluation scope for dynamic `columns do…end` blocks at request time.
+    #
+    # Delegates everything to the request's view_context so the block can call
+    # current_user, current_scoped_entity, params, helpers, etc. directly —
+    # exactly like Plutonium::Action::ConditionContext does for action conditions.
+    class Context < SimpleDelegator
+    end
+  end
+end

data/lib/plutonium/kanban/dsl.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Kanban
+    class DSL
+      def self.build(&block)
+        dsl = new
+        dsl.instance_eval(&block) if block
+        dsl.to_board
+      end
+
+      def initialize
+        @columns = []
+        @columns_block = nil
+        @card_fields = nil
+        @per_column = nil
+        @realtime = false
+        @position_config = Positioning::Config.default
+        @lazy = true
+        @show_in = nil
+      end
+
+      def column(key, **opts, &blk)
+        col = Column.new(key, **opts)
+        col.instance_eval(&blk) if blk
+        @columns << col
+      end
+
+      # Fluent DSL setters — `attr_writer` would change the call syntax
+      # (`per_column 25` → `self.per_column = 25`), so keep them as methods.
+      # standard:disable Style/TrivialAccessors
+      def columns(&blk) = @columns_block = blk
+      def card_fields(**slots) = @card_fields = slots
+      def per_column(n) = @per_column = n
+      def realtime(v = true) = @realtime = v
+      def lazy(v = true) = @lazy = v
+      # standard:enable Style/TrivialAccessors
+
+      # Overrides where a card click opens the record's show page, for this
+      # board only:
+      #   :modal — open in a centered modal dialog
+      #   :page  — navigate the whole page to the show route
+      # When unset, the board inherits the definition's `show_in` (default :page).
+      def show_in(mode) = @show_in = mode # standard:disable Style/TrivialAccessors
+
+      def position_on(attr = :position, &blk)
+        @position_config =
+          if attr == false
+            Positioning::Config.disabled
+          elsif blk
+            Positioning::Config.with_block(attr, blk)
+          else
+            Positioning::Config.attribute(attr)
+          end
+      end
+
+      def to_board
+        Board.new(
+          columns: @columns,
+          columns_block: @columns_block,
+          card_fields: @card_fields,
+          per_column: @per_column,
+          realtime: @realtime,
+          position_config: @position_config,
+          lazy: @lazy,
+          show_in: @show_in
+        )
+      end
+    end
+  end
+end

data/lib/plutonium/kanban/grouping.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Kanban
+    # Groups an already-authorized, query-applied, UN-paginated relation into
+    # ordered, per_column-capped column entries.
+    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.
+      def resolve_columns(board, context)
+        return board.columns unless board.dynamic?
+        Array(context.instance_exec(&board.columns_block)).flatten
+      end
+
+      # Applies a column scope to a relation.
+      #   Symbol → relation.public_send(sym)   (named scope)
+      #   Proc   → relation.instance_exec(&scope) (inline lambda, e.g. -> { where(status: "todo") })
+      #   nil    → relation unchanged
+      def apply_scope(relation, scope)
+        case scope
+        when Symbol then relation.public_send(scope)
+        when Proc then relation.instance_exec(&scope)
+        when nil then relation
+        else raise ArgumentError, "Unsupported column scope: #{scope.inspect} (expected Symbol, Proc, or nil)"
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/kanban/positioning.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "plutonium/positioning"
+
+module Plutonium
+  module Kanban
+    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
+    end
+  end
+end

data/lib/plutonium/kanban.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "plutonium/positioning"
+require "plutonium/kanban/positioning"
+require "plutonium/kanban/action"
+require "plutonium/kanban/column"
+require "plutonium/kanban/board"
+require "plutonium/kanban/dsl"
+require "plutonium/kanban/context"
+require "plutonium/kanban/grouping"
+require "plutonium/kanban/broadcaster"

data/lib/plutonium/migrations.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Plutonium
+  # Registry of per-feature migration paths.
+  #
+  # Features register their migration directory against a configuration key. A
+  # path is only surfaced by {.enabled_paths} when its feature's config
+  # (+Plutonium.configuration.<feature>+) responds to +.enabled+ and it is true.
+  module Migrations
+    @registry = {}
+
+    class << self
+      # Register a migration path for a feature.
+      #
+      # @param feature [Symbol, String] the configuration key (e.g. +:wizards+)
+      # @param path [String] the absolute migration directory path
+      # @return [String] the registered path
+      def register(feature, path)
+        @registry[feature.to_sym] = path
+      end
+
+      # Clear the registry. Intended for tests.
+      #
+      # @return [Hash]
+      def reset!
+        @registry = {}
+      end
+
+      # Migration paths for features that are currently enabled.
+      #
+      # @return [Array<String>]
+      def enabled_paths
+        @registry.filter_map do |feature, path|
+          cfg = Plutonium.configuration.public_send(feature) if Plutonium.configuration.respond_to?(feature)
+          path if cfg&.respond_to?(:enabled) && cfg.enabled
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/models/has_cents.rb

@@ -76,6 +76,24 @@ module Plutonium
         class_attribute :has_cents_attributes, instance_writer: false, default: {}
       end
 
+      # Resolves the currency unit (symbol) configured for a has_cents decimal
+      # accessor, e.g. :price for `has_cents :price_cents, unit: "£"`.
+      #
+      # @param decimal_attribute [Symbol, String] The decimal accessor name.
+      # @return [String, nil] The unit — a String verbatim, the value of the
+      #   method named by a Symbol unit (per-row currencies), or nil when the
+      #   attribute has no unit configured / is not a has_cents accessor.
+      def has_cents_unit_for(decimal_attribute)
+        decimal_attribute = decimal_attribute.to_sym
+        config = self.class.has_cents_attributes.values.find { |opts| opts[:name] == decimal_attribute }
+        return unless config
+
+        case (unit = config[:unit])
+        when Symbol then public_send(unit)
+        else unit
+        end
+      end
+
       module ClassMethods
         # # Inherit validations from cents attribute to decimal attribute
         # def validate(*args, &block)
@@ -109,10 +127,20 @@ module Plutonium
         #   - rate: 1000 for dollars/mils (1 dollar = 1000 mils)
         #   - rate: 1 for a whole number representation
         # @param suffix [String] The suffix to append to the cents_name if name is not provided (default: "amount").
+        # @param unit [String, Symbol, nil] The currency unit used when the value is rendered as currency.
+        #   A String is used verbatim as the symbol ("£"); a Symbol names a method read off the record for
+        #   per-row currencies (`unit: :currency_symbol`); nil (default) renders with no symbol. Consumers
+        #   (the Currency display component, grid/kanban cards) read this via {#has_cents_unit_for}.
         #
         # @example Standard currency (dollars and cents)
         #   has_cents :price_cents
         #
+        # @example Static currency symbol
+        #   has_cents :price_cents, unit: "£"
+        #
+        # @example Per-row currency symbol read off the record
+        #   has_cents :price_cents, unit: :currency_symbol
+        #
         # @example Custom rate for a different currency division
         #   has_cents :amount_cents, name: :cost, rate: 1000
         #
@@ -121,14 +149,14 @@ module Plutonium
         #
         # @example Using custom suffix
         #   has_cents :total_cents, suffix: "value"
-        def has_cents(cents_name, name: nil, rate: 100, suffix: "amount")
+        def has_cents(cents_name, name: nil, rate: 100, suffix: "amount", unit: nil)
           cents_name = cents_name.to_sym
           name ||= cents_name.to_s.gsub(/_cents$/, "")
           name = name.to_sym
           name = (name == cents_name) ? :"#{cents_name}_#{suffix}" : name
 
           self.has_cents_attributes = has_cents_attributes.merge(
-            cents_name => {name: name, rate: rate}
+            cents_name => {name: name, rate: rate, unit: unit}
           )
 
           class_eval <<-RUBY, __FILE__, __LINE__ + 1

data/lib/plutonium/positioning.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Plutonium
+  # 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
+  #
+  # 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
+
+    # Returns the position that sits between +prev_val+ and +next_val+.
+    #
+    # Rules:
+    #   both nil  → 0.0            (first item in an empty list)
+    #   prev nil  → next_val - 1   (prepend)
+    #   next nil  → prev_val + 1   (append)
+    #   else      → midpoint
+    def self.position_between(prev_val, next_val)
+      return 0.0 if prev_val.nil? && next_val.nil?
+      return next_val - 1 if prev_val.nil?
+      return prev_val + 1 if next_val.nil?
+      (prev_val + next_val) / 2.0
+    end
+
+    # Returns true when +prev_val+ and +next_val+ are so close together
+    # that inserting a new midpoint would produce a duplicate.
+    def self.gap_exhausted?(prev_val, next_val)
+      return false if prev_val.nil? || next_val.nil?
+      (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:
+    #
+    #   create_table :tasks do |t|
+    #     t.position                # decimal :position, precision: 16, scale: 8
+    #     t.position :sort_order    # custom column name
+    #     t.position index: true    # also add a single-column index
+    #   end
+    #
+    #   change_table :tasks do |t|
+    #     t.position
+    #   end
+    #
+    # The precision/scale give midpoints ample headroom over the rebalance
+    # threshold (EPSILON = 1e-6) — a too-small scale lets the last subdivision
+    # round to a neighbor. Pass precision:/scale: to override.
+    module MigrationHelpers
+      DEFAULT_PRECISION = 16
+      DEFAULT_SCALE = 8
+
+      def position(name = :position, **options)
+        column name, :decimal, precision: DEFAULT_PRECISION, scale: DEFAULT_SCALE, **options
+      end
+    end
+  end
+end

data/lib/plutonium/railtie.rb

@@ -39,6 +39,30 @@ module Plutonium
       load_plutonium_initializers
     end
 
+    initializer "plutonium.register_migrations" do
+      Plutonium::Migrations.register(:wizards, Plutonium.root.join("db/migrate/wizard").to_s)
+    end
+
+    # Runs after the host's config/initializers/plutonium.rb (load_config_initializers)
+    # so feature flags like config.wizards.enabled are honoured. Railtie
+    # initializers otherwise run before host initializers, leaving the flag false.
+    initializer "plutonium.migrations", after: :load_config_initializers do |app|
+      # v1 supports `config.wizards.database == :primary` only; the option is
+      # reserved for future multi-db routing of wizard sessions. Fail loudly on an
+      # unsupported value rather than silently registering on the primary database.
+      if Plutonium.configuration.wizards.enabled &&
+          Plutonium.configuration.wizards.database != :primary
+        raise ArgumentError,
+          "config.wizards.database = #{Plutonium.configuration.wizards.database.inspect} is not " \
+          "supported (only :primary). Multi-database routing for wizard sessions is a roadmap follow-up."
+      end
+
+      Plutonium::Migrations.enabled_paths.each do |path|
+        app.config.paths["db/migrate"] << path
+        ActiveRecord::Migrator.migrations_paths << path unless ActiveRecord::Migrator.migrations_paths.include?(path)
+      end
+    end
+
     initializer "plutonium.asset_server" do
       setup_development_asset_server if Plutonium.configuration.development?
     end
@@ -47,6 +71,14 @@ module Plutonium
       extend_action_dispatch
     end
 
+    # Make `t.position` available in create_table / change_table blocks.
+    initializer "plutonium.positioning" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::ConnectionAdapters::TableDefinition.include(Plutonium::Positioning::MigrationHelpers)
+        ActiveRecord::ConnectionAdapters::Table.include(Plutonium::Positioning::MigrationHelpers)
+      end
+    end
+
     initializer "plutonium.phlexi_themes" do
       setup_phlexi_themes
     end
@@ -97,6 +129,7 @@ module Plutonium
 
     def extend_action_dispatch
       ActionDispatch::Routing::Mapper.prepend Plutonium::Routing::MapperExtensions
+      ActionDispatch::Routing::Mapper.prepend Plutonium::Routing::WizardRegistration
       ActionDispatch::Routing::RouteSet.prepend Plutonium::Routing::RouteSetExtensions
       Rails::Engine.include Plutonium::Routing::ResourceRegistration
     end