plutonium 0.49.1 → 0.51.0

data/lib/plutonium/ui/component/kit.rb

@@ -78,6 +78,8 @@ module Plutonium
 
         def BuildTableScopesBar(...) = Plutonium::UI::Table::Components::ScopesBar.new(...)
 
+        def BuildTableScopesPills(...) = Plutonium::UI::Table::Components::ScopesPills.new(...)
+
         def BuildTableInfo(...) = Plutonium::UI::Table::Components::PagyInfo.new(...)
 
         def BuildTablePagination(...) = Plutonium::UI::Table::Components::PagyPagination.new(...)
@@ -86,7 +88,17 @@ module Plutonium
 
         def BuildBulkActionsToolbar(...) = Plutonium::UI::Table::Components::BulkActionsToolbar.new(...)
 
+        def BuildTableToolbar(...) = Plutonium::UI::Table::Components::Toolbar.new(...)
+
+        def BuildTableFilterPills(...) = Plutonium::UI::Table::Components::FilterPills.new(...)
+
+        def BuildTableViewSwitcher(...) = Plutonium::UI::Table::Components::ViewSwitcher.new(...)
+
         def BuildColorModeSelector(...) = Plutonium::UI::ColorModeSelector.new(...)
+
+        def BuildModalCentered(...) = Plutonium::UI::Modal::Centered.new(...)
+
+        def BuildModalSlideover(...) = Plutonium::UI::Modal::Slideover.new(...)
       end
     end
   end

data/lib/plutonium/ui/component/methods.rb

@@ -40,10 +40,14 @@ module Plutonium
           :current_user,
           :current_parent,
           :current_definition,
+          :resource_definition,
           :current_query_object,
           :raw_resource_query_params,
           :current_policy,
           :current_turbo_frame,
+          :in_frame?,
+          :in_modal?,
+          :in_secondary_modal?,
           :current_interactive_action,
           :current_engine,
           :policy_for,

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

@@ -46,7 +46,9 @@ module Plutonium
 
         def fields_wrapper(&)
           div(class: themed(:fields_wrapper)) {
-            yield
+            div(class: themed(:fields_inner)) {
+              yield
+            }
           }
         end
       end

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

@@ -13,56 +13,93 @@ module Plutonium
           @resource_definition = resource_definition
         end
 
+        # Metadata fields the user is permitted to see — intersection of
+        # the definition's declared metadata with the policy-filtered
+        # `resource_fields`. Computed lazily so we don't run the
+        # intersection when the resource doesn't declare any metadata.
+        def metadata_fields
+          @metadata_fields ||= resource_definition.defined_metadata_fields & resource_fields
+        end
+
         def display_template
-          render_fields
-          render_associations if present_associations?
+          if associations_present?
+            render_tablist_with_details
+          else
+            render_fields
+          end
         end
 
         private
 
+        def associations_present?
+          present_associations? && resource_associations.present?
+        end
+
         def render_fields
+          if metadata_fields.any?
+            div(class: "grid grid-cols-1 lg:grid-cols-[minmax(0,1fr)_320px] gap-6 items-start") do
+              div { render_main_field_card }
+              aside { render_metadata_panel }
+            end
+          else
+            render_main_field_card
+          end
+        end
+
+        def render_main_field_card
           Block do
             fields_wrapper do
-              resource_fields.each do |name|
+              # Skip fields claimed by the metadata panel — rendering
+              # them in both places duplicates information.
+              (resource_fields - metadata_fields).each do |name|
                 render_resource_field name
               end
             end
           end
         end
 
-        def render_associations
-          return unless resource_associations.present?
+        # Renders the declared metadata fields as a vertical stack beside
+        # the main field card. Reuses render_resource_field (same path
+        # the main details use) so labels/values match in style; the
+        # only difference from the main card is the wrapper — a single
+        # column of fields instead of the form's multi-column grid.
+        def render_metadata_panel
+          Block do
+            div(class: "pu-card-body flex flex-col gap-6") do
+              metadata_fields.each { |name| render_resource_field(name) }
+            end
+          end
+        end
 
+        def render_tablist_with_details
           tablist = BuildTabList()
 
+          # Build an inner display component for the Details tab.
+          # It must be a standalone Phlex component so that TabList can call
+          # `render(details_display)` from within its own context. Phlex propagates
+          # @_state through render calls, so the inner component writes to the same
+          # buffer as the outer Resource display even though self changes.
+          details_display = build_details_display
+
+          tablist.with_tab(
+            identifier: "details",
+            title: -> { plain "Details" }
+          ) do
+            render details_display
+          end
+
           resource_associations.each do |name|
             reflection = object.class.reflect_on_association name
-
-            if !reflection
-              raise ArgumentError,
-                "unknown association #{object.class}##{name} defined in #permitted_associations"
-            elsif !registered_resources.include?(reflection.klass)
-              raise ArgumentError,
-                "#{object.class}##{name} defined in #permitted_associations, but #{reflection.klass} is not a registered resource"
-            end
+            raise_unknown_association(name) unless reflection
+            raise_unregistered_association(name, reflection) unless registered_resources.include?(reflection.klass)
 
             title = object.class.human_attribute_name(name)
-            src = case reflection.macro
-            when :belongs_to
-              associated = object.public_send name
-              resource_url_for(associated, parent: nil) if associated
-            when :has_one
-              associated = object.public_send name
-              resource_url_for(associated, parent: object, association: name)
-            when :has_many
-              resource_url_for(reflection.klass, parent: object, association: name)
-            end
-
+            src = association_src(name, reflection)
             next unless src
 
             tablist.with_tab(
               identifier: title.parameterize,
-              title: -> { h5(class: "text-2xl font-bold tracking-tight text-[var(--pu-text)]") { title } }
+              title: -> { plain title }
             ) do
               FrameNavigatorPanel(title: "", src:, panel_id: "association-panel-#{title.parameterize}")
             end
@@ -71,6 +108,53 @@ module Plutonium
           render tablist
         end
 
+        # Builds a standalone Phlex component whose sole job is to render the
+        # resource fields. Having a distinct component lets TabList call
+        # `render(details_display)` so that Phlex propagates its @_state correctly,
+        # while avoiding the `instance_exec` context-switch problem that would
+        # occur if we put `render_fields` directly inside the `with_tab` block.
+        #
+        # The anonymous subclass overrides `view_template` to skip the outer
+        # `display_wrapper` div (which would duplicate the dom id already emitted
+        # by the parent Resource display) and renders just the fields content.
+        def build_details_display
+          resource = self
+
+          klass = Class.new(self.class) do
+            define_method(:view_template) do
+              resource.send(:render_fields)
+            end
+          end
+
+          klass.new(
+            object,
+            resource_fields: resource_fields,
+            resource_associations: [],
+            resource_definition: resource_definition
+          )
+        end
+
+        def association_src(name, reflection)
+          case reflection.macro
+          when :belongs_to
+            associated = object.public_send name
+            resource_url_for(associated, parent: nil) if associated
+          when :has_one
+            associated = object.public_send name
+            resource_url_for(associated, parent: object, association: name)
+          when :has_many
+            resource_url_for(reflection.klass, parent: object, association: name)
+          end
+        end
+
+        def raise_unknown_association(name)
+          raise ArgumentError, "unknown association #{object.class}##{name} defined in #permitted_associations"
+        end
+
+        def raise_unregistered_association(name, reflection)
+          raise ArgumentError, "#{object.class}##{name} defined in #permitted_associations, but #{reflection.klass} is not a registered resource"
+        end
+
         def render_resource_field(name)
           when_permitted(name) do
             # field :name, as: :string

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

@@ -8,7 +8,8 @@ module Plutonium
           super.merge({
             base: "",
             value_wrapper: "max-h-[300px] overflow-y-auto",
-            fields_wrapper: "p-8 grid grid-cols-1 md:grid-cols-2 2xl:grid-cols-4 gap-x-8 gap-y-8 grid-flow-row-dense",
+            fields_wrapper: "pu-card",
+            fields_inner: "pu-card-body grid grid-cols-1 md:grid-cols-2 2xl:grid-cols-4 gap-x-8 gap-y-6 grid-flow-row-dense",
 
             # Labels and descriptions
             label: "text-sm font-semibold uppercase tracking-wide text-[var(--pu-text-muted)] mb-2",

data/lib/plutonium/ui/dyna_frame/content.rb

@@ -1,29 +1,23 @@
 module Plutonium
   module UI
     module DynaFrame
+      # Conditionally wraps its content in a turbo-frame matching the inbound
+      # request's `Turbo-Frame` header. In frame mode adds the flash partial
+      # so toast/alert messages still surface inside frames; in non-frame
+      # mode renders the block as-is.
       class Content < Plutonium::UI::Component::Base
         include Phlex::Rails::Helpers::TurboFrameTag
 
-        def initialize(content = nil)
-          @content = content
-        end
-
-        def view_template
+        def view_template(&block)
           if current_turbo_frame.present?
-            # Frame request: render only the turbo-frame with content
             turbo_frame_tag(current_turbo_frame) do
               render partial("flash")
-              @content&.call
+              yield if block_given?
             end
-          else
-            # Regular request: yield self so caller can call frame.render_content
-            yield(self)
+          elsif block_given?
+            yield
           end
         end
-
-        def render_content
-          @content&.call
-        end
       end
     end
   end

data/lib/plutonium/ui/empty_card.rb

@@ -8,7 +8,7 @@ module Plutonium
       end
 
       def view_template
-        div(class: "pu-card") do
+        div(class: "pu-card mt-4") do
           div(class: "pu-empty-state") do
             p(class: "pu-empty-state-description") { message }
             yield if block_given?

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

@@ -10,6 +10,28 @@ module Plutonium
           include Phlexi::Field::Common::Tokens
           include Plutonium::UI::Form::Options::InferredTypes
 
+          # Consume `:as` here so it doesn't land in Phlexi's `@options` —
+          # `:as` is a Plutonium-internal concept (it picks the tag method),
+          # not a Phlexi field option.
+          def initialize(*args, as: nil, **kwargs, &block)
+            @as = as
+            super(*args, **kwargs, &block)
+          end
+
+          attr_reader :as
+
+          def hidden?
+            as.to_s == "hidden"
+          end
+
+          # Hidden fields (`form.field(name, as: :hidden)`) skip the label /
+          # hint / error chrome and render inside a `<div hidden>` so they're
+          # also excluded from CSS Grid / Flex layout.
+          def wrapped(**, &)
+            return Plutonium::UI::Form::Components::HiddenWrapper.new(self, &) if hidden?
+            super
+          end
+
           def textarea_tag(**attributes, &)
             attributes[:data_controller] = tokens(attributes[:data_controller], "textarea-autogrow")
             super
@@ -44,8 +66,18 @@ module Plutonium
             create_component(Components::KeyValueStore, :key_value_store, **, &)
           end
 
+          def json_input_tag(**, &)
+            create_component(Components::Json, :json, **, &)
+          end
+
           def resource_select_tag(**attributes, &)
-            create_component(Components::ResourceSelect, :select, **attributes, &)
+            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select")
+            # class!: "" clears the underlying <select>'s themed classes
+            # (pu-input etc.) — the visible element is slim-select's
+            # generated .ss-main, so leaving Tailwind input chrome on the
+            # native select can leak into chip layout (e.g. forcing
+            # flex-direction: column or w-full on multi-mode chips).
+            create_component(Components::ResourceSelect, :select, class!: "", **attributes, &)
           end
 
           def secure_association_tag(**attributes, &)
@@ -79,8 +111,8 @@ module Plutonium
           alias_method :date_tag, :flatpickr_tag
           alias_method :time_tag, :flatpickr_tag
           alias_method :rich_text_tag, :markdown_tag
-          alias_method :json_tag, :textarea_tag
-          alias_method :jsonb_tag, :textarea_tag
+          alias_method :json_tag, :json_input_tag
+          alias_method :jsonb_tag, :json_input_tag
           alias_method :hstore_tag, :key_value_store_tag
           alias_method :key_value_tag, :key_value_store_tag
           alias_method :association_tag, :secure_association_tag

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Wrapper for fields configured as `as: :hidden`. Emits a hidden div
+        # containing only the input — no label, no hint, no error chrome.
+        # `hidden: true` (HTML5) sets `display: none` so the wrapper is
+        # excluded from CSS Grid / Flex layout, not just visually hidden.
+        class HiddenWrapper < Phlexi::Form::Components::Base
+          def view_template(&block)
+            div(hidden: true) do
+              yield(field) if block
+            end
+          end
+
+          # No id needed for a layout-suppressed wrapper.
+          def build_attributes
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Textarea-based input for `json` / `jsonb` columns.
+        #
+        # On render, serializes Hash/Array values to pretty JSON so users see
+        # valid JSON instead of Ruby `Hash#to_s` output (e.g. `{:k=>"v"}`).
+        # Strings are pretty-formatted if parseable, passed through verbatim
+        # otherwise — preserves an in-progress edit on form re-render.
+        #
+        # On submit, accepts either a JSON string (typed input) or a raw
+        # Hash/Array (e.g. a JSON-bodied API request that Rails has already
+        # parsed into params). Unparseable strings are passed through so model
+        # validation can surface the error, rather than being silently dropped.
+        class Json < Phlexi::Form::Components::Textarea
+          def view_template
+            textarea(**attributes) { serialized_value }
+          end
+
+          protected
+
+          def serialized_value
+            case (raw = field.value)
+            when nil then ""
+            when String then format_string(raw)
+            else JSON.pretty_generate(raw)
+            end
+          end
+
+          def format_string(str)
+            JSON.pretty_generate(JSON.parse(str))
+          rescue JSON::ParserError
+            str
+          end
+
+          def normalize_input(input_value)
+            case input_value
+            when nil then nil
+            when Hash, Array then input_value
+            when "" then nil
+            else
+              begin
+                JSON.parse(input_value)
+              rescue JSON::ParserError
+                input_value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,24 +6,156 @@ module Plutonium
       module Components
         # Select for choosing a resource record
         class ResourceSelect < Phlexi::Form::Components::Select
+          include Plutonium::UI::Component::Methods
+          include Plutonium::UI::Form::Concerns::TypeaheadAttributes
+
+          # Cap on the number of records the dropdown materialises. Keeps
+          # very large association tables from rendering thousands of
+          # options into the page; consumers needing more should pair this
+          # with a typeahead control later.
+          DEFAULT_CHOICE_LIMIT = 100
+
           protected
 
           def choices
             @choices ||= begin
-              collection = @raw_choices || @association_class&.all || []
+              collection = if @raw_choices
+                @raw_choices
+              elsif @association_class.nil?
+                []
+              else
+                authorized_relation(limit: @choice_limit)
+              end
               build_choice_mapper(collection)
             end
           end
 
+          # Builds the authorized relation for the association class, optionally
+          # capped at `limit`. Shared by `choices` (with the limit) and
+          # `normalize_simple_input` (without — so typeahead picks beyond the
+          # rendered subset still validate).
+          def authorized_relation(limit: nil)
+            relation = @association_class.all
+            relation = relation.limit(limit) if limit && relation.respond_to?(:limit)
+            return relation if @skip_authorization
+            authorized_resource_scope(@association_class, relation: relation)
+          end
+
           def build_attributes
+            # Defaults must land BEFORE super — AcceptsChoices.build_attributes
+            # consumes :value_method / :label_method off `attributes` into
+            # its own ivars, so anything we set after super has no effect.
+            attributes[:value_method] ||= :to_signed_global_id
+            attributes[:label_method] ||= :to_label
+
             super
+
             @association_class = attributes.delete(:association_class)
+            @skip_authorization = attributes.delete(:skip_authorization)
+            @choice_limit = attributes.fetch(:choice_limit) { DEFAULT_CHOICE_LIMIT }
+            attributes.delete(:choice_limit)
+            # Stash the typeahead option; the URL helper needs view_context
+            # which only exists once we're rendering.
+            @typeahead_option = attributes.delete(:typeahead)
+          end
+
+          # Phlex hook fires right before view_template runs and view_context
+          # is available, so this is where we can resolve the typeahead URL
+          # and inject the data attr.
+          def before_template
+            super
+            configure_typeahead_attributes!(@typeahead_option)
+          end
+
+          # SGIDs include a timestamp + signature, so the SGID in the URL
+          # (generated when the user submitted) won't string-equal the
+          # SGID we just generated for the same record. Compare by the
+          # decoded model id instead, falling back to raw string equality
+          # for non-SGID values (legacy URLs / explicit raw choices).
+          def selected?(option)
+            if attributes[:multiple]
+              Array(field.value).any? { |v| same_record?(v, option) }
+            else
+              same_record?(field.value, option)
+            end
+          end
+
+          # AcceptsChoices.normalize_simple_input rejects any submitted
+          # value that doesn't string-match an option's value. With SGIDs
+          # the URL value (signed/timestamped at submit time) never
+          # string-equals a freshly generated option SGID for the same
+          # record, so the value gets silently dropped — no WHERE clause
+          # is built and the filter behaves as if it weren't applied.
+          #
+          # For SGID values backed by an association class, validate against
+          # the unbounded authorized relation rather than the rendered
+          # `choices` (which is capped at `choice_limit` and may not include
+          # records reachable via typeahead). For raw values / explicit
+          # `@raw_choices`, fall back to record-equality against the rendered
+          # options.
+          def normalize_simple_input(input_value)
+            return nil if input_value.blank?
+
+            sgid = SignedGlobalID.parse(input_value)
+            if sgid && @association_class && !@raw_choices
+              return nil unless sgid.model_class <= @association_class
+              return authorized_relation.exists?(id: sgid.model_id) ? input_value : nil
+            end
+
+            choices.values.find { |opt| same_record?(input_value, opt) } && input_value
+          end
+
+          # Two values point at the same record when both decode to the
+          # same SGID (class + id). For explicit non-SGID `@raw_choices`,
+          # both sides are plain strings and string-equality is the only
+          # sensible answer. Mixed-format (one SGID, one raw) returns
+          # false — no cross-format guessing.
+          def same_record?(a, b)
+            return false if a.blank? || b.blank?
+
+            a_pair = decode_class_and_id(a)
+            b_pair = decode_class_and_id(b)
+            return a_pair == b_pair if a_pair && b_pair
+            return false if a_pair || b_pair
+
+            a.to_s == b.to_s
+          end
+
+          def decode_class_and_id(value)
+            gid = SignedGlobalID.parse(value)
+            gid && [gid.model_class.name, gid.model_id]
+          rescue
+            nil
           end
 
           # Use include_blank string as blank option text (Phlexi default uses placeholder)
           def blank_option_text
             @include_blank.is_a?(String) ? @include_blank : super
           end
+
+          private
+
+          def typeahead_target_class
+            @association_class
+          end
+
+          def typeahead_kind_and_name(_typeahead_option)
+            detect_typeahead_kind_and_name
+          end
+
+          # Plutonium::UI::Form::Query roots its form with `as: :q`, so
+          # any field whose ancestry includes a node keyed :q is a filter
+          # input. The filter name is the immediate child of that root.
+          # Form inputs (new/edit) fall through to :input + the field key.
+          def detect_typeahead_kind_and_name
+            lineage = field.dom.lineage
+            q_index = lineage.find_index { |node| node.key == :q }
+            if q_index && (filter_node = lineage[q_index + 1])
+              [:filter, filter_node.key]
+            else
+              [:input, field.key]
+            end
+          end
         end
       end
     end