plutonium 0.60.5 → 0.61.0

data/lib/plutonium/ui/form/wizard.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      # Renders the CURRENT wizard step through the existing resource-form pipeline
+      # (§7). It rides `Form::Resource` unchanged — the only wizard-specific wiring
+      # is the per-step adapter (`resource_definition`), the value source (the
+      # wizard's typed `data`, so inputs render seeded from staged data for
+      # resume/back, including repeater rows), the `wizard[...]` param namespace,
+      # the step POST URL, and a hidden `_direction` (default `next`).
+      class Wizard < Resource
+        # @param step    [Plutonium::Wizard::Step]
+        # @param data    [Object] the wizard's typed `data` snapshot (the form
+        #   `object`; responds to every step attribute / structured input name).
+        # @param action  [String] the current step's POST URL.
+        # @param fields  [Array<Symbol>] the step's renderable field names
+        #   (scalar attributes + structured inputs).
+        def initialize(step:, data:, action:, fields:, **options, &)
+          @step = step
+          options[:key] = :wizard
+          options[:as] = :wizard
+          options[:action] = action
+          options[:resource_fields] = fields
+          options[:resource_definition] = Plutonium::Wizard::StepAdapter.new(step)
+          options[:singular_resource] = true
+          super(data, **options, &)
+        end
+
+        private
+
+        attr_reader :step
+
+        def form_template
+          # The direction defaults to "next"; the nav buttons in the page override
+          # it per-button. The wizard Stimulus controller targets it.
+          input(type: :hidden, name: "_direction", value: "next", data: {wizard_target: "direction"})
+          render_fields
+        end
+
+        # The wizard form has no submit footer of its own — the page renders the
+        # Back/Next/Finish/Cancel strip. (We still override the resource actions
+        # away so no stray "Create"/"Update" button appears.)
+        def render_actions
+        end
+
+        # The step form sits INSIDE the wizard card body (which already supplies the
+        # surface + padding), so drop the default `pu-card my-4 p-8` form chrome —
+        # otherwise it reads as a card-in-card. Keep just the vertical field rhythm.
+        def form_class
+          "space-y-6"
+        end
+
+        attr_reader :form_action
+
+        def initialize_attributes
+          super
+          attributes[:id] = "wizard-form"
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/grid/card.rb

@@ -8,18 +8,24 @@ module Plutonium
       # `grid_fields` on the resource definition. Each slot is optional;
       # `header` falls back to `record.to_label` when undeclared.
       class Card < Plutonium::UI::Component::Base
-        attr_reader :record, :resource_definition, :resource_fields
+        attr_reader :record, :resource_definition, :resource_fields, :card_fields
 
-        def initialize(record, resource_definition:, resource_fields: nil)
+        def initialize(record, resource_definition:, resource_fields: nil, card_fields: nil, show_turbo_frame: nil)
           @record = record
           @resource_definition = resource_definition
           @resource_fields = resource_fields
+          @card_fields = card_fields
+          # Overrides the show link's turbo-frame target. Defaults to the show
+          # action's own frame (nil → normal navigation). The kanban board sets
+          # "_top" so a card click escapes its column's lazy turbo-frame instead
+          # of loading the show page inside the column.
+          @show_turbo_frame = show_turbo_frame
         end
 
         def view_template
           article(
             class: card_class,
-            data: {controller: "row-click", action: "click->row-click#click"}
+            data: {controller: "row-click", action: "click->row-click#click auxclick->row-click#click"}
           ) do
             render_show_link if can_show?
             render_actions_dropdown
@@ -32,7 +38,12 @@ module Plutonium
 
         private
 
-        def slots = resource_definition.defined_grid_fields
+        # Returns the slot hash used for rendering.
+        # When the kanban board declares `card_fields`, it is passed in
+        # explicitly and takes precedence over the resource definition's
+        # `defined_grid_fields`.  A nil card_fields falls back to the
+        # definition, which is the default for the grid view.
+        def slots = @card_fields || resource_definition.defined_grid_fields
 
         # ---------------------------------------------------------------
         # Layout shells
@@ -201,7 +212,7 @@ module Plutonium
           url = route_options_to_url(show.route_options, record)
           a(
             href: url,
-            data: {row_click_target: "show", turbo_frame: show.turbo_frame(resource_definition)},
+            data: {row_click_target: "show", turbo_frame: @show_turbo_frame || show.turbo_frame(resource_definition)},
             class: "sr-only",
             tabindex: "-1",
             "aria-label": "Open #{header_text}"

data/lib/plutonium/ui/kanban/card.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Kanban
+      # Thin wrapper around Grid::Card that makes the card draggable.
+      #
+      # Emits a draggable container div carrying:
+      #   data-kanban-record-id — the record's id, consumed by the Stimulus
+      #                           drag controller (Task 11) to identify the card
+      #   data-kanban-column-key — the source column key, used by the move
+      #                            handler (Task 7) to determine which column
+      #                            the card came from
+      #
+      # All actual card rendering (image, header, meta, actions dropdown) is
+      # delegated to Plutonium::UI::Grid::Card which already handles slots,
+      # policy-gated actions, and the row-click controller.
+      class Card < Plutonium::UI::Component::Base
+        attr_reader :record, :column_key, :resource_definition, :resource_fields, :card_fields
+
+        def initialize(record, column_key:, resource_definition:, resource_fields:, card_fields: nil, show_turbo_frame: "_top")
+          @record = record
+          @column_key = column_key
+          @resource_definition = resource_definition
+          @resource_fields = resource_fields
+          # Optional slot-layout override from the board's card_fields declaration.
+          # Threaded through to Grid::Card so it takes precedence over the
+          # resource definition's grid_fields.  nil means use the definition.
+          @card_fields = card_fields
+          # The turbo-frame the card's show link targets — the remote-modal frame
+          # (board show_in :modal) or "_top" (show_in :page). Either escapes the
+          # column's lazy frame. Defaults to "_top".
+          @show_turbo_frame = show_turbo_frame
+        end
+
+        def view_template
+          div(
+            draggable: "true",
+            data: {
+              kanban_record_id: record.id,
+              kanban_column_key: column_key.to_s
+            }
+          ) do
+            render_grid_card
+          end
+        end
+
+        private
+
+        # Extracted so tests can stub render_grid_card without needing a full
+        # view_context (Grid::Card calls policy_for, route_options_to_url, etc.).
+        def render_grid_card
+          render Plutonium::UI::Grid::Card.new(
+            record,
+            resource_definition: resource_definition,
+            resource_fields: resource_fields,
+            card_fields: @card_fields,
+            # Escape the column's lazy turbo-frame: either "_top" (full page) or
+            # the document-wide remote-modal frame, both of which resolve outside
+            # the kanban-col-<key> frame.
+            show_turbo_frame: @show_turbo_frame
+          )
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/kanban/color_dot.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Kanban
+      # Shared color-dot rendering for the board shell placeholder header
+      # (Resource) and the loaded column header (Column), so a column's
+      # `color:` shows consistently in both states.
+      module ColorDot
+        def render_color_dot(color)
+          span(
+            class: "shrink-0 w-2.5 h-2.5 rounded-full",
+            style: "background-color: #{color_css_value(color)}"
+          )
+        end
+
+        # Maps a column color symbol to a CSS value via Tailwind design tokens.
+        # Raw CSS strings (e.g. "#ff0000") are passed through unchanged.
+        def color_css_value(color)
+          case color.to_sym
+          when :red then "var(--color-red-500)"
+          when :orange then "var(--color-orange-500)"
+          when :amber then "var(--color-amber-500)"
+          when :yellow then "var(--color-yellow-500)"
+          when :green then "var(--color-green-500)"
+          when :blue then "var(--color-blue-500)"
+          when :purple then "var(--color-purple-500)"
+          when :pink then "var(--color-pink-500)"
+          when :gray then "var(--pu-text-muted)"
+          else color.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/kanban/column.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Kanban
+      # Renders a single column body: header with wip badge, card list, and a
+      # "+N more" footer when the total exceeds per_column.
+      #
+      # This is the component that Task 6's lazy frame endpoint serves. The
+      # board shell (Resource) wraps each column in a <turbo-frame>; the frame
+      # src hits the column endpoint which renders this component as the body.
+      #
+      # Collapsed variant: when column.collapsed? the component renders a thin
+      # rotated-label strip instead of the full card list. Both the strip and
+      # the expanded body are always emitted in the HTML; CSS (controlled by
+      # the `pu-kanban-column-collapsed` class on the wrapper) shows one and
+      # hides the other. The Stimulus controller's toggleColumn action flips the
+      # class and persists the choice to localStorage.
+      #
+      # Action slot: column.actions are rendered as minimal placeholder buttons
+      # so the DOM seam is in place for Task 8 which wires the actual action
+      # handlers (interactive bulk actions). The buttons carry data-kanban-action
+      # and data-kanban-column attributes for Stimulus targeting.
+      #
+      # Drop policy: the wrapper emits data-kanban-accepts and data-kanban-locked
+      # so the Stimulus drag controller can provide client-side drop hints without
+      # re-implementing server-side logic. The server remains the authority.
+      class Column < Plutonium::UI::Component::Base
+        include ColorDot
+        include Phlex::Rails::Helpers::LinkTo
+
+        attr_reader :column, :cards, :total, :per_column, :resource_definition, :resource_fields
+
+        # column_action_data: array of {action: Plutonium::Kanban::Action, ids: [Integer, ...]}
+        # Resolved by the controller (KanbanActions#render_kanban_column_html) and
+        # threaded here so the component can render real bulk-action links without
+        # needing to re-query the DB.  Defaults to [] when the component is
+        # constructed outside of a controller context (e.g., tests or the board
+        # shell which renders column frames without card data).
+        #
+        # column_add_url: URL for the "+ Add" quick-add button (or nil).
+        # Set by the controller when column.add? is true and the policy permits
+        # create. Carries kanban_column=<key> so the new form pre-fills the
+        # grouping attribute via apply_kanban_column_defaults!.
+        #
+        # card_fields: optional slot-layout hash from the board's card_fields
+        # declaration (e.g. { header: :title, meta: [:status] }).  Threaded
+        # through to each Kanban::Card (and ultimately Grid::Card) so it
+        # overrides the resource definition's grid_fields for every card in the
+        # column.  nil means "use the definition's grid_fields" (default).
+        # card_show_frame: the turbo-frame each card's show link targets — the
+        # remote-modal frame (board show_in :modal) or "_top" (show_in :page).
+        # Resolved by the controller and threaded through to Kanban::Card.
+        # Defaults to "_top" so a card always escapes the column's lazy frame when
+        # the component is built outside a controller (tests, board shell).
+        def initialize(column:, cards:, total:, per_column:, resource_definition:, resource_fields:, column_action_data: [], column_add_url: nil, card_fields: nil, card_show_frame: "_top")
+          @column = column
+          @cards = cards
+          @total = total
+          @per_column = per_column
+          @resource_definition = resource_definition
+          @resource_fields = resource_fields
+          @column_action_data = column_action_data
+          @column_add_url = column_add_url
+          @card_fields = card_fields
+          @card_show_frame = card_show_frame
+        end
+
+        def view_template
+          # Wrapper carries the drop-policy data attributes and the initial
+          # collapsed CSS class. The Stimulus controller reads data-kanban-col
+          # to find wrappers unambiguously (distinct from toggle button attrs).
+          div(
+            class: tokens(
+              "pu-kanban-column-wrapper",
+              column.collapsed? && "pu-kanban-column-collapsed"
+            ),
+            data: {
+              kanban_col: column.key.to_s,
+              kanban_accepts: accepts_value,
+              kanban_locked: column.locked?.to_s
+            }
+          ) do
+            render_collapsed_strip
+            render_expanded
+          end
+        end
+
+        private
+
+        # ---------------------------------------------------------------
+        # Collapsed strip
+        # ---------------------------------------------------------------
+
+        def render_collapsed_strip
+          # CSS hides this strip when the wrapper lacks pu-kanban-column-collapsed.
+          # Always emitted so the JS toggle can switch between strip and body
+          # without a server round-trip.
+          div(
+            class: "pu-kanban-strip w-10 flex flex-col items-center justify-between " \
+                   "py-3 gap-2 bg-[var(--pu-surface)] border border-[var(--pu-border)] " \
+                   "rounded-[var(--pu-radius-md)] select-none",
+            data: {kanban_role: "strip"}
+          ) do
+            span(
+              class: "text-xs font-semibold text-[var(--pu-text-muted)] " \
+                     "[writing-mode:vertical-lr] rotate-180"
+            ) { plain column.label }
+            span(class: "pu-badge pu-badge-neutral text-xs font-mono") { plain cards.size.to_s }
+            # Expand toggle button — the primary interactive seam for
+            # collapsing/expanding. data-kanban-column-key is on this button so
+            # the integration test can assert the contract without JS execution.
+            button(
+              class: "p-0.5 rounded text-[var(--pu-text-muted)] " \
+                     "hover:text-[var(--pu-text)] hover:bg-[var(--pu-surface-alt)]",
+              title: "Expand #{column.label}",
+              type: "button",
+              data: {
+                action: "click->kanban#toggleColumn",
+                kanban_column_key: column.key.to_s
+              }
+            ) { plain "▶" }
+            render_column_actions if column.actions.any?
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Expanded column
+        # ---------------------------------------------------------------
+
+        def render_expanded
+          # CSS hides this body when the wrapper has pu-kanban-column-collapsed.
+          div(
+            class: "pu-kanban-body pu-kanban-column w-72 shrink-0 flex flex-col " \
+                   "bg-[var(--pu-surface-alt)] border border-[var(--pu-border)] " \
+                   "rounded-[var(--pu-radius-md)] overflow-hidden",
+            data: {kanban_role: "body"}
+          ) do
+            render_header
+            render_card_list
+            render_more_footer if more_count > 0
+          end
+        end
+
+        def render_header
+          div(class: "px-3 py-2 flex items-center justify-between gap-2 border-b border-[var(--pu-border)] bg-[var(--pu-surface)]") do
+            div(class: "flex items-center gap-2 min-w-0 flex-1") do
+              render_color_dot(column.color) if column.color
+              span(class: "font-semibold text-sm text-[var(--pu-text)] truncate") { plain column.label }
+              render_wip_badge if column.wip
+            end
+            render_column_actions if @column_add_url || column.actions.any?
+            # Collapse toggle — always present in the expanded header so the
+            # user can collapse a column even when no other actions are visible.
+            # Kept outside render_column_actions so the action-slot tests are
+            # unaffected (they check the flex-gap container which is conditional).
+            button(
+              class: "shrink-0 p-0.5 rounded text-[var(--pu-text-muted)] " \
+                     "hover:text-[var(--pu-text)] hover:bg-[var(--pu-surface-alt)]",
+              title: "Collapse #{column.label}",
+              type: "button",
+              data: {
+                action: "click->kanban#toggleColumn",
+                kanban_column_key: column.key.to_s
+              }
+            ) { plain "◀" }
+          end
+        end
+
+        def render_wip_badge
+          over = wip_over_limit?
+          span(
+            class: tokens(
+              "pu-badge text-xs font-mono",
+              over ? "pu-badge-danger" : "pu-badge-neutral"
+            ),
+            title: over ? "WIP limit exceeded" : "WIP limit: #{column.wip}"
+          ) do
+            plain "#{cards.size}/#{column.wip}"
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Card list
+        # ---------------------------------------------------------------
+
+        def render_card_list
+          div(
+            class: "flex flex-col gap-2 p-2 min-h-[3rem] flex-1",
+            data: {
+              kanban_target: "column",
+              kanban_column_key_value: column.key.to_s
+            }
+          ) do
+            render_cards
+          end
+        end
+
+        # Extracted so tests can stub render_cards without needing a real
+        # view_context (Grid::Card requires policy_for etc.).
+        def render_cards
+          cards.each do |record|
+            render Plutonium::UI::Kanban::Card.new(
+              record,
+              column_key: column.key,
+              resource_definition: resource_definition,
+              resource_fields: resource_fields,
+              card_fields: @card_fields,
+              show_turbo_frame: @card_show_frame
+            )
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # "+N more" footer
+        # ---------------------------------------------------------------
+
+        def render_more_footer
+          div(class: "px-3 py-2 border-t border-[var(--pu-border)] bg-[var(--pu-surface)]") do
+            span(class: "text-xs text-[var(--pu-text-muted)]") do
+              plain "+#{more_count} more"
+            end
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Column action slot
+        # ---------------------------------------------------------------
+
+        # Renders the "+ Add" quick-add button that opens the resource's new form
+        # in the remote modal frame, pre-seeded for this column.
+        def render_add_button
+          link_to(
+            @column_add_url,
+            class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
+            title: "Add to #{column.label}",
+            data: {turbo_frame: Plutonium::REMOTE_MODAL_FRAME}
+          ) do
+            plain "+ Add"
+          end
+        end
+
+        # Renders bulk-action links for each column action, and the "+ Add"
+        # quick-add button when column_add_url is present.
+        #
+        # Each bulk-action link targets GET /resources/bulk_actions/:key?ids[]=…,
+        # which is the existing interactive_bulk_action route.  The action is only
+        # rendered when:
+        #   1. The resolved action is registered in defined_actions (auto-registered
+        #      by Definition::IndexViews.kanban at class-load time).
+        #   2. current_policy.allowed_to?(:"#{key}?") returns true.
+        #
+        # The bulk endpoint re-authorizes each record individually, so this
+        # check is a display-only gate — not the security boundary.
+        def render_column_actions
+          div(class: "flex items-center gap-1 shrink-0") do
+            render_add_button if @column_add_url
+            @column_action_data.each do |entry|
+              col_action = entry[:action]
+              ids = entry[:ids]
+
+              registered = current_definition.defined_actions[col_action.key]
+              next unless registered&.permitted_by?(current_policy)
+
+              # Skip when the resolved id set is empty: resource_url_for with
+              # ids: [] would resolve to the RESOURCE action route
+              # (/resource_actions/:key) rather than the bulk route, misfiring
+              # if clicked. An empty column simply renders no action link.
+              next if ids.empty?
+
+              url = resource_url_for(resource_class, interaction: col_action.key, ids: ids)
+              label = col_action.label || col_action.key.to_s.humanize
+              data_attrs = {
+                kanban_action: col_action.key.to_s,
+                kanban_column: column.key.to_s
+              }
+              data_attrs[:turbo_confirm] = col_action.confirmation if col_action.confirmation
+
+              link_to(
+                url,
+                class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
+                title: label,
+                data: data_attrs
+              ) do
+                render col_action.icon.new(class: "h-4 w-4") if col_action.icon
+                plain label
+              end
+            end
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Pure helpers
+        # ---------------------------------------------------------------
+
+        def wip_over_limit?
+          column.wip && cards.size > column.wip
+        end
+
+        def more_count
+          [total - cards.size, 0].max
+        end
+
+        # Serialises the column's accepts policy for the data-kanban-accepts
+        # attribute consumed by the Stimulus drag controller for drop hints.
+        # The server remains the authority; this is display only.
+        #
+        # true  → "all"    (any source is accepted)
+        # false → "none"   (no source is accepted)
+        # Array → comma-joined list of accepted source column keys
+        # Proc  → "all"    (per-card predicate; treated as permissive at the
+        #                    column level — server evaluates per record)
+        def accepts_value
+          case column.accepts
+          when true then "all"
+          when false then "none"
+          when Array then column.accepts.join(",")
+          else "all"
+          end
+        end
+      end
+    end
+  end
+end