infotable 0.1.0

data/app/assets/javascripts/infotable/index.js

@@ -0,0 +1,14 @@
+// InfoTable JavaScript entry point
+// This works with any bundler: importmap, esbuild, webpack, vite, etc.
+
+import TableController from "./controllers/table_controller";
+import DrawerController from "./controllers/drawer_controller";
+
+// Export controllers for manual registration
+export { TableController, DrawerController };
+
+// Auto-register function for convenience
+export function registerInfotableControllers(application) {
+  application.register("infotable--table", TableController);
+  application.register("infotable--drawer", DrawerController);
+}

data/app/controllers/infotable/application_controller.rb

@@ -0,0 +1,4 @@
+module Infotable
+  class ApplicationController < Infotable.configuration.parent_controller.constantize
+  end
+end

data/app/controllers/infotable/tables_controller.rb

@@ -0,0 +1,299 @@
+module Infotable
+  class TablesController < ApplicationController
+    include Pagy::Method
+
+    before_action :load_table_class
+    before_action :authorize_table
+
+    # A value PostgreSQL cannot represent (e.g. an id filter of 10**40) is a bad request, not a crash
+    rescue_from ActiveRecord::RangeError do
+      render plain: "Parameter out of range", status: :bad_request
+    end
+    before_action :set_params
+
+    def show
+      process_table_request
+      render_table_frame
+    end
+
+    def data
+      process_table_request
+
+      respond_to do |format|
+        format.html {
+          # Always render the full frame
+          render_table_frame
+        }
+        format.turbo_stream {
+          # For infinite scroll - return turbo stream to append rows and replace pagination frame
+          # Following the guide's "Frames + Streams" pattern
+          streams = [
+            turbo_stream.append(
+              "#{params[:table_name]}_tbody",
+              partial: "infotable/tables/table_rows",
+              locals: {
+                records: @records,
+                table_class: @table_class
+              }
+            )
+          ]
+
+          # Replace the pagination frame with the next one (or end indicator)
+          if @pagy.next
+            streams << turbo_stream.replace(
+              "#{params[:table_name]}_pagination",
+              partial: "infotable/tables/next_page_frame"
+            )
+          else
+            # No more pages - replace with end indicator
+            streams << turbo_stream.replace(
+              "#{params[:table_name]}_pagination",
+              '<div class="infotable-end-indicator border-t border-gray-100 bg-white px-6 py-8 text-center"><div class="inline-flex items-center gap-2 text-sm text-gray-500"><svg class="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"></path></svg><span class="font-medium">All items loaded</span></div></div>'.html_safe
+            )
+          end
+
+          render turbo_stream: streams
+        }
+      end
+    end
+
+    def export
+      require "csv"
+
+      # Process the same query as show/data but without pagination
+      @query = build_query
+
+      # Get visible columns from params or use all visible columns
+      visible_column_names = if params[:visible_columns].present?
+        params[:visible_columns].split(",").map(&:strip)
+      else
+        @table_class.visible_columns.map { |c| c[:name].to_s }
+      end
+      visible_columns = @table_class.columns.select { |col| visible_column_names.include?(col[:name].to_s) }
+
+      # Set CSV headers for streaming download
+      headers["Content-Type"] = "text/csv; charset=utf-8"
+      headers["Content-Disposition"] = "attachment; filename=\"#{params[:table_name].to_s.gsub(/[^\w-]/, '')}_#{Time.current.strftime('%Y%m%d_%H%M%S')}.csv\""
+      headers["Last-Modified"] = Time.current.httpdate
+      headers["Cache-Control"] = "no-cache"
+      headers["X-Accel-Buffering"] = "no" # Disable buffering for nginx
+      headers["X-Content-Type-Options"] = "nosniff"
+
+      # Stream CSV response
+      self.response_body = Enumerator.new do |y|
+        # Write header row
+        header_row = visible_columns.map { |col| col[:label] }
+        y << CSV.generate_line(header_row)
+
+        # Write data rows using find_each for memory efficiency
+        # Batched with OFFSET so the requested ORDER BY is kept (find_each ignores it)
+        offset = 0
+        loop do
+          batch = @query.limit(EXPORT_BATCH_SIZE).offset(offset).to_a
+          batch.each do |record|
+            row = visible_columns.map { |column| csv_safe(raw_cell_value(record, column)) }
+            y << CSV.generate_line(row)
+          end
+          break if batch.size < EXPORT_BATCH_SIZE
+          offset += EXPORT_BATCH_SIZE
+        end
+      end
+    end
+
+    private
+
+    def load_table_class
+      @table_class = Infotable::TableResolver.resolve(params[:table_name])
+    rescue Infotable::TableResolver::NotFound => e
+      render plain: e.message, status: :not_found
+    end
+
+    def authorize_table
+      head :forbidden unless @table_class.authorized?(self)
+    end
+
+    def set_params
+      @page = params[:page].to_s.to_i.clamp(1, MAX_PAGE)
+      @per_page = sanitize_per_page(scalar_param(:per_page))
+      @sorts = parse_sorts
+      @sort_column = @sorts.first&.first
+      @sort_direction = @sorts.first ? @sorts.first.last : normalize_sort_direction(scalar_param(:sort_direction))
+      @filters = params[:filters].respond_to?(:to_unsafe_h) ? params[:filters] : {}
+      @search = scalar_param(:search).to_s.strip.presence
+      @infinite_scroll_enabled = @table_class.infinite_scroll_enabled?
+    end
+
+    def process_table_request
+      @query = build_query
+
+      # Apply pagination
+      @pagy, @records = paginate(@page)
+    rescue Pagy::RangeError # page past the end: show the first page
+      @pagy, @records = paginate(1)
+    end
+
+    def paginate(page)
+      if @table_class.countless?
+        pagy(:countless, @query, limit: @per_page, page: page, raise_range_error: true)
+      else
+        pagy(:offset, @query, limit: @per_page, page: page, raise_range_error: true)
+      end
+    end
+
+    # Base query + filters + sorting, shared by show/data and export
+    def build_query
+      query = @table_class.base_query(self)
+
+      if @filters.present?
+        query = Infotable::FilterProcessor.new(query, @table_class, @filters).apply
+      end
+
+      if @search
+        query = Infotable::SearchProcessor.new(query, @table_class, @search).apply
+      end
+
+      query = apply_sorting(query)
+      @table_class.preloads.any? ? query.preload(*@table_class.preloads) : query
+    end
+
+    def apply_sorting(query)
+      sorts = @sorts.presence || default_sorts
+      return query if sorts.empty?
+
+      query = sorts.reduce(query) do |relation, (column, direction)|
+        relation.order(Arel.sql("#{get_sort_expression(column, relation)} #{direction}"))
+      end
+      add_sort_tiebreaker(query, sorts.map(&:first))
+    end
+
+    def default_sorts
+      column = @table_class.sort_settings[:column]
+      return [] unless column
+
+      [ [ column.to_s, normalize_sort_direction(@table_class.sort_settings[:direction]) ] ]
+    end
+
+    MAX_SORTS = 3
+
+    # Multi-column: sort=name:asc,age:desc (shift-click in the UI). Falls back to the
+    # single sort_column / sort_direction pair. Unknown or non-sortable columns are dropped.
+    def parse_sorts
+      pairs =
+        if (multi = scalar_param(:sort)).present?
+          multi.split(",").first(MAX_SORTS).map { |item| item.split(":", 2) }
+        elsif (single = scalar_param(:sort_column)).present?
+          [ [ single, scalar_param(:sort_direction) ] ]
+        else
+          []
+        end
+
+      pairs.filter_map do |name, direction|
+        [ name.to_s, normalize_sort_direction(direction) ] if column_sortable?(name)
+      end.uniq(&:first)
+    end
+
+    # Equal sort keys have no defined order in PostgreSQL, so rows can repeat or vanish
+    # between pages. Order by the primary key last to make pagination stable.
+    def add_sort_tiebreaker(query, sort_columns)
+      model = query.model
+      pk = model.primary_key
+      return query if pk.blank? || sort_columns.map(&:to_s).include?(pk) || query.distinct_value
+
+      query.order(Arel.sql("#{model.table_name}.#{pk} ASC"))
+    end
+
+    MAX_PER_PAGE = 500
+    MAX_PAGE = 1_000_000
+
+    # Query params are user input: arrays/hashes ("sort_column[]=x") are treated as absent
+    def scalar_param(key)
+      value = params[key]
+      value.is_a?(String) ? value : nil
+    end
+    EXPORT_BATCH_SIZE = 1000
+
+    def sanitize_per_page(value)
+      default = @table_class.pagination_settings[:per_page]
+      requested = value.to_i
+      requested.positive? ? [ requested, MAX_PER_PAGE ].min : default
+    end
+
+    # Guard against spreadsheet formula injection
+    def csv_safe(value)
+      value.is_a?(String) && value.match?(/\A[=+\-@\t\r]/) ? "'#{value}" : value
+    end
+
+    def render_table_frame
+      respond_to do |format|
+        format.html { render "infotable/tables/show" }
+        format.turbo_stream {
+          # For turbo-stream requests, render the show template
+          # Turbo will extract the frame content
+          render "infotable/tables/show"
+        }
+      end
+    end
+
+    # Normalize sort direction to always be a string ('asc' or 'desc')
+    def normalize_sort_direction(direction)
+      direction = direction.to_s.downcase
+      %w[asc desc].include?(direction) ? direction : "asc"
+    end
+
+    # Check if column is sortable
+    def column_sortable?(column_name)
+      @table_class.sortable_columns.any? { |col| col[:name].to_s == column_name.to_s }
+    end
+
+    # Sanitize column name to prevent SQL injection
+    def sanitize_column_name(column_name)
+      # Only allow alphanumeric characters, underscores, and dots (for associations)
+      column_name.to_s.gsub(/[^a-zA-Z0-9_.]/, "")
+    end
+
+    # Get the SQL expression for sorting a column
+    # For virtual columns, use virtual_sql if provided, otherwise use qualified column name
+    def get_sort_expression(column_name, query)
+      column = @table_class.columns.find { |col| col[:name].to_s == column_name.to_s }
+
+      if column && column[:sort_sql].present?
+        column[:sort_sql]
+      elsif column && column[:sql].present?
+        column[:sql]
+      elsif column && column[:virtual] && column[:virtual_sql].present?
+        # Virtual column with SQL expression - use it directly
+        column[:virtual_sql]
+      else
+        # Regular column - qualify with table name to avoid ambiguous column errors
+        table_name = query.model.table_name
+        sanitized_column = sanitize_column_name(column_name)
+        "#{table_name}.#{sanitized_column}"
+      end
+    end
+
+    # Extract raw cell value for CSV export (without formatting)
+    def raw_cell_value(record, column)
+      value = @table_class.cell_value(record, column)
+
+      # Return nil placeholder if value is nil
+      if value.nil?
+        return @table_class.nil_value_placeholder
+      end
+
+      # Return empty placeholder if value is empty string
+      if value.is_a?(String) && value.empty?
+        return @table_class.empty_value_placeholder
+      end
+
+      # Return raw value without formatting
+      case column[:type]
+      when :datetime, :date
+        value.iso8601
+      when :boolean
+        value ? "true" : "false"
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/app/helpers/infotable/application_helper.rb

@@ -0,0 +1,5 @@
+module Infotable
+  module ApplicationHelper
+    include Infotable::TablesHelper
+  end
+end

data/app/helpers/infotable/tables_helper.rb

@@ -0,0 +1,354 @@
+module Infotable
+  module TablesHelper
+    # Main helper method to render an infotable
+    # Usage: <%= infotable :users_table %>
+    def infotable(table_name, **options, &block)
+      table_class = resolve_table_class(table_name)
+
+      # Merge options with defaults
+      config = build_table_config(table_class, options)
+
+      # Allow block configuration
+      if block_given?
+        yield config if block.arity > 0
+      end
+
+      # Build locals for partial
+      locals = {
+        table_name: table_name,
+        table_class: table_class,
+        config: config
+      }
+
+      # Only pass title/subtitle if explicitly provided
+      locals[:title] = options[:title] if options.key?(:title)
+      locals[:subtitle] = options[:subtitle] if options.key?(:subtitle)
+
+      # Render the table frame
+      render partial: "infotable/tables/table", locals: locals
+    end
+
+    # Format cell value based on column definition
+    def format_cell_value(record, column, table_class = nil)
+      value = (table_class || Infotable::Base).cell_value(record, column)
+
+      # If formatter is provided, use it (formatters handle nil values themselves)
+      if column[:formatter]
+        if column[:formatter].is_a?(Proc)
+          # Execute formatter proc with value and record
+          return instance_exec(value, record, &column[:formatter])
+        elsif column[:formatter].is_a?(Symbol)
+          # Use named formatter
+          return placeholder_for(value, column, table_class) ||
+                 format_with_named_formatter(value, record, column)
+        elsif column[:formatter].is_a?(Hash)
+          # Formatter with options: { type: :badge, options: {...} }
+          formatter_type = column[:formatter][:type]
+          formatter_options = column[:formatter][:options] || {}
+          return format_with_named_formatter(value, record, column.merge(formatter: formatter_type, formatter_options: formatter_options))
+        end
+      end
+
+      # Return nil placeholder for nil values (except for types that handle nil specially)
+      if value.nil? && table_class && ![ :boolean, :action ].include?(column[:type])
+        return table_class.nil_value_placeholder
+      end
+
+      # Return empty placeholder for empty strings (except for types that handle empty specially)
+      if value.is_a?(String) && value.empty? && table_class && ![ :boolean, :action ].include?(column[:type])
+        return table_class.empty_value_placeholder
+      end
+
+      # Default formatting based on type
+      case column[:type]
+      when :datetime
+        format_datetime(value)
+      when :date
+        format_date(value)
+      when :boolean
+        format_boolean(value, column)
+      when :currency
+        format_currency(value, column)
+      when :badge
+        format_badge(value, column)
+      when :action
+        format_actions(value, record, column)
+      else
+        value.to_s
+      end
+    end
+
+    # Build export params with current filters, sort, and visible columns
+    def build_export_params(table_name, table_class)
+      params_hash = {
+        table_name: table_name,
+        sort_column: scalar_request_param(:sort_column),
+        sort_direction: scalar_request_param(:sort_direction),
+        sort: scalar_request_param(:sort)
+      }
+
+      # Add filters if present
+      if params[:filters].present?
+        params_hash[:filters] = params[:filters]
+      end
+
+      # Get visible columns from localStorage via JavaScript or use defaults
+      # For now, we'll pass all visible columns and let the controller handle it
+      # The JavaScript will need to update the link dynamically
+      visible_column_names = table_class.visible_columns.map { |c| c[:name].to_s }
+      params_hash[:visible_columns] = visible_column_names.join(",")
+
+      params_hash.compact
+    end
+
+    private
+
+    def resolve_table_class(table_name)
+      Infotable::TableResolver.resolve(table_name)
+    end
+
+    def build_table_config(table_class, options)
+      ActiveSupport::OrderedOptions.new.merge!({
+        per_page: options[:per_page] || table_class.pagination_settings[:per_page],
+        per_page_options: options[:per_page_options] || table_class.pagination_settings[:per_page_options],
+        drawer_position: options[:drawer_position] || Infotable.configuration.drawer_position,
+        drawer_width: options[:drawer_width] || Infotable.configuration.drawer_width,
+        theme: options[:theme] || Infotable.configuration.theme,
+        autofilter: options.fetch(:autofilter, Infotable.configuration.autofilter)
+      })
+    end
+
+    # nil / "" placeholders for named formatters, which would otherwise each
+    # render their own idea of "nothing" (BooleanFormatter and ActionFormatter handle it themselves)
+    def placeholder_for(value, column, table_class)
+      return unless table_class
+      return if %i[boolean action actions avatar].include?(column[:type]) || %i[boolean action actions avatar].include?(column[:formatter])
+
+      return table_class.nil_value_placeholder if value.nil?
+      table_class.empty_value_placeholder if value.is_a?(String) && value.empty?
+    end
+
+    def format_with_named_formatter(value, record, column)
+      formatter_name = column[:formatter]
+      formatter_options = column[:formatter_options] || {}
+
+      formatter_class = case formatter_name
+      when :date, :datetime
+        Infotable::Formatters::DateFormatter
+      when :currency
+        Infotable::Formatters::CurrencyFormatter
+      when :boolean
+        Infotable::Formatters::BooleanFormatter
+      when :badge, :status
+        Infotable::Formatters::BadgeFormatter
+      when :action, :actions
+        Infotable::Formatters::ActionFormatter
+      when :link
+        Infotable::Formatters::LinkFormatter
+      when :avatar
+        Infotable::Formatters::AvatarFormatter
+      when :percent
+        Infotable::Formatters::PercentFormatter
+      else
+        # Custom formatter: :avatar => AvatarFormatter (or Namespaced::AvatarFormatter)
+        "#{formatter_name.to_s.camelize}Formatter".safe_constantize ||
+          raise(Infotable::Error, "Unknown formatter :#{formatter_name} for column :#{column[:name]}. " \
+                                  "Built-ins: date, currency, boolean, badge, action, link, avatar, percent; custom: define #{formatter_name.to_s.camelize}Formatter.")
+      end
+
+      formatter_class.new(self).format(value, record, formatter_options)
+    end
+
+    # Default formatters for types
+    def format_datetime(value)
+      return "" if value.blank?
+      formatter = Infotable::Formatters::DateFormatter.new(self)
+      formatter.format(value, nil, format: :datetime)
+    end
+
+    def format_date(value)
+      return "" if value.blank?
+      formatter = Infotable::Formatters::DateFormatter.new(self)
+      formatter.format(value, nil, format: :short)
+    end
+
+    def format_boolean(value, column)
+      formatter = Infotable::Formatters::BooleanFormatter.new(self)
+      formatter.format(value, nil, column[:formatter_options] || {})
+    end
+
+    def format_currency(value, column)
+      return "" if value.blank?
+      formatter = Infotable::Formatters::CurrencyFormatter.new(self)
+      formatter.format(value, nil, column[:formatter_options] || {})
+    end
+
+    def format_badge(value, column)
+      return "" if value.blank?
+      formatter = Infotable::Formatters::BadgeFormatter.new(self)
+      formatter.format(value, nil, column[:formatter_options] || {})
+    end
+
+    def format_actions(value, record, column)
+      formatter = Infotable::Formatters::ActionFormatter.new(self)
+      formatter.format(value, record, column[:formatter_options] || column[:actions] || {})
+    end
+
+    # Route helpers for engine routes
+    def infotable_table_path(options = {})
+      Infotable::Engine.routes.url_helpers.table_path(options)
+    end
+
+    def infotable_table_data_path(options = {})
+      Infotable::Engine.routes.url_helpers.table_data_path(options)
+    end
+
+    def infotable_table_export_path(options = {})
+      Infotable::Engine.routes.url_helpers.table_export_path(options)
+    end
+
+    INITIAL_STATE_KEYS = %w[search sort sort_column sort_direction page per_page filters].freeze
+
+    # Table state carried by the host page's own URL as `?users_table[search]=x&users_table[page]=2`
+    # (written by the table controller). Only known keys and plain values survive; the data
+    # endpoint validates them again when the frame loads.
+    def infotable_initial_state(table_name)
+      raw = params[table_name.to_s]
+      return {} unless raw.respond_to?(:to_unsafe_h)
+
+      raw.to_unsafe_h.slice(*INITIAL_STATE_KEYS).each_with_object({}) do |(key, value), state|
+        clean = sanitize_state_value(value)
+        state[key.to_sym] = clean unless clean.nil? || clean == ""
+      end
+    end
+
+    # Helper to build table URL params while preserving current state
+    # This ensures sorting, pagination, and other state is maintained across interactions
+    def table_url_params(new_params = {})
+      base_params = {
+        table_name: params[:table_name],
+        sort_column: scalar_request_param(:sort_column),
+        sort_direction: scalar_request_param(:sort_direction),
+        sort: scalar_request_param(:sort),
+        page: scalar_request_param(:page),
+        per_page: scalar_request_param(:per_page)
+      }
+      base_params[:search] = params[:search] if params[:search].is_a?(String) && params[:search].present?
+      base_params[:filters] = params[:filters].to_unsafe_h if params[:filters].respond_to?(:to_unsafe_h) && params[:filters].present?
+
+      base_params.compact.merge(new_params)
+    end
+
+    def sanitize_state_value(value, depth = 0)
+      case value
+      when String then value.delete("\u0000")[0, 500]
+      when Array then depth < 3 ? value.first(50).filter_map { sanitize_state_value(_1, depth + 1) }.select { _1.is_a?(String) } : nil
+      when Hash then depth < 3 ? value.first(50).to_h { |k, v| [ k.to_s[0, 100], sanitize_state_value(v, depth + 1) ] }.compact : nil
+      end
+    end
+
+    DRAWER_WIDTH_FORMAT = /\A\d+(\.\d+)?(px|rem|em|vw|%)\z/
+    DEFAULT_DRAWER_WIDTH = "26rem".freeze
+
+    # HTML attributes for the slide-in drawer (side and width from config)
+    def infotable_drawer_attributes(config)
+      side = config.drawer_position.to_s == "left" ? "left" : "right"
+      width = config.drawer_width.to_s.match?(DRAWER_WIDTH_FORMAT) ? config.drawer_width.to_s : DEFAULT_DRAWER_WIDTH
+      hidden = side == "left" ? "-100%" : "100%"
+
+      {
+        style: "#{side}: 0; width: #{width}; max-width: 90%; transform: translateX(#{hidden});",
+        class: "absolute top-0 bottom-0 bg-white #{side == 'left' ? 'border-r rounded-l-xl' : 'border-l rounded-r-xl'} border-indigo-200 shadow-2xl transition-all duration-300 ease-in-out z-50",
+        role: "dialog",
+        inert: true, # closed drawer is off-screen: keep it out of the tab order (JS toggles it)
+        aria: { label: I18n.t("infotable.drawer.label"), hidden: true },
+        data: { infotable__drawer_target: "drawer", drawer_side: side }
+      }
+    end
+
+    BATCH_BUTTON_COLORS = {
+      default: "border-gray-300 bg-white text-gray-700 hover:bg-gray-50",
+      primary: "border-indigo-600 bg-indigo-600 text-white hover:bg-indigo-700",
+      success: "border-green-600 bg-green-600 text-white hover:bg-green-700",
+      warning: "border-yellow-500 bg-yellow-500 text-white hover:bg-yellow-600",
+      danger: "border-red-600 bg-red-600 text-white hover:bg-red-700"
+    }.freeze
+
+    def infotable_batch_button_classes(color)
+      "inline-flex items-center px-3 py-1.5 border text-sm font-medium rounded-lg transition-colors #{BATCH_BUTTON_COLORS.fetch(color, BATCH_BUTTON_COLORS[:default])}"
+    end
+
+    # Query params are user input: only plain strings are echoed back into links
+    def scalar_request_param(key)
+      value = params[key]
+      value.is_a?(String) ? value : nil
+    end
+
+    # [[column, direction], ...] currently applied, for header indicators
+    def current_sorts
+      @sorts || []
+    end
+
+    # Page numbers to link to: first, last and two either side of the current page.
+    # (Pagy's #series is protected since Pagy 43, and gaps were never rendered anyway.)
+    def infotable_page_window(pagy, around: 2)
+      last = pagy.last.to_i
+      ([ 1, last ] + ((pagy.page - around)..(pagy.page + around)).to_a).select { |n| n.between?(1, last) }.uniq.sort
+    end
+
+    # DOM id for a filter control, scoped by table so two tables on one page
+    # with the same column names do not collide (labels, getElementById).
+    def infotable_filter_id(table_name, column, suffix)
+      "filter_#{table_name}_#{column[:name]}_#{suffix}"
+    end
+
+    # [options, total] for a select filter. The Proc runs in the view (so it can use helpers),
+    # the result is cut to the column's `filter_options_limit` (default
+    # Infotable.configuration.max_filter_options) and, with `filter_options_cache: 5.minutes`,
+    # cached per table and column. Do not cache options that depend on the current user.
+    def infotable_filter_options(table_class, column)
+      source = column[:filter_options]
+      options = if source.is_a?(Proc)
+        ttl = column[:filter_options_cache]
+        if ttl
+          key = [ "infotable", "filter_options", table_class&.name || table_class.object_id, column[:name].to_s ]
+          Rails.cache.fetch(key, expires_in: ttl) { instance_exec(&source).to_a }
+        else
+          instance_exec(&source).to_a
+        end
+      else
+        source.to_a
+      end
+
+      limit = column[:filter_options_limit] || Infotable.configuration.max_filter_options
+      [ limit ? options.first(limit) : options, options.size ]
+    end
+
+    # Per-page choices for the selector: the table's own options plus the current limit
+    def per_page_choices(table_class, current)
+      (table_class.pagination_settings[:per_page_options].to_a + [ current ]).compact.map(&:to_i).uniq.sort
+    end
+
+    # Determine which filter partial to render based on column type and filter_type
+    def filter_type_for_column(column)
+      # Explicit filter_type takes precedence
+      return column[:filter_type].to_s if column[:filter_type]
+
+      # Otherwise infer from column type
+      case column[:type]
+      when :string, :text
+        "text"
+      when :boolean
+        "boolean"
+      when :integer, :float, :decimal, :number
+        "number"
+      when :date, :datetime
+        "date"
+      when :select
+        "select"
+      else
+        "text" # default to text filter
+      end
+    end
+  end
+end

data/app/jobs/infotable/application_job.rb

@@ -0,0 +1,4 @@
+module Infotable
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/infotable/application_mailer.rb

@@ -0,0 +1,6 @@
+module Infotable
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end