plutonium 0.62.2 → 0.63.0

data/lib/generators/pu/lib/plutonium_generators/concerns/mounts_engines.rb

@@ -42,14 +42,46 @@ module PlutoniumGenerators
         constraint_file = "app/constraints/management_constraint.rb"
         return if File.exist?(File.expand_path(constraint_file, destination_root))
 
-        create_file constraint_file, <<~RUBY
+        create_file constraint_file, management_constraint_source
+      end
+
+      # Prefer the Rodauth constraint when the app has an admin account to point
+      # at — `Rodauth::Rails.authenticate` redirects unauthenticated requests to
+      # the login page instead of 404ing on the mount.
+      def management_constraint_source
+        account = rodauth_management_account
+        return management_constraint_stub unless account
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          # Gates the management engines mounted in config/routes.rb.
+          class ManagementConstraint
+            AUTHENTICATE = Rodauth::Rails.authenticate(#{account})
+
+            def self.matches?(request)
+              AUTHENTICATE.call(request)
+            end
+          end
+        RUBY
+      end
+
+      def management_constraint_stub
+        <<~RUBY
           # frozen_string_literal: true
 
+          # Gates the management engines mounted in config/routes.rb.
           class ManagementConstraint
+            # Rodauth (redirects to the login page when signed out):
+            #   AUTHENTICATE = Rodauth::Rails.authenticate(:admin)
+            #
+            #   def self.matches?(request)
+            #     AUTHENTICATE.call(request)
+            #   end
+
             def self.matches?(request)
               false # TODO: Implement authentication
               # Examples:
-              #   Rodauth:    request.env["rodauth.admin"]&.logged_in?
               #   Devise:     request.env["warden"].user(:admin).present?
               #   Custom:     request.session[:admin_id].present?
               #   HTTP Basic: authenticate_with_http_basic(request)
@@ -67,6 +99,19 @@ module PlutoniumGenerators
           end
         RUBY
       end
+
+      # Returns the `Rodauth::Rails.authenticate` argument for the account that
+      # should guard management routes — only ever the `:admin` configuration.
+      # `nil` when the app has no admin account, so the constraint is left
+      # unimplemented rather than silently handing management routes to whatever
+      # other account happens to exist.
+      def rodauth_management_account
+        rodauth_app = File.expand_path("app/rodauth/rodauth_app.rb", destination_root)
+        return unless File.exist?(rodauth_app)
+
+        names = File.read(rodauth_app).scan(/^\s*configure\s+::\w+\s*,\s*:(\w+)/).flatten
+        ":admin" if names.include?("admin")
+      end
     end
   end
 end

data/lib/generators/pu/lib/plutonium_generators/concerns/resource_registration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlutoniumGenerators
+  module Concerns
+    module ResourceRegistration
+      private
+
+      # Insert `register_resource ::<Klass>` into a routes file. Idempotent:
+      # skips if already present. Falls back when the conventional
+      # `# register resources above.` marker is missing.
+      def register_resource_in_routes(routes_path, resource, singular: false)
+        line = "register_resource ::#{resource}"
+        line += ", singular: true" if singular
+        content = File.read(File.join(destination_root, routes_path))
+
+        if /^\s*#{Regexp.escape(line)}\b/.match?(content)
+          say_status :identical, "#{routes_path} already registers #{resource}", :blue
+          return
+        end
+
+        if /^\s*#\s*register resources above\b/.match?(content)
+          insert_into_file routes_path,
+            indent("#{line}\n", 2),
+            before: /^\s*#\s*register resources above\b.*/
+        elsif /^\s*Rails\.application\.routes\.draw do\b/.match?(content)
+          insert_into_file routes_path,
+            indent("#{line}\n", 2),
+            after: /^\s*Rails\.application\.routes\.draw do.*\n/
+        elsif (match = content.match(/^(\w+::Engine)\.routes\.draw do.*\n/))
+          insert_into_file routes_path,
+            indent("#{line}\n", 2),
+            after: /^\s*#{Regexp.escape(match[1])}\.routes\.draw do.*\n/
+        else
+          say_status :warn,
+            "Could not locate routes block in #{routes_path}; add manually: #{line}",
+            :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/pu/lite/litestream/litestream_generator.rb

@@ -55,7 +55,7 @@ module Pu
         return if file_includes?(deploy_file, "litestream:")
 
         insert_into_file deploy_file, after: /^servers:.*\n/ do
-          <<~YAML
+          <<~YAML.indent(2)
             litestream:
               hosts:
                 - <%= ENV['DEPLOY_HOST'] %>

data/lib/generators/pu/lite/solid_queue/solid_queue_generator.rb

@@ -75,7 +75,7 @@ module Pu
         return if file_includes?(deploy_file, "job:")
 
         insert_into_file deploy_file, after: /^servers:.*\n/ do
-          <<~YAML
+          <<~YAML.indent(2)
             job:
               hosts:
                 - <%= ENV['DEPLOY_HOST'] %>

data/lib/generators/pu/res/conn/conn_generator.rb

@@ -7,6 +7,7 @@ module Pu
     class ConnGenerator < Rails::Generators::Base
       include PlutoniumGenerators::Generator
       include PlutoniumGenerators::Concerns::ResourceSelector
+      include PlutoniumGenerators::Concerns::ResourceRegistration
 
       source_root File.expand_path("templates", __dir__)
 
@@ -26,6 +27,9 @@ module Pu
       class_option :definition, type: :boolean, default: false,
         desc: "Create portal-specific definition even if base definition exists"
 
+      class_option :controller_for, type: :string, default: nil,
+        desc: "Explicit controller_for target, when the controller's name won't infer the resource on its own"
+
       def start
         selected_resources = resources_selection
         @app_namespace = portal_option(:dest, prompt: "Select destination portal").camelize
@@ -36,7 +40,7 @@ module Pu
           @resource_class = resource
 
           if app_namespace == "MainApp"
-            register_resource_in_routes("config/routes.rb", resource)
+            register_resource_in_routes("config/routes.rb", resource, singular: options[:singular])
           else
             if options[:policy] || !expected_parent_policy
               template "app/policies/resource_policy.rb",
@@ -51,7 +55,8 @@ module Pu
             template "app/controllers/resource_controller.rb",
               "packages/#{package_namespace}/app/controllers/#{package_namespace}/#{resource.pluralize.underscore}_controller.rb"
 
-            register_resource_in_routes("packages/#{package_namespace}/config/routes.rb", resource)
+            register_resource_in_routes("packages/#{package_namespace}/config/routes.rb", resource,
+              singular: options[:singular])
           end
         end
       rescue => e
@@ -62,45 +67,10 @@ module Pu
 
       attr_reader :app_namespace, :resource_class
 
-      # Insert `register_resource ::<Klass>` into a routes file. Idempotent:
-      # skips if already present. Falls back when the conventional
-      # `# register resources above.` marker is missing.
-      def register_resource_in_routes(routes_path, resource)
-        line = "register_resource ::#{resource}#{singular_option}"
-        content = File.read(File.join(destination_root, routes_path))
-
-        if /^\s*#{Regexp.escape(line)}\b/.match?(content)
-          say_status :identical, "#{routes_path} already registers #{resource}", :blue
-          return
-        end
-
-        if /^\s*#\s*register resources above\b/.match?(content)
-          insert_into_file routes_path,
-            indent("#{line}\n", 2),
-            before: /^\s*#\s*register resources above\b.*/
-        elsif /^\s*Rails\.application\.routes\.draw do\b/.match?(content)
-          insert_into_file routes_path,
-            indent("#{line}\n", 2),
-            after: /^\s*Rails\.application\.routes\.draw do.*\n/
-        elsif (match = content.match(/^(\w+::Engine)\.routes\.draw do.*\n/))
-          insert_into_file routes_path,
-            indent("#{line}\n", 2),
-            after: /^\s*#{Regexp.escape(match[1])}\.routes\.draw do.*\n/
-        else
-          say_status :warn,
-            "Could not locate routes block in #{routes_path}; add manually: #{line}",
-            :yellow
-        end
-      end
-
       def package_namespace
         app_namespace.underscore
       end
 
-      def singular_option
-        options[:singular] ? ", singular: true" : ""
-      end
-
       def resource_namespace
         app_namespace.underscore
       end
@@ -114,18 +84,28 @@ module Pu
         expected_parent_controller || "#{app_namespace}::ResourceController"
       end
 
+      # A gem-provided resource (e.g. Plutonium::Interaction::Async::Run) already has
+      # a working policy that subclasses Plutonium::Resource::Policy directly
+      # rather than through this host's ::ResourcePolicy — so the `< ::ResourcePolicy`
+      # check alone misses it and would regenerate a redundant, shadowing-prone
+      # override by default.
       def expected_parent_policy
         expected_parent_policy = "::#{resource_class.classify}Policy".safe_constantize
-        expected_parent_policy if expected_parent_policy.present? && expected_parent_policy < ::ResourcePolicy
+        return unless expected_parent_policy.present?
+
+        expected_parent_policy if expected_parent_policy < ::ResourcePolicy || expected_parent_policy < Plutonium::Resource::Policy
       end
 
       def parent_policy
         expected_parent_policy || "ResourcePolicy"
       end
 
+      # See expected_parent_policy — same reasoning for definitions.
       def expected_parent_definition
         expected_parent_definition = "::#{resource_class.classify}Definition".safe_constantize
-        expected_parent_definition if expected_parent_definition.present? && expected_parent_definition < ::ResourceDefinition
+        return unless expected_parent_definition.present?
+
+        expected_parent_definition if expected_parent_definition < ::ResourceDefinition || expected_parent_definition < Plutonium::Resource::Definition
       end
 
       def parent_definition

data/lib/generators/pu/res/conn/templates/app/controllers/resource_controller.rb.tt

@@ -1,3 +1,7 @@
 class <%= app_namespace %>::<%= resource_class.pluralize %>Controller < ::<%= parent_controller %>
+<%- if options[:controller_for] -%>
+  controller_for ::<%= options[:controller_for] %>
+
+<%- end -%>
   include <%= app_namespace %>::Concerns::Controller
 end

data/lib/generators/pu/rodauth/templates/app/rodauth/account_rodauth_plugin.rb.tt

@@ -233,11 +233,11 @@ class <%= account_path.classify %>RodauthPlugin < RodauthPlugin
 
     # ==> Remember Feature
 
-    # Remember all logged in users.
-    after_login { remember_login }
+    # Only remember users who ticked the "Remember Me" checkbox on the login form.
+    after_login { remember_login if param_or_nil(remember_param) == remember_remember_param_value }
 
-    # Or only remember users that have ticked a "Remember Me" checkbox on login.
-    # after_login { remember_login if param_or_nil("remember") }
+    # Or remember every user who logs in, whether they asked to be or not.
+    # after_login { remember_login }
 
     # Extend user's remember period when remembered via a cookie
     extend_remember_deadline? true
@@ -246,8 +246,17 @@ class <%= account_path.classify %>RodauthPlugin < RodauthPlugin
     remember_cookie_key "_<%= table_prefix %>_remember"
 <% end -%>
 
-    # Session security
-    session_key "_<%= table_prefix %>_session"
+    # Session security: namespace EVERY session key this configuration touches -
+    # the account id plus `authenticated_by`, `login_redirect`,
+    # `two_factor_auth_setup` and friends. Without this, configurations share those
+    # keys and clobber each other's state, and `session_isolation` cannot tell which
+    # entries belong to which configuration.
+    #
+    # Do not also set `session_key` here. An explicit `session_key` is NOT prefixed,
+    # so the account id key would rotate on a different schedule from every other
+    # key - and Rodauth crashes on a session that has an account id but no
+    # `authenticated_by` (`nil.include?` in `logged_in_via_remember_key?`).
+    session_key_prefix "<%= table_prefix %>_"
 
     # ==> Hooks
 

data/lib/generators/pu/rodauth/templates/app/rodauth/rodauth_plugin.rb.tt

@@ -9,6 +9,13 @@ class RodauthPlugin < Rodauth::Rails::Auth
     # See the Rodauth documentation for the list of available config options:
     # http://rodauth.jeremyevans.net/documentation.html
 
+    # Keep each configuration's session state to itself, so a person can be signed
+    # into more than one portal at a time. Without this, Rodauth's session reset on
+    # login (and on the `remember` feature's autologin) wipes the whole Rails
+    # session, evicting every other configuration's login.
+    # Relies on each configuration setting `session_key_prefix`.
+    enable :session_isolation
+
     # List of authentication features that are loaded.
     # enable :create_account, :verify_account, :verify_account_grace_period,
     #   :reset_password, :change_password, :change_password_notify,

data/lib/generators/pu/saas/welcome/templates/app/views/layouts/welcome.html.erb.tt

@@ -13,8 +13,8 @@
     <%%= javascript_include_tag "application", "data-turbo-track": "reload", defer: true %>
   <%% end %>
 </head>
-<body class="antialiased min-h-screen bg-[var(--pu-body)]">
-  <main class="p-4 min-h-screen flex flex-col items-center justify-center gap-2 px-6 py-8 mx-auto lg:py-0">
+<body class="antialiased pu-min-h-viewport bg-[var(--pu-body)]">
+  <main class="p-4 pu-min-h-viewport flex flex-col items-center justify-center gap-2 px-6 py-8 mx-auto lg:py-0">
     <%% if flash.any? %>
       <%% flash.each do |type, message| %>
         <div class="fixed z-50 top-16 inset-x-0 mx-auto flex items-center w-full max-w-md p-4 rounded-[var(--pu-radius-lg)]"

data/lib/generators/pu/wizards/install_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../lib/plutonium_generators"
+
+module Pu
+  module Wizards
+    # Turns the wizard subsystem on.
+    #
+    # App-wide, and takes no portal — unlike pu:async_interactions:install,
+    # which connects a RESOURCE and therefore needs somewhere to route it. A
+    # wizard mounts itself wherever it is declared (the `wizard` macro on a
+    # definition, or `register_wizard` in a portal or the main app), so there is
+    # nothing here to attach to a portal.
+    #
+    # What it does is the two steps every wizard app needs and neither of which
+    # a wizard can do for itself: flip the flag that registers the migration
+    # path, and schedule the sweep.
+    class InstallGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+      include PlutoniumGenerators::Concerns::ConfiguresRecurring
+
+      desc(
+        "Enable wizards and schedule the abandonment sweep\n\n" \
+        "e.g. rails g pu:wizards:install"
+      )
+
+      class_option :schedule, type: :string, default: "every 15 minutes",
+        desc: "Cron-style schedule for the SweepJob recurring task"
+
+      def start
+        enable_wizards
+        schedule_sweep_job
+        migration_reminder
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      # The flag gates the MIGRATION as well as the behaviour: while it is off
+      # the wizard migration path is never registered, so
+      # plutonium_wizard_sessions does not exist and nothing works.
+      def enable_wizards
+        configure_plutonium "config.wizards.enabled = true"
+      end
+
+      # Idempotent via add_recurring_tasks, so re-running this is a no-op.
+      #
+      # Scheduling matters more than it looks. For an +execute+-only wizard an
+      # unscheduled sweep just leaves stale session rows, which is untidy; for an
+      # +on_submit+ wizard it is the only thing that cleans up the partial domain
+      # records an abandoned run left behind.
+      def schedule_sweep_job
+        if gem_in_bundle?("solid_queue")
+          unless add_recurring_tasks(sweep_job_task_yaml, marker: "sweep_abandoned_wizards")
+            log :skip, "SweepJob not scheduled (config/recurring.yml missing or already scheduled)"
+          end
+        else
+          log :info, "solid_queue not found — schedule Plutonium::Wizard::SweepJob yourself (see docs)"
+        end
+      end
+
+      def sweep_job_task_yaml
+        <<~YAML
+          sweep_abandoned_wizards:
+            class: Plutonium::Wizard::SweepJob
+            schedule: "#{options[:schedule]}"
+        YAML
+      end
+
+      # Not run for you: the migration path is registered from the initializer at
+      # BOOT, and this process booted before the flag was written.
+      def migration_reminder
+        log :info, "wizards enabled — run `rails db:migrate` to create plutonium_wizard_sessions"
+      end
+    end
+  end
+end

data/lib/plutonium/action/base.rb

@@ -6,7 +6,7 @@ module Plutonium
   module Action
     # Base class for all actions in the Plutonium framework.
     class Base
-      attr_reader :name, :label, :description, :icon, :route_options, :confirmation, :turbo, :color, :category, :position, :return_to, :condition
+      attr_reader :name, :label, :description, :icon, :route_options, :confirmation, :turbo, :color, :category, :position, :return_to, :condition, :link, :button
 
       def initialize(name, **options)
         @name = name.to_sym
@@ -23,12 +23,20 @@ module Plutonium
         @collection_record_action = options[:collection_record_action] || false
         @record_action = options[:record_action] || false
         @resource_action = options[:resource_action] || false
-        @kanban_drop = options[:kanban_drop] || false
+        @hidden = options[:hidden] || false
         @category = ActiveSupport::StringInquirer.new((options[:category] || :secondary).to_s)
         @position = options[:position] || 50
         @modal_mode = options[:modal]
         @modal_size = options[:size]
         @condition = options[:condition]
+        # Author-supplied HTML attributes, keyed by the element they target:
+        # `link:` merges onto every anchor rendering (the GET link and dropdown
+        # items — which are anchors even for non-GET actions), `button:` onto
+        # the button_to <form> (the non-GET toolbar rendering). Both deep-merge
+        # over the framework's attributes at render time, with the author
+        # winning.
+        @link = normalize_html_attribute_bag(options[:link], :link)
+        @button = normalize_html_attribute_bag(options[:button], :button)
         validate_modal_mode!
         validate_modal_size!
 
@@ -69,11 +77,14 @@ module Plutonium
       def record_action? = @record_action
       def resource_action? = @resource_action
 
-      # True when this action was auto-registered for a kanban column's
-      # `enter_interaction`. Such actions exist only so their policy method,
-      # form, and params machinery are wired up — they are reachable by
-      # dropping a card, never rendered as a normal toolbar/row button.
-      def kanban_drop? = @kanban_drop
+      # True when this action must never render. It still has a live route,
+      # policy predicate, and (if interactive) form + params machinery — it is
+      # simply reachable only by something other than a button: a kanban drop,
+      # a drag-reorder, a custom Stimulus controller.
+      #
+      # Display-only, like #condition_met? — NOT an authorization boundary.
+      # Keep authorization in the policy.
+      def hidden? = @hidden
 
       def permitted_by?(policy)
         policy.allowed_to?(:"#{name}?")
@@ -94,6 +105,21 @@ module Plutonium
         ConditionContext.new(view_context, record).instance_exec(&@condition)
       end
 
+      # Merge points for rendering surfaces: deep-merge the author's bag over
+      # the framework-built attributes for the element being rendered, with
+      # the author winning on every key. `link_attributes` is for anchors
+      # (the GET toolbar link, dropdown items — anchors even for non-GET
+      # actions — bulk-action links, kanban column actions, card show links);
+      # `button_attributes` is for the button_to <form> wrapper. Surfaces
+      # call these instead of merging #link/#button themselves.
+      def link_attributes(attributes)
+        merge_author_bag(@link, attributes)
+      end
+
+      def button_attributes(attributes)
+        merge_author_bag(@button, attributes)
+      end
+
       # Returns a new Action with the given options merged over this one.
       def with(**overrides)
         self.class.new(name, **to_options.merge(overrides))
@@ -119,21 +145,57 @@ module Plutonium
           collection_record_action: @collection_record_action,
           record_action: @record_action,
           resource_action: @resource_action,
-          kanban_drop: @kanban_drop,
+          hidden: @hidden,
           category: @category.to_sym,
           position: @position,
           modal: @modal_mode,
           size: @modal_size,
-          condition: @condition
+          condition: @condition,
+          link: @link,
+          button: @button
         }
       end
 
       private
 
+      def merge_author_bag(bag, attributes)
+        bag.empty? ? attributes : attributes.deep_merge(bag)
+      end
+
       def targets_remote_modal?
         @turbo_frame == Plutonium::REMOTE_MODAL_FRAME
       end
 
+      # Stores the action's own symbol-keyed copy of an author attribute bag.
+      # Symbolizing is load-bearing, not cosmetic: the render-time deep_merge
+      # matches keys exactly, so a string-keyed bag would sit alongside the
+      # framework's symbol keys and emit duplicate attributes instead of
+      # overriding them. Copying keeps the caller's hash untouched (no
+      # freezing objects we don't own), and the deep structural freeze makes
+      # the bag as immutable as the action itself.
+      def normalize_html_attribute_bag(bag, name)
+        return {}.freeze if bag.nil?
+        unless bag.is_a?(Hash)
+          raise ArgumentError, "#{name} must be a Hash of HTML attributes, got #{bag.inspect}"
+        end
+        deep_freeze_structure(bag.deep_symbolize_keys)
+      end
+
+      # Freezes nested hashes/arrays (fresh copies from deep_symbolize_keys)
+      # but not leaf values, which are still shared with the caller.
+      def deep_freeze_structure(value)
+        case value
+        when Hash
+          value.each_value { |v| deep_freeze_structure(v) }
+          value.freeze
+        when Array
+          value.each { |v| deep_freeze_structure(v) }
+          value.freeze
+        else
+          value
+        end
+      end
+
       def validate_modal_mode!
         return if @modal_mode.nil?
         return if [:centered, :slideover].include?(@modal_mode)

data/lib/plutonium/action/interactive.rb

@@ -35,6 +35,15 @@ module Plutonium
         @immediate ? "#{label}?" : nil
       end
 
+      protected
+
+      # Extends Base's round-trip contract with the keywords this class's
+      # initialize requires — without them, #with would raise missing
+      # keywords when reconstructing the action.
+      def to_options
+        super.merge(interaction: @interaction, immediate: @immediate)
+      end
+
       # Factory for creating Interactive actions
       class Factory
         # TODO: move these into Plutonium::Action::Interactive