plutonium 0.34.1 → 0.35.0

data/lib/plutonium/query/filters/date.rb

@@ -0,0 +1,97 @@
+module Plutonium
+  module Query
+    module Filters
+      # Date filter for date/datetime columns
+      #
+      # @example Filter by exact date
+      #   filter :created_at, with: :date, predicate: :eq
+      #
+      # @example Filter by date before
+      #   filter :due_date, with: :date, predicate: :lt
+      #
+      # @example Filter by date on or after
+      #   filter :start_date, with: :date, predicate: :gteq
+      #
+      class Date < Filter
+        VALID_PREDICATES = [
+          :eq,    # Equal (on this date)
+          :not_eq, # Not equal
+          :lt,    # Less than (before)
+          :lteq,  # Less than or equal (on or before)
+          :gt,    # Greater than (after)
+          :gteq   # Greater than or equal (on or after)
+        ].freeze
+
+        def initialize(predicate: :eq, **)
+          super(**)
+          unless VALID_PREDICATES.include?(predicate)
+            raise ArgumentError, "unsupported predicate #{predicate}. Valid predicates are: #{VALID_PREDICATES.join(", ")}"
+          end
+          @predicate = predicate
+        end
+
+        def apply(scope, value:)
+          return scope if value.blank?
+
+          date_value = parse_date(value)
+          return scope unless date_value
+
+          case @predicate
+          when :eq
+            scope.where(key => date_value.all_day)
+          when :not_eq
+            scope.where.not(key => date_value.all_day)
+          when :lt
+            scope.where(key => ...date_value.beginning_of_day)
+          when :lteq
+            scope.where(key => ..date_value.end_of_day)
+          when :gt
+            scope.where(key => (date_value.end_of_day + 1.second)..)
+          when :gteq
+            scope.where(key => date_value.beginning_of_day..)
+          else
+            raise NotImplementedError, "date filter predicate #{@predicate}"
+          end
+        end
+
+        def customize_inputs
+          input :value, as: :date
+          field :value, placeholder: generate_placeholder
+        end
+
+        private
+
+        def parse_date(value)
+          case value
+          when ::Date, ::DateTime, ::Time, ActiveSupport::TimeWithZone
+            value.to_date
+          when String
+            ::Date.parse(value)
+          end
+        rescue ArgumentError
+          nil
+        end
+
+        def generate_placeholder
+          base = key.to_s.humanize
+          case @predicate
+          when :eq
+            base
+          when :not_eq
+            "#{base} not on..."
+          when :lt
+            "#{base} before..."
+          when :lteq
+            "#{base} on or before..."
+          when :gt
+            "#{base} after..."
+          when :gteq
+            "#{base} on or after..."
+          else
+            base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/query/filters/date_range.rb

@@ -0,0 +1,58 @@
+module Plutonium
+  module Query
+    module Filters
+      # DateRange filter for filtering between two dates
+      #
+      # @example Basic usage
+      #   filter :created_at, with: :date_range
+      #
+      # @example With custom labels
+      #   filter :published_at, with: :date_range, from_label: "Published from", to_label: "Published to"
+      #
+      class DateRange < Filter
+        def initialize(from_label: nil, to_label: nil, **)
+          super(**)
+          @from_label = from_label
+          @to_label = to_label
+        end
+
+        def apply(scope, from: nil, to: nil)
+          from_date = parse_date(from)
+          to_date = parse_date(to)
+
+          if from_date && to_date
+            scope.where(key => from_date.beginning_of_day..to_date.end_of_day)
+          elsif from_date
+            scope.where(key => from_date.beginning_of_day..)
+          elsif to_date
+            scope.where(key => ..to_date.end_of_day)
+          else
+            scope
+          end
+        end
+
+        def customize_inputs
+          input :from, as: :date
+          input :to, as: :date
+          field :from, placeholder: @from_label || "#{key.to_s.humanize} from..."
+          field :to, placeholder: @to_label || "#{key.to_s.humanize} to..."
+        end
+
+        private
+
+        def parse_date(value)
+          return nil if value.blank?
+
+          case value
+          when ::Date, ::DateTime, ::Time, ActiveSupport::TimeWithZone
+            value.to_date
+          when String
+            ::Date.parse(value)
+          end
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/query/filters/select.rb

@@ -0,0 +1,55 @@
+module Plutonium
+  module Query
+    module Filters
+      # Select filter for choosing from a predefined collection of options
+      #
+      # @example Basic usage with array
+      #   filter :status, with: :select, choices: %w[draft published archived]
+      #
+      # @example With proc for dynamic choices
+      #   filter :category, with: :select, choices: -> { Category.pluck(:name, :id) }
+      #
+      # @example With multiple selection
+      #   filter :tags, with: :select, choices: %w[ruby rails js], multiple: true
+      #
+      class Select < Filter
+        def initialize(choices: nil, multiple: false, **)
+          super(**)
+          @choices = choices
+          @multiple = multiple
+        end
+
+        def apply(scope, value:)
+          return scope if value.blank?
+
+          if @multiple && value.is_a?(Array)
+            scope.where(key => value.reject(&:blank?))
+          else
+            scope.where(key => value)
+          end
+        end
+
+        def customize_inputs
+          input :value,
+            as: :select,
+            choices: resolved_choices,
+            multiple: @multiple,
+            include_blank: @multiple ? false : "All"
+        end
+
+        private
+
+        def resolved_choices
+          case @choices
+          when Proc
+            @choices
+          when nil
+            []
+          else
+            @choices
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -53,9 +53,14 @@ module Plutonium
 
           respond_to do |format|
             if params[:pre_submit]
-              format.any(:html, :turbo_stream) { render :new, formats: [:html], status: :unprocessable_content }
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form)) }
+              format.html { render :new, status: :unprocessable_content }
             elsif resource_record!.save
-              format.any(:html, :turbo_stream) do
+              format.turbo_stream do
+                flash.notice = "#{resource_class.model_name.human} was successfully created."
+                render turbo_stream: helpers.turbo_stream_redirect(redirect_url_after_submit)
+              end
+              format.html do
                 redirect_to redirect_url_after_submit,
                   notice: "#{resource_class.model_name.human} was successfully created."
               end
@@ -94,9 +99,14 @@ module Plutonium
 
           respond_to do |format|
             if params[:pre_submit]
-              format.any(:html, :turbo_stream) { render :edit, formats: [:html], status: :unprocessable_content }
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form)) }
+              format.html { render :edit, status: :unprocessable_content }
             elsif resource_record!.save
-              format.any(:html, :turbo_stream) do
+              format.turbo_stream do
+                flash.notice = "#{resource_class.model_name.human} was successfully updated."
+                render turbo_stream: helpers.turbo_stream_redirect(redirect_url_after_submit)
+              end
+              format.html do
                 redirect_to redirect_url_after_submit,
                   notice: "#{resource_class.model_name.human} was successfully updated.",
                   status: :see_other
@@ -121,13 +131,21 @@ module Plutonium
           respond_to do |format|
             resource_record!.destroy
 
-            format.any(:html, :turbo_stream) do
+            format.turbo_stream do
+              flash.notice = "#{resource_class.model_name.human} was successfully deleted."
+              render turbo_stream: helpers.turbo_stream_redirect(redirect_url_after_destroy)
+            end
+            format.html do
               redirect_to redirect_url_after_destroy,
                 notice: "#{resource_class.model_name.human} was successfully deleted."
             end
             format.json { head :no_content }
           rescue ActiveRecord::InvalidForeignKey
-            format.any(:html, :turbo_stream) do
+            format.turbo_stream do
+              flash.alert = "#{resource_class.model_name.human} is referenced by other records."
+              render turbo_stream: helpers.turbo_stream_redirect(resource_url_for(resource_record!))
+            end
+            format.html do
               redirect_to resource_url_for(resource_record!),
                 alert: "#{resource_class.model_name.human} is referenced by other records."
             end

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

@@ -18,9 +18,12 @@ module Plutonium
           ]
 
           before_action :authorize_interactive_resource_action!, only: %i[
-            interactive_bulk_action commit_interactive_bulk_action
             interactive_resource_action commit_interactive_resource_action
           ]
+
+          before_action :authorize_interactive_bulk_action!, only: %i[
+            interactive_bulk_action commit_interactive_bulk_action
+          ]
         end
 
         # GET /resources/1/record_actions/:interactive_action
@@ -39,7 +42,10 @@ module Plutonium
           build_interactive_record_action_interaction
 
           if params[:pre_submit]
-            render :interactive_record_action, formats: [:html], status: :unprocessable_content
+            respond_to do |format|
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("interaction-form", view_context.render(@interaction.build_form)) }
+              format.html { render :interactive_record_action, formats: [:html], status: :unprocessable_content }
+            end
             return
           end
 
@@ -50,15 +56,12 @@ module Plutonium
               if outcome.success?
                 return_url = redirect_url_after_action_on(resource_record!)
 
-                if helpers.current_turbo_frame == "remote_modal"
-                  format.turbo_stream do
-                    render turbo_stream: [
-                      helpers.turbo_stream_redirect(return_url)
-                    ]
-                  end
+                format.turbo_stream do
+                  render turbo_stream: helpers.turbo_stream_redirect(return_url)
+                end
+                format.html do
+                  redirect_to return_url, status: :see_other
                 end
-
-                format.any { redirect_to return_url, status: :see_other }
               else
                 format.any(:html, :turbo_stream) do
                   render :interactive_record_action, formats: [:html], status: :unprocessable_content
@@ -95,9 +98,8 @@ module Plutonium
 
           if params[:pre_submit]
             respond_to do |format|
-              format.any(:html, :turbo_stream) do
-                render :interactive_resource_action, formats: [:html], status: :unprocessable_content
-              end
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("interaction-form", view_context.render(@interaction.build_form)) }
+              format.html { render :interactive_resource_action, status: :unprocessable_content }
             end
             return
           end
@@ -109,15 +111,12 @@ module Plutonium
               if outcome.success?
                 return_url = redirect_url_after_action_on(resource_class)
 
-                if helpers.current_turbo_frame == "remote_modal"
-                  format.turbo_stream do
-                    render turbo_stream: [
-                      helpers.turbo_stream_redirect(return_url)
-                    ]
-                  end
+                format.turbo_stream do
+                  render turbo_stream: helpers.turbo_stream_redirect(return_url)
+                end
+                format.html do
+                  redirect_to return_url, status: :see_other
                 end
-
-                format.any { redirect_to return_url, status: :see_other }
               else
                 format.any(:html, :turbo_stream) do
                   render :interactive_resource_action, formats: [:html], status: :unprocessable_content
@@ -133,48 +132,51 @@ module Plutonium
 
         # GET /resources/bulk_actions/:interactive_action?ids[]=1&ids[]=2
         def interactive_bulk_action
-          raise NotImplementedError
-          # # TODO: ensure that the selected list matches the returned value
-          # interactive_bulk
-          # @interaction = current_interactive_action.interaction.new((params[:interaction] || {}).except(:resources))
+          build_interactive_bulk_action_interaction
 
-          # if helpers.current_turbo_frame == "remote_modal"
-          #   render layout: false
-          # else
-          #   render :interactive_bulk_action
-          # end
+          if helpers.current_turbo_frame == "remote_modal"
+            render layout: false, formats: [:html]
+          else
+            render :interactive_bulk_action, formats: [:html]
+          end
         end
 
         # POST /resources/bulk_actions/:interactive_action?ids[]=1&ids[]=2
         def commit_interactive_bulk_action
-          raise NotImplementedError
-          # respond_to do |format|
-          #   inputs = interaction_params.merge(resources: interactive_bulk)
-          #   @interaction = current_interactive_action.interaction.run(inputs)
-
-          #   if @interaction.valid?
-          #     collection_count = interactive_bulk.size
-
-          #     flash[:notice] = "TODO:#{current_interactive_action} #{collection_count} #{resource_class.model_name.human.pluralize(collection_count)} successfully updated."
-
-          #     format.html { redirect_to resource_url_for(resource_class) }
-          #     if helpers.current_turbo_frame == "remote_modal"
-          #       format.turbo_stream do
-          #         render turbo_stream: [
-          #           helpers.turbo_stream_redirect(resource_url_for(resource_class))
-          #         ]
-          #       end
-          #     end
-          #   else
-          #     format.html do
-          #       render :interactive_bulk_action, status: :unprocessable_content
-          #     end
-          #     format.any do
-          #       @errors = @interaction.errors
-          #       render "errors", status: :unprocessable_content
-          #     end
-          #   end
-          # end
+          build_interactive_bulk_action_interaction
+
+          if params[:pre_submit]
+            respond_to do |format|
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("interaction-form", view_context.render(@interaction.build_form)) }
+              format.html { render :interactive_bulk_action, formats: [:html], status: :unprocessable_content }
+            end
+            return
+          end
+
+          outcome = @interaction.call
+
+          outcome.to_response.process(self) do |value|
+            respond_to do |format|
+              if outcome.success?
+                return_url = redirect_url_after_action_on(resource_class)
+
+                format.turbo_stream do
+                  render turbo_stream: helpers.turbo_stream_redirect(return_url)
+                end
+                format.html do
+                  redirect_to return_url, status: :see_other
+                end
+              else
+                format.any(:html, :turbo_stream) do
+                  render :interactive_bulk_action, formats: [:html], status: :unprocessable_content
+                end
+                format.any do
+                  @errors = @interaction.errors
+                  render "errors", status: :unprocessable_content
+                end
+              end
+            end
+          end
         end
 
         private
@@ -206,6 +208,16 @@ module Plutonium
           authorize_current! resource_class, to: :"#{interactive_resource_action}?"
         end
 
+        def authorize_interactive_bulk_action!
+          action_name = params[:interactive_action]&.to_sym
+          policy_method = :"#{action_name}?"
+
+          # Authorize each record individually - fail if any record is not authorized
+          interactive_bulk.each do |record|
+            authorize_current! record, to: policy_method
+          end
+        end
+
         def interactive_bulk
           @interactive_bulk ||= current_authorized_scope.from_path_param(params.require(:ids))
         end
@@ -222,6 +234,12 @@ module Plutonium
           @interaction
         end
 
+        def build_interactive_bulk_action_interaction
+          @interaction = current_interactive_action.interaction.new(view_context:)
+          @interaction.attributes = interaction_params.merge(resources: interactive_bulk)
+          @interaction
+        end
+
         # Returns the submitted resource parameters
         # @return [Hash] The submitted resource parameters
         def submitted_interaction_params

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

@@ -31,10 +31,12 @@ module Plutonium
 
               current_definition.defined_filters.each do |key, value|
                 with = value[:options][:with]
-                if with.is_a?(Class) && with < Plutonium::Query::Filter
+                if with
+                  # Resolve symbol types (e.g., :text, :select) to filter classes
+                  filter_class = Plutonium::Query::Filter.lookup(with)
                   options = value[:options].except(:with)
                   options[:key] ||= key
-                  with = with.new(**options)
+                  with = filter_class.new(**options)
                 end
                 query_object.define_filter key, with, &value[:block]
               end

data/lib/plutonium/resource/query_object.rb

@@ -198,7 +198,7 @@ module Plutonium
       # @return [Symbol] The sort field.
       # @raise [RuntimeError] If unable to determine sort logic.
       def determine_sort_field(name)
-        if resource_class.primary_key == name.to_s || resource_class.content_column_field_names.include?(name)
+        if resource_class.column_names.include?(name.to_s)
           name
         elsif resource_class.belongs_to_association_field_names.include?(name)
           resource_class.reflect_on_association(name).foreign_key.to_sym

data/lib/plutonium/ui/action_button.rb

@@ -6,6 +6,17 @@ module Plutonium
       include Phlex::Rails::Helpers::LinkTo
       include Phlex::Rails::Helpers::ButtonTo
 
+      # Color to CSS class mapping for standard and soft button variants
+      COLOR_CLASSES = {
+        primary: {default: "pu-btn-primary", soft: "pu-btn-soft-primary"},
+        success: {default: "pu-btn-success", soft: "pu-btn-soft-success"},
+        info: {default: "pu-btn-info", soft: "pu-btn-soft-info"},
+        warning: {default: "pu-btn-warning", soft: "pu-btn-soft-warning"},
+        danger: {default: "pu-btn-danger", soft: "pu-btn-soft-danger"},
+        accent: {default: "pu-btn-accent", soft: "pu-btn-soft-accent"},
+        secondary: {default: "pu-btn-secondary", soft: "pu-btn-soft-secondary"}
+      }.freeze
+
       def initialize(action, url:, variant: :default)
         @action = action
         @url = url
@@ -67,80 +78,27 @@ module Plutonium
 
       def button_classes
         tokens(
-          base_classes,
-          color_classes,
-          size_classes,
-          -> { @action.icon && @variant != :table } => "space-x-1"
+          "pu-btn",
+          size_class,
+          color_class,
+          -> { @action.icon } => "gap-1.5"
         )
       end
 
-      def base_classes
-        if @variant == :table
-          "inline-flex items-center justify-center py-1 px-2 rounded-lg focus:outline-none focus:ring-2"
-        else
-          "flex items-center justify-center px-4 py-2 text-sm font-medium rounded-lg focus:outline-none focus:ring-4"
-        end
+      def size_class
+        (@variant == :table) ? "pu-btn-xs" : "pu-btn-md"
       end
 
       def icon_classes
-        if @variant == :table
-          "h-4 w-4 mr-1"
-        else
-          "h-3.5 w-3.5 -ml-1"
-        end
-      end
-
-      def size_classes
-        (@variant == :table) ? "text-xs" : "text-sm"
+        (@variant == :table) ? "h-4 w-4" : "h-3.5 w-3.5"
       end
 
-      def color_classes
-        case @action.color || @action.category.to_sym
-        when :primary
-          variant_class(
-            "bg-primary-700 text-white hover:bg-primary-800 focus:ring-primary-300 dark:bg-primary-600 dark:hover:bg-primary-700 dark:focus:ring-primary-800",
-            table: "bg-primary-100 text-primary-700 hover:bg-primary-200 focus:ring-primary-300 dark:bg-primary-700 dark:text-primary-100 dark:hover:bg-primary-600 dark:focus:ring-primary-600"
-          )
-        when :success
-          variant_class(
-            "bg-success-700 text-white hover:bg-success-800 focus:ring-success-300 dark:bg-success-600 dark:hover:bg-success-700 dark:focus:ring-success-800",
-            table: "bg-success-100 text-success-700 hover:bg-success-200 focus:ring-success-300 dark:bg-success-700 dark:text-success-100 dark:hover:bg-success-600 dark:focus:ring-success-600"
-          )
-        when :info
-          variant_class(
-            "bg-info-700 text-white hover:bg-info-800 focus:ring-info-300 dark:bg-info-600 dark:hover:bg-info-700 dark:focus:ring-info-800",
-            table: "bg-info-100 text-info-700 hover:bg-info-200 focus:ring-info-300 dark:bg-info-700 dark:text-info-100 dark:hover:bg-info-600 dark:focus:ring-info-600"
-          )
-        when :warning
-          variant_class(
-            "bg-warning-700 text-white hover:bg-warning-800 focus:ring-warning-300 dark:bg-warning-600 dark:hover:bg-warning-700 dark:focus:ring-warning-800",
-            table: "bg-warning-100 text-warning-700 hover:bg-warning-200 focus:ring-warning-300 dark:bg-warning-700 dark:text-warning-100 dark:hover:bg-warning-600 dark:focus:ring-warning-600"
-          )
-        when :danger
-          variant_class(
-            "bg-danger-700 text-white hover:bg-danger-800 focus:ring-danger-300 dark:bg-danger-600 dark:hover:bg-danger-700 dark:focus:ring-danger-800",
-            table: "bg-danger-100 text-danger-700 hover:bg-danger-200 focus:ring-danger-300 dark:bg-danger-700 dark:text-danger-100 dark:hover:bg-danger-600 dark:focus:ring-danger-600"
-          )
-        when :accent
-          variant_class(
-            "bg-accent-700 text-white hover:bg-accent-800 focus:ring-accent-300 dark:bg-accent-600 dark:hover:bg-accent-700 dark:focus:ring-accent-800",
-            table: "bg-accent-100 text-accent-700 hover:bg-accent-200 focus:ring-accent-300 dark:bg-accent-700 dark:text-accent-100 dark:hover:bg-accent-600 dark:focus:ring-accent-600"
-          )
-        else
-          variant_class(
-            "bg-secondary-700 text-white hover:bg-secondary-800 focus:ring-secondary-300 dark:bg-secondary-600 dark:hover:bg-secondary-700 dark:focus:ring-secondary-800",
-            table: "bg-secondary-100 text-secondary-700 hover:bg-secondary-200 focus:ring-secondary-300 dark:bg-secondary-700 dark:text-secondary-100 dark:hover:bg-secondary-600 dark:focus:ring-secondary-600"
-          )
-        end
-      end
+      def color_class
+        color_key = (@action.color || @action.category)&.to_sym || :secondary
+        color_mapping = COLOR_CLASSES[color_key] || COLOR_CLASSES[:secondary]
 
-      def variant_class(default, table:)
-        case @variant
-        when :table
-          table
-        else
-          default
-        end
+        # Table variant uses soft (tinted) buttons, default uses solid buttons
+        (@variant == :table) ? color_mapping[:soft] : color_mapping[:default]
       end
     end
   end