elaine_crud 0.1.0

data/lib/elaine_crud/record_fetching.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ElaineCrud
+  # Methods for fetching records and determining column visibility
+  # Handles data retrieval, scoping, and column selection
+  module RecordFetching
+    extend ActiveSupport::Concern
+
+    included do
+      # Make determine_per_page available as a helper method in views
+      helper_method :determine_per_page
+    end
+
+    private
+
+    # Fetch all records for index view
+    # Can be overridden in subclasses for custom filtering/scoping
+    # @return [ActiveRecord::Relation] The records to display
+    def fetch_records
+      records = crud_model.all
+
+      # Apply parent filtering for has_many relationships
+      records = apply_has_many_filtering(records)
+
+      # Include all relationships to avoid N+1 queries
+      includes_list = get_all_relationship_includes
+      records = records.includes(includes_list) if includes_list.any?
+
+      # Apply search and filters
+      records = apply_search_and_filters(records)
+
+      # Apply sorting
+      records = apply_sorting(records)
+
+      # Apply pagination
+      apply_pagination(records)
+    end
+
+    # Fetch records without pagination (for exports)
+    def fetch_records_for_export
+      records = crud_model.all
+
+      # Apply parent filtering for has_many relationships
+      records = apply_has_many_filtering(records)
+
+      # Include all relationships to avoid N+1 queries
+      includes_list = get_all_relationship_includes
+      records = records.includes(includes_list) if includes_list.any?
+
+      # Apply search and filters
+      records = apply_search_and_filters(records)
+
+      # Apply sorting
+      records = apply_sorting(records)
+
+      # Return without pagination
+      records
+    end
+
+    # Apply pagination to the record set
+    # @param records [ActiveRecord::Relation] The records to paginate
+    # @return [ActiveRecord::Relation] The paginated records
+    def apply_pagination(records)
+      # Update session with per_page preference if provided
+      if session.present? && params[:per_page].present?
+        session[:elaine_crud_per_page] = params[:per_page].to_i
+      end
+
+      # Determine records per page
+      per_page = determine_per_page
+
+      # Apply Kaminari pagination
+      records.page(params[:page]).per(per_page)
+    end
+
+    # Determine how many records to show per page
+    # Priority: 1. URL param, 2. Session, 3. Default
+    # @return [Integer] Number of records per page
+    def determine_per_page
+      if params[:per_page].present?
+        params[:per_page].to_i
+      elsif session.present? && session[:elaine_crud_per_page].present?
+        session[:elaine_crud_per_page].to_i
+      else
+        25 # Default
+      end
+    end
+
+    # Find a single record by ID
+    # @return [ActiveRecord::Base] The found record
+    def find_record
+      crud_model.find(params[:id])
+    end
+
+    # Find a record by a specific ID (used for inline editing)
+    # @param id [Integer] The record ID
+    # @return [ActiveRecord::Base, nil] The found record or nil
+    def find_record_by_id(id)
+      crud_model.find(id)
+    rescue ActiveRecord::RecordNotFound
+      nil
+    end
+
+    # Determine which columns to display
+    # @return [Array<String>] List of column names to display
+    def determine_columns
+      # Get all potential columns (database columns + configured virtual fields)
+      db_columns = crud_model.column_names
+      virtual_fields = configured_virtual_fields
+      all_columns = (db_columns + virtual_fields).uniq
+
+      # Filter columns based on field configurations and new visibility rules
+      all_columns.select do |col|
+        field_config = field_config_for(col.to_sym)
+
+        if field_config&.visible == false
+          # Explicitly hidden via field configuration
+          false
+        elsif field_config&.visible == true
+          # Explicitly shown via field configuration (even if it ends with '_at')
+          true
+        elsif virtual_fields.include?(col)
+          # Virtual fields are shown if configured (like has_many relationships)
+          true
+        else
+          # Default behavior for DB columns: hide columns ending with '_at', show everything else
+          !col.end_with?('_at')
+        end
+      end
+    end
+
+    # Get list of configured virtual fields (non-database columns)
+    # @return [Array<String>] List of configured virtual field names
+    def configured_virtual_fields
+      return [] unless field_configurations
+
+      virtual_fields = []
+      field_configurations.each do |field_name, config|
+        field_name_str = field_name.to_s
+
+        # Include if it's not a database column but is configured
+        unless crud_model.column_names.include?(field_name_str)
+          virtual_fields << field_name_str
+        end
+      end
+
+      virtual_fields
+    end
+  end
+end

data/lib/elaine_crud/relationship_handling.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module ElaineCrud
+  # Methods for handling ActiveRecord relationships (belongs_to, has_many)
+  # Provides eager loading, filtering, and parent context management
+  module RelationshipHandling
+    extend ActiveSupport::Concern
+
+    included do
+      # Make parent filter methods available as helper methods in views
+      helper_method :detect_parent_filters if respond_to?(:helper_method)
+    end
+
+    # Get list of belongs_to associations to include for avoiding N+1 queries
+    # @return [Array<Symbol>] List of association names to include
+    def get_belongs_to_includes
+      return [] unless crud_model
+
+      includes = []
+
+      # Get all belongs_to relationships that are displayed
+      crud_model.reflections.each do |name, reflection|
+        next unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+
+        foreign_key = reflection.foreign_key.to_sym
+
+        # Include if this foreign key is in the displayed columns or configured
+        if determine_columns.include?(foreign_key.to_s) || field_configured?(foreign_key)
+          includes << name.to_sym
+        end
+      end
+
+      includes
+    end
+
+    # Get has_many relationships that need to be included
+    # @return [Array<Symbol>] List of association names to include
+    def get_has_many_includes
+      return [] unless crud_model
+
+      includes = []
+
+      crud_model.reflections.each do |name, reflection|
+        next unless reflection.is_a?(ActiveRecord::Reflection::HasManyReflection)
+
+        # Include if this relationship is displayed in columns or configured
+        if determine_columns.include?(name) || field_configured?(name.to_sym)
+          includes << name.to_sym
+        end
+      end
+
+      includes
+    end
+
+    # Get has_one relationships that need to be included
+    # @return [Array<Symbol>] List of association names to include
+    def get_has_one_includes
+      return [] unless crud_model
+
+      includes = []
+
+      crud_model.reflections.each do |name, reflection|
+        next unless reflection.is_a?(ActiveRecord::Reflection::HasOneReflection)
+
+        # Include if this relationship is displayed in columns or configured
+        if determine_columns.include?(name) || field_configured?(name.to_sym)
+          includes << name.to_sym
+        end
+      end
+
+      includes
+    end
+
+    # Get has_and_belongs_to_many relationships that need to be included
+    # @return [Array<Symbol>] List of association names to include
+    def get_habtm_includes
+      return [] unless crud_model
+
+      includes = []
+
+      crud_model.reflections.each do |name, reflection|
+        next unless reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+
+        # Include if this relationship is displayed in columns or configured
+        if determine_columns.include?(name) || field_configured?(name.to_sym)
+          includes << name.to_sym
+        end
+      end
+
+      includes
+    end
+
+    # Get list of associations to include for avoiding N+1 queries
+    # @return [Array<Symbol>] List of association names to include
+    def get_all_relationship_includes
+      return [] unless crud_model
+
+      includes = []
+
+      # Include belongs_to relationships (existing logic)
+      includes += get_belongs_to_includes
+
+      # Include has_many relationships that are displayed
+      includes += get_has_many_includes
+
+      # Include has_one relationships that are displayed
+      includes += get_has_one_includes
+
+      # Include has_and_belongs_to_many relationships that are displayed
+      includes += get_habtm_includes
+
+      includes.uniq
+    end
+
+    # Apply filtering based on parent relationship parameters
+    # @param records [ActiveRecord::Relation] The base query
+    # @return [ActiveRecord::Relation] Filtered query
+    def apply_has_many_filtering(records)
+      parent_filters = detect_parent_filters
+
+      parent_filters.each do |parent_field, parent_id|
+        next unless parent_id.present?
+
+        # Validate that this is a legitimate foreign key
+        if valid_parent_filter?(parent_field)
+          records = records.where(parent_field => parent_id)
+
+          # Set instance variables for UI context
+          set_parent_context(parent_field, parent_id)
+        end
+      end
+
+      records
+    end
+
+    # Detect parent filter parameters from URL
+    # @return [Hash] Hash of foreign_key => parent_id
+    def detect_parent_filters
+      parent_filters = {}
+
+      # Look for foreign key parameters in the URL
+      crud_model.reflections.each do |name, reflection|
+        next unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+
+        foreign_key = reflection.foreign_key.to_sym
+        param_value = params[foreign_key]
+
+        if param_value.present?
+          parent_filters[foreign_key] = param_value
+        end
+      end
+
+      parent_filters
+    end
+
+    # Validate that the parent filter is legitimate
+    # @param field_name [Symbol] The field name to validate
+    # @return [Boolean] True if valid foreign key column
+    def valid_parent_filter?(field_name)
+      crud_model.column_names.include?(field_name.to_s) &&
+      field_name.to_s.end_with?('_id')
+    end
+
+    # Set context for UI display
+    # @param parent_field [Symbol] The foreign key field
+    # @param parent_id [Integer] The parent record ID
+    def set_parent_context(parent_field, parent_id)
+      reflection = find_reflection_by_foreign_key(parent_field)
+      return unless reflection
+
+      begin
+        parent_record = reflection.klass.find(parent_id)
+        @parent_context = {
+          record: parent_record,
+          relationship_name: reflection.name,
+          foreign_key: parent_field,
+          model_class: reflection.klass
+        }
+      rescue ActiveRecord::RecordNotFound
+        @parent_context = {
+          error: "#{reflection.klass.name} with ID #{parent_id} not found",
+          foreign_key: parent_field,
+          model_class: reflection.klass
+        }
+      end
+    end
+
+    # Find reflection by foreign key name
+    # @param foreign_key [Symbol] The foreign key field
+    # @return [ActiveRecord::Reflection::BelongsToReflection, nil] The reflection or nil
+    def find_reflection_by_foreign_key(foreign_key)
+      crud_model.reflections.values.find do |reflection|
+        reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) &&
+        reflection.foreign_key.to_sym == foreign_key.to_sym
+      end
+    end
+
+    # Populate parent relationships from URL parameters
+    # @param record [ActiveRecord::Base] The record to populate
+    def populate_parent_relationships(record)
+      detect_parent_filters.each do |foreign_key, parent_id|
+        if valid_parent_filter?(foreign_key) && record.public_send(foreign_key).blank?
+          record.public_send("#{foreign_key}=", parent_id)
+        end
+      end
+    end
+
+    # Determine redirect path after create based on context
+    # @return [String] The redirect path
+    def redirect_after_create_path
+      if @parent_context
+        # Redirect back to filtered index view
+        polymorphic_path([crud_model], @parent_context[:foreign_key] => @parent_context[:record].id)
+      else
+        # Standard redirect to show page
+        polymorphic_path(@record)
+      end
+    end
+  end
+end

data/lib/elaine_crud/routing.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ElaineCrud
+  # Extends ActionDispatch::Routing::Mapper to automatically add export routes
+  # to all resources that inherit from ElaineCrud::BaseController
+  module Routing
+    # Override the resources method to automatically add export action
+    # for controllers inheriting from ElaineCrud::BaseController
+    def resources(*args, &block)
+      super(*args) do
+        # Check if the controller uses ElaineCrud
+        resource_name = args.first
+        controller_name = "#{resource_name.to_s.camelize}Controller"
+
+        begin
+          controller_class = controller_name.constantize
+          # Add ElaineCrud routes if controller inherits from ElaineCrud::BaseController
+          if controller_class < ElaineCrud::BaseController
+            collection do
+              get :export      # For CSV/Excel/JSON export
+              get :new_modal   # For nested record creation in modal
+            end
+          end
+        rescue NameError
+          # Controller doesn't exist yet or doesn't use ElaineCrud - skip
+        end
+
+        # Allow custom block to be evaluated
+        instance_eval(&block) if block_given?
+      end
+    end
+  end
+end

data/lib/elaine_crud/search_and_filtering.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module ElaineCrud
+  # Methods for handling search and filtering of records
+  # Provides global text search and per-field filtering capabilities
+  module SearchAndFiltering
+    extend ActiveSupport::Concern
+
+    included do
+      # Make search/filter methods available as helper methods in views
+      helper_method :search_active?, :search_query, :filters if respond_to?(:helper_method)
+    end
+
+    # Apply search and filters to records
+    # @param records [ActiveRecord::Relation] The base query
+    # @return [ActiveRecord::Relation] Filtered query
+    def apply_search_and_filters(records)
+      records = apply_global_search(records) if search_query.present?
+      records = apply_filters(records) if filters.present?
+      records
+    end
+
+    # Get search query from params
+    # @return [String, nil] The search term
+    def search_query
+      params[:search]
+    end
+
+    # Get filter parameters
+    # @return [Hash] Filter parameters
+    def filters
+      filter_params = params[:filter] || {}
+      # Convert ActionController::Parameters to Hash for compatibility
+      if filter_params.respond_to?(:to_unsafe_h)
+        filter_params.to_unsafe_h
+      elsif filter_params.respond_to?(:to_h)
+        filter_params.to_h
+      elsif filter_params.is_a?(Hash)
+        filter_params
+      else
+        # Handle malformed filter parameter (e.g., plain string)
+        {}
+      end
+    end
+
+    # Apply global text search across searchable columns
+    # @param records [ActiveRecord::Relation]
+    # @return [ActiveRecord::Relation]
+    def apply_global_search(records)
+      # Get searchable columns (string/text types)
+      searchable_columns = determine_searchable_columns
+
+      return records if searchable_columns.empty?
+
+      # Build OR conditions for each searchable column using Arel
+      # This prevents SQL injection in column names
+      table = crud_model.arel_table
+      search_pattern = "%#{search_query.downcase}%"
+
+      conditions = searchable_columns.map do |column|
+        table[column].lower.matches(search_pattern)
+      end
+
+      # Combine all conditions with OR
+      records.where(conditions.reduce(:or))
+    end
+
+    # Apply individual field filters
+    # @param records [ActiveRecord::Relation]
+    # @return [ActiveRecord::Relation]
+    def apply_filters(records)
+      filters.each do |field, value|
+        next if value.blank?
+
+        # Skip special date range fields (handled separately)
+        next if field.to_s.end_with?('_from', '_to')
+
+        # Validate field is in the model
+        next unless valid_filter_field?(field)
+
+        records = apply_field_filter(records, field, value)
+      end
+
+      # Apply date range filters
+      records = apply_date_range_filters(records)
+
+      records
+    end
+
+    # Apply filter for a specific field
+    # @param records [ActiveRecord::Relation]
+    # @param field [String, Symbol] Field name
+    # @param value [String, Array] Filter value
+    # @return [ActiveRecord::Relation]
+    def apply_field_filter(records, field, value)
+      column_type = get_column_type(field)
+      table = crud_model.arel_table
+
+      case column_type
+      when :string, :text
+        # Partial match for text fields using Arel
+        # This prevents SQL injection in field names
+        records.where(table[field].lower.matches("%#{value.downcase}%"))
+      when :boolean
+        # Exact match for booleans using Arel
+        records.where(table[field].eq(ActiveModel::Type::Boolean.new.cast(value)))
+      when :integer
+        # Handle foreign keys and integers using Arel
+        if value.is_a?(Array)
+          records.where(table[field].in(value))
+        else
+          records.where(table[field].eq(value))
+        end
+      else
+        # Default: exact match using Arel
+        records.where(table[field].eq(value))
+      end
+    end
+
+    # Apply date range filters
+    # @param records [ActiveRecord::Relation]
+    # @return [ActiveRecord::Relation]
+    def apply_date_range_filters(records)
+      date_fields = determine_date_columns
+      table = crud_model.arel_table
+
+      date_fields.each do |field|
+        from_key = "#{field}_from"
+        to_key = "#{field}_to"
+
+        # Use Arel to safely construct date range queries
+        # This prevents SQL injection in field names
+        if filters[from_key].present?
+          records = records.where(table[field].gteq(filters[from_key]))
+        end
+
+        if filters[to_key].present?
+          records = records.where(table[field].lteq(filters[to_key]))
+        end
+      end
+
+      records
+    end
+
+    # Determine which columns are searchable (string/text types)
+    # @return [Array<String>] Column names
+    def determine_searchable_columns
+      return [] unless crud_model
+
+      searchable = []
+
+      crud_model.columns.each do |col|
+        # Include string/text columns that are displayed
+        if [:string, :text].include?(col.type) &&
+           !%w[id created_at updated_at].include?(col.name) &&
+           determine_columns.include?(col.name)
+
+          # Check if field is configured as searchable
+          config = field_config_for(col.name.to_sym)
+          if config&.respond_to?(:searchable)
+            searchable << col.name if config.searchable
+          else
+            # Default: string/text fields are searchable
+            searchable << col.name
+          end
+        end
+      end
+
+      searchable
+    end
+
+    # Determine which columns are filterable
+    # @return [Array<Hash>] Array of hashes with field info
+    def determine_filterable_columns
+      return [] unless crud_model
+
+      filterable = []
+
+      determine_columns.each do |col_name|
+        next if %w[id created_at updated_at].include?(col_name.to_s)
+
+        config = field_config_for(col_name.to_sym)
+
+        # Check if explicitly configured as non-filterable
+        if config&.respond_to?(:filterable)
+          next unless config.filterable  # Skip if explicitly set to false
+        end
+
+        # Default: all fields are filterable (matching search behavior)
+        filterable << {
+          name: col_name.to_sym,
+          type: infer_filter_type(col_name),
+          config: config
+        }
+      end
+
+      filterable
+    end
+
+    # Get column type for a field
+    # @param field [String, Symbol] Field name
+    # @return [Symbol] Column type
+    def get_column_type(field)
+      column = crud_model.columns.find { |col| col.name == field.to_s }
+      column&.type || :string
+    end
+
+    # Determine date columns for range filtering
+    # @return [Array<String>] Column names
+    def determine_date_columns
+      return [] unless crud_model
+
+      date_cols = []
+
+      crud_model.columns.each do |col|
+        if [:date, :datetime, :timestamp].include?(col.type) &&
+           determine_columns.include?(col.name)
+
+          # Check if explicitly configured as non-filterable
+          config = field_config_for(col.name.to_sym)
+          if config&.respond_to?(:filterable)
+            next unless config.filterable  # Skip if explicitly set to false
+          end
+
+          # Default: date fields are filterable
+          date_cols << col.name
+        end
+      end
+
+      date_cols
+    end
+
+    # Infer filter type from column type and configuration
+    # @param field_name [String, Symbol] Field name
+    # @return [Symbol] Filter type
+    def infer_filter_type(field_name)
+      column = crud_model.columns.find { |col| col.name == field_name.to_s }
+      return :text unless column
+
+      config = field_config_for(field_name.to_sym)
+
+      # Use configured filter type if available
+      return config.filter_type if config&.respond_to?(:filter_type) && config.filter_type
+
+      # Infer from column type
+      case column.type
+      when :boolean then :boolean
+      when :date, :datetime, :timestamp then :date_range
+      when :integer
+        # Check if it's a foreign key
+        if field_name.to_s.end_with?('_id')
+          :select
+        else
+          :text
+        end
+      else
+        :text
+      end
+    end
+
+    # Check if any search or filters are active
+    # @return [Boolean]
+    def search_active?
+      search_query.present? || filters.present?
+    end
+
+    # Get total count without filters (for "X of Y results" display)
+    # @return [Integer]
+    def total_unfiltered_count
+      @total_unfiltered_count ||= begin
+        # Build base query without search/filters
+        records = crud_model.all
+        records = apply_has_many_filtering(records)
+        records.count
+      end
+    end
+
+    # Validate that a field is safe to filter on
+    # @param field [String, Symbol] Field name
+    # @return [Boolean]
+    def valid_filter_field?(field)
+      crud_model.column_names.include?(field.to_s)
+    end
+  end
+end