infotable 0.1.0

data/lib/infotable/filter_processor.rb

@@ -0,0 +1,326 @@
+module Infotable
+  class FilterProcessor
+    attr_reader :query, :table_class, :filters
+
+    def initialize(query, table_class, filters = {})
+      @query = query
+      @table_class = table_class
+      @filters = normalize_filters(filters)
+      @table_name = query.model.table_name
+    end
+
+    # Apply all filters to the query
+    def apply
+      return query if filters.blank?
+
+      filters.each do |column_name, filter_params|
+        next if filter_params.blank?
+
+        column = find_column(column_name)
+        next unless column && column[:filterable]
+
+        @query = apply_filter(column, filter_params)
+      end
+
+      query
+    end
+
+    private
+
+    # Accept Hash / ActionController::Parameters, drop anything else
+    def normalize_filters(filters)
+      filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
+      filters.is_a?(Hash) ? filters.with_indifferent_access : {}
+    end
+
+    # Scalar-only string value (arrays/hashes from tampered params become nil)
+    def scalar(value)
+      return nil if value.is_a?(Array) || value.is_a?(Hash)
+
+      value.is_a?(String) ? value.delete("\u0000") : value # PostgreSQL rejects NUL bytes
+    end
+
+    # Aggregate (virtual_sql) columns filter with HAVING; row-level :sql columns with WHERE
+    def having?(column)
+      column[:virtual] && column[:sql].blank?
+    end
+
+    def find_column(column_name)
+      table_class.columns.find { |col| col[:name].to_s == column_name.to_s }
+    end
+
+    # Get qualified column reference for SQL queries
+    # Returns either the virtual SQL expression or the qualified table.column format
+    def qualified_column_ref(column)
+      if column[:sql].present?
+        column[:sql]
+      elsif column[:virtual] && column[:virtual_sql].present?
+        column[:virtual_sql]
+      else
+        "#{@table_name}.#{column[:name]}"
+      end
+    end
+
+    def apply_filter(column, filter_params)
+      filter_type = determine_filter_type(column)
+
+      case filter_type
+      when :text
+        apply_text_filter(column, filter_params)
+      when :boolean
+        apply_boolean_filter(column, filter_params)
+      when :number
+        apply_number_filter(column, filter_params)
+      when :date
+        apply_date_filter(column, filter_params)
+      when :select
+        apply_select_filter(column, filter_params)
+      else
+        query
+      end
+    end
+
+    def determine_filter_type(column)
+      # Explicit filter_type
+      return column[:filter_type].to_sym if column[:filter_type]
+
+      # 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
+      end
+    end
+
+    # Text filter with operations
+    def apply_text_filter(column, params)
+      return query unless params.is_a?(Hash)
+
+      op = params[:op] || params["op"] || "contains"
+      value = scalar(params[:value] || params["value"])
+      column_name = column[:name]
+      is_virtual = having?(column)
+      # Use qualified column reference
+      column_ref = qualified_column_ref(column)
+
+      result = query
+
+      # Use having() for virtual columns, where() for regular columns
+      filter_method = is_virtual ? :having : :where
+
+      case op
+      when "contains"
+        result = result.public_send(filter_method, "#{column_ref} ILIKE ?", "%#{sanitize_like(value)}%") if value.present?
+      when "exact"
+        if is_virtual
+          result = result.having("LOWER(#{column_ref}) = LOWER(?)", value) if value.present?
+        else
+          result = result.where("LOWER(#{column_ref}) = LOWER(?)", value) if value.present?
+        end
+      when "not_contain"
+        result = result.public_send(filter_method, "NOT #{column_ref} ILIKE ?", "%#{sanitize_like(value)}%") if value.present?
+      when "starts_with"
+        result = result.public_send(filter_method, "#{column_ref} ILIKE ?", "#{sanitize_like(value)}%") if value.present?
+      when "ends_with"
+        result = result.public_send(filter_method, "#{column_ref} ILIKE ?", "%#{sanitize_like(value)}") if value.present?
+      when "is_empty"
+        result = result.public_send(filter_method, "#{column_ref} IS NULL OR #{column_ref} = ''")
+      when "is_not_empty"
+        if is_virtual
+          result = result.having("#{column_ref} IS NOT NULL AND #{column_ref} != ''")
+        else
+          result = result.where.not("#{column_ref} IS NULL OR #{column_ref} = ''")
+        end
+      end
+
+      result
+    end
+
+    # Boolean filter
+    def apply_boolean_filter(column, params)
+      return query unless params.is_a?(Hash)
+
+      value = scalar(params[:value] || params["value"])
+      column_name = column[:name]
+      is_virtual = having?(column)
+      # Use qualified column reference
+      column_ref = qualified_column_ref(column)
+
+      result = query
+
+      # Use having() for virtual columns, where() for regular columns
+      filter_method = is_virtual ? :having : :where
+
+      case value.to_s
+      when "true"
+        if is_virtual
+          result = result.having("#{column_ref} = ?", true)
+        else
+          result = result.where("#{column_ref} = ?", true)
+        end
+      when "false"
+        if is_virtual
+          result = result.having("#{column_ref} = ?", false)
+        else
+          result = result.where("#{column_ref} = ?", false)
+        end
+      when "is_empty"
+        if is_virtual
+          result = result.having("#{column_ref} IS NULL")
+        else
+          result = result.where("#{column_ref} IS NULL")
+        end
+      when "is_not_empty"
+        if is_virtual
+          result = result.having("#{column_ref} IS NOT NULL")
+        else
+          result = result.where.not("#{column_ref} IS NULL")
+        end
+      end
+
+      result
+    end
+
+    NUMBER_OPERATORS = { "eq" => "=", "neq" => "<>", "gt" => ">", "gte" => ">=", "lt" => "<", "lte" => "<=" }.freeze
+
+    # Number filter. Without :op it is a range (from/to, either may be blank).
+    # With :op (eq neq gt gte lt lte between is_empty is_not_empty) it compares :value.
+    def apply_number_filter(column, params)
+      return query unless params.is_a?(Hash)
+
+      column_ref = qualified_column_ref(column)
+      filter_method = having?(column) ? :having : :where
+      op = (params[:op] || params["op"]).to_s
+
+      case op
+      when "is_empty"     then return query.public_send(filter_method, "#{column_ref} IS NULL")
+      when "is_not_empty" then return query.public_send(filter_method, "#{column_ref} IS NOT NULL")
+      when *NUMBER_OPERATORS.keys
+        value = numeric(scalar(params[:value] || params["value"]))
+        return value.nil? ? query : query.public_send(filter_method, "#{column_ref} #{NUMBER_OPERATORS[op]} CAST(? AS numeric)", value)
+      end
+
+      from = numeric(scalar(params[:from] || params["from"]))
+      to = numeric(scalar(params[:to] || params["to"]))
+      result = query
+      # CAST: a decimal bound against an integer column is otherwise rejected by PostgreSQL
+      result = result.public_send(filter_method, "#{column_ref} >= CAST(? AS numeric)", from) if from
+      result = result.public_send(filter_method, "#{column_ref} <= CAST(? AS numeric)", to) if to
+      result
+    end
+
+    # Date filter. Without :op it is a range (from/to). With :op (on before after between
+    # is_empty is_not_empty) it compares :value; `on` matches the whole day.
+    def apply_date_filter(column, params)
+      return query unless params.is_a?(Hash)
+
+      column_ref = qualified_column_ref(column)
+      filter_method = having?(column) ? :having : :where
+      datetime = column[:type] == :datetime
+      op = (params[:op] || params["op"]).to_s
+
+      case op
+      when "is_empty"     then return query.public_send(filter_method, "#{column_ref} IS NULL")
+      when "is_not_empty" then return query.public_send(filter_method, "#{column_ref} IS NOT NULL")
+      when "on", "before", "after"
+        day = parse_date(scalar(params[:value] || params["value"]))
+        return query unless day
+
+        return case op
+               when "on"     then query.public_send(filter_method, "#{column_ref} >= ? AND #{column_ref} <= ?", datetime ? day.beginning_of_day : day, datetime ? day.end_of_day : day)
+               when "before" then query.public_send(filter_method, "#{column_ref} < ?", datetime ? day.beginning_of_day : day)
+               else               query.public_send(filter_method, "#{column_ref} > ?", datetime ? day.end_of_day : day)
+               end
+      end
+
+      from = parse_date(scalar(params[:from] || params["from"]))
+      to = parse_date(scalar(params[:to] || params["to"]))
+      to = to.end_of_day if to && datetime
+
+      result = query
+      result = result.public_send(filter_method, "#{column_ref} >= ?", from) if from
+      result = result.public_send(filter_method, "#{column_ref} <= ?", to) if to
+      result
+    end
+
+    # Select filter: one value (params[:value]) or several (array, or params[:value] as array).
+    # Values are cast to the column type; values the type cannot hold never match.
+    def apply_select_filter(column, params)
+      raw = params.is_a?(Hash) ? (params[:value] || params["value"]) : params
+      values = Array(raw).flatten.reject { |v| v.is_a?(Hash) || v.blank? }.map { |v| v.to_s.delete("\u0000") }.reject(&:blank?)
+      return query if values.empty?
+
+      typed = values.map { |v| cast_select_value(column, v) }.reject(&:nil?)
+      return query.none if typed.empty?
+
+      ref = qualified_column_ref(column)
+      # Custom SQL of unknown type (declared :string but e.g. comments.author_id): compare as text
+      ref = "CAST(#{ref} AS text)" if (column[:sql].present? || column[:virtual]) && DECLARED_TYPES[column[:type]].nil?
+
+      query.public_send(having?(column) ? :having : :where, "#{ref} IN (?)", typed)
+    end
+
+    INTEGER_RANGE = (-(2**63)..(2**63 - 1))
+
+    def cast_select_value(column, value)
+      case select_column_type(column)
+      when :integer, :bigint
+        Integer(value, 10, exception: false)&.then { |n| n if INTEGER_RANGE.cover?(n) }
+      when :decimal, :float
+        numeric(value)
+      when :boolean
+        { "true" => true, "false" => false, "1" => true, "0" => false }[value.downcase]
+      when :date, :datetime
+        parse_date(value)
+      else
+        value
+      end
+    end
+
+    DECLARED_TYPES = { integer: :integer, number: :decimal, decimal: :decimal, float: :decimal, currency: :decimal,
+                       boolean: :boolean, date: :date, datetime: :datetime }.freeze
+
+    # Attribute type of the model column; for custom SQL / aggregate columns the type declared in the DSL
+    def select_column_type(column)
+      unless column[:sql].present? || column[:virtual]
+        db_type = query.model.columns_hash[column[:name].to_s]&.type
+        return db_type if db_type
+      end
+
+      DECLARED_TYPES[column[:type]]
+    end
+
+    # Helper to sanitize LIKE values
+    def sanitize_like(value)
+      return "" if value.blank?
+      value.to_s.gsub(/[%_]/, '\\\\\&')
+    end
+
+    def numeric(value)
+      number = BigDecimal(value.to_s)
+      return nil unless number.finite?
+
+      number.frac.zero? ? number.to_i : number
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    # Helper to parse date strings
+    def parse_date(date_string)
+      return nil if date_string.blank?
+
+      Date.parse(date_string.to_s)
+    rescue ArgumentError, RangeError
+      nil
+    end
+  end
+end

data/lib/infotable/formatters/action_formatter.rb

@@ -0,0 +1,141 @@
+module Infotable
+  module Formatters
+    class ActionFormatter < BaseFormatter
+      def format(value, record, options = {})
+        actions = options[:actions] || []
+        style = options[:style] || :buttons # :buttons, :links, :dropdown
+
+        case style
+        when :buttons
+          render_buttons(actions, record)
+        when :dropdown
+          render_dropdown(actions, record)
+        else
+          render_links(actions, record)
+        end
+      end
+
+      private
+
+      def render_buttons(actions, record)
+        buttons = actions.map do |action|
+          render_button(action, record)
+        end
+
+        safe_join(buttons, " ")
+      end
+
+      def render_links(actions, record)
+        links = actions.map do |action|
+          render_link(action, record)
+        end
+
+        safe_join(links, " • ")
+      end
+
+      def render_button(action, record)
+        url = resolve_url(action[:url], record)
+        method = action[:method] || :get
+        data = action[:data] || {}
+
+        link_to(
+          button_content(action),
+          url,
+          class: button_classes(action[:color]),
+          data: link_data(data, method, action[:confirm])
+        )
+      end
+
+      def render_link(action, record)
+        url = resolve_url(action[:url], record)
+        method = action[:method] || :get
+        data = action[:data] || {}
+
+        link_to(
+          action[:label] || action[:icon] || view_context.t("infotable.formatters.action"),
+          url,
+          class: link_classes(action[:color]),
+          data: link_data(data, method, action[:confirm])
+        )
+      end
+
+      # Turbo-compatible: non-GET verbs use data-turbo-method, confirm uses data-turbo-confirm
+      def link_data(data, method, confirm)
+        data = data.dup
+        data[:turbo_method] = method unless method.to_sym == :get
+        data[:turbo_confirm] = confirm if confirm
+        data
+      end
+
+      def render_menu_item(action, record)
+        link_to(
+          action[:label] || action[:icon] || view_context.t("infotable.formatters.action"),
+          resolve_url(action[:url], record),
+          role: "menuitem",
+          class: "block px-3 py-1.5 text-sm whitespace-nowrap #{link_classes(action[:color])} hover:bg-gray-50",
+          data: link_data(action[:data] || {}, action[:method] || :get, action[:confirm])
+        )
+      end
+
+      def render_dropdown(actions, record)
+        # <details> gives open/close and keyboard support without JS
+        content_tag(:details, class: "relative inline-block text-left") do
+          summary = content_tag(:summary, "\u22EF".html_safe,
+            class: "list-none cursor-pointer inline-flex items-center px-2 py-1 rounded-md border border-gray-300 bg-white text-gray-600 hover:bg-gray-50",
+            "aria-label": view_context.t("infotable.formatters.action"), "aria-haspopup": "menu")
+          menu = content_tag(:div, role: "menu",
+            class: "absolute right-0 z-30 mt-1 min-w-36 rounded-md border border-gray-200 bg-white py-1 shadow-lg") do
+            safe_join(actions.map { |action| render_menu_item(action, record) })
+          end
+          summary + menu
+        end
+      end
+
+      def button_content(action)
+        if action[:icon]
+          safe_join([ html_safe(action[:icon]), (action[:label] ? " #{action[:label]}" : nil) ].compact)
+        else
+          action[:label] || view_context.t("infotable.formatters.action")
+        end
+      end
+
+      def button_classes(color = nil)
+        base = "inline-flex items-center px-2 py-1 border text-xs font-medium rounded-md transition-colors"
+
+        color_classes = case color&.to_s
+        when "primary"
+          "border-indigo-600 bg-indigo-600 text-white hover:bg-indigo-700"
+        when "danger"
+          "border-red-600 bg-red-600 text-white hover:bg-red-700"
+        when "success"
+          "border-green-600 bg-green-600 text-white hover:bg-green-700"
+        else
+          "border-gray-300 bg-white text-gray-700 hover:bg-gray-50"
+        end
+
+        "#{base} #{color_classes}"
+      end
+
+      def link_classes(color = nil)
+        case color&.to_s
+        when "danger"
+          "text-red-600 hover:text-red-900"
+        when "success"
+          "text-green-600 hover:text-green-900"
+        else
+          "text-indigo-600 hover:text-indigo-900"
+        end
+      end
+
+      def resolve_url(url, record)
+        if url.is_a?(Proc)
+          view_context.instance_exec(record, &url)
+        elsif url.is_a?(Symbol)
+          view_context.send(url, record)
+        else
+          url
+        end
+      end
+    end
+  end
+end

data/lib/infotable/formatters/avatar_formatter.rb

@@ -0,0 +1,49 @@
+module Infotable
+  module Formatters
+    # formatter: :avatar
+    # The cell value is the image URL. With no image, initials of `name` are shown on a coloured disc.
+    #   formatter_options: {
+    #     name: ->(record) { record.name },   # shown next to the picture and used for initials / alt text
+    #     size: :md,                          # :sm, :md, :lg
+    #     label: false                        # true (default when name is given) shows the name beside the picture
+    #   }
+    class AvatarFormatter < BaseFormatter
+      SIZES = { sm: "h-6 w-6 text-xs", md: "h-8 w-8 text-sm", lg: "h-10 w-10 text-base" }.freeze
+      COLORS = [
+        "bg-indigo-100 text-indigo-700", "bg-green-100 text-green-700", "bg-yellow-100 text-yellow-700",
+        "bg-pink-100 text-pink-700", "bg-blue-100 text-blue-700", "bg-purple-100 text-purple-700"
+      ].freeze
+
+      def format(value, record, options = {})
+        name = resolve(options[:name], record)
+        return "" if value.blank? && name.blank?
+
+        size = SIZES.fetch((options[:size] || :md).to_sym, SIZES[:md])
+        picture = image?(value) ? image(value, name, size) : initials(name, size)
+        return picture if name.blank? || options[:label] == false
+
+        content_tag(:div, safe_join([ picture, content_tag(:span, name.to_s, class: "truncate") ]), class: "flex items-center gap-2")
+      end
+
+      private
+
+      def image?(value)
+        Infotable::Formatters::LinkFormatter.safe_url?(value) && value.to_s.match?(%r{\A(https?:)?//|\A/})
+      end
+
+      def image(url, name, size)
+        tag.img(src: url.to_s, alt: name.to_s, loading: "lazy", class: "#{size.split.first(2).join(' ')} rounded-full object-cover flex-none")
+      end
+
+      def initials(name, size)
+        letters = name.to_s.split.first(2).map { _1[0] }.join.upcase.presence || "?"
+        color = COLORS[name.to_s.sum % COLORS.size]
+        content_tag(:span, letters, class: "inline-flex items-center justify-center rounded-full font-medium flex-none #{size} #{color}", "aria-hidden": "true")
+      end
+
+      def resolve(option, record)
+        option.is_a?(Proc) ? view_context.instance_exec(record, &option) : option
+      end
+    end
+  end
+end

data/lib/infotable/formatters/badge_formatter.rb

@@ -0,0 +1,80 @@
+module Infotable
+  module Formatters
+    class BadgeFormatter < BaseFormatter
+      # Default color mappings
+      DEFAULT_COLORS = {
+        active: "green",
+        inactive: "gray",
+        pending: "yellow",
+        success: "green",
+        warning: "yellow",
+        error: "red",
+        info: "blue",
+        primary: "indigo"
+      }.freeze
+
+      def format(value, record, options = {})
+        return "" if value.blank?
+
+        color = determine_color(value, options)
+        size = options[:size] || :medium
+        display_value = options[:label] || value.to_s.titleize
+
+        render_badge(display_value, color, size)
+      end
+
+      private
+
+      def determine_color(value, options)
+        # Check if custom color mapping provided
+        if options[:colors].is_a?(Hash)
+          return options[:colors][value.to_s.downcase.to_sym] || options[:colors][value.to_s] || "gray"
+        end
+
+        # Use default mapping
+        DEFAULT_COLORS[value.to_s.downcase.to_sym] || "gray"
+      end
+
+      def render_badge(text, color, size)
+        classes = badge_classes(color, size)
+        content_tag(:span, text, class: classes)
+      end
+
+      def badge_classes(color, size)
+        base = "inline-flex items-center rounded-full font-medium"
+
+        size_classes = case size
+        when :small
+          "px-2 py-0.5 text-xs"
+        when :large
+          "px-3 py-1 text-sm"
+        else # medium
+          "px-2.5 py-0.5 text-xs"
+        end
+
+        color_classes = case color.to_s
+        when "green"
+          "bg-green-100 text-green-800"
+        when "red"
+          "bg-red-100 text-red-800"
+        when "yellow"
+          "bg-yellow-100 text-yellow-800"
+        when "blue"
+          "bg-blue-100 text-blue-800"
+        when "indigo"
+          "bg-indigo-100 text-indigo-800"
+        when "purple"
+          "bg-purple-100 text-purple-800"
+        when "pink"
+          "bg-pink-100 text-pink-800"
+        when "cyan"
+          "bg-cyan-100 text-cyan-800"
+        else # gray
+          "bg-gray-100 text-gray-800"
+        end
+
+        "#{base} #{size_classes} #{color_classes}"
+      end
+    end
+  end
+end

data/lib/infotable/formatters/base_formatter.rb

@@ -0,0 +1,47 @@
+module Infotable
+  module Formatters
+    class BaseFormatter
+      attr_reader :view_context
+
+      def initialize(view_context)
+        @view_context = view_context
+      end
+
+      # Override this in subclasses
+      def format(value, record, options = {})
+        value.to_s
+      end
+
+      protected
+
+      # Helper methods available to all formatters
+      def link_to(*args, &block)
+        view_context.link_to(*args, &block)
+      end
+
+      def content_tag(*args, &block)
+        view_context.content_tag(*args, &block)
+      end
+
+      def safe_join(*args)
+        view_context.safe_join(*args)
+      end
+
+      def tag
+        view_context.tag
+      end
+
+      def number_to_currency(*args)
+        view_context.number_to_currency(*args)
+      end
+
+      def number_with_delimiter(*args)
+        view_context.number_with_delimiter(*args)
+      end
+
+      def html_safe(str)
+        str.to_s.html_safe
+      end
+    end
+  end
+end

data/lib/infotable/formatters/boolean_formatter.rb

@@ -0,0 +1,38 @@
+module Infotable
+  module Formatters
+    class BooleanFormatter < BaseFormatter
+      def format(value, record, options = {})
+        true_text = options[:true_text] || view_context.t("infotable.formatters.boolean.true")
+        false_text = options[:false_text] || view_context.t("infotable.formatters.boolean.false")
+        style = options[:style] || :badge # :badge, :text, :icon
+
+        case style
+        when :badge
+          format_as_badge(value, true_text, false_text)
+        when :icon
+          format_as_icon(value)
+        else
+          value ? true_text : false_text
+        end
+      end
+
+      private
+
+      def format_as_badge(value, true_text, false_text)
+        if value
+          content_tag(:span, true_text, class: "inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-800")
+        else
+          content_tag(:span, false_text, class: "inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-gray-100 text-gray-800")
+        end
+      end
+
+      def format_as_icon(value)
+        if value
+          html_safe('<svg class="w-5 h-5 text-green-500" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd"/></svg>')
+        else
+          html_safe('<svg class="w-5 h-5 text-gray-400" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd"/></svg>')
+        end
+      end
+    end
+  end
+end