spree_admin 5.2.6 → 5.3.0.rc1

data/app/models/spree/admin/table/filter.rb

@@ -0,0 +1,116 @@
+module Spree
+  module Admin
+    class Table
+      class Filter
+        OPERATORS = {
+          eq: { label: 'equals', predicate: '_eq' },
+          not_eq: { label: 'does not equal', predicate: '_not_eq' },
+          cont: { label: 'contains', predicate: '_cont' },
+          not_cont: { label: 'does not contain', predicate: '_not_cont' },
+          start: { label: 'starts with', predicate: '_start' },
+          end: { label: 'ends with', predicate: '_end' },
+          gt: { label: 'greater than', predicate: '_gt' },
+          gteq: { label: 'greater than or equal to', predicate: '_gteq' },
+          lt: { label: 'less than', predicate: '_lt' },
+          lteq: { label: 'less than or equal to', predicate: '_lteq' },
+          in: { label: 'is any of', predicate: '_in' },
+          not_in: { label: 'is none of', predicate: '_not_in' },
+          null: { label: 'is empty', predicate: '_null', no_value: true },
+          not_null: { label: 'is not empty', predicate: '_not_null', no_value: true }
+        }.freeze
+
+        attr_accessor :field, :operator, :value, :id
+
+        def initialize(field: nil, operator: :eq, value: nil, id: nil)
+          @field = field
+          @operator = operator.to_sym
+          @value = value
+          @id = id || SecureRandom.hex(8)
+        end
+
+        # Convert to ransack parameter format
+        # @return [Hash]
+        def to_ransack_param
+          return {} if field.blank?
+
+          operator_config = OPERATORS[@operator]
+          return {} unless operator_config
+
+          param_name = "#{field}#{operator_config[:predicate]}"
+
+          if operator_config[:no_value]
+            { param_name => true }
+          else
+            { param_name => extract_ransack_value }
+          end
+        end
+
+        private
+
+        # Extract the actual value for ransack from potentially complex value structures
+        # Handles arrays of objects (from autocomplete) by extracting IDs
+        # @return [Object]
+        def extract_ransack_value
+          return value unless value.is_a?(Array)
+
+          # Extract IDs if array contains hashes with 'id' key (from autocomplete)
+          extracted = if value.first.is_a?(Hash) && (value.first.key?('id') || value.first.key?(:id))
+                        value.map { |item| item['id'] || item[:id] }
+                      else
+                        value
+                      end
+
+          # For eq/not_eq operators, use single value instead of array
+          if %i[eq not_eq].include?(@operator) && extracted.is_a?(Array) && extracted.size == 1
+            extracted.first
+          else
+            extracted
+          end
+        end
+
+        public
+
+        # Get human-readable operator label
+        # @return [String]
+        def operator_label
+          OPERATORS.dig(@operator, :label) || @operator.to_s.humanize
+        end
+
+        # Check if this operator requires a value
+        # @return [Boolean]
+        def requires_value?
+          !OPERATORS.dig(@operator, :no_value)
+        end
+
+        # Convert to hash
+        # @return [Hash]
+        def to_h
+          { field: field, operator: operator, value: value, id: id }
+        end
+
+        # Create filter from params hash
+        # @param params [Hash]
+        # @return [Filter, nil]
+        def self.from_params(params)
+          return nil unless params.is_a?(Hash)
+
+          params = params.symbolize_keys
+          new(
+            field: params[:field],
+            operator: params[:operator] || :eq,
+            value: params[:value],
+            id: params[:id]
+          )
+        end
+
+        # Get available operators with labels for UI
+        # @return [Array<Hash>]
+        def self.operators_for_select
+          OPERATORS.map do |key, config|
+            { value: key.to_s, label: config[:label], no_value: config[:no_value] || false }
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/admin/table/filter_group.rb

@@ -0,0 +1,144 @@
+module Spree
+  module Admin
+    class Table
+      class FilterGroup
+        COMBINATORS = %i[and or].freeze
+
+        attr_accessor :combinator, :filters, :groups, :id
+
+        def initialize(combinator: :and, filters: [], groups: [], id: nil)
+          @combinator = combinator.to_sym
+          @filters = filters
+          @groups = groups
+          @id = id || SecureRandom.hex(8)
+        end
+
+        # Add a filter to this group
+        # @param filter [Filter]
+        def add_filter(filter)
+          @filters << filter
+        end
+
+        # Add a nested group
+        # @param group [FilterGroup]
+        def add_group(group)
+          @groups << group
+        end
+
+        # Remove a filter by id
+        # @param filter_id [String]
+        def remove_filter(filter_id)
+          @filters.reject! { |f| f.id == filter_id }
+        end
+
+        # Remove a nested group by id
+        # @param group_id [String]
+        def remove_group(group_id)
+          @groups.reject! { |g| g.id == group_id }
+        end
+
+        # Check if group is empty
+        # @return [Boolean]
+        def empty?
+          @filters.empty? && @groups.empty?
+        end
+
+        # Convert to ransack params format
+        # AND groups use regular params: { name_cont: 'value', status_eq: 'active' }
+        # OR groups use ransack groupings: { g: { '0' => { m: 'or', c: { ... } } } }
+        # @return [Hash]
+        def to_ransack_params
+          if combinator == :or
+            to_or_ransack_params
+          else
+            to_and_ransack_params
+          end
+        end
+
+        # Convert to hash for JSON serialization
+        # @return [Hash]
+        def to_h
+          {
+            combinator: combinator,
+            filters: filters.map(&:to_h),
+            groups: groups.map(&:to_h),
+            id: id
+          }
+        end
+
+        # Create from params hash
+        # @param params [Hash]
+        # @return [FilterGroup]
+        def self.from_params(params)
+          return new if params.blank?
+
+          params = params.symbolize_keys if params.respond_to?(:symbolize_keys)
+
+          group = new(
+            combinator: params[:combinator] || :and,
+            id: params[:id]
+          )
+
+          Array(params[:filters]).each do |filter_params|
+            filter = Filter.from_params(filter_params)
+            group.add_filter(filter) if filter
+          end
+
+          Array(params[:groups]).each do |group_params|
+            nested_group = from_params(group_params)
+            group.add_group(nested_group) if nested_group
+          end
+
+          group
+        end
+
+        private
+
+        def to_and_ransack_params
+          result = {}
+
+          filters.each do |filter|
+            result.merge!(filter.to_ransack_param)
+          end
+
+          groups.each_with_index do |group, index|
+            if group.combinator == :or
+              result[:g] ||= {}
+              result[:g][index.to_s] = build_or_grouping(group)
+            else
+              result.merge!(group.to_ransack_params)
+            end
+          end
+
+          result
+        end
+
+        def to_or_ransack_params
+          {
+            g: {
+              '0' => build_or_grouping(self)
+            }
+          }
+        end
+
+        def build_or_grouping(group)
+          conditions = {}
+
+          group.filters.each_with_index do |filter, index|
+            param = filter.to_ransack_param
+            next if param.empty?
+
+            conditions[index.to_s] = {
+              a: { '0' => { name: filter.field, p: filter.operator.to_s.sub('_', ''), v: { '0' => { value: filter.value } } } }
+            }
+          end
+
+          {
+            m: 'or',
+            c: conditions
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/spree/admin/table/query_builder.rb

@@ -0,0 +1,114 @@
+module Spree
+  module Admin
+    class Table
+      class QueryBuilder
+        attr_reader :root_group, :table
+
+        def initialize(table)
+          @table = table
+          @root_group = FilterGroup.new(combinator: :and)
+        end
+
+        # Add a filter to the root group
+        # @param field [String] ransack attribute name
+        # @param operator [Symbol] filter operator
+        # @param value [Object] filter value
+        # @return [Filter]
+        def add_filter(field:, operator:, value:)
+          filter = Filter.new(field: field, operator: operator, value: value)
+          @root_group.add_filter(filter)
+          filter
+        end
+
+        # Add a nested group
+        # @param combinator [Symbol] :and or :or
+        # @return [FilterGroup]
+        def add_group(combinator: :and)
+          group = FilterGroup.new(combinator: combinator)
+          @root_group.add_group(group)
+          group
+        end
+
+        # Clear all filters
+        def clear
+          @root_group = FilterGroup.new(combinator: :and)
+        end
+
+        # Check if there are any filters
+        # @return [Boolean]
+        def empty?
+          @root_group.empty?
+        end
+
+        # Convert to ransack params format
+        # @return [Hash]
+        def to_ransack_params
+          @root_group.to_ransack_params
+        end
+
+        # Convert to JSON string for storing in hidden field
+        # @return [String]
+        def to_json_state
+          @root_group.to_h.to_json
+        end
+
+        # Load state from params hash
+        # @param params [Hash]
+        def load_from_params(params)
+          @root_group = FilterGroup.from_params(params)
+        end
+
+        # Load state from JSON string
+        # @param json_string [String]
+        def load_from_json(json_string)
+          return if json_string.blank?
+
+          params = JSON.parse(json_string, symbolize_names: true)
+          @root_group = FilterGroup.from_params(params)
+        rescue JSON::ParserError
+          @root_group = FilterGroup.new(combinator: :and)
+        end
+
+        # Get available fields for filtering based on table configuration
+        # @return [Array<Hash>]
+        def available_fields
+          @table.filterable_columns.map do |column|
+            {
+              key: column.ransack_attribute,
+              label: column.resolve_label,
+              type: column.filter_type.to_s,
+              operators: column.operators.map(&:to_s),
+              value_options: format_value_options(column.value_options),
+              search_url: column.search_url
+            }
+          end
+        end
+
+        # Get available operators for UI
+        # @return [Array<Hash>]
+        def available_operators
+          Filter.operators_for_select
+        end
+
+        private
+
+        def format_value_options(options)
+          return nil if options.blank?
+
+          # Resolve Proc/lambda options at runtime
+          resolved_options = options.is_a?(Proc) ? options.call : options
+
+          return nil if resolved_options.blank?
+
+          resolved_options.map do |opt|
+            if opt.is_a?(Hash)
+              { value: opt[:value] || opt['value'], label: opt[:label] || opt['label'] }
+            else
+              { value: opt.to_s, label: opt.to_s.humanize }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/admin/table/visibility.rb

@@ -0,0 +1,20 @@
+module Spree
+  module Admin
+    class Table
+      # Shared visibility logic for components with conditional display
+      module Visibility
+        extend ActiveSupport::Concern
+
+        # Check if component is visible for the given context
+        # @param context [Object, nil] view context with access to helper methods
+        # @return [Boolean]
+        def visible?(context = nil)
+          return true if condition.nil?
+          return condition unless condition.respond_to?(:call)
+
+          context&.respond_to?(:instance_exec) ? context.instance_exec(&condition) : condition.call(context)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/admin/table.rb

@@ -0,0 +1,313 @@
+module Spree
+  module Admin
+    class Table
+      attr_reader :columns, :bulk_actions, :context, :model_class, :key
+      attr_accessor :search_param, :search_placeholder, :row_actions, :row_actions_edit, :row_actions_delete, :new_resource,
+                    :date_range_param, :date_range_label, :link_to_action
+
+      def initialize(context, key: nil, model_class: nil, search_param: :name_cont, search_placeholder: nil, row_actions: false, row_actions_edit: true, row_actions_delete: false, new_resource: true, date_range_param: nil, date_range_label: nil, link_to_action: :edit)
+        @context = context
+        @key = key
+        @model_class = model_class
+        @columns = {}
+        @bulk_actions = {}
+        @search_param = search_param
+        @search_placeholder = search_placeholder
+        @row_actions = row_actions
+        @row_actions_edit = row_actions_edit
+        @row_actions_delete = row_actions_delete
+        @new_resource = new_resource
+        @date_range_param = date_range_param
+        @date_range_label = date_range_label
+        @link_to_action = link_to_action
+      end
+
+      # Check if date range filter is enabled
+      # @return [Boolean]
+      def date_range?
+        @date_range_param.present?
+      end
+
+      # Check if row actions are enabled
+      # @return [Boolean]
+      def row_actions?
+        @row_actions
+      end
+
+      # Check if edit row action is enabled
+      # @return [Boolean]
+      def row_actions_edit?
+        @row_actions_edit
+      end
+
+      # Check if delete row action is enabled
+      # @return [Boolean]
+      def row_actions_delete?
+        @row_actions_delete
+      end
+
+      # Add a column definition
+      # @param key [Symbol] unique column identifier
+      # @param options [Hash] column options (label, type, sortable, filterable, default, position, etc.)
+      # @return [Column] the created column
+      # @raise [ArgumentError] if column configuration is invalid
+      def add(key, **options, &block)
+        key = key.to_sym
+        # Handle :if as alias for :condition
+        options[:condition] = options.delete(:if) if options.key?(:if)
+        column = Column.new(**options.merge(key: key.to_s))
+
+        unless column.valid?
+          errors = column.errors.full_messages.join(', ')
+          raise ArgumentError, "Invalid column '#{key}' in table '#{@context}': #{errors}"
+        end
+
+        @columns[key] = column
+
+        if block_given?
+          builder = Builder.new(self, column)
+          builder.instance_eval(&block)
+        end
+
+        sort_columns!
+        column
+      end
+
+      # Remove a column
+      # @param key [Symbol] column key to remove
+      # @return [Column, nil] the removed column or nil
+      def remove(key)
+        @columns.delete(key.to_sym)
+      end
+
+      # Update an existing column
+      # @param key [Symbol] column key to update
+      # @param options [Hash] attributes to update
+      # @return [Column, nil] the updated column or nil
+      def update(key, **options)
+        column = @columns[key.to_sym]
+        return nil unless column
+
+        apply_attributes(column, options)
+        sort_columns!
+        column
+      end
+
+      # Find a column by key
+      # @param key [Symbol] column key
+      # @return [Column, nil]
+      def find(key)
+        @columns[key.to_sym]
+      end
+
+      # Check if column exists
+      # @param key [Symbol] column key
+      # @return [Boolean]
+      def exists?(key)
+        @columns.key?(key.to_sym)
+      end
+
+      # Insert column before another column
+      # @param target_key [Symbol] existing column key
+      # @param new_key [Symbol] new column key
+      # @param options [Hash] column options
+      # @return [Column, nil]
+      def insert_before(target_key, new_key, **options)
+        target = find(target_key)
+        return nil unless target
+
+        add(new_key, **options.merge(position: target.position - 1))
+      end
+
+      # Insert column after another column
+      # @param target_key [Symbol] existing column key
+      # @param new_key [Symbol] new column key
+      # @param options [Hash] column options
+      # @return [Column, nil]
+      def insert_after(target_key, new_key, **options)
+        target = find(target_key)
+        return nil unless target
+
+        add(new_key, **options.merge(position: target.position + 1))
+      end
+
+      # Get visible columns for user (respecting selection)
+      # @param selected_keys [Array<Symbol>, nil] user-selected column keys
+      # @param view_context [Object, nil] view context for visibility checks
+      # @return [Array<Column>]
+      def visible_columns(selected_keys = nil, view_context = nil)
+        cols = if selected_keys.present?
+                 selected_keys.map { |k| find(k) }.compact
+               else
+                 default_columns
+               end
+
+        cols.select { |c| c.visible?(view_context) }
+      end
+
+      # Get default columns (marked as default: true and displayable)
+      # @return [Array<Column>]
+      def default_columns
+        @columns.values.select { |c| c.default? && c.displayable? }.sort_by(&:position)
+      end
+
+      # Get all available columns that can be displayed
+      # @return [Array<Column>]
+      def available_columns
+        @columns.values.select(&:displayable?).sort_by(&:position)
+      end
+
+      # Get sortable columns
+      # @return [Array<Column>]
+      def sortable_columns
+        @columns.values.select(&:sortable?).sort_by(&:position)
+      end
+
+      # Find column with custom sort scope for the given sort param
+      # @param sort_param [String] the sort param (e.g., "master_price desc")
+      # @return [Column, nil] column with custom sort scope or nil
+      def find_custom_sort_column(sort_param)
+        return nil if sort_param.blank?
+
+        attribute = sort_param.to_s.split.first
+        @columns.values.find { |c| c.ransack_attribute == attribute && c.custom_sort? }
+      end
+
+      # Apply custom sort scope to collection
+      # @param collection [ActiveRecord::Relation] the collection to sort
+      # @param sort_param [String] the sort param (e.g., "master_price desc")
+      # @return [ActiveRecord::Relation] sorted collection
+      def apply_custom_sort(collection, sort_param)
+        column = find_custom_sort_column(sort_param)
+        return collection unless column
+
+        direction = sort_param.to_s.include?('desc') ? :desc : :asc
+        scope_name = direction == :desc ? column.sort_scope_desc : column.sort_scope_asc
+
+        return collection unless scope_name.present?
+
+        collection.send(scope_name)
+      end
+
+      # Get filterable columns (columns that can be used in query builder)
+      # @return [Array<Column>]
+      def filterable_columns
+        @columns.values.select(&:filterable?).sort_by(&:position)
+      end
+
+      # Add a bulk action definition
+      # @param key [Symbol] unique action identifier
+      # @param options [Hash] action options (label, icon, action_path, position, etc.)
+      # @return [BulkAction] the created action
+      # @raise [ArgumentError] if action configuration is invalid
+      def add_bulk_action(key, **options)
+        key = key.to_sym
+        action = BulkAction.new(**options.merge(key: key))
+
+        unless action.valid?
+          errors = action.errors.full_messages.join(', ')
+          raise ArgumentError, "Invalid bulk action '#{key}' in table '#{@context}': #{errors}"
+        end
+
+        @bulk_actions[key] = action
+        sort_bulk_actions!
+        action
+      end
+
+      # Remove a bulk action
+      # @param key [Symbol] action key to remove
+      # @return [BulkAction, nil] the removed action or nil
+      def remove_bulk_action(key)
+        @bulk_actions.delete(key.to_sym)
+      end
+
+      # Update an existing bulk action
+      # @param key [Symbol] action key to update
+      # @param options [Hash] attributes to update
+      # @return [BulkAction, nil] the updated action or nil
+      def update_bulk_action(key, **options)
+        action = @bulk_actions[key.to_sym]
+        return nil unless action
+
+        apply_attributes(action, options)
+        sort_bulk_actions!
+        action
+      end
+
+      # Find a bulk action by key
+      # @param key [Symbol] action key
+      # @return [BulkAction, nil]
+      def find_bulk_action(key)
+        @bulk_actions[key.to_sym]
+      end
+
+      # Get visible bulk actions for the given context
+      # @param view_context [Object, nil] view context for visibility checks
+      # @return [Array<BulkAction>]
+      def visible_bulk_actions(view_context = nil)
+        @bulk_actions.values.select { |a| a.visible?(view_context) }.sort_by(&:position)
+      end
+
+      # Check if bulk operations are enabled (has any bulk actions)
+      # @return [Boolean]
+      def bulk_operations_enabled?
+        @bulk_actions.any?
+      end
+
+      # Deep clone the registry
+      # @return [Table]
+      def deep_clone
+        cloned = self.class.new(
+          context,
+          model_class: model_class,
+          search_param: search_param,
+          search_placeholder: search_placeholder,
+          row_actions: row_actions,
+          row_actions_edit: row_actions_edit,
+          row_actions_delete: row_actions_delete,
+          new_resource: new_resource,
+          date_range_param: date_range_param,
+          date_range_label: date_range_label,
+          link_to_action: link_to_action
+        )
+        @columns.each do |key, column|
+          cloned.columns[key] = column.deep_clone
+        end
+        @bulk_actions.each do |key, action|
+          cloned.bulk_actions[key] = action.deep_clone
+        end
+        cloned
+      end
+
+      # Clear all columns
+      def clear
+        @columns.clear
+      end
+
+      # Clear all bulk actions
+      def clear_bulk_actions
+        @bulk_actions.clear
+      end
+
+      def inspect
+        "#<Spree::Admin::Table context=#{context} columns=#{@columns.size} bulk_actions=#{@bulk_actions.size}>"
+      end
+
+      private
+
+      def apply_attributes(object, options)
+        options.each do |attr, value|
+          object.send("#{attr}=", value) if object.respond_to?("#{attr}=")
+        end
+      end
+
+      def sort_columns!
+        @columns = @columns.sort_by { |_key, col| [col.position, col.key.to_s] }.to_h
+      end
+
+      def sort_bulk_actions!
+        @bulk_actions = @bulk_actions.sort_by { |_key, action| [action.position, action.key.to_s] }.to_h
+      end
+    end
+  end
+end