solid_queue_tui 0.1.1 → 0.1.2

data/lib/solid_queue_tui/views/blocked_view.rb

@@ -3,67 +3,72 @@
 module SolidQueueTui
   module Views
     class BlockedView
+      include Filterable
+
+
+      LOAD_THRESHOLD = 10
+
       def initialize(tui)
         @tui = tui
         @table_state = RatatuiRuby::TableState.new(nil)
         @table_state.select(0)
         @selected_row = 0
         @jobs = []
+        @total_count = nil
+        @all_loaded = false
+        init_filter
       end
 
       def update(jobs:)
         @jobs = jobs
+        @all_loaded = jobs.size < SolidQueueTui.page_size
         @selected_row = @selected_row.clamp(0, [@jobs.size - 1, 0].max)
         @table_state.select(@selected_row)
       end
 
-      def render(frame, area)
-        columns = [
-          { key: :id,              label: "ID",              width: 8 },
-          { key: :queue_name,      label: "QUEUE",            width: 14 },
-          { key: :class_name,      label: "CLASS",            width: :fill },
-          { key: :priority,        label: "PRI",              width: 5 },
-          { key: :concurrency_key, label: "CONCURRENCY KEY",  width: :fill },
-          { key: :expires_at,      label: "EXPIRES AT",       width: 20 },
-          { key: :blocked_since,   label: "BLOCKED SINCE",    width: 14 }
-        ]
+      def append(jobs:)
+        @jobs.concat(jobs)
+        @all_loaded = jobs.size < SolidQueueTui.page_size
+      end
 
-        rows = @jobs.map do |job|
-          {
-            id: job.id,
-            queue_name: job.queue_name,
-            class_name: job.class_name,
-            priority: job.priority,
-            concurrency_key: job.concurrency_key || "n/a",
-            expires_at: format_time(job.expires_at),
-            blocked_since: time_ago(job.created_at)
-          }
-        end
+      def total_count=(count)
+        @total_count = count
+      end
 
-        table = Components::JobTable.new(
-          @tui,
-          title: "Blocked",
-          columns: columns,
-          rows: rows,
-          selected_row: @selected_row,
-          empty_message: "No blocked jobs"
-        )
+      def current_offset
+        @jobs.size
+      end
 
-        table.render(frame, area, @table_state)
+      def reset_pagination!
+        @jobs = []
+        @total_count = nil
+        @all_loaded = false
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      def render(frame, area)
+        if filter_mode?
+          filter_area, content_area = @tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              @tui.constraint_length(3),
+              @tui.constraint_fill(1)
+            ]
+          )
+          render_filter_input(frame, filter_area)
+          render_table(frame, content_area)
+        else
+          render_table(frame, area)
+        end
       end
 
       def handle_input(event)
-        case event
-        in { type: :key, code: "j" } | { type: :key, code: "up" }
-          move_selection(-1)
-        in { type: :key, code: "k" } | { type: :key, code: "down" }
-          move_selection(1)
-        in { type: :key, code: "g" }
-          jump_to_top
-        in { type: :key, code: "G" }
-          jump_to_bottom
+        if filter_mode?
+          handle_filter_input(event)
         else
-          nil
+          handle_normal_input(event)
         end
       end
 
@@ -73,21 +78,59 @@ module SolidQueueTui
       end
 
       def bindings
-        [
-          { key: "j/k", action: "Navigate" },
-          { key: "Enter", action: "Detail" },
-          { key: "G/g", action: "Bottom/Top" }
-        ]
+        if filter_mode?
+          filter_bindings
+        else
+          [
+            { key: "j/k", action: "Navigate" },
+            { key: "Enter", action: "Detail" },
+            { key: "/", action: "Filter" },
+            { key: "G/g", action: "Bottom/Top" }
+          ]
+        end
+      end
+
+      def capturing_input?
+        filter_mode?
       end
 
-      def breadcrumb = "blocked"
+      def breadcrumb
+        @filters.empty? ? "blocked" : "blocked:filtered"
+      end
 
       private
 
+      def needs_more?
+        !@all_loaded && @selected_row >= @jobs.size - LOAD_THRESHOLD
+      end
+
+      def handle_normal_input(event)
+        case event
+        in { type: :key, code: "j" } | { type: :key, code: "up" }
+          move_selection(-1)
+        in { type: :key, code: "k" } | { type: :key, code: "down" }
+          result = move_selection(1)
+          return :load_more if result == :load_more
+          nil
+        in { type: :key, code: "g" }
+          jump_to_top
+        in { type: :key, code: "G" }
+          jump_to_bottom
+        in { type: :key, code: "/" }
+          enter_filter_mode
+          nil
+        in { type: :key, code: "esc" }
+          clear_filter
+        else
+          nil
+        end
+      end
+
       def move_selection(delta)
         return if @jobs.empty?
         @selected_row = (@selected_row + delta).clamp(0, @jobs.size - 1)
         @table_state.select(@selected_row)
+        :load_more if needs_more?
       end
 
       def jump_to_top
@@ -99,6 +142,43 @@ module SolidQueueTui
         return if @jobs.empty?
         @selected_row = @jobs.size - 1
         @table_state.select(@selected_row)
+        return :load_more if needs_more?
+      end
+
+      def render_table(frame, area)
+        columns = [
+          { key: :id,              label: "ID",              width: 8 },
+          { key: :queue_name,      label: "QUEUE",            width: 14 },
+          { key: :class_name,      label: "CLASS",            width: :fill },
+          { key: :priority,        label: "PRI",              width: 5 },
+          { key: :concurrency_key, label: "CONCURRENCY KEY",  width: :fill },
+          { key: :expires_at,      label: "EXPIRES AT",       width: 20 },
+          { key: :blocked_since,   label: "BLOCKED SINCE",    width: 14 }
+        ]
+
+        rows = @jobs.map do |job|
+          {
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
+            concurrency_key: job.concurrency_key || "n/a",
+            expires_at: format_time(job.expires_at),
+            blocked_since: time_ago(job.created_at)
+          }
+        end
+
+        table = Components::JobTable.new(
+          @tui,
+          title: filter_title("Blocked"),
+          columns: columns,
+          rows: rows,
+          selected_row: @selected_row,
+          total_count: @total_count,
+          empty_message: @filters.empty? ? "No blocked jobs" : "No blocked jobs matching filters"
+        )
+
+        table.render(frame, area, @table_state)
       end
 
       def format_time(time)

data/lib/solid_queue_tui/views/concerns/filterable.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    module Filterable
+      FILTER_FIELDS = [
+        { key: :class_name, label: "Class" },
+        { key: :queue, label: "Queue" }
+      ].freeze
+
+      def init_filter
+        @filters = {}
+        @filter_mode = false
+        @filter_inputs = {}
+        @active_field = 0
+      end
+
+      def filters = @filters
+      def filter_mode? = @filter_mode
+
+      def handle_filter_input(event)
+        case event
+        in { type: :key, code: "enter" }
+          @filters = @filter_inputs.reject { |_, v| v.nil? || v.empty? }
+          @filter_mode = false
+          @selected_row = 0
+          @table_state.select(0)
+          :refresh
+        in { type: :key, code: "esc" }
+          @filter_mode = false
+          @filter_inputs = @filters.dup
+          nil
+        in { type: :key, code: "tab" }
+          @active_field = (@active_field + 1) % FILTER_FIELDS.size
+          nil
+        in { type: :key, code: "back_tab" }
+          @active_field = (@active_field - 1) % FILTER_FIELDS.size
+          nil
+        in { type: :key, code: "backspace" }
+          field_key = FILTER_FIELDS[@active_field][:key]
+          current = @filter_inputs[field_key] || ""
+          @filter_inputs[field_key] = current[0...-1]
+          nil
+        in { type: :key, code: /\A.\z/ => char }
+          field_key = FILTER_FIELDS[@active_field][:key]
+          @filter_inputs[field_key] = (@filter_inputs[field_key] || "") + char
+          nil
+        else
+          nil
+        end
+      end
+
+      def enter_filter_mode
+        @filter_mode = true
+        @filter_inputs = @filters.dup
+        @active_field = 0
+      end
+
+      def clear_filter
+        @filters = {}
+        @filter_inputs = {}
+        :refresh
+      end
+
+      def render_filter_input(frame, area)
+        spans = []
+
+        FILTER_FIELDS.each_with_index do |field, idx|
+          active = idx == @active_field
+          value = @filter_inputs[field[:key]] || ""
+
+          spans << @tui.text_span(
+            content: " #{field[:label]}: ",
+            style: @tui.style(fg: active ? :yellow : :dark_gray, modifiers: active ? [:bold] : [])
+          )
+
+          if active
+            spans << @tui.text_span(content: value + "\u2588", style: @tui.style(fg: :white))
+          else
+            spans << @tui.text_span(
+              content: value.empty? ? "\u2014" : value,
+              style: @tui.style(fg: :dark_gray)
+            )
+          end
+
+          spans << @tui.text_span(content: "   ", style: @tui.style(fg: :white))
+        end
+
+        frame.render_widget(
+          @tui.paragraph(
+            text: @tui.text_line(spans: spans),
+            block: @tui.block(
+              title: " Filters ",
+              title_style: @tui.style(fg: :yellow),
+              titles: [
+                { content: " Tab: next field \u2502 Enter: apply \u2502 Esc: cancel ",
+                  position: :top, alignment: :right }
+              ],
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :cyan)
+            )
+          ),
+          area
+        )
+      end
+
+      def filter_title(base_title)
+        return base_title if @filters.empty?
+
+        parts = FILTER_FIELDS.filter_map do |field|
+          value = @filters[field[:key]]
+          "#{field[:label].downcase}: #{value}" if value && !value.empty?
+        end
+
+        "#{base_title} (#{parts.join(', ')})"
+      end
+
+      def filter_bindings
+        [
+          { key: "Tab", action: "Next Field" },
+          { key: "Enter", action: "Apply" },
+          { key: "Esc", action: "Cancel" }
+        ]
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/views/dashboard_view.rb

@@ -36,7 +36,8 @@ module SolidQueueTui
 
       def bindings
         [
-          { key: "Tab", action: "Next View" }
+          { key: "Tab", action: "Next View" },
+          { key: "Shift Tab", action: "Prev View" },
         ]
       end
 

data/lib/solid_queue_tui/views/failed_view.rb

@@ -3,47 +3,74 @@
 module SolidQueueTui
   module Views
     class FailedView
+      include Filterable
+
+
+      LOAD_THRESHOLD = 10
+
       def initialize(tui)
         @tui = tui
         @table_state = RatatuiRuby::TableState.new(nil)
         @table_state.select(0)
         @selected_row = 0
         @failed_jobs = []
-        @filter = nil
-        @filter_mode = false
-        @filter_input = ""
+        @total_count = nil
+        @all_loaded = false
         @confirm_action = nil
+        init_filter
       end
 
       def update(failed_jobs:)
         @failed_jobs = failed_jobs
+        @all_loaded = failed_jobs.size < SolidQueueTui.page_size
         @selected_row = @selected_row.clamp(0, [@failed_jobs.size - 1, 0].max)
         @table_state.select(@selected_row)
       end
 
+      def append(failed_jobs:)
+        @failed_jobs.concat(failed_jobs)
+        @all_loaded = failed_jobs.size < SolidQueueTui.page_size
+      end
+
+      def total_count=(count)
+        @total_count = count
+      end
+
+      def current_offset
+        @failed_jobs.size
+      end
+
+      def reset_pagination!
+        @failed_jobs = []
+        @total_count = nil
+        @all_loaded = false
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
       def render(frame, area)
         if @confirm_action
-          content_area, confirm_area = @tui.layout_split(
+          confirm_area, content_area = @tui.layout_split(
             area,
             direction: :vertical,
             constraints: [
-              @tui.constraint_fill(1),
-              @tui.constraint_length(3)
+              @tui.constraint_length(3),
+              @tui.constraint_fill(1)
             ]
           )
-          render_failed_table(frame, content_area)
           render_confirm(frame, confirm_area)
-        elsif @filter_mode
-          content_area, filter_area = @tui.layout_split(
+          render_failed_table(frame, content_area)
+        elsif filter_mode?
+          filter_area, content_area = @tui.layout_split(
             area,
             direction: :vertical,
             constraints: [
-              @tui.constraint_fill(1),
-              @tui.constraint_length(3)
+              @tui.constraint_length(3),
+              @tui.constraint_fill(1)
             ]
           )
-          render_failed_table(frame, content_area)
           render_filter_input(frame, filter_area)
+          render_failed_table(frame, content_area)
         else
           render_failed_table(frame, area)
         end
@@ -52,7 +79,7 @@ module SolidQueueTui
       def handle_input(event)
         if @confirm_action
           handle_confirm_input(event)
-        elsif @filter_mode
+        elsif filter_mode?
           handle_filter_input(event)
         else
           handle_normal_input(event)
@@ -64,19 +91,14 @@ module SolidQueueTui
         @failed_jobs[@selected_row]
       end
 
-      def filter = @filter
-
       def bindings
         if @confirm_action
           [
             { key: "y", action: "Confirm" },
             { key: "n/Esc", action: "Cancel" }
           ]
-        elsif @filter_mode
-          [
-            { key: "Enter", action: "Apply" },
-            { key: "Esc", action: "Cancel" }
-          ]
+        elsif filter_mode?
+          filter_bindings
         else
           [
             { key: "j/k", action: "Navigate" },
@@ -90,21 +112,27 @@ module SolidQueueTui
       end
 
       def capturing_input?
-        @filter_mode || @confirm_action
+        filter_mode? || @confirm_action
       end
 
       def breadcrumb
-        @filter ? "failed:#{@filter}" : "failed"
+        @filters.empty? ? "failed" : "failed:filtered"
       end
 
       private
 
+      def needs_more?
+        !@all_loaded && @selected_row >= @failed_jobs.size - LOAD_THRESHOLD
+      end
+
       def handle_normal_input(event)
         case event
         in { type: :key, code: "j" } | { type: :key, code: "up" }
           move_selection(-1)
         in { type: :key, code: "k" } | { type: :key, code: "down" }
-          move_selection(1)
+          result = move_selection(1)
+          return :load_more if result == :load_more
+          nil
         in { type: :key, code: "g" }
           jump_to_top
         in { type: :key, code: "G" }
@@ -119,13 +147,10 @@ module SolidQueueTui
           @confirm_action = :retry_all unless @failed_jobs.empty?
           nil
         in { type: :key, code: "/" }
-          @filter_mode = true
-          @filter_input = @filter || ""
+          enter_filter_mode
           nil
         in { type: :key, code: "esc" }
-          @filter = nil
-          @filter_input = ""
-          :refresh
+          clear_filter
         else
           nil
         end
@@ -148,7 +173,8 @@ module SolidQueueTui
             Actions::DiscardJob.call(item.id)
             :refresh
           when :retry_all
-            Actions::RetryJob.retry_all
+            f = filters
+            Actions::RetryJob.retry_all(filter: f[:class_name], queue: f[:queue])
             :refresh
           end
         in { type: :key, code: "n" } | { type: :key, code: "esc" }
@@ -159,32 +185,11 @@ module SolidQueueTui
         end
       end
 
-      def handle_filter_input(event)
-        case event
-        in { type: :key, code: "enter" }
-          @filter = @filter_input.empty? ? nil : @filter_input
-          @filter_mode = false
-          @selected_row = 0
-          @table_state.select(0)
-          :refresh
-        in { type: :key, code: "esc" }
-          @filter_mode = false
-          nil
-        in { type: :key, code: "backspace" }
-          @filter_input = @filter_input[0...-1]
-          nil
-        in { type: :key, code: /\A.\z/ => char }
-          @filter_input += char
-          nil
-        else
-          nil
-        end
-      end
-
       def move_selection(delta)
         return if @failed_jobs.empty?
         @selected_row = (@selected_row + delta).clamp(0, @failed_jobs.size - 1)
         @table_state.select(@selected_row)
+        :load_more if needs_more?
       end
 
       def jump_to_top
@@ -196,6 +201,7 @@ module SolidQueueTui
         return if @failed_jobs.empty?
         @selected_row = @failed_jobs.size - 1
         @table_state.select(@selected_row)
+        return :load_more if needs_more?
       end
 
       def render_failed_table(frame, area)
@@ -219,14 +225,13 @@ module SolidQueueTui
           }
         end
 
-        title = @filter ? "Failed Jobs (filter: #{@filter})" : "Failed Jobs"
-
         table = Components::JobTable.new(
           @tui,
-          title: title,
+          title: filter_title("Failed Jobs"),
           columns: columns,
           rows: rows,
           selected_row: @selected_row,
+          total_count: @total_count,
           empty_message: "No failed jobs — everything is running smoothly!"
         )
 
@@ -242,7 +247,9 @@ module SolidQueueTui
                     job = selected_item
                     "Discard job ##{job&.job_id} (#{job&.class_name})? This cannot be undone. [y/n]"
                   when :retry_all
-                    "Retry ALL #{@failed_jobs.size} failed jobs? [y/n]"
+                    count = @total_count || @failed_jobs.size
+                    label = @filters.empty? ? "failed jobs" : "filtered failed jobs"
+                    "Retry ALL #{count} #{label}? [y/n]"
                   end
 
         frame.render_widget(
@@ -261,23 +268,6 @@ module SolidQueueTui
         )
       end
 
-      def render_filter_input(frame, area)
-        frame.render_widget(
-          @tui.paragraph(
-            text: @filter_input + "█",
-            style: @tui.style(fg: :white),
-            block: @tui.block(
-              title: " Filter by class name ",
-              title_style: @tui.style(fg: :yellow),
-              borders: [:all],
-              border_type: :rounded,
-              border_style: @tui.style(fg: :cyan)
-            )
-          ),
-          area
-        )
-      end
-
       def truncate(str, max)
         return "" unless str
         str.length > max ? "#{str[0...max - 3]}..." : str