plutonium 0.24.5 → 0.24.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f9e098d47ef383cae732c39bef92132a9084e0dcda2119bcbb33c9726ae5d6b
-  data.tar.gz: f43fe2a2794feb1bc1ee698587b9c6169459b08859a862a7e615f7364f174ec3
+  metadata.gz: cc9806660f2996abd33f6a5bfd149c489f6baa696500c1ff15d4a052d567c956
+  data.tar.gz: 5c5ce03afc23a152e9c1ff395bffff240a6ce5eb7b7be3e2b2ee49f080c20a68
 SHA512:
-  metadata.gz: d6c70ccd4aca7091971465a5c55b465bf8b380d699b7ce0df4d265ee854efef660b3e85202593532f88d192f8487d8af8a241e30edbed9fb2b35e1c674bdd352
-  data.tar.gz: 78a8129530a6d1d036b507cb71b66b152cc7bfe463a849cf2ab5fe2b0378a1893ec3570da1fbd45e9b81aadbd02561adb2b7d4fe697de413d1f5f361ac1262cf
+  metadata.gz: 2fcb9db510846fcb3208dc9c12c3672fa6cb32dd8df9a8db3a828eb4c733eb93bea5c2807bd798791b8abc7e8aad5fb79011dfd5ff86e39294482fccfa59a3ab
+  data.tar.gz: 68d70cc364a4963f8a1409bc642562dccac57393161ee28d3eb6b54c5e2c7c2487c6d19ab4f2b626e5be5defa33a083c440fcb261b982b0f448bd80b4b30810b

data/config/initializers/{sqlite_json_alias.rb → sqlite_alias.rb}

@@ -4,5 +4,9 @@ ActiveSupport.on_load(:active_record) do
     def jsonb(*args, **options)
       json(*args, **options)
     end
+
+    def uuid(*args, **options)
+      string(*args, **options)
+    end
   end
 end

data/docs/modules/action.md

@@ -113,6 +113,53 @@ action :documentation,
 ```
 :::
 
+### Dynamic Route Options
+
+For actions that need dynamic URL generation based on the current record or context, use the `RouteOptions` class with a custom `url_resolver`:
+
+::: code-group
+```ruby [Dynamic Parent-Child Navigation]
+# Navigate to create a child resource with the current record as parent
+action :create_deployment,
+       label: "Create Deployment",
+       icon: Phlex::TablerIcons::Rocket,
+       record_action: true,
+       route_options: Plutonium::Action::RouteOptions.new(
+         url_resolver: ->(subject) {
+           resource_url_for(UniversalFlow::Deployment, action: :new, parent: subject)
+         }
+       )
+```
+```ruby [Conditional Routing]
+# Different routes based on user permissions or record state
+action :manage_settings,
+       label: "Manage Settings",
+       resource_action: true,
+       route_options: Plutonium::Action::RouteOptions.new(
+         url_resolver: ->(subject) {
+           if current_user.admin?
+             admin_settings_path(subject)
+           else
+             basic_settings_path(subject)
+           end
+         }
+       )
+```
+```ruby [External Integration]
+# Dynamic external URLs based on record attributes
+action :view_external,
+       label: "View in External System",
+       record_action: true,
+       route_options: Plutonium::Action::RouteOptions.new(
+         url_resolver: ->(subject) {
+           "https://external-system.com/items/#{subject.external_id}"
+         }
+       )
+```
+:::
+
+The `url_resolver` lambda receives the current record (for record actions) or resource class (for resource actions) as the `subject` parameter, allowing you to generate URLs dynamically based on the context.
+
 ### Interactive Actions
 
 Interactive actions are powered by an `Interaction` class and handle business logic. The action's properties (label, description, etc.) are often inferred from the interaction itself.
@@ -173,6 +220,13 @@ end
 4. **Meaningful Confirmations**: Use confirmation messages for destructive actions
 5. **Logical Positioning**: Order actions by importance and frequency of use
 
+### Dynamic Route Actions
+
+1. **Context Awareness**: Use the subject parameter to make routing decisions based on the current record or resource
+2. **Error Handling**: Handle cases where dynamic URLs might fail (e.g., missing external IDs)
+3. **Performance**: Keep url_resolver lambdas simple to avoid performance issues
+4. **Security**: Validate permissions within the lambda when generating sensitive URLs
+
 ### Interactive Actions
 
 1. **Single Purpose**: Each action should have a single, well-defined purpose

data/docs/modules/interaction.md

@@ -314,6 +314,178 @@ class PostDefinition < Plutonium::Resource::Definition
 end
 ```
 
+### Dynamic Route Actions
+
+For actions that need dynamic URL generation, combine interactions with custom route options:
+
+```ruby
+class PostDefinition < Plutonium::Resource::Definition
+  # Simple interaction with static route
+  action :publish, interaction: PublishPostInteraction
+
+  # Complex action with dynamic route generation using RouteOptions
+  action :create_deployment,
+    label: "Create Deployment",
+    icon: Phlex::TablerIcons::Rocket,
+    record_action: true,
+    interaction: CreateDeploymentInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        resource_url_for(Deployment, action: :new, parent: subject)
+      }
+    )
+
+  # Conditional routing based on user permissions
+  action :manage_advanced_settings,
+    label: "Advanced Settings",
+    resource_action: true,
+    interaction: ManageAdvancedSettingsInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        if current_user.admin?
+          admin_settings_path(subject)
+        else
+          basic_settings_path(subject)
+        end
+      }
+    )
+
+  # External system integration with dynamic URLs
+  action :sync_with_external,
+    label: "Sync External",
+    record_action: true,
+    interaction: SyncExternalInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        "https://api.external-system.com/sync/#{subject.external_id}"
+      }
+    )
+end
+```
+
+The `url_resolver` lambda provides powerful flexibility:
+- **Record Actions**: Receive the current record as `subject`
+- **Resource Actions**: Receive the resource class as `subject`
+- **Bulk Actions**: Receive the resource class with selected records available in params
+- **Context Access**: Full access to controller context including `current_user`, helper methods, etc.
+
+### Advanced Dynamic Routing Examples
+
+```ruby
+class ProjectDefinition < Plutonium::Resource::Definition
+  # Multi-step workflow routing
+  action :start_workflow,
+    label: "Start Workflow",
+    record_action: true,
+    interaction: StartWorkflowInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        case subject.status
+        when 'draft'
+          new_project_review_path(subject)
+        when 'review'
+          project_approval_path(subject)
+        else
+          project_path(subject)
+        end
+      }
+    )
+
+  # Dynamic nested resource creation
+  action :add_team_member,
+    label: "Add Team Member",
+    record_action: true,
+    interaction: AddTeamMemberInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        if subject.team.full?
+          project_team_waitlist_path(subject)
+        else
+          new_project_team_member_path(subject)
+        end
+      }
+    )
+
+  # Conditional external redirects
+  action :open_in_ide,
+    label: "Open in IDE",
+    record_action: true,
+    interaction: OpenInIDEInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        if subject.repository_url.present?
+          "vscode://vscode.git/clone?url=#{subject.repository_url}"
+        else
+          project_repository_setup_path(subject)
+        end
+      }
+    )
+end
+```
+
+### Custom Interaction with Dynamic Routing
+
+```ruby
+class CreateChildResourceInteraction < Plutonium::Interaction::Base
+  attribute :parent_id, :integer
+  attribute :resource_type, :string
+  attribute :attributes, :hash
+
+  validates :parent_id, :resource_type, presence: true
+
+  private
+
+  def execute
+    parent = find_parent_resource
+    child_class = resource_type.constantize
+    child = child_class.new(attributes.merge(parent_key => parent))
+
+    if child.save
+      succeed(child)
+        .with_message("#{resource_type} created successfully")
+        .with_redirect_response(resource_url_for(child, parent: parent))
+    else
+      failed(child.errors)
+    end
+  end
+
+  def find_parent_resource
+    # Dynamic parent resolution based on context
+    case resource_type
+    when 'Deployment'
+      Project.find(parent_id)
+    when 'Task'
+      Project.find(parent_id)
+    else
+      raise ArgumentError, "Unknown resource type: #{resource_type}"
+    end
+  end
+
+  def parent_key
+    case resource_type
+    when 'Deployment', 'Task'
+      :project_id
+    else
+      raise ArgumentError, "Unknown parent key for: #{resource_type}"
+    end
+  end
+end
+
+# Usage in resource definition
+class ProjectDefinition < Plutonium::Resource::Definition
+  action :create_deployment,
+    label: "Create Deployment",
+    record_action: true,
+    interaction: CreateChildResourceInteraction,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        # The subject here will be the Project record
+        new_deployment_path(project_id: subject.id)
+      }
+    )
+end
+```
+
 ### Controller Integration
 
 Controllers can call interactions directly, but this requires manual setup:

data/docs/modules/routing.md

@@ -373,6 +373,55 @@ bulk_action_url(Post, :archive, ids: [1, 2, 3])
 # => "/posts/bulk_actions/archive?ids[]=1&ids[]=2&ids[]=3"
 ```
 
+### Dynamic URL Generation for Actions
+
+For actions that need context-aware URL generation, use `RouteOptions` with custom `url_resolver`:
+
+```ruby
+# In a resource definition
+class ProjectDefinition < Plutonium::Resource::Definition
+  # Dynamic parent-child navigation
+  action :create_deployment,
+    label: "Create Deployment",
+    icon: Phlex::TablerIcons::Rocket,
+    record_action: true,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        resource_url_for(UniversalFlow::Deployment, action: :new, parent: subject)
+      }
+    )
+
+  # Conditional routing based on permissions
+  action :manage_settings,
+    label: "Settings",
+    resource_action: true,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        if current_user.admin?
+          admin_project_settings_path(subject)
+        else
+          project_settings_path(subject)
+        end
+      }
+    )
+
+  # External system integration
+  action :view_in_external_system,
+    label: "View Externally",
+    record_action: true,
+    route_options: Plutonium::Action::RouteOptions.new(
+      url_resolver: ->(subject) {
+        "https://external-system.com/projects/#{subject.external_id}"
+      }
+    )
+end
+```
+
+The `url_resolver` lambda receives:
+- **For record actions**: The current record instance
+- **For resource actions**: The resource class
+- **For bulk actions**: The resource class (with selected IDs available in params)
+
 ### Context-Aware URL Generation
 
 In nested controller contexts, URLs automatically include proper context:

data/lib/plutonium/definition/actions.rb

@@ -48,6 +48,18 @@ module Plutonium
           record_action: true, collection_record_action: true, category: :danger,
           icon: Phlex::TablerIcons::Trash, position: 100,
           confirmation: "Are you sure?", turbo_frame: "_top")
+
+        # Example of dynamic route options using custom url_resolver:
+        #
+        # action(:create_deployment,
+        #   label: "Create Deployment",
+        #   icon: Phlex::TablerIcons::Rocket,
+        #   record_action: true,
+        #   route_options: Plutonium::Action::RouteOptions.new(
+        #     url_resolver: ->(subject) {
+        #       resource_url_for(UniversalFlow::Deployment, action: :new, parent: subject)
+        #     }
+        #   ))
       end
     end
   end

data/lib/plutonium/resource/controllers/interactive_actions.rb

@@ -52,7 +52,7 @@ module Plutonium
           outcome.to_response.process(self) do |value|
             respond_to do |format|
               if outcome.success?
-                return_url = redirect_url_after_action_on(resource_class)
+                return_url = redirect_url_after_action_on(resource_record!)
 
                 format.any { redirect_to return_url, status: :see_other }
 

data/lib/plutonium/ui/action_button.rb

@@ -23,8 +23,14 @@ module Plutonium
       private
 
       def render_link
+        uri = URI.parse(@url)
+        params = Rack::Utils.parse_nested_query(uri.query)
+        params["return_to"] = request.original_url
+        uri.query = params.to_query
+        uri.to_s
+
         link_to(
-          @url,
+          uri.to_s,
           class: button_classes,
           data: {turbo_frame: @action.turbo_frame}
         ) do

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

@@ -23,6 +23,7 @@ module Plutonium
         end
 
         delegate \
+          :main_app,
           :resource_class,
           :resource_record!,
           :resource_record?,

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

@@ -61,7 +61,7 @@ module Plutonium
         private
 
         def render_actions
-          input name: :return_to, value: request.params[:return_to], type: :hidden, hidden: true
+          input name: "return_to", value: request.params[:return_to], type: :hidden, hidden: true
 
           actions_wrapper {
             render submit_button

data/lib/plutonium/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plutonium
 version: !ruby/object:Gem::Version
-  version: 0.24.5
+  version: 0.24.7
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-27 00:00:00.000000000 Z
+date: 2025-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -488,7 +488,7 @@ files:
 - config/initializers/hotwire_turbo_monkey_patches.rb
 - config/initializers/pagy.rb
 - config/initializers/rabl.rb
-- config/initializers/sqlite_json_alias.rb
+- config/initializers/sqlite_alias.rb
 - docs/.vitepress/config.ts
 - docs/.vitepress/theme/custom.css
 - docs/.vitepress/theme/index.ts