plutonium 0.61.0 → 0.62.0

data/lib/plutonium/resource/policy.rb

@@ -10,6 +10,12 @@ module Plutonium
       authorize :entity_scope, allow_nil: true
       authorize :parent, optional: true
       authorize :parent_association, optional: true
+      # Supplied only during a kanban drag-move (kanban_move? authorization): the
+      # source and destination Plutonium::Kanban::Column. Optional — nil for every
+      # other authorization. Lets a policy gate a specific transition, e.g.
+      #   def kanban_move? = kanban_to&.key == :closed_won ? user.admin? : super
+      authorize :kanban_from, optional: true
+      authorize :kanban_to, optional: true
 
       relation_scope do |relation|
         default_relation_scope(relation)

data/lib/plutonium/routing/mapper_extensions.rb

@@ -151,6 +151,7 @@ module Plutonium
             as: :interactive_record_action
           post "record_actions/:interactive_action", action: :commit_interactive_record_action,
             as: :commit_interactive_record_action
+          get "kanban_move_form", action: :kanban_move_form, as: :kanban_move_form
           post "kanban_move", action: :kanban_move, as: :kanban_move
         end
       end

data/lib/plutonium/ui/display/components/currency.rb

@@ -6,16 +6,52 @@ module Plutonium
   module UI
     module Display
       module Components
-        # Renders a numeric value as currency (delimited, 2 decimals). No symbol
-        # by default; pass a literal `unit:` ("£") or a Symbol read off the
-        # record (`unit: :currency_symbol`) for per-row currencies.
+        # Renders a numeric value as currency (delimited, 2 decimals). The symbol
+        # is resolved by {resolve_unit}: an explicit `unit:` (a literal "£", a
+        # Symbol read off the record for per-row currencies, or `false` for no
+        # symbol) → the record's `has_cents` unit → `default_currency_unit` /
+        # the i18n `number.currency.format.unit` ($ in en).
         #
-        #   display :price, as: :currency
+        #   display :price, as: :currency               # → configured/i18n default unit
         #   display :price, as: :currency, unit: "£"
         #   display :price, as: :currency, unit: :currency_symbol
+        #   display :price, as: :currency, unit: false  # no symbol
         class Currency < Phlexi::Display::Components::Base
           include Phlexi::Display::Components::Concerns::DisplaysValue
 
+          # Resolves the currency unit string for a value, shared by this
+          # component and the grid/kanban {Grid::Card} so both format currency
+          # identically. Precedence, where `nil` means "not set, keep looking"
+          # and `false` means "explicitly no symbol, stop":
+          #   explicit unit → record's has_cents unit → configured/i18n default.
+          #
+          # @param explicit [String, Symbol, false, nil] a per-display `unit:`.
+          # @param record [Object] the record being rendered.
+          # @param key [Symbol] the attribute name.
+          # @return [String] the unit to pass to number_to_currency ("" for none).
+          def self.resolve_unit(explicit, record, key)
+            unit = explicit
+            unit = record.has_cents_unit_for(key) if unit.nil? && record.respond_to?(:has_cents_unit_for)
+            unit = default_unit if unit.nil?
+
+            case unit
+            when nil, false then ""
+            when Symbol then record.public_send(unit).to_s
+            else unit.to_s
+            end
+          end
+
+          # The unit used when nothing more specific is configured. Returns the
+          # `default_currency_unit` config verbatim when set (including `false`
+          # to disable the symbol); otherwise the i18n `number.currency.format.unit`
+          # *if the locale defines it*, else no symbol. We don't hardcode a "$".
+          def self.default_unit
+            config = Plutonium.configuration.default_currency_unit
+            return config unless config.nil?
+
+            I18n.t("number.currency.format.unit", default: "")
+          end
+
           def render_value(value)
             p(**attributes) { format_currency(value) }
           end
@@ -35,11 +71,7 @@ module Plutonium
           end
 
           def resolved_unit
-            case @unit
-            when nil then ""
-            when Symbol then field.object.public_send(@unit)
-            else @unit
-            end
+            self.class.resolve_unit(@unit, field.object, field.key)
           end
 
           def normalize_value(value) = value

data/lib/plutonium/ui/display/options/inferred_types.rb

@@ -5,6 +5,8 @@ module Plutonium
     module Display
       module Options
         module InferredTypes
+          include Plutonium::UI::Options::HasCentsField
+
           private
 
           def infer_field_component
@@ -23,11 +25,6 @@ module Plutonium
               super
             end
           end
-
-          def has_cents_field?
-            klass = object.class
-            klass.respond_to?(:has_cents_decimal_attribute?) && klass.has_cents_decimal_attribute?(key)
-          end
         end
       end
     end

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

@@ -63,6 +63,12 @@ module Plutonium
             create_component(Components::Flatpickr, :flatpickr, **, &)
           end
 
+          # Money input: a number field with an optional currency-unit prefix.
+          # See {Components::Currency} for how the unit resolves.
+          def currency_tag(**, &)
+            create_component(Components::Currency, :currency, **, &)
+          end
+
           def int_tel_input_tag(**, &)
             create_component(Components::IntlTelInput, :int_tel_input, **, &)
           end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A numeric (money) input with an OPTIONAL currency-unit prefix. The unit
+        # is resolved by the SAME rules as the currency *display*
+        # ({Display::Components::Currency.resolve_unit}), so the input and the
+        # show/index/summary render the same symbol: an explicit `unit:` (a
+        # literal "£", a Symbol read off the record, or `false` for none) → the
+        # record's `has_cents` unit → `default_currency_unit` / the i18n default.
+        # When nothing resolves (or `unit: false`) the prefix is omitted and it's
+        # a plain number input.
+        #
+        #   input :price, as: :currency               # → configured/i18n default unit
+        #   input :price, as: :currency, unit: "£"
+        #   input :price, as: :currency, unit: false  # no prefix
+        class Currency < Phlexi::Form::Components::Input
+          def view_template
+            return super if @unit_prefix.blank?
+
+            # Overlay the unit at the input's left edge; the currency-input
+            # Stimulus controller measures this prefix and sets the input's
+            # left padding to match, so digits always clear it whatever the
+            # symbol's width ("$" vs "GH₵").
+            div(class: "relative", data: {controller: "currency-input"}) do
+              span(
+                class: "pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3 text-sm text-[var(--pu-text-muted)]",
+                aria_hidden: "true",
+                data: {currency_input_target: "prefix"}
+              ) { plain @unit_prefix }
+              super
+            end
+          end
+
+          protected
+
+          def build_input_attributes
+            @unit_prefix = resolve_unit_prefix
+            attributes[:type] = :number
+            attributes[:inputmode] = "decimal"
+            attributes[:step] ||= "0.01"
+            # Mark the input so the currency-input controller can measure the
+            # prefix and set the exact left padding at connect (see the JS).
+            if @unit_prefix.present?
+              attributes[:data] = (attributes[:data] || {}).merge(currency_input_target: "field")
+            end
+            super
+          end
+
+          private
+
+          # Resolve the prefix and strip `unit:` from the attributes so it never
+          # leaks onto the <input>. Returns "" when there's no unit to show.
+          def resolve_unit_prefix
+            explicit = attributes.delete(:unit)
+            Plutonium::UI::Display::Components::Currency.resolve_unit(explicit, field.object, field.key)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,10 @@ module Plutonium
       module Components
         class IntlTelInput < Phlexi::Form::Components::Input
           def view_template
-            div(data_controller: "intl-tel-input") {
+            div(data: {
+              controller: "intl-tel-input",
+              intl_tel_input_options_value: @intl_options.to_json
+            }) {
               super
             }
           end
@@ -16,6 +19,29 @@ module Plutonium
           def build_input_attributes
             super
             attributes[:data_intl_tel_input_target] = tokens(attributes[:data_intl_tel_input_target], :input)
+            @intl_options = build_intl_options
+          end
+
+          # Options forwarded to the intl-tel-input library via the Stimulus
+          # controller's `options` value. Supports a convenient `initial_country:`
+          # shortcut plus an `intl_options:` hash for any other library option
+          # (keys are the library's own camelCase names, e.g. `separateDialCode`).
+          # Both are deleted from `attributes` so they don't leak onto the <input>.
+          #
+          #   input :phone, as: :phone, initial_country: "gh"
+          #   input :phone, as: :phone, intl_options: {separateDialCode: true, strictMode: false}
+          #
+          # When no country is given, falls back to
+          # `Plutonium.configuration.default_phone_country`.
+          def build_intl_options
+            options = {}
+            if (country = attributes.delete(:initial_country) || Plutonium.configuration.default_phone_country)
+              options[:initialCountry] = country
+            end
+            if (extra = attributes.delete(:intl_options))
+              options.merge!(extra)
+            end
+            options
           end
         end
       end

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

@@ -80,8 +80,13 @@ module Plutonium
               },
               title: attachment.filename.to_s
             ) do
-              # Hidden field to preserve the uploaded file
-              input(type: :hidden, name: input_name, multiple: attributes[:multiple], value: attachment.signed_id, autocomplete: "off", hidden: true)
+              # Hidden field to preserve the uploaded file across a re-render.
+              # Only when we actually have a signed_id — on a non-JS submit or a
+              # validation-failure re-render the blob may be unsaved, and asking
+              # for its signed_id would raise. Nothing to preserve → omit it.
+              if (signed_id = preservable_signed_id(attachment))
+                input(type: :hidden, name: input_name, multiple: attributes[:multiple], value: signed_id, autocomplete: "off", hidden: true)
+              end
 
               render_preview_content(attachment)
               render_filename(attachment)
@@ -89,6 +94,19 @@ module Plutonium
             end
           end
 
+          # ActiveStorage delegates signed_id to the blob, and a *new* blob raises
+          # "Cannot get a signed_id for a new record" — so skip it there. Other
+          # backends (active_shrine, the wizard's Resolved) sign the file data
+          # itself and work fine on an unsaved record, so we must NOT gate them on
+          # the parent being persisted (that would drop a still-valid token on a
+          # validation re-render). Guarding only the new-blob case covers all three.
+          def preservable_signed_id(attachment)
+            blob = attachment.try(:blob)
+            return if blob&.new_record?
+
+            attachment.signed_id
+          end
+
           def render_preview_content(attachment)
             a(
               href: attachment.url,

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      # The drop-interaction form used by the kanban card-drop modal.
+      #
+      # Behaves exactly like a standard interaction form (same fields, same
+      # namespacing under `interaction[...]`, same submit button) with two
+      # deliberate differences:
+      #
+      #   1. It POSTs to the record's `kanban_move` member route rather than the
+      #      interaction's own commit URL, so Task 4's atomic handler runs the
+      #      interaction AND repositions the card in one request.
+      #   2. It carries the move context (from_column/to_column/to_index) as
+      #      top-level hidden fields so the move handler knows where the card
+      #      came from and where it landed.
+      class KanbanMove < Interaction
+        private
+
+        # POST to <member>/kanban_move for the dropped record.
+        def form_action
+          resource_url_for(resource_record!, action: :kanban_move)
+        end
+
+        def form_template
+          render_kanban_move_context
+          super
+        end
+
+        # Emit the move context as top-level params (NOT namespaced under
+        # interaction[...]) — the move handler reads params[:from_column] etc.
+        # Values come from the GET request's query string.
+        def render_kanban_move_context
+          {
+            from_column: params[:from_column],
+            to_column: params[:to_column],
+            to_index: params[:to_index]
+          }.each do |name, value|
+            input(type: :hidden, name: name.to_s, value: value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/options/inferred_types.rb

@@ -5,6 +5,8 @@ module Plutonium
     module Form
       module Options
         module InferredTypes
+          include Plutonium::UI::Options::HasCentsField
+
           private
 
           def infer_field_component
@@ -16,6 +18,10 @@ module Plutonium
             # `*_key`, `salt`, ...) — see #secret_field_name?.
             return :password if inferred_string_field_type == :password || secret_field_name?
 
+            # has_cents decimal accessors render as a currency input (number field
+            # + unit prefix), mirroring the display — no explicit `as: :currency`.
+            return :currency if has_cents_field?
+
             case inferred_field_type
             when :rich_text
               return :markdown

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

@@ -202,6 +202,18 @@ module Plutonium
             hidden: true,
             data: {controller: "capture-url"}
 
+          # Kanban quick-add: carry the column key through to the create POST so
+          # the controller can apply that column's on_enter + positioning to the
+          # new record post-create (the "+ Add" link opens this form with
+          # ?kanban_column=<key>). Only emitted when present, so it never appears
+          # on ordinary new/edit forms.
+          if request.params[:kanban_column].present?
+            input name: "kanban_column",
+              value: request.params[:kanban_column],
+              type: :hidden,
+              hidden: true
+          end
+
           if in_modal?
             div(class: "shrink-0 px-6 py-3 " \
                        "bg-[var(--pu-surface)] border-t border-[var(--pu-border)] " \

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

@@ -80,6 +80,13 @@ module Plutonium
             invalid_flatpickr: :invalid_input,
             neutral_flatpickr: :neutral_input,
 
+            # Currency (money input; the number field styles as a normal input,
+            # the unit prefix is overlaid by the component)
+            currency: :input,
+            valid_currency: :valid_input,
+            invalid_currency: :invalid_input,
+            neutral_currency: :neutral_input,
+
             # Int tel input
             int_tel_input: :input,
             valid_int_tel_input: :valid_input,

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

@@ -127,14 +127,13 @@ module Plutonium
         end
 
         def render_meta_slot
-          fields = Array(slots[:meta])
-          values = fields.map { |f| field_value(f) }.reject(&:blank?)
+          pairs = Array(slots[:meta]).map { |name| [name, field_value(name)] }.reject { |_, value| value.blank? }
 
           div(class: "flex flex-wrap items-center gap-1.5 mt-1") do
-            if values.empty?
+            if pairs.empty?
               render_blank_placeholder
             else
-              values.each { |v| render_meta_badge(v) }
+              pairs.each { |name, value| render_meta_badge(name, value) }
             end
           end
         end
@@ -158,21 +157,38 @@ module Plutonium
             # rendered by the timeago Stimulus controller.
             raw safe(helpers.display_datetime_value(value))
           elsif currency_field?(name)
-            plain helpers.number_to_currency(value, unit: "")
+            plain helpers.number_to_currency(value, unit: currency_unit_for(name))
           else
             plain helpers.display_name_of(value)
           end
         end
 
-        # Renders a meta value as a colored pill, borrowing the Badge
-        # display component's semantic color + humanize logic. Status-like
-        # values (published, pending, failed…) get meaningful colors;
-        # free-form values get a deterministic decorative color.
-        def render_meta_badge(value)
+        # Renders a meta value as a colored pill, borrowing the Badge display
+        # component's semantic color + humanize logic. Non-string types are
+        # formatted by type first so they don't badge their raw value:
+        #   - has_cents columns → currency (matches render_formatted_value)
+        #   - associations → display_name_of (label, not an object inspect)
+        #   - everything else → humanized, with the RAW value driving the
+        #     variant so status-like enums (in_progress, published…) still
+        #     resolve to a semantic color.
+        # The variant hashes the stable formatted label for currency/associations,
+        # so the decorative color no longer churns on an object's memory address.
+        def render_meta_badge(name, value)
           badge = Plutonium::UI::Display::Components::Badge
-          variant = badge.variant_for(value)
+
+          if currency_field?(name)
+            label = helpers.number_to_currency(value, unit: currency_unit_for(name))
+            variant = badge.variant_for(label)
+          elsif association_field?(name)
+            label = helpers.display_name_of(value)
+            variant = badge.variant_for(label)
+          else
+            label = badge.humanize(value)
+            variant = badge.variant_for(value)
+          end
+
           span(class: tokens("pu-badge", "pu-badge-#{variant}")) do
-            plain badge.humanize(value)
+            plain label
           end
         end
 
@@ -181,6 +197,17 @@ module Plutonium
           klass.respond_to?(:has_cents_decimal_attribute?) && klass.has_cents_decimal_attribute?(name.to_sym)
         end
 
+        # Delegates to the shared resolver so cards format currency identically to
+        # the Currency display component — has_cents unit → configured/i18n default,
+        # with `false` meaning no symbol. Cards have no per-display unit (nil).
+        def currency_unit_for(name)
+          Plutonium::UI::Display::Components::Currency.resolve_unit(nil, record, name)
+        end
+
+        def association_field?(name)
+          record.class.reflect_on_association(name.to_sym).present?
+        end
+
         # A declared slot with no value renders a muted em-dash rather than
         # collapsing, so cards in a grid keep an even height instead of
         # ragged rows when some records lack the field.
@@ -243,7 +270,7 @@ module Plutonium
 
         def row_actions
           @row_actions ||= resource_definition.defined_actions.values.select { |a|
-            a.collection_record_action? && a.permitted_by?(record_policy) && a.condition_met?(view_context, record:)
+            a.collection_record_action? && !a.kanban_drop? && a.permitted_by?(record_policy) && a.condition_met?(view_context, record:)
           }
         end