plutonium 0.67.0 → 0.69.0

data/lib/plutonium/ui/form/components/secure_association.rb

@@ -87,14 +87,25 @@ module Plutonium
             uri.to_s
           end
 
+          # Capped at `choice_limit`, plus the records the field holds now:
+          # one past the cap or outside the viewer's scope would otherwise not
+          # render, and saving the form would drop it (a select falls back to
+          # its blank option, an unrendered checkbox is not submitted).
           def choices
             @choices ||= begin
               collection = @raw_choices || authorized_relation
-              collection = collection.limit(@choice_limit) if @choice_limit && collection.respond_to?(:limit)
+              if collection.is_a?(ActiveRecord::Relation)
+                collection = collection.limit(@choice_limit) if @choice_limit
+                collection = (collection.to_a + selected_records).uniq
+              end
               build_choice_mapper(collection)
             end
           end
 
+          def selected_records
+            @selected_records ||= Array(field.object.public_send(association_reflection.name))
+          end
+
           # Builds the authorized association relation. Shared by `choices`
           # (which then applies `choice_limit`) and `normalize_simple_input`
           # (which validates against the full set so typeahead picks beyond
@@ -106,8 +117,11 @@ module Plutonium
             authorized_resource_scope(klass, relation: relation)
           end
 
+          # AssociationBase#build_attributes already calls
+          # build_association_attributes. Calling it here too ran it twice, and
+          # the second pass re-read the keys the first had deleted, silently
+          # dropping `skip_authorization:` and `add_action:`.
           def build_attributes
-            build_association_attributes
             super
             # Stash; the URL helper needs view_context which only exists
             # once we're rendering.
@@ -163,8 +177,16 @@ module Plutonium
           # not include records reachable via typeahead). For explicit
           # `@raw_choices`, fall back to membership in the rendered list.
           def normalize_simple_input(input_value)
+            # An explicit blank (the select's blank option, a "None" radio)
+            # clears a singular association: "" survives resource_params'
+            # `compact` and `<name>_sgid = ""` locates nil. A field that was not
+            # submitted arrives as nil and is left alone.
+            return "" if input_value == "" && !attributes[:multiple]
+
             sgid = SignedGlobalID.parse(input_value.presence)
             return nil unless sgid
+            # Keeping what the field already holds is not a new grant.
+            return sgid if selected_records.map(&:to_global_id).include?(sgid)
 
             if @raw_choices
               @signed_global_ids ||= choices.values.map { |choice| SignedGlobalID.parse(choice) }
@@ -177,13 +199,14 @@ module Plutonium
             nil
           end
 
+          # Compared as URI strings: URI objects don't match by value in a Set.
           def selected?(option)
-            case association_reflection.macro
-            when :belongs_to, :has_one
-              singular_field_value == SignedGlobalID.parse(option)
-            when :has_many, :has_and_belongs_to_many
-              collection_field_value.any? { |item| item == SignedGlobalID.parse(option) }
-            end
+            selected_gids.include?(SignedGlobalID.parse(option)&.uri&.to_s)
+          end
+
+          def selected_gids
+            @selected_gids ||= Array(attributes[:multiple] ? collection_field_value : singular_field_value)
+              .compact.to_set { |sgid| sgid.uri.to_s }
           end
 
           def singular_field_value

data/lib/plutonium/ui/form/components/secure_association_checkboxes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A has_many / habtm association rendered as one checkbox per authorized
+        # record (`input :tags, as: :association_checkboxes`).
+        class SecureAssociationCheckboxes < SecureAssociationChoices
+          protected
+
+          def control_type = :checkbox
+
+          def control_theme = :association_checkbox
+
+          def supported_macros = %i[has_many has_and_belongs_to_many]
+
+          # Unchecked boxes are not submitted, so without this blank value
+          # clearing every box would leave the param out entirely and keep the
+          # existing records. The blank is dropped by normalize_array_input.
+          # Disabled with the list: a disabled list submits no boxes, so a live
+          # blank would save as "no records" and wipe the association.
+          def render_hidden_input
+            input(type: :hidden, name: attributes[:name], value: "", autocomplete: "off", hidden: true, disabled: attributes[:disabled])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/secure_association_choices.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Abstract base for the list-style association inputs: every choice is
+        # rendered as its own control (checkbox, toggle or radio button) instead
+        # of an option inside a slim-select.
+        #
+        # Everything that makes the association input "secure" is inherited from
+        # {SecureAssociation} unchanged: the choices come from the policy-scoped
+        # relation (or `choices:`), each value is a signed global id, submitted
+        # ids are validated against the authorized relation, and the inline "+"
+        # add button still renders. Only the markup differs.
+        #
+        # Subclasses declare the control's input type, the macros they accept and
+        # the theme key their controls style off.
+        class SecureAssociationChoices < SecureAssociation
+          def view_template
+            div(class: "flex items-start space-x-1") do
+              # The wrapper's <label for=> points at this id, but a label can't
+              # name a div, so the group carries the field label itself.
+              div(**group_attributes) do
+                render_hidden_input
+                render_blank_choice if include_blank?
+                render_choices
+              end
+              render_add_button
+            end
+          end
+
+          protected
+
+          # The type attribute of each control: "checkbox" or "radio".
+          def control_type = raise(NotImplementedError, "#{self.class}#control_type")
+
+          # Theme key the individual controls style off.
+          def control_theme = raise(NotImplementedError, "#{self.class}#control_theme")
+
+          # Association macros this variant can represent.
+          def supported_macros = raise(NotImplementedError, "#{self.class}#supported_macros")
+
+          def group_role = "group"
+
+          # Everything the caller passed (data-*, aria-*, ...) lands on the
+          # group; what belongs to a form control goes on each choice instead.
+          CONTROL_ATTRIBUTES = %i[name required disabled multiple size autofocus form value].freeze
+
+          def group_attributes
+            mix(attributes.except(*CONTROL_ATTRIBUTES), {role: group_role, aria: {label: field.label}})
+          end
+
+          def build_association_attributes
+            super
+
+            unless supported_macros.include?(association_reflection.macro)
+              raise ArgumentError,
+                "#{self.class.name.demodulize} does not support #{association_reflection.macro} " \
+                "associations (#{association_name}). Supported: #{supported_macros.join(", ")}."
+            end
+
+            if association_reflection.polymorphic?
+              raise ArgumentError, "#{self.class.name.demodulize} does not support polymorphic associations (#{association_name})."
+            end
+          end
+
+          def association_name = "#{field.object.class.name}##{association_reflection.name}"
+
+          def build_attributes
+            super
+            if @group_method
+              raise ArgumentError, "#{self.class.name.demodulize} does not support group_method: (#{association_name})."
+            end
+
+            # Typeahead drives a slim-select dropdown; a rendered list has no
+            # search box to wire it to.
+            @typeahead_option = false
+          end
+
+          def render_choices
+            if choices.values.empty?
+              p(class: "pu-hint") { Plutonium::Translation.t("plutonium.ui.form.association_choices.empty") }
+              return
+            end
+
+            choices.each.with_index do |(value, text), index|
+              render_choice(value:, text:, id: "#{attributes[:id]}_#{index}", checked: selected?(value), autofocus: index.zero? && attributes[:autofocus])
+            end
+          end
+
+          def render_choice(value:, text:, id:, checked:, autofocus: false)
+            label(for: id, class: themed(:association_choice_label, field)) do
+              input(
+                type: control_type,
+                id:,
+                name: attributes[:name],
+                value:,
+                checked:,
+                required: control_required?,
+                disabled: attributes[:disabled],
+                form: attributes[:form],
+                autofocus:,
+                class: themed(control_theme, field)
+              )
+              span { text }
+            end
+          end
+
+          def render_hidden_input
+          end
+
+          def render_blank_choice
+          end
+
+          def include_blank? = false
+
+          def control_required? = false
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/secure_association_radio_buttons.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A belongs_to / has_one association rendered as one radio button per
+        # authorized record (`input :category, as: :association_radio_buttons`).
+        #
+        # An optional association also gets a blank "None" choice, since a
+        # radio group can't otherwise be cleared once something is picked.
+        # `include_blank: false` drops it. A required association never gets
+        # one: a checked "None" would satisfy the group's `required`.
+        class SecureAssociationRadioButtons < SecureAssociationChoices
+          protected
+
+          def control_type = :radio
+
+          def control_theme = :association_radio_button
+
+          def supported_macros = %i[belongs_to has_one]
+
+          def group_role = "radiogroup"
+
+          def include_blank?
+            return false if attributes[:required]
+
+            @include_blank != false
+          end
+
+          # `required` on any radio in a group makes picking one of them required.
+          def control_required? = attributes[:required]
+
+          def render_blank_choice
+            render_choice(value: "", text: blank_choice_text, id: "#{attributes[:id]}_blank", checked: singular_field_value.nil?)
+          end
+
+          def blank_choice_text
+            field.placeholder.presence || Plutonium::Translation.t("plutonium.ui.form.association_choices.none")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/secure_association_toggles.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Switch-styled {SecureAssociationCheckboxes}
+        # (`input :tags, as: :association_toggles`). Same behavior; only the
+        # `.pu-toggle` styling differs.
+        class SecureAssociationToggles < SecureAssociationCheckboxes
+          protected
+
+          def control_theme = :association_toggle
+        end
+      end
+    end
+  end
+end

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

@@ -149,7 +149,21 @@ module Plutonium
             polymorphic_association: :association,
             valid_polymorphic_association: :valid_association,
             invalid_polymorphic_association: :invalid_association,
-            neutral_polymorphic_association: :neutral_association
+            neutral_polymorphic_association: :neutral_association,
+
+            # List-style association variants (`as: :association_checkboxes`,
+            # `:association_toggles`, `:association_radio_buttons`). The bare key
+            # styles the list; `association_<control>` styles each control.
+            association_checkboxes: "flex flex-col gap-2",
+            association_toggles: "flex flex-col gap-2",
+            association_radio_buttons: "flex flex-col gap-2",
+            association_choice_label: "inline-flex items-center gap-2 text-sm text-[var(--pu-text)] cursor-pointer",
+            association_checkbox: :checkbox,
+            invalid_association_checkbox: :invalid_boolean,
+            association_toggle: :toggle,
+            invalid_association_toggle: :invalid_toggle,
+            association_radio_button: :radio_button,
+            invalid_association_radio_button: "pu-radio pu-input-invalid"
           })
         end
       end

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

@@ -105,13 +105,21 @@ module Plutonium
           value = field_value(slots[:image])
 
           if size == :cover
-            # Cover is a full-width banner, not an avatar: only render when an
-            # actual image resolves (no deterministic fallback).
+            # Cover is a full-width banner, not an avatar, so a record with no
+            # image gets no generated stand-in. It still gets the banner's
+            # space, as an empty slot elsewhere gets its em-dash: without it the
+            # card is a banner shorter than its neighbours, and the row stretches
+            # it into a block of blank card under its text.
             src = Plutonium::UI::Avatar.resolve_image_src(value, helpers)
-            return unless src
 
             div(class: "w-full aspect-video bg-[var(--pu-surface-alt)] overflow-hidden") do
-              img(src: src, alt: header_text.to_s, class: "w-full h-full object-cover")
+              if src
+                img(src: src, alt: header_text.to_s, class: "w-full h-full object-cover")
+              else
+                div(class: "w-full h-full flex items-center justify-center text-[var(--pu-text-subtle)]", aria_hidden: "true") do
+                  render Phlex::TablerIcons::Photo.new(class: "w-8 h-8")
+                end
+              end
             end
           else
             # Small avatar slot: render the resolved image, or Avatar's generic

data/lib/plutonium/ui/interaction/async/run_progress.rb

@@ -43,6 +43,8 @@ module Plutonium
             "running" => "info",
             "completed" => "success",
             "completed_with_errors" => "warning",
+            # The input was refused, nothing broke: see Run#rejected?.
+            "rejected" => "warning",
             "failed" => "danger"
           }.freeze
 
@@ -83,7 +85,9 @@ module Plutonium
             div(class: "pu-card pu-run-progress", **poll_attributes) do
               div(class: "pu-card-body space-y-4") do
                 render_status
-                render_progress
+                # A rejected run never started: an empty progress line beside
+                # "Nothing was processed" would say the same thing twice.
+                run.rejected? ? render_rejected : render_progress
                 render_failures if run.errors_log.any?
               end
             end
@@ -123,15 +127,24 @@ module Plutonium
               # The count rides alongside the badge rather than only in the list
               # below: a partially-applied :continue run ends as "completed", and
               # the one thing a reader must not be able to miss is that it did not
-              # do everything it was asked to.
+              # do everything it was asked to. Muted, because the alert below
+              # carries the colour (danger or warning) for what the problems mean.
               if run.error_count.positive?
-                span(class: "text-xs font-medium text-[var(--pu-text-danger)]") do
+                span(class: "text-xs font-medium text-[var(--pu-text-muted)]") do
                   plain t("plutonium.async.progress.error_count", count: run.error_count)
                 end
               end
             end
           end
 
+          # In place of the progress line: "0 of 50 targets" reads as a run that
+          # died at its first target. A rejected run never started, and says so.
+          def render_rejected
+            div(class: "text-xs text-[var(--pu-text-muted)]") do
+              plain t("plutonium.async.progress.rejected")
+            end
+          end
+
           # NEVER rendered without {#render_status} above it. After a refused
           # partial batch (:halt / :transactional), progress_done counts targets
           # DISPOSITIONED, not applied — so a run that performed nothing at all can
@@ -201,19 +214,20 @@ module Plutonium
             ((Time.current - started) * 1000).to_i % SWEEP_DURATION_MS
           end
 
+          # The framework's inline alert, so the problems read like every other
+          # message Plutonium shows rather than as a panel of their own.
           def render_failures
-            div(class: "space-y-1") do
-              div(class: "text-[10px] font-semibold uppercase tracking-wider text-[var(--pu-text-muted)]") do
-                plain t("plutonium.async.progress.failures")
-              end
-              ul(class: "pu-run-progress-failures text-xs space-y-1") do
-                run.errors_log.each do |entry|
-                  li(class: "text-[var(--pu-text-danger)]") { plain failure_text(entry) }
-                end
+            div(class: "pu-alert pu-alert-#{failures_variant} pu-run-progress-failures", role: "alert") do
+              ul(class: "pu-alert-message") do
+                run.errors_log.each { |entry| li { plain failure_text(entry) } }
               end
             end
           end
 
+          # Danger only for a run that broke. Refused input (rejected) and partial
+          # application (completed_with_errors) are warnings, matching the badge.
+          def failures_variant = (run.outcome == "failed") ? "danger" : "warning"
+
           # A nil target_id is the RUN-LEVEL sentinel (see AsyncRun#record_target_failure!),
           # not a target whose id happens to be blank.
           def failure_text(entry)

data/lib/plutonium/ui/interaction/async/running_banner.rb

@@ -4,7 +4,9 @@ module Plutonium
   module UI
     module Interaction
       module Async
-        # Lists the runs currently working on THIS resource, above its collection.
+        # Lists the runs currently working on THIS resource, above its collection,
+        # followed by the viewer's own runs that finished within
+        # +recent_runs_window+ (see Page::Index#render_running_banner).
         #
         # == Why it exists
         #
@@ -16,8 +18,9 @@ module Plutonium
         #
         # +target_type+ is a real column rather than a key inside the +options+
         # JSON precisely so this predicate can be indexed — see the migration's own
-        # comment. An opaque run has no +target_type+ at all and therefore appears
-        # on no resource index: it belongs to no resource.
+        # comment. An opaque run dispatched from a resource still records that
+        # resource as its +target_type+, so it shows on that resource's index; one
+        # dispatched from nowhere has none and appears on no resource index.
         #
         # == Why it can render nothing
         #
@@ -51,13 +54,26 @@ module Plutonium
                 # own page renders the pair.
                 span(class: "font-medium text-[var(--pu-text)]") { plain run.to_label }
                 plain " "
-                span(class: "text-[var(--pu-text-muted)]") { plain(Plutonium::Translation.value_label(run.class, :state, run.state) || run.state.humanize) }
+                run.in_progress? ? render_state(run) : render_outcome(run)
               end
               a(href: resource_url_for(run), class: "pu-btn pu-btn-xs pu-btn-soft-primary shrink-0") do
-                plain t("plutonium.async.banner.view_progress")
+                plain t(run.in_progress? ? "plutonium.async.banner.view_progress" : "plutonium.async.banner.view_run")
               end
             end
           end
+
+          def render_state(run)
+            span(class: "text-[var(--pu-text-muted)]") { plain(Plutonium::Translation.value_label(run.class, :state, run.state) || run.state.humanize) }
+          end
+
+          # A finished run is listed for what it ended as, so outcome rather than
+          # state ("completed" hides a partial :continue run; "failed" hides a
+          # rejection), in the progress panel's colours.
+          def render_outcome(run)
+            span(class: "pu-badge pu-badge-#{RunProgress::BADGE_VARIANTS.fetch(run.outcome, "neutral")}") do
+              plain(Plutonium::Translation.value_label(run.class, :outcome, run.outcome) || run.outcome.humanize)
+            end
+          end
         end
       end
     end

data/lib/plutonium/ui/layout/base.rb

@@ -244,15 +244,6 @@ module Plutonium
               "sha384-uqD/OYCNfagd1EgXMgl5QedTD5K+B3e9b8GYo/41t7+Serf7CBxvl+tU1gHd+qd1",
             crossorigin: "anonymous"
           )
-          # EasyMDE's toolbar uses Font Awesome 4 class names (renamed in 5+).
-          link(
-            rel: "stylesheet",
-            href:
-              "https://cdn.jsdelivr.net/npm/font-awesome@4.7.0/css/font-awesome.min.css",
-            integrity:
-              "sha384-wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVnN",
-            crossorigin: "anonymous"
-          )
         end
 
         def render_scripts

data/lib/plutonium/ui/page/dashboard.rb

@@ -36,6 +36,7 @@ module Plutonium
         attr_reader :dashboard
 
         def render_content
+          render Plutonium::UI::Dashboard::Toolbar.new(dashboard:)
           render Plutonium::UI::Dashboard::Board.new(dashboard:)
         end
 

data/lib/plutonium/ui/page/index.rb

@@ -4,6 +4,11 @@ module Plutonium
   module UI
     module Page
       class Index < Base
+        # How many recently finished runs the running banner lists at most. It
+        # sits above the collection; a burst of dispatches must not push the
+        # collection off the screen. The run index has the rest.
+        RECENT_RUNS_LIMIT = 5
+
         # Cookie name carrying a per-resource view preference. Single
         # source of truth — Table::Resource, Grid::Resource, and the
         # Stimulus view-switcher controller all read from here. Underscored
@@ -101,12 +106,26 @@ module Plutonium
           # a URL for a route that doesn't exist here.
           return unless registered_resources.include?(Plutonium::Interaction::Async::Run)
 
-          runs = authorized_resource_scope(
-            Plutonium::Interaction::Async::Run,
-            relation: Plutonium::Interaction::Async::Run.for_target(resource_class).in_progress
+          run_class = Plutonium::Interaction::Async::Run
+          in_progress = authorized_resource_scope(
+            run_class, relation: run_class.for_target(resource_class).in_progress
+          ).to_a
+
+          # The current user's own runs that settled moments ago. A dispatch
+          # sends them back here, and a short run (or one its pre_check rejected)
+          # finishes before this page renders, so "in progress" alone would show
+          # them nothing. Only their own: someone else's finished run is not news.
+          recent = authorized_resource_scope(
+            run_class,
+            relation: run_class.for_target(resource_class)
+              .where(initiator: current_user)
+              .finished_since(Plutonium.configuration.async_interactions.recent_runs_window.ago)
+              .order(finished_at: :desc)
+              .limit(RECENT_RUNS_LIMIT)
           ).to_a
 
-          render Plutonium::UI::Interaction::Async::RunningBanner.new(runs: runs)
+          # uniq: a run that finishes between the two queries is in both.
+          render Plutonium::UI::Interaction::Async::RunningBanner.new(runs: (in_progress + recent).uniq)
         end
 
         def selected_view

data/lib/plutonium/ui/table/components/scopes_bar.rb

@@ -42,7 +42,7 @@ module Plutonium
           end
 
           def scope_label(name)
-            Plutonium::Translation.label_for(:scope, current_query_object.resource_class, name) || name.to_s.humanize
+            current_query_object.scope_label(name)
           end
 
           def current_scope

data/lib/plutonium/ui/table/components/scopes_pills.rb

@@ -32,7 +32,7 @@ module Plutonium
 
           def render_pill(key)
             active = current_query_object.selected_scope.to_s == key.to_s
-            label = Plutonium::Translation.label_for(:scope, current_query_object.resource_class, key) || key.to_s.humanize
+            label = current_query_object.scope_label(key)
 
             a(
               id: "#{key}-scope",

data/lib/plutonium/version.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  VERSION = "0.67.0"
+  VERSION = "0.69.0"
   NEXT_MAJOR_VERSION = VERSION.split(".").tap { |v|
     v[1] = v[1].to_i + 1
     v[2] = 0

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radioactive-labs/plutonium",
-  "version": "0.67.0",
+  "version": "0.69.0",
   "description": "Build production-ready Rails apps in minutes, not days. Convention-driven, fully customizable, AI-ready.",
   "type": "module",
   "main": "src/js/core.js",

data/plutonium.gemspec

@@ -60,7 +60,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "phlex-rails"
   spec.add_dependency "phlex-tabler_icons"
   spec.add_dependency "phlexi-field", ">= 0.2.0"
-  spec.add_dependency "phlexi-form", ">= 0.14.3"
+  spec.add_dependency "phlexi-form", ">= 0.14.4"
   spec.add_dependency "phlexi-table", ">= 0.2.0"
   spec.add_dependency "phlexi-display", ">= 0.2.0"
   spec.add_dependency "phlexi-menu", ">= 0.4.1"

data/src/css/components.css

@@ -1222,6 +1222,15 @@ html.pu-rail-pinned .icon-rail-pin-expand {
   margin-left: var(--pu-drag-marker-gap, 4px);
 }
 
+/* The failures on an async run's progress panel: an inline alert holding a
+   list, so it sits flush in the card and the list keeps its bullets. */
+.pu-run-progress-failures {
+  @apply mb-0 items-start;
+}
+.pu-run-progress-failures .pu-alert-message {
+  @apply ms-0 ps-4 list-disc space-y-1;
+}
+
 /* Indeterminate progress for an async run with no denominator (opaque work).
    A short segment sweeping the track: the motion is what says "alive", which a
    static bar at any width cannot, and a full-width bar would misread as done. */