plutonium 0.59.0 → 0.60.1

data/lib/generators/pu/rodauth/views_generator.rb

@@ -13,7 +13,7 @@ module Pu
       desc "Generate views for selected features\n\n" \
            "Supported Features\n" \
            "=========================================\n" \
-           "#{VIEW_CONFIG.keys.sort.map(&:to_s).join "\n"}\n\n\n\n"
+           "#{VIEW_CONFIG.keys.sort.join "\n"}\n\n\n\n"
 
       argument :plugin_name, type: :string, optional: true,
         desc: "[CONFIG] Name of the configured rodauth app. Leave blank to use the primary account."

data/lib/plutonium/auth/rodauth.rb

@@ -7,7 +7,7 @@ module Plutonium
           extend ActiveSupport::Concern
 
           included do
-            helper_method :current_user
+            helper_method :current_user, :current_#{name}
             helper_method :logout_url
             helper_method :profile_url
           end
@@ -23,6 +23,7 @@ module Plutonium
           def current_user
             rodauth.rails_account
           end
+          alias_method :current_#{name}, :current_user
 
           def logout_url
             rodauth.logout_path

data/lib/plutonium/configuration.rb

@@ -27,7 +27,8 @@ module Plutonium
     # @return [Float] the current defaults version
     attr_reader :defaults_version
 
-    # @return [Symbol] :classic (legacy Header/Sidebar) or :modern (Topbar/IconRail)
+    # @return [Symbol] :modern (Topbar/IconRail, default), :plain (Topbar, no
+    #   icon rail), or :classic (legacy Header/Sidebar).
     attr_accessor :shell
 
     # @return [String] host URL of the Navii avatar service (no path), used by

data/lib/plutonium/core/controller.rb

@@ -45,6 +45,25 @@ module Plutonium
         append_view_path File.expand_path("app/views", Plutonium.root)
         layout -> { turbo_frame_request? ? false : "resource" }
         helper_method :registered_resources
+
+        class_attribute :_rail_enabled, instance_writer: false, default: nil
+        helper_method :rail?
+      end
+
+      class_methods do
+        # Enable or disable the modern icon rail for this controller and its
+        # subclasses. nil (the default) inherits the global shell default.
+        def rail(enabled)
+          self._rail_enabled = enabled
+        end
+      end
+
+      # Whether the modern icon rail is active for this request. Resolves the
+      # per-controller `rail` setting, falling back to the shell default.
+      # Public: the resource layout calls `controller.rail?`.
+      def rail?
+        return _rail_enabled unless _rail_enabled.nil?
+        Plutonium.configuration.shell == :modern
       end
 
       private

data/lib/plutonium/definition/base.rb

@@ -34,6 +34,7 @@ module Plutonium
       include Search
       include NestedInputs
       include StructuredInputs
+      include FormLayout
       include IndexViews
       include Metadata
 

data/lib/plutonium/definition/form_layout.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Definition
+    # Declarative form sectioning. Mixed into both resource definitions and
+    # interactions (mirrors StructuredInputs). The layout references field KEYS
+    # only and carries section-level options; per-field config stays on `input`.
+    #
+    # @example
+    #   form_layout do
+    #     section :identity, :name, :email, label: "Your identification"
+    #     section :address, :street, :city, collapsible: true, columns: 2,
+    #       condition: -> { object.requires_address? }
+    #     ungrouped label: "Other"
+    #   end
+    module FormLayout
+      extend ActiveSupport::Concern
+
+      UNGROUPED_KEY = :ungrouped
+
+      # One declared section, or the implicit `ungrouped` bucket (empty `fields`).
+      Section = Struct.new(:key, :fields, :options) do
+        def ungrouped? = key == UNGROUPED_KEY
+        def label = options[:label] || key.to_s.humanize
+        def description = options[:description]
+        def collapsible? = !!options[:collapsible]
+        def collapsed? = !!options[:collapsed]
+        def columns = options[:columns]
+        def condition = options[:condition]
+      end
+
+      # A section paired with the concrete fields it will render (after policy
+      # filtering). Produced by #resolve_form_sections (a later task).
+      ResolvedSection = Struct.new(:section, :fields)
+
+      # Collects section/ungrouped calls from a form_layout block in order.
+      class Builder
+        attr_reader :sections
+
+        def initialize
+          @sections = []
+          @ungrouped_seen = false
+        end
+
+        def section(key, *fields, **options)
+          if key == UNGROUPED_KEY
+            raise ArgumentError,
+              "`section :#{UNGROUPED_KEY}` is reserved — use the `ungrouped` macro"
+          end
+          validate_columns!(options)
+          @sections << Section.new(key:, fields: fields.freeze, options: options.freeze)
+        end
+
+        def ungrouped(**options)
+          raise ArgumentError, "`ungrouped` may only be declared once" if @ungrouped_seen
+          @ungrouped_seen = true
+          validate_columns!(options)
+          @sections << Section.new(key: UNGROUPED_KEY, fields: [].freeze, options: options.freeze)
+        end
+
+        private
+
+        def validate_columns!(options)
+          return unless options.key?(:columns)
+          value = options[:columns]
+          unless Integer === value && value > 0
+            raise ArgumentError,
+              "form_layout :columns must be a positive Integer, got #{value.inspect}"
+          end
+        end
+      end
+
+      class_methods do
+        # Declare the form layout. Re-declaring replaces it as a unit.
+        def form_layout(&block)
+          raise ArgumentError, "`form_layout` requires a block" unless block
+          builder = Builder.new
+          builder.instance_exec(&block)
+          @defined_form_layout = builder.sections.freeze
+        end
+
+        # Ordered Array<Section>, or nil when no layout was declared.
+        def defined_form_layout
+          @defined_form_layout
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@defined_form_layout, defined_form_layout&.dup)
+        end
+      end
+
+      # Instance access — the form render path holds a definition/interaction
+      # instance (mirrors the defineable_prop convention).
+      def defined_form_layout
+        self.class.defined_form_layout
+      end
+
+      # Resolve the policy-filtered field list into ordered ResolvedSections.
+      # Returns nil when no layout is declared (caller falls back to one grid).
+      def resolve_form_sections(resource_fields)
+        layout = defined_form_layout
+        return nil unless layout
+
+        resource_fields = resource_fields.map(&:to_sym)
+        known = resource_fields.to_set
+
+        # First-section-wins assignment: each field is claimed by the first
+        # section that lists it. A field a section lists but that isn't in the
+        # currently-permitted set (policy, per-action, entity scoping, nesting)
+        # is simply skipped — it never renders and is never an error.
+        owner = {}
+        layout.each do |section|
+          next if section.ungrouped?
+          section.fields.each do |f|
+            owner[f] ||= section.key if known.include?(f)
+          end
+        end
+        leftovers = resource_fields.reject { |f| owner.key?(f) }
+
+        resolved = layout.map do |section|
+          fields =
+            if section.ungrouped?
+              leftovers
+            else
+              section.fields.select { |f| owner[f] == section.key }
+            end
+          ResolvedSection.new(section:, fields:)
+        end
+
+        unless layout.any?(&:ungrouped?)
+          implicit = ResolvedSection.new(
+            section: Section.new(key: UNGROUPED_KEY, fields: [].freeze, options: {}.freeze),
+            fields: leftovers
+          )
+          resolved.push(implicit)
+        end
+
+        resolved
+      end
+    end
+  end
+end

data/lib/plutonium/interaction/base.rb

@@ -26,6 +26,7 @@ module Plutonium
       include Plutonium::Definition::ConfigAttr
       include Plutonium::Definition::Presentable
       include Plutonium::Definition::StructuredInputs
+      include Plutonium::Definition::FormLayout
 
       # On interactions, declaring a structured input also declares the backing
       # ActiveModel attribute so the value survives `attributes=` and appears in

data/lib/plutonium/package/engine.rb

@@ -4,14 +4,24 @@ module Plutonium
       extend ActiveSupport::Concern
 
       included do
-        # prevent this package from being added to the view lookup
-        # since we need finer control over how views are resolved.
-        # view lookup configuration is handled at the controller level
-        config.before_configuration do
-          # this touches the internals of rails, but I could not find a good way of doing this
-          # we get the initializer instance and set the block property to a noop
+        # Prevent this package's app/views from being appended to the global
+        # ActionController/ActionMailer view lookup — Plutonium resolves package
+        # views at the controller level (see Plutonium::Core::Controllers::Bootable,
+        # which reads current_engine.paths["app/views"]). We neutralize the
+        # engine's built-in `add_view_paths` initializer rather than clearing
+        # config.paths["app/views"], which that controller-level resolver needs.
+        #
+        # This MUST run as a real initializer (before :add_view_paths), NOT in
+        # before_configuration: that hook can fire before sibling package engines
+        # are loaded (it does in development, where :before_configuration has
+        # already run by the time config/packages.rb loads). Touching
+        # Rails.application.initializers there forces Rails.application.railties
+        # to memoize early — with only the packages loaded so far — permanently
+        # dropping the rest from the autoload paths (e.g. `uninitialized constant
+        # Blogging::Post`). By initializer-run time, railties is fully populated.
+        initializer :plutonium_neutralize_add_view_paths, before: :add_view_paths do
           add_view_paths_initializer = Rails.application.initializers.find do |a|
-            a.context_class == self && a.name.to_s == "add_view_paths"
+            a.context_class == self.class && a.name.to_s == "add_view_paths"
           end
           add_view_paths_initializer&.instance_variable_set(:@block, ->(app) {})
         end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Renders a form section's chrome (heading/description, optional native
+        # <details> collapsible, and a fields grid) and yields to a block that
+        # renders the section's fields (the form supplies render_resource_field).
+        class Section < Plutonium::UI::Component::Base
+          def initialize(resolved, grid_class:)
+            @section = resolved.section
+            @grid_class = grid_class
+          end
+
+          SECTION_CLASS = "space-y-4 border-t border-[var(--pu-border-muted)] pt-6 first:border-t-0 first:pt-0"
+          HEADING_CLASS = "text-base font-semibold text-[var(--pu-text)]"
+          SUMMARY_CLASS = "#{HEADING_CLASS} cursor-pointer select-none"
+          DESCRIPTION_CLASS = "text-sm text-[var(--pu-text-muted)]"
+
+          def view_template(&fields_block)
+            if @section.collapsible?
+              details(open: !@section.collapsed?, class: SECTION_CLASS) do
+                summary(class: SUMMARY_CLASS) { heading_text }
+                describe
+                grid(&fields_block)
+              end
+            else
+              div(class: SECTION_CLASS) do
+                header_block
+                grid(&fields_block)
+              end
+            end
+          end
+
+          private
+
+          def header_block
+            return if @section.ungrouped? && @section.options[:label].nil?
+            h3(class: HEADING_CLASS) { heading_text }
+            describe
+          end
+
+          def heading_text = @section.label
+
+          def describe
+            return unless @section.description
+            p(class: DESCRIPTION_CLASS) { @section.description }
+          end
+
+          def grid(&fields_block)
+            div(class: @grid_class, &fields_block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Plutonium
       module Components
         class StickyFooter < Plutonium::UI::Component::Base
           def view_template(&block)
-            div(class: "fixed bottom-0 left-0 right-0 lg:left-14 z-20 " \
+            div(class: "pu-sticky-footer fixed bottom-0 left-0 right-0 lg:left-14 z-20 " \
                        "h-14 bg-[var(--pu-surface)] border-t border-[var(--pu-border)] " \
                        "px-6 flex items-center justify-end gap-2", &block)
           end

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

@@ -98,11 +98,81 @@ module Plutonium
         end
 
         def render_fields
-          fields_wrapper {
-            resource_fields.each { |name|
-              render_resource_field name
+          sections = resolve_form_layout
+          if sections.nil?
+            fields_wrapper {
+              resource_fields.each { |name| render_resource_field name }
             }
-          }
+          else
+            sections.each { |rs| render_form_section(rs) }
+          end
+        end
+
+        # Resolve the whole form layout for THIS render, in one pass: drop
+        # condition-hidden sections and evaluate any proc-valued options, all in
+        # the form instance context (where `object`, `current_user`, `params` and
+        # helpers live — same context as input/section `condition:`). Returns nil
+        # when no form_layout is declared (caller falls back to a single grid).
+        def resolve_form_layout
+          sections = resource_definition.resolve_form_sections(resource_fields)
+          return nil if sections.nil?
+
+          sections.filter_map do |resolved|
+            section = resolved.section
+            condition = section.condition
+            next if condition && !instance_exec(&condition)
+
+            # `columns` stays a validated literal; everything else may be a proc.
+            options = section.options.to_h do |key, value|
+              [key, (key != :condition && value.is_a?(Proc)) ? instance_exec(&value) : value]
+            end
+            Plutonium::Definition::FormLayout::ResolvedSection.new(
+              section: Plutonium::Definition::FormLayout::Section.new(
+                key: section.key, fields: section.fields, options: options.freeze
+              ),
+              fields: resolved.fields
+            )
+          end
+        end
+
+        # Pure presentation — the section is already resolved (visible, options
+        # evaluated) by resolve_form_layout.
+        def render_form_section(resolved)
+          section = resolved.section
+          render Plutonium::UI::Form::Components::Section.new(
+            resolved, grid_class: section_grid_class(section.columns)
+          ) do
+            # Inside a multi-column section, let fields flow into the grid cells
+            # instead of forcing each to span the full row (see col-span default
+            # in render_simple_resource_field).
+            previous = @section_columns
+            @section_columns = section.columns
+            begin
+              resolved.fields.each { |name| render_resource_field name }
+            ensure
+              @section_columns = previous
+            end
+          end
+        end
+
+        # True while rendering fields inside a section that declared an explicit
+        # column count > 1. Such fields default to a single grid cell rather than
+        # `col-span-full`, so the section's grid actually lays out in columns.
+        def in_multi_column_section?
+          @section_columns.to_i > 1
+        end
+
+        # nil → the form's default responsive grid; an Integer overrides columns.
+        def section_grid_class(columns)
+          return themed(:fields_wrapper, nil) if columns.nil?
+
+          base = "grid gap-6 grid-flow-row-dense grid-cols-1"
+          case columns.to_i
+          when 1 then base
+          when 2 then "#{base} md:grid-cols-2"
+          when 3 then "#{base} md:grid-cols-2 lg:grid-cols-3"
+          else "#{base} md:grid-cols-2 2xl:grid-cols-#{columns.to_i}"
+          end
         end
 
         def render_actions
@@ -232,10 +302,18 @@ module Plutonium
             end
           else
             wrapper_options = input_options[:wrapper] || {}
+            # Only supply a default column span when the field hasn't declared its
+            # own (via `wrapper: {class: "col-span-..."}`). A field-level col-span
+            # ALWAYS wins — including inside a section with `columns:` — so authors
+            # can opt a single field back to full width in a multi-column section,
+            # or vice versa.
+            # TODO: remove the string check once theming supports class merges.
             if !wrapper_options[:class] || !wrapper_options[:class].include?("col-span")
-              # temp hack to allow col span overrides
-              # TODO: remove once we complete theming, which will support merges
-              wrapper_options[:class] = tokens("col-span-full", wrapper_options[:class])
+              # In a multi-column section the field flows into a single grid cell
+              # (no col-span), so the declared `columns:` actually takes effect.
+              # Everywhere else fields span the full row.
+              default_span = in_multi_column_section? ? nil : "col-span-full"
+              wrapper_options[:class] = tokens(default_span, wrapper_options[:class])
             end
 
             render form.field(name, **field_options).wrapped(

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

@@ -48,7 +48,11 @@ module Plutonium
         #   on <html> based on whether the incoming body contains an icon-rail,
         #   preventing layout shift on Turbo navigations between rail and non-rail
         #   pages. Initial-load rail-pinned is handled by ResourceLayout.
+        #   The same listener also keeps `pu-no-rail` in sync (inverse of the rail
+        #   signal) for non-classic shells, since Turbo Drive does not update
+        #   <html> attributes across cross-URL visits.
         def render_pre_paint_scripts
+          manage_no_rail = Plutonium.configuration.shell != :classic
           script do
             raw(safe(<<~JS))
               (function () {
@@ -68,6 +72,7 @@ module Plutonium
                     } else {
                       document.documentElement.classList.remove("pu-rail-pinned");
                     }
+                    #{'document.documentElement.classList.toggle("pu-no-rail", !hasRail);' if manage_no_rail}
                   });
                 } catch (e) {}
               })();

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

@@ -4,11 +4,18 @@ module Plutonium
       class ResourceLayout < Base
         private
 
+        # Whether the modern icon rail is active for this request. Delegates to
+        # the controller's resolution (shell default + per-controller `rail`).
+        def rail? = controller.rail?
+
         # Sets pu-rail-pinned immediately on initial page load so the rail
         # renders in its pinned state from the first frame. Turbo navigations
-        # are handled by the turbo:before-render listener in Base.
+        # are handled by the turbo:before-render listener in Base. Skipped
+        # entirely when the layout renders no rail.
         def render_pre_paint_scripts
           super
+          return unless rail?
+
           script do
             raw(safe(<<~JS))
               (function () {
@@ -22,12 +29,21 @@ module Plutonium
           end
         end
 
+        # Adds `pu-no-rail` to <html> (server-side, no FOUC) so decoupled fixed
+        # chrome (Topbar, form StickyFooter) can cancel their rail insets.
+        # Scoped to the modern family — :classic keeps its own offsets.
+        def html_attributes
+          attrs = super
+          return attrs if Plutonium.configuration.shell == :classic
+
+          rail? ? attrs : mix(attrs, {class: "pu-no-rail"})
+        end
+
         def main_attributes
-          classes = case Plutonium.configuration.shell
-          when :modern
-            "pt-16 pb-6 px-6 lg:pl-20"
-          else
+          classes = if Plutonium.configuration.shell == :classic
             "pt-20 lg:ml-64"
+          else
+            rail? ? "pt-16 pb-6 px-6 lg:pl-20" : "pt-16 pb-6 px-6"
           end
 
           mix(super, {class: classes})
@@ -43,7 +59,7 @@ module Plutonium
           super
 
           render partial("resource_header")
-          render partial("resource_sidebar")
+          render partial("resource_sidebar") if rail?
         end
       end
     end

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

@@ -33,7 +33,7 @@ module Plutonium
 
         def view_template
           nav(
-            class: "fixed top-0 right-0 left-0 lg:left-14 z-30 h-12 " \
+            class: "pu-topbar fixed top-0 right-0 left-0 lg:left-14 z-30 h-12 " \
                    "bg-[var(--pu-surface)] border-b border-[var(--pu-border)] " \
                    "flex items-center gap-3 px-4",
             data: {

data/lib/plutonium/version.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  VERSION = "0.59.0"
+  VERSION = "0.60.1"
   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.59.0",
+  "version": "0.60.1",
   "description": "Build production-ready Rails apps in minutes, not days. Convention-driven, fully customizable, AI-ready.",
   "type": "module",
   "main": "src/js/core.js",

data/src/css/components.css

@@ -757,6 +757,15 @@ html.pu-rail-pinned .icon-rail-pin-expand {
   }
 }
 
+/* Rail-less layouts (html.pu-no-rail): cancel the icon-rail inset on fixed
+   chrome so the topbar and form sticky footer span the full width. */
+@media (min-width: 1024px) {
+  html.pu-no-rail .pu-topbar,
+  html.pu-no-rail .pu-sticky-footer {
+    left: 0 !important;
+  }
+}
+
 /* Flyout: visibility controlled by Stimulus (data-flyout-open) via position:fixed */
 .icon-rail-parent {
   position: relative;

data/src/css/slim_select.css

@@ -43,9 +43,11 @@
   border-radius: var(--pu-radius-md);
   color: var(--pu-text);
 }
+
 .ss-main:hover {
   border-color: var(--pu-border-strong);
 }
+
 .ss-main:focus,
 .ss-main[aria-expanded="true"] {
   border-color: var(--pu-input-focus-ring);
@@ -196,9 +198,11 @@
   font-size: inherit;
   line-height: inherit;
 }
+
 .ss-content .ss-search input::placeholder {
   color: var(--pu-input-placeholder);
 }
+
 .ss-content .ss-search input:focus {
   border-color: var(--pu-input-focus-ring);
   box-shadow: 0 0 0 3px theme(colors.primary.500 / 15%);
@@ -225,7 +229,7 @@
 
 /* List */
 .ss-content .ss-list {
-  @apply flex-auto h-auto overflow-x-hidden overflow-y-auto;
+  @apply flex-auto h-auto overflow-x-hidden overflow-y-auto mb-2;
 }
 
 .ss-content .ss-list .ss-error {
@@ -345,10 +349,12 @@
 .ss-main.ss-invalid {
   @apply border-danger-500 bg-danger-50/50 text-danger-900;
 }
+
 .ss-main.ss-invalid:focus,
 .ss-main.ss-invalid[aria-expanded="true"] {
   box-shadow: 0 0 0 3px theme(colors.danger.500 / 15%);
 }
+
 .dark .ss-main.ss-invalid {
   @apply bg-danger-950/20 border-danger-500/70 text-danger-200;
 }
@@ -360,10 +366,12 @@
 .ss-main.ss-valid {
   @apply border-success-500 bg-success-50/50 text-success-900;
 }
+
 .ss-main.ss-valid:focus,
 .ss-main.ss-valid[aria-expanded="true"] {
   box-shadow: 0 0 0 3px theme(colors.success.500 / 15%);
 }
+
 .dark .ss-main.ss-valid {
   @apply bg-success-950/20 border-success-500/70 text-success-200;
 }
@@ -385,7 +393,8 @@
   width: 100% !important;
   border-radius: 0 !important;
   margin: 0 !important;
-  pointer-events: none !important; /* Disabled by default */
+  pointer-events: none !important;
+  /* Disabled by default */
 }
 
 /* When active (dropdown is expanded), enable pointer events */