plutonium 0.25.1 → 0.26.0

data/app/javascript/controllers/key_value_store_controller.js

@@ -0,0 +1,119 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Connects to data-controller="key-value-store"
+export default class extends Controller {
+  static targets = ["container", "pair", "template", "addButton", "keyInput", "valueInput"]
+  static values = { limit: Number }
+
+  connect() {
+    this.updateIndices()
+    this.updateAddButtonState()
+  }
+
+  addPair(event) {
+    event.preventDefault()
+
+    if (this.pairTargets.length >= this.limitValue) {
+      return
+    }
+
+    const template = this.templateTarget
+    const newPair = template.content.cloneNode(true)
+    const index = this.pairTargets.length
+
+    // Update the template placeholders with actual indices
+    this.updatePairIndices(newPair, index)
+
+    this.containerTarget.appendChild(newPair)
+    this.updateIndices()
+    this.updateAddButtonState()
+
+    // Focus on the key input of the new pair
+    const newKeyInput = this.containerTarget.lastElementChild.querySelector('[data-key-value-store-target="keyInput"]')
+    if (newKeyInput) {
+      newKeyInput.focus()
+    }
+  }
+
+  removePair(event) {
+    event.preventDefault()
+
+    const pair = event.target.closest('[data-key-value-store-target="pair"]')
+    if (pair) {
+      pair.remove()
+      this.updateIndices()
+      this.updateAddButtonState()
+    }
+  }
+
+  updateIndices() {
+    this.pairTargets.forEach((pair, index) => {
+      const keyInput = pair.querySelector('[data-key-value-store-target="keyInput"]')
+      const valueInput = pair.querySelector('[data-key-value-store-target="valueInput"]')
+
+      if (keyInput) {
+        // Update name attribute
+        keyInput.name = keyInput.name.replace(/\[\d+\]/, `[${index}]`)
+        // Update id attribute for Turbo compatibility
+        keyInput.id = keyInput.id.replace(/_\d+_/, `_${index}_`)
+      }
+      if (valueInput) {
+        // Update name attribute
+        valueInput.name = valueInput.name.replace(/\[\d+\]/, `[${index}]`)
+        // Update id attribute for Turbo compatibility
+        valueInput.id = valueInput.id.replace(/_\d+_/, `_${index}_`)
+      }
+    })
+  }
+
+  updatePairIndices(element, index) {
+    const inputs = element.querySelectorAll('input')
+    inputs.forEach(input => {
+      if (input.name) {
+        input.name = input.name.replace('__INDEX__', index)
+      }
+      if (input.id) {
+        input.id = input.id.replace('___INDEX___', `_${index}_`)
+      }
+    })
+  }
+
+  updateAddButtonState() {
+    const addButton = this.addButtonTarget
+    if (this.pairTargets.length >= this.limitValue) {
+      addButton.disabled = true
+      addButton.classList.add('opacity-50', 'cursor-not-allowed')
+    } else {
+      addButton.disabled = false
+      addButton.classList.remove('opacity-50', 'cursor-not-allowed')
+    }
+  }
+
+  // Serialize the current key-value pairs to JSON
+  toJSON() {
+    const pairs = {}
+    this.pairTargets.forEach(pair => {
+      const keyInput = pair.querySelector('[data-key-value-store-target="keyInput"]')
+      const valueInput = pair.querySelector('[data-key-value-store-target="valueInput"]')
+
+      if (keyInput && valueInput && keyInput.value.trim()) {
+        pairs[keyInput.value.trim()] = valueInput.value
+      }
+    })
+    return JSON.stringify(pairs)
+  }
+
+  // Get the current key-value pairs as an object
+  toObject() {
+    const pairs = {}
+    this.pairTargets.forEach(pair => {
+      const keyInput = pair.querySelector('[data-key-value-store-target="keyInput"]')
+      const valueInput = pair.querySelector('[data-key-value-store-target="valueInput"]')
+
+      if (keyInput && valueInput && keyInput.value.trim()) {
+        pairs[keyInput.value.trim()] = valueInput.value
+      }
+    })
+    return pairs
+  }
+}

data/docs/guide/deep-dive/resources.md

@@ -371,7 +371,7 @@ class PostDefinition < Plutonium::Resource::Definition
 
   # Add filters to the sidebar
   filter :published, with: ->(scope, value) { value ? scope.where.not(published_at: nil) : scope.where(published_at: nil) }, as: :boolean
-  filter :user, as: :select, collection: -> { User.pluck(:name, :id) }
+  filter :user, as: :select, choices: User.pluck(:name, :id)
 
   # Define named scopes that appear as buttons
   scope :all

data/docs/modules/definition.md

@@ -71,7 +71,7 @@ class PostDefinition < Plutonium::Resource::Definition
   # Only override when you need custom input behavior:
   input :content, as: :rich_text               # Override text -> rich_text
   input :title, placeholder: "Enter title"    # Add placeholder
-  input :category, as: :select, collection: %w[Tech Business]  # Add options
+  input :category, as: :select, choices: %w[Tech Business]  # Add options
   input :published_at, as: :date               # Override datetime -> date only
 end
 ```
@@ -158,8 +158,8 @@ end
 ```ruby
 class PostDefinition < Plutonium::Resource::Definition
   # Provide options for select inputs
-  input :category, as: :select, collection: %w[Tech Business Lifestyle]
-  input :author, as: :select, collection: -> { User.active.pluck(:name, :id) }
+  input :category, as: :select, choices: %w[Tech Business Lifestyle]
+  input :author, as: :select, choices: -> { User.active.pluck(:name, :id) }
 end
 ```
 
@@ -177,7 +177,7 @@ class PostDefinition < Plutonium::Resource::Definition
 
   # Use `pre_submit` to create dynamic forms where inputs appear based on other inputs.
   input :send_notifications, as: :boolean, pre_submit: true
-  input :notification_channel, as: :select, collection: %w[Email SMS],
+  input :notification_channel, as: :select, choices: %w[Email SMS],
         condition: -> { object.send_notifications? }
 
   # Show debug fields only in development
@@ -280,6 +280,7 @@ The block syntax offers more control over rendering, allowing for custom compone
 - Building complex layouts with multiple components or custom HTML (for `display` only).
 - You need conditional logic to determine which component to render.
 - You need to call specific form builder methods with custom logic (for `input`).
+- **You need dynamic choices for select inputs** (since `choices:` option only accepts static arrays).
 
 ::: code-group
 ```ruby [Custom Display Components]
@@ -302,6 +303,29 @@ input :birth_date do |f|
   end
 end
 ```
+```ruby [Dynamic Choices for Select Inputs]
+# Dynamic choices based on object state
+input :widget_type do |f|
+  choices = case object.question_type
+  when nil, ""
+    []
+  when "text"
+    ["input", "textarea"]
+  when "choice"
+    ["radio", "select", "checkbox"]
+  when "scale"
+    ["slider", "radio_scale", "select_scale"]
+  when "date"
+    ["date_picker", "datetime_picker"]
+  when "boolean"
+    ["checkbox", "toggle", "yes_no"]
+  else
+    Question::WIDGET_TYPES
+  end
+
+  f.select_tag choices: choices
+end
+```
 ```ruby [Conditional Rendering]
 # Conditional display based on value
 display :metrics do |field|
@@ -829,32 +853,43 @@ display :content,
   condition: -> { current_user.can_see_content? }
 ```
 
-### Collection Options (for selects)
+### Choices Options (for selects)
 ```ruby
-input :category, as: :select, collection: %w[Tech Business Lifestyle]
-input :author, as: :select, collection: -> { User.active.pluck(:name, :id) }
+# Static choices
+input :category, as: :select, choices: %w[Tech Business Lifestyle]
 
-# Collection procs are executed in the form rendering context
-# and have access to current_user and other helpers:
-input :team_members, as: :select, collection: -> {
-  current_user.organization.users.active.pluck(:name, :id)
-}
+# Dynamic choices require block form
+input :author do |f|
+  choices = User.active.pluck(:name, :id)
+  f.select_tag choices: choices
+end
 
-# You can also access the form object being edited:
-input :related_posts, as: :select, collection: -> {
-  Post.where.not(id: object.id).published.pluck(:title, :id) if object.persisted?
-}
+# Dynamic choices with access to context
+input :team_members do |f|
+  choices = current_user.organization.users.active.pluck(:name, :id)
+  f.select_tag choices: choices
+end
+
+# Dynamic choices based on object state
+input :related_posts do |f|
+  choices = if object.persisted?
+    Post.where.not(id: object.id).published.pluck(:title, :id)
+  else
+    []
+  end
+  f.select_tag choices: choices
+end
 ```
 
-::: tip Collection Context
-Collection procs are evaluated in the form rendering context, which means they have access to:
+::: tip Dynamic Choices Context
+When using block forms for dynamic choices, you have access to:
 - `current_user` - The authenticated user
 - `current_parent` - Parent record for nested resources
 - `object` - The record being edited (in edit forms)
 - `request` and `params` - Request information
 - All helper methods available in the form context
 
-This is the same context as `condition` procs, allowing for dynamic, user-specific collections.
+Block forms are required for dynamic choices since the `choices:` option only accepts static arrays.
 :::
 
 ### File Upload Options
@@ -868,7 +903,7 @@ input :documents, as: :file, multiple: true,
 ## Dynamic Configuration & Policies
 
 ::: danger IMPORTANT
-Definitions are instantiated outside the controller context, which means **`current_user` and other controller methods are NOT available** within the definition file itself. However, `condition` and `collection` procs ARE evaluated in the rendering context where `current_user` and the record (`object`) are available.
+Definitions are instantiated outside the controller context, which means **`current_user` and other controller methods are NOT available** within the definition file itself. However, `condition` procs and input blocks ARE evaluated in the rendering context where `current_user` and the record (`object`) are available.
 :::
 
 The `condition` option configures **if an input is rendered**. It does not control if a field's *value* is accessible. For that, you must use policies.

data/docs/modules/table.md

@@ -65,7 +65,7 @@ column :published_at, as: :datetime
 column :is_active, as: :boolean
 column :priority, as: :badge
 column :profile_picture, as: :attachment
-column :metadata, as: :json
+column :metadata, as: :key_value_store
 ```
 
 ### Alignment

data/docs/public/plutonium.mdc

@@ -90,7 +90,7 @@ class PostDefinition < Plutonium::Resource::Definition
 
   # Only declare fields when you want to override defaults:
   field :content, as: :rich_text  # Override text → rich_text
-  field :status, as: :select, collection: %w[draft published archived]
+  field :status, as: :select, choices: %w[draft published archived]
 
   # Display customization (show/index pages)
   display :title, as: :string
@@ -119,7 +119,7 @@ class PostDefinition < Plutonium::Resource::Definition
   # Input configuration (new/edit forms)
   input :title, placeholder: "Enter post title"  # No need for as: :string (auto-detected)
   input :content, as: :rich_text
-  input :category, as: :select, collection: %w[Tech Business Lifestyle]
+  input :category, as: :select, choices: %w[Tech Business Lifestyle]
 
   # New: Custom component classes
   input :color_picker, as: ColorPickerComponent
@@ -239,19 +239,32 @@ display :content,
   condition: -> { Rails.env.development? }  # Cosmetic condition only
 ```
 
-#### Collection Options (for selects)
+#### Choices Options (for selects)
 ```ruby
-input :category, as: :select, collection: %w[Tech Business Lifestyle]
-input :author, as: :select, collection: -> { User.active.pluck(:name, :id) }
-
-# Collection procs are executed in form rendering context with access to:
-# current_user, current_parent, object, request, params, and helpers
-input :team_members, as: :select, collection: -> {
-  current_user.organization.users.active.pluck(:name, :id)
-}
-input :related_posts, as: :select, collection: -> {
-  Post.where.not(id: object.id).published.pluck(:title, :id) if object.persisted?
-}
+# Static choices
+input :category, as: :select, choices: %w[Tech Business Lifestyle]
+
+# Dynamic choices require block form
+input :author do |f|
+  choices = User.active.pluck(:name, :id)
+  f.select_tag choices: choices
+end
+
+# Dynamic choices with access to context
+input :team_members do |f|
+  choices = current_user.organization.users.active.pluck(:name, :id)
+  f.select_tag choices: choices
+end
+
+# Dynamic choices based on object state  
+input :related_posts do |f|
+  choices = if object.persisted?
+    Post.where.not(id: object.id).published.pluck(:title, :id)
+  else
+    []
+  end
+  f.select_tag choices: choices
+end
 ```
 
 #### File Upload Options

data/lib/plutonium/core/controller.rb

@@ -79,13 +79,13 @@ module Plutonium
               url_args[:id] = element.to_param unless resource_route_config[:route_type] == :resource
               url_args[:action] ||= :show
             else
-              url_args[element.model_name.singular_route_key.to_sym] = element.to_param
+              url_args[element.model_name.singular.to_sym] = element.to_param
             end
           end
         end
         url_args[:controller] = "/#{controller_chain.join("::").underscore}"
 
-        url_args[:"#{parent.model_name.singular_route_key}_id"] = parent.to_param if parent.present?
+        url_args[:"#{parent.model_name.singular}_id"] = parent.to_param if parent.present?
         if scoped_to_entity? && scoped_entity_strategy == :path
           url_args[scoped_entity_param_key] = current_scoped_entity
         end

data/lib/plutonium/core/controllers/entity_scoping.rb

@@ -43,6 +43,11 @@ module Plutonium
           current_engine.scoped_entity_param_key
         end
 
+        def scoped_entity_route_key
+          ensure_legal_entity_scoping_method_access!(__method__)
+          current_engine.scoped_entity_route_key
+        end
+
         # Returns the class of the scoped entity.
         #
         # @return [Class] the scoped entity class

data/lib/plutonium/engine.rb

@@ -5,12 +5,13 @@ module Plutonium
     extend ActiveSupport::Concern
 
     class_methods do
-      attr_reader :scoped_entity_class, :scoped_entity_strategy, :scoped_entity_param_key
+      attr_reader :scoped_entity_class, :scoped_entity_strategy, :scoped_entity_param_key, :scoped_entity_route_key
 
-      def scope_to_entity(entity_class, strategy: :path, param_key: nil)
+      def scope_to_entity(entity_class, strategy: :path, param_key: nil, route_key: nil)
         @scoped_entity_class = entity_class
         @scoped_entity_strategy = strategy
         @scoped_entity_param_key = param_key || entity_class.model_name.singular_route_key.to_sym
+        @scoped_entity_route_key = route_key || entity_class.model_name.singular.to_sym
       end
 
       def scoped_to_entity?

data/lib/plutonium/interaction/response/redirect.rb

@@ -12,7 +12,18 @@ module Plutonium
         # @param controller [ActionController::Base] The controller instance.
         # @return [void]
         def execute(controller)
-          controller.redirect_to(*@args, **@options)
+          controller.instance_eval do
+            url = url_for(*@args)
+
+            format.any { redirect_to(url, **@options) }
+            if helpers.current_turbo_frame == "remote_modal"
+              format.turbo_stream do
+                render turbo_stream: [
+                  helpers.turbo_stream_redirect(url)
+                ]
+              end
+            end
+          end
         end
       end
     end

data/lib/plutonium/resource/register.rb

@@ -44,7 +44,7 @@ module Plutonium
       def route_key_lookup
         freeze
         resources.to_h do |resource|
-          [resource.model_name.singular_route_key.to_sym, resource]
+          [resource.model_name.singular.to_sym, resource]
         end
       end
       # memoize_unless_reloading :route_key_lookup

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

@@ -35,6 +35,10 @@ module Plutonium
           alias_method :file_tag, :uppy_tag
           alias_method :attachment_tag, :uppy_tag
 
+          def key_value_store_tag(**, &)
+            create_component(Components::KeyValueStore, :key_value_store, **, &)
+          end
+
           def secure_association_tag(**attributes, &)
             attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
             create_component(Components::SecureAssociation, :association, **attributes, &)

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        class KeyValueStore < Phlexi::Form::Components::Base
+          include Phlexi::Form::Components::Concerns::HandlesInput
+
+          DEFAULT_LIMIT = 10
+
+          def view_template
+            div(**container_attributes) do
+              render_key_value_pairs
+              render_add_button
+              render_template
+            end
+          end
+
+          protected
+
+          def build_attributes
+            super
+            attributes[:class] = [attributes[:class], "key-value-store"].compact.join(" ")
+            set_data_attributes
+          end
+
+          private
+
+          def container_attributes
+            {
+              id: attributes[:id],
+              class: attributes[:class],
+              data: {
+                controller: "key-value-store",
+                key_value_store_limit_value: limit
+              }
+            }
+          end
+
+          def set_data_attributes
+            attributes[:data] ||= {}
+            attributes[:data][:controller] = "key-value-store"
+            attributes[:data][:key_value_store_limit_value] = limit
+          end
+
+          def render_header
+            div(class: "key-value-store-header") do
+              if attributes[:label]
+                h3(class: "text-lg font-semibold text-gray-900 dark:text-white") do
+                  plain attributes[:label]
+                end
+              end
+              if attributes[:description]
+                p(class: "text-sm text-gray-500 dark:text-gray-400") do
+                  plain attributes[:description]
+                end
+              end
+            end
+          end
+
+          def render_key_value_pairs
+            div(class: "key-value-pairs space-y-2", data_key_value_store_target: "container") do
+              pairs.each_with_index do |(key, value), index|
+                render_key_value_pair(key, value, index)
+              end
+            end
+          end
+
+          def render_key_value_pair(key, value, index)
+            div(
+              class: "key-value-pair flex items-center gap-2 p-2 border border-gray-200 dark:border-gray-700 rounded",
+              data_key_value_store_target: "pair"
+            ) do
+              # Key input
+              input(
+                type: :text,
+                placeholder: "Key",
+                value: key,
+                name: "#{field_name}[#{index}][key]",
+                id: "#{field.dom.id}_#{index}_key",
+                class: "flex-1 px-3 py-1 text-sm border border-gray-300 rounded focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:text-white",
+                data_key_value_store_target: "keyInput"
+              )
+
+              # Value input
+              input(
+                type: :text,
+                placeholder: "Value",
+                value: value,
+                name: "#{field_name}[#{index}][value]",
+                id: "#{field.dom.id}_#{index}_value",
+                class: "flex-1 px-3 py-1 text-sm border border-gray-300 rounded focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:text-white",
+                data_key_value_store_target: "valueInput"
+              )
+
+              # Remove button
+              button(
+                type: :button,
+                class: "px-2 py-1 text-red-600 hover:text-red-800 focus:outline-none",
+                data_action: "key-value-store#removePair"
+              ) do
+                plain "×"
+              end
+            end
+          end
+
+          def render_add_button
+            div(class: "key-value-store-actions mt-2") do
+              button(
+                type: :button,
+                id: "#{field.dom.id}_add_button",
+                class: "inline-flex items-center px-3 py-1 text-sm font-medium text-blue-600 bg-blue-50 border border-blue-200 rounded hover:bg-blue-100 focus:outline-none focus:ring-2 focus:ring-blue-500 dark:bg-blue-900 dark:text-blue-300 dark:border-blue-700 dark:hover:bg-blue-800",
+                data: {
+                  action: "key-value-store#addPair",
+                  key_value_store_target: "addButton"
+                }
+              ) do
+                plain "+ Add Pair"
+              end
+            end
+          end
+
+          def render_template
+            template(data_key_value_store_target: "template") do
+              div(
+                class: "key-value-pair flex items-center gap-2 p-2 border border-gray-200 dark:border-gray-700 rounded",
+                data_key_value_store_target: "pair"
+              ) do
+                input(
+                  type: :text,
+                  placeholder: "Key",
+                  name: "#{field_name}[__INDEX__][key]",
+                  id: "#{field.dom.id}___INDEX___key",
+                  class: "flex-1 px-3 py-1 text-sm border border-gray-300 rounded focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:text-white",
+                  data_key_value_store_target: "keyInput"
+                )
+
+                input(
+                  type: :text,
+                  placeholder: "Value",
+                  name: "#{field_name}[__INDEX__][value]",
+                  id: "#{field.dom.id}___INDEX___value",
+                  class: "flex-1 px-3 py-1 text-sm border border-gray-300 rounded focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:text-white",
+                  data_key_value_store_target: "valueInput"
+                )
+
+                button(
+                  type: :button,
+                  class: "px-2 py-1 text-red-600 hover:text-red-800 focus:outline-none",
+                  data_action: "key-value-store#removePair"
+                ) do
+                  plain "×"
+                end
+              end
+            end
+          end
+
+          def pairs
+            @pairs ||= normalize_value_to_pairs(field.value)
+          end
+
+          def normalize_value_to_pairs(value)
+            case value
+            when Hash
+              # Convert hash to array of [key, value] pairs
+              value.to_a
+            when String
+              parse_json_string(value)
+            else
+              []
+            end
+          end
+
+          def parse_json_string(value)
+            return [] if value.blank?
+
+            begin
+              parsed = JSON.parse(value)
+              case parsed
+              when Hash
+                parsed.to_a
+              else
+                []
+              end
+            rescue JSON::ParserError
+              []
+            end
+          end
+
+          def field_name
+            field.dom.name
+          end
+
+          def limit
+            attributes.fetch(:limit, DEFAULT_LIMIT)
+          end
+
+          # Override from ExtractsInput concern to normalize form parameters
+          def normalize_input(input_value)
+            case input_value
+            when Hash
+              if input_value.keys.all? { |k| k.to_s.match?(/^\d+$/) }
+                # Handle indexed form params: {"0" => {"key" => "foo", "value" => "bar"}}
+                process_indexed_params(input_value)
+              else
+                # Handle direct hash params
+                input_value.reject { |k, v| k.blank? || (v.blank? && v != false) }
+              end
+            when nil
+              {}
+            end
+          end
+
+          private
+
+          # Process indexed form parameters into a hash
+          def process_indexed_params(params)
+            params.values.each_with_object({}) do |pair, hash|
+              next unless pair.is_a?(Hash)
+
+              key = pair["key"] || pair[:key]
+              value = pair["value"] || pair[:value]
+
+              if key.present?
+                hash[key] = value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end