plutonium 0.15.4 → 0.15.5

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

@@ -0,0 +1,77 @@
+module Plutonium
+  module Query
+    module Filters
+      class Text < Filter
+        VALID_PREDICATES = [
+          :eq,           # Equal
+          :not_eq,       # Not equal
+          :matches,      # LIKE with wildcards
+          :not_matches,  # NOT LIKE with wildcards
+          :starts_with,  # LIKE with suffix wildcard
+          :ends_with,    # LIKE with prefix wildcard
+          :contains,     # LIKE with wildcards on both sides
+          :not_contains # NOT LIKE with wildcards on both sides
+        ].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, query:)
+          case @predicate
+          when :eq
+            scope.where(key => query)
+          when :not_eq
+            scope.where.not(key => query)
+          when :matches
+            scope.where("#{key} LIKE ?", query.tr("*", "%"))
+          when :not_matches
+            scope.where.not("#{key} LIKE ?", query.tr("*", "%"))
+          when :starts_with
+            scope.where("#{key} LIKE ?", "#{sanitize_like(query)}%")
+          when :ends_with
+            scope.where("#{key} LIKE ?", "%#{sanitize_like(query)}")
+          when :contains
+            scope.where("#{key} LIKE ?", "%#{sanitize_like(query)}%")
+          when :not_contains
+            scope.where.not("#{key} LIKE ?", "%#{sanitize_like(query)}%")
+          else
+            raise NotImplementedError, "text filter predicate #{@predicate}"
+          end
+        end
+
+        def customize_inputs
+          input :query
+          field :query, placeholder: generate_placeholder
+        end
+
+        private
+
+        def generate_placeholder
+          base = key.to_s.humanize
+          case @predicate
+          when :matches, :not_matches
+            "#{base} (use * as wildcard)"
+          when :starts_with
+            "#{base} starts with..."
+          when :ends_with
+            "#{base} ends with..."
+          when :contains, :not_contains
+            "#{base} contains..."
+          else
+            base
+          end
+        end
+
+        def sanitize_like(string)
+          # Escape special LIKE characters: %, _, and \
+          string.gsub(/[%_\\]/) { |char| "\\#{char}" }
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/query/model_scope.rb

@@ -0,0 +1,19 @@
+module Plutonium
+  module Query
+    class ModelScope < Base
+      attr_reader :name
+
+      # Initializes a ModelScope with a given name.
+      #
+      # @param name [Symbol] The name of the scope.
+      def initialize(name)
+        super()
+        @name = name
+      end
+
+      def apply(scope, **)
+        scope.public_send(name, **)
+      end
+    end
+  end
+end

data/lib/plutonium/resource/controller.rb

@@ -1,9 +1,6 @@
 require "action_controller"
 require "pagy"
 
-require File.expand_path("refinements/parameter_refinements", Plutonium.lib_root)
-using Plutonium::Refinements::ParameterRefinements
-
 module Plutonium
   module Resource
     # Controller module to handle resource actions and concerns

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

@@ -0,0 +1,26 @@
+module Plutonium
+  module Resource
+    module Controllers
+      module CrudActions
+        module IndexAction
+          extend ActiveSupport::Concern
+
+          private
+
+          def setup_index_action!
+            @pagy, @resource_records = pagy filtered_resource_collection
+          end
+
+          def filtered_resource_collection
+            query_params = current_definition
+              .query_form.new(nil, query_object: current_query_object, page_size: nil)
+              .extract_input(params)[:q]
+
+            base_query = current_authorized_scope
+            current_query_object.apply(base_query, query_params)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ module Plutonium
     module Controllers
       module CrudActions
         extend ActiveSupport::Concern
+        include IndexAction
 
         included do
           helper_method :preferred_action_after_submit
@@ -13,11 +14,7 @@ module Plutonium
           authorize_current! resource_class
           set_page_title resource_class.model_name.human.pluralize.titleize
 
-          @search_object = current_query_object
-          base_query = current_authorized_scope
-          base_query = @search_object.apply(base_query)
-          # base_query = base_query.public_send(params[:scope].to_sym) if params[:scope].present?
-          @pagy, @resource_records = pagy base_query
+          setup_index_action!
 
           render :index
         end

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

@@ -1,5 +1,3 @@
-using Plutonium::Refinements::ParameterRefinements
-
 module Plutonium
   module Resource
     module Controllers

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

@@ -1,5 +1,3 @@
-using Plutonium::Refinements::ParameterRefinements
-
 module Plutonium
   module Resource
     module Controllers
@@ -7,7 +5,7 @@ module Plutonium
         extend ActiveSupport::Concern
 
         included do
-          helper_method :resource_query_params, :current_query_object
+          helper_method :raw_resource_query_params, :current_query_object
         end
 
         def resource_query_object(resource_class, params)
@@ -16,28 +14,46 @@ module Plutonium
         end
 
         def current_query_object
-          @current_query_object ||= Plutonium::Resource::QueryObject.new(resource_context, resource_query_params) do |query_object|
-            if current_definition.search_definition
-              query_object.define_search proc { |scope, search:|
-                current_definition.search_definition.call(scope, search)
-              }
-            end
-
-            current_definition.defined_scopes.each do |key, value|
-              query_object.define_scope key, value[:block], **value[:options]
+          @current_query_object ||=
+            Plutonium::Resource::QueryObject.new(resource_class, raw_resource_query_params) do |query_object|
+              if current_definition.search_definition
+                query_object.define_search proc { |scope, search:|
+                  current_definition.search_definition.call(scope, search)
+                }
+              end
+
+              current_definition.defined_scopes.each do |key, value|
+                query_object.define_scope key, value[:block], **value[:options]
+              end
+
+              current_definition.defined_sorts.each do |key, value|
+                query_object.define_sorter key, value[:block], **value[:options]
+              end
+
+              current_definition.defined_filters.each do |key, value|
+                with = value[:options][:with]
+                if with.is_a?(Class) && with < Plutonium::Query::Filter
+                  options = value[:options].except(:with)
+                  options[:key] ||= key
+                  with = with.new(**options)
+                end
+                query_object.define_filter key, with, &value[:block]
+              end
+
+              query_object
             end
+        end
 
-            current_definition.defined_sorts.each do |key, value|
-              query_object.define_sorter key, value[:block], **value[:options]
+        def raw_resource_query_params
+          @raw_resource_query_params ||= begin
+            query_params = params[:q]
+            if query_params.is_a?(ActionController::Parameters)
+              query_params.to_unsafe_h
+            else
+              {}.with_indifferent_access
             end
-
-            query_object
           end
         end
-
-        def resource_query_params
-          (params[:q]&.nilify&.to_unsafe_h || {}).with_indifferent_access
-        end
       end
     end
   end

data/lib/plutonium/resource/policy.rb

@@ -87,7 +87,7 @@ module Plutonium
         update?
       end
 
-      # Checks if the search action is permitted.
+      # Checks if record search is permitted.
       #
       # @return [Boolean] Delegates to index?.
       def search?

data/lib/plutonium/resource/query_object.rb

@@ -1,127 +1,27 @@
 module Plutonium
   module Resource
     class QueryObject
-      class << self
-      end
-
-      class Query
-        include Plutonium::Core::Definers::FieldInputDefiner
-
-        # Applies the query to the given scope using the provided parameters.
-        #
-        # @param scope [Object] The initial scope to which the query will be applied.
-        # @param params [Hash] The parameters for the query.
-        # @return [Object] The modified scope.
-        def apply(scope, params)
-          params = extract_query_params(params)
-
-          if input_definitions.size == params.size
-            apply_internal(scope, params)
-          else
-            scope
-          end
-        end
-
-        private
-
-        # Abstract method to apply the query logic to the scope.
-        # Should be implemented by subclasses.
-        #
-        # @param scope [Object] The initial scope.
-        # @param params [Hash] The parameters for the query.
-        # @raise [NotImplementedError] If the method is not implemented.
-        def apply_internal(scope, params)
-          raise NotImplementedError, "#{self.class}#apply_internal"
-        end
-
-        # Extracts query parameters based on the defined inputs.
-        #
-        # @param params [Hash] The parameters to extract.
-        # @return [Hash] The extracted and symbolized parameters.
-        def extract_query_params(params)
-          input_definitions.collect_all(params).compact.symbolize_keys
-        end
-
-        # @return [nil] The resource class (default implementation returns nil).
-        def resource_class = nil
-      end
-
-      class ScopeQuery < Query
-        attr_reader :name
-
-        # Initializes a ScopeQuery with a given name.
-        #
-        # @param name [Symbol] The name of the scope.
-        def initialize(name)
-          @name = name
-          yield self if block_given?
-        end
-
-        private
-
-        # Applies the scope query to the given scope.
-        #
-        # @param scope [Object] The initial scope.
-        # @param params [Hash] The parameters for the query.
-        # @return [Object] The modified scope.
-        def apply_internal(scope, params)
-          scope.public_send(name, **params)
-        end
-      end
-
-      class BlockQuery < Query
-        attr_reader :body
-
-        # Initializes a BlockQuery with a given block of code.
-        #
-        # @param body [Proc] The block of code for the query.
-        def initialize(body)
-          @body = body
-          yield self if block_given?
-        end
-
-        private
-
-        # Applies the block query to the given scope.
-        #
-        # @param scope [Object] The initial scope.
-        # @param params [Hash] The parameters for the query.
-        # @return [Object] The modified scope.
-        def apply_internal(scope, params)
-          if body.arity == 1
-            body.call(scope)
-          else
-            body.call(scope, **params)
-          end
-        end
-      end
-
       attr_reader :search_filter, :search_query
 
-      # Initializes a QueryObject with the given context and parameters.
+      # Initializes a QueryObject with the given resource_class and parameters.
       #
-      # @param context [Object] The context in which the query object is used.
+      # @param resource_class [Object] The resource class.
       # @param params [Hash] The parameters for initialization.
-      def initialize(context, params, &)
-        @context = context
+      def initialize(resource_class, params, &)
+        @resource_class = resource_class
+        @params = params
 
         define_standard_queries
-        define_scopes
-        define_filters
-        define_sorters
-
         yield self if block_given?
-
-        extract_filter_params(params)
-        extract_sort_params(params)
+        extract_filter_params
+        extract_sort_params
       end
 
       # Defines a filter with the given name and body.
       #
       # @param name [Symbol] The name of the filter.
       # @param body [Proc, nil] The body of the filter.
-      def define_filter(name, body = nil, &)
-        body ||= name
+      def define_filter(name, body, &)
         filter_definitions[name] = build_query(body, &)
       end
 
@@ -145,7 +45,7 @@ module Plutonium
         end
 
         sort_definitions[name] = build_query(body) do |query|
-          query.define_field_input :direction
+          query.input :direction
         end
       end
 
@@ -154,7 +54,7 @@ module Plutonium
       # @param body [Proc, Symbol] The body of the search filter.
       def define_search(body)
         @search_filter = build_query(body) do |query|
-          query.define_field_input :search
+          query.input :search
         end
       end
 
@@ -172,17 +72,21 @@ module Plutonium
         q[:sort_fields] = selected_sort_fields.dup
         handle_sort_options!(q, options)
 
-        "?#{{q: q}.to_param}"
+        q.merge! params.slice(*filter_definitions.keys)
+        query_params = deep_compact({q: q}).to_param
+        "?#{query_params}"
       end
 
       # Applies the defined filters and sorts to the given scope.
       #
       # @param scope [Object] The initial scope to which filters and sorts are applied.
       # @return [Object] The modified scope.
-      def apply(scope)
-        scope = search_filter.apply(scope, {search: search_query}) if search_filter.present?
-        scope = scope_definitions[selected_scope_filter].apply(scope, {}) if selected_scope_filter.present?
-        apply_sorts(scope)
+      def apply(scope, params)
+        params = deep_compact(params.with_indifferent_access)
+        scope = search_filter.apply(scope, search: params[:search]) if search_filter && params[:search]
+        scope = scope_definitions[params[:scope]].apply(scope, **{}) if scope_definitions[params[:scope]]
+        scope = apply_sorts(scope, params)
+        apply_filters(scope, params)
       end
 
       def scope_definitions = @scope_definitions ||= {}.with_indifferent_access
@@ -208,22 +112,7 @@ module Plutonium
 
       private
 
-      attr_reader :context, :selected_sort_fields, :selected_sort_directions, :selected_scope_filter
-
-      # Defines standard filters.
-      def define_filters
-        # Implement filter definitions if needed
-      end
-
-      # Defines standard scopes.
-      def define_scopes
-        # Implement scope definitions if needed
-      end
-
-      # Defines standard sorters.
-      def define_sorters
-        # Implement sorter definitions if needed
-      end
+      attr_reader :resource_class, :params, :selected_sort_fields, :selected_sort_directions, :selected_scope_filter
 
       # Defines standard queries for search and scope.
       def define_standard_queries
@@ -233,7 +122,7 @@ module Plutonium
       # Extracts filter parameters from the given params.
       #
       # @param params [Hash] The parameters to extract.
-      def extract_filter_params(params)
+      def extract_filter_params
         @search_query = params[:search]
         @selected_scope_filter = params[:scope]
       end
@@ -241,7 +130,7 @@ module Plutonium
       # Extracts sort parameters from the given params.
       #
       # @param params [Hash] The parameters to extract.
-      def extract_sort_params(params)
+      def extract_sort_params
         @selected_sort_fields = Array(params[:sort_fields])
         @selected_sort_fields &= sort_definitions.keys
 
@@ -251,17 +140,24 @@ module Plutonium
       # Builds a query object based on the given body and optional block.
       #
       # @param body [Proc, Symbol] The body of the query.
-      # @yieldparam query [Query] The query object.
-      # @return [Query] The constructed query object.
-      def build_query(body, &)
-        case body
+      # @yieldparam query [Plutonium::Query::Base] The query object.
+      # @return [Plutonium::Query::Base] The constructed query object.
+      def build_query(body)
+        query = case body
         when Symbol
           raise "Cannot find scope :#{body} on #{resource_class}" unless resource_class.respond_to?(body)
 
-          ScopeQuery.new(body, &)
+          Plutonium::Query::ModelScope.new(body)
+        when Proc
+          Plutonium::Query::AdhocBlock.new(body)
+        when Plutonium::Query::Filter
+          body
         else
-          BlockQuery.new(body, &)
+          raise NotImplementedError, "Unsupported query body: #{body.class} -> #{body}"
         end
+
+        yield query if block_given?
+        query
       end
 
       # Determines the sort field for the given name.
@@ -284,7 +180,7 @@ module Plutonium
       # @param params [Hash] The parameters to extract.
       # @return [Hash] The extracted sort directions.
       def extract_sort_directions(params)
-        params[:sort_directions]&.slice(*sort_definitions.keys) || {}
+        params[:sort_directions]&.slice(*sort_definitions.keys.map(&:to_sym)) || {}
       end
 
       # Handles the sort options for building the URL.
@@ -322,19 +218,37 @@ module Plutonium
       #
       # @param scope [Object] The initial scope.
       # @return [Object] The modified scope.
-      def apply_sorts(scope)
+      def apply_sorts(scope, params)
+        selected_sort_directions = extract_sort_directions(params)
         selected_sort_fields.each do |name|
-          sorter = sort_definitions[name]
-          next unless sorter.present?
+          next unless (sorter = sort_definitions[name])
+
+          direction = selected_sort_directions[name] || "ASC"
+          scope = sorter.apply(scope, direction:)
+        end
+        scope
+      end
+
+      def apply_filters(scope, params)
+        filter_definitions.each do |name, filter|
+          name = name.to_sym
+          filter_params = params[name]
+          next if filter_params.blank?
 
-          params = {direction: selected_sort_directions[name] || "ASC"}
-          scope = sorter.apply(scope, params)
+          scope = filter.apply(scope, **filter_params.symbolize_keys)
         end
         scope
       end
 
-      # @return [Object] The resource class from the context.
-      def resource_class = context.resource_class
+      def deep_compact(hash)
+        hash.transform_values do |value|
+          if value.respond_to?(:transform_values)
+            deep_compact(value).presence
+          else
+            value.presence
+          end
+        end.compact
+      end
     end
   end
 end

data/lib/plutonium/{refinements/parameter_refinements.rb → support/parameters.rb}

@@ -1,11 +1,9 @@
-require "action_controller"
-
 module Plutonium
-  module Refinements
-    module ParameterRefinements
-      refine ActionController::Parameters do
-        def nilify
-          transform_values { |value| nilify_internal value }
+  module Support
+    module Parameters
+      class << self
+        def nilify(params)
+          params.transform_values { |value| nilify_internal(value) }
         end
 
         private

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

@@ -41,7 +41,7 @@ module Plutonium
           :resource_url_for,
           :current_definition,
           :current_query_object,
-          :resource_query_params,
+          :raw_resource_query_params,
           :current_policy,
           :current_turbo_frame,
           :current_interactive_action,

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

@@ -37,27 +37,31 @@ module Plutonium
         end
 
         def render_resource_field(name)
-          # display :name, as: :string
-          # display :description, class: "col-span-full"
-          # display :age, field: {class: "max-h-fit"}
-          # display :dob do |f|
-          #   f.date_tag
-          # end
-
           when_permitted(name) do
+            # field :name, as: :string
+            # display :name, as: :string
+            # display :description, class: "col-span-full"
+            # display :age, tag: {class: "max-h-fit"}
+            # display :dob do |f|
+            #   f.date_tag
+            # end
+
+            field_options = resource_definition.defined_fields[name] ? resource_definition.defined_fields[name][:options] : {}
+
             display_definition = resource_definition.defined_displays[name] || {}
             display_options = display_definition[:options] || {}
-            display_field_as = display_options.delete(:as)
 
-            display_field_options = display_options.delete(:field) || {}
-            display_block = display_definition[:block] || ->(f) {
-              display_field_as ||= f.inferred_field_component
-              f.send(:"#{display_field_as}_tag", **display_field_options)
+            tag = field_options[:as] || display_options[:as]
+            tag_attributes = display_options[:tag] || {}
+            tag_block = display_definition[:block] || ->(f) {
+              tag ||= f.inferred_field_component
+              f.send(:"#{tag}_tag", **tag_attributes)
             }
 
-            field_options = resource_definition.defined_fields[name] ? resource_definition.defined_fields[name][:options] : {}
-            render field(name, **field_options).wrapped(**display_options) do |f|
-              render display_block.call(f)
+            field_options = field_options.except(:as)
+            wrapper_options = display_options.except(:tag, :as)
+            render field(name, **field_options).wrapped(**wrapper_options) do |f|
+              render tag_block.call(f)
             end
           end
         end