solid_queue_tui 0.1.1 → 0.1.3

data/lib/solid_queue_tui/data/stats.rb

@@ -20,18 +20,16 @@ module SolidQueueTui
       end
 
       def self.fetch
-        conn = ActiveRecord::Base.connection
-
         new(
-          ready: count_table(conn, "solid_queue_ready_executions"),
-          claimed: count_table(conn, "solid_queue_claimed_executions"),
-          failed: count_table(conn, "solid_queue_failed_executions"),
-          scheduled: count_table(conn, "solid_queue_scheduled_executions"),
-          blocked: count_table(conn, "solid_queue_blocked_executions"),
-          total_jobs: count_table(conn, "solid_queue_jobs"),
-          completed_jobs: count_where(conn, "solid_queue_jobs", "finished_at IS NOT NULL"),
-          process_count: count_table(conn, "solid_queue_processes"),
-          processes_by_kind: processes_by_kind(conn)
+          ready: SolidQueue::ReadyExecution.count,
+          claimed: SolidQueue::ClaimedExecution.count,
+          failed: SolidQueue::FailedExecution.count,
+          scheduled: SolidQueue::ScheduledExecution.count,
+          blocked: SolidQueue::BlockedExecution.count,
+          total_jobs: SolidQueue::Job.count,
+          completed_jobs: SolidQueue::Job.finished.count,
+          process_count: SolidQueue::Process.count,
+          processes_by_kind: SolidQueue::Process.group(:kind).count
         )
       rescue => e
         empty(error: e.message)
@@ -44,22 +42,6 @@ module SolidQueueTui
           processes_by_kind: {}
         )
       end
-
-      private_class_method def self.count_table(conn, table)
-        conn.select_value("SELECT COUNT(*) FROM #{table}").to_i
-      end
-
-      private_class_method def self.count_where(conn, table, condition)
-        conn.select_value("SELECT COUNT(*) FROM #{table} WHERE #{condition}").to_i
-      end
-
-      private_class_method def self.processes_by_kind(conn)
-        rows = conn.select_rows(
-          "SELECT kind, COUNT(*) FROM solid_queue_processes GROUP BY kind"
-        )
-        rows.to_h { |kind, count| [kind, count.to_i] }
-      end
-
     end
   end
 end

data/lib/solid_queue_tui/formatting_helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module FormattingHelpers
+    def time_ago(time)
+      return "n/a" unless time
+      seconds = (Time.now.utc - time).to_i
+      case seconds
+      when 0..59       then "#{seconds}s ago"
+      when 60..3599    then "#{seconds / 60}m ago"
+      when 3600..86399 then "#{seconds / 3600}h ago"
+      else "#{seconds / 86400}d ago"
+      end
+    end
+
+    def format_time(time)
+      return "n/a" unless time
+      time.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def format_duration(seconds)
+      return "n/a" unless seconds
+      seconds = seconds.to_i
+      if seconds < 1
+        "<1s"
+      elsif seconds < 60
+        "#{seconds}s"
+      elsif seconds < 3600
+        "#{seconds / 60}m #{seconds % 60}s"
+      elsif seconds < 86400
+        "#{seconds / 3600}h #{(seconds % 3600) / 60}m"
+      else
+        "#{seconds / 86400}d #{(seconds % 86400) / 3600}h"
+      end
+    end
+
+    def format_number(n)
+      return "0" if n.nil? || n == 0
+      n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+    end
+
+    def truncate(str, max)
+      return "" unless str
+      str.length > max ? "#{str[0...max - 3]}..." : str
+    end
+
+    def humanize_duration(seconds)
+      case seconds.abs
+      when 0..59       then "#{seconds.abs}s"
+      when 60..3599    then "#{seconds.abs / 60}m"
+      when 3600..86399 then "#{seconds.abs / 3600}h"
+      else "#{seconds.abs / 86400}d"
+      end
+    end
+
+    def time_until(time)
+      return "n/a" unless time
+      seconds = (time - Time.now.utc).to_i
+      return "now" if seconds <= 0
+      "in #{humanize_duration(seconds)}"
+    end
+  end
+end

data/lib/solid_queue_tui/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/solid_queue_tui.rake"
+    end
+  end
+end

data/lib/solid_queue_tui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidQueueTui
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/solid_queue_tui/views/blocked_view.rb

@@ -3,21 +3,95 @@
 module SolidQueueTui
   module Views
     class BlockedView
+      include Filterable
+      include Paginatable
+      include FormattingHelpers
+
       def initialize(tui)
         @tui = tui
-        @table_state = RatatuiRuby::TableState.new(nil)
-        @table_state.select(0)
-        @selected_row = 0
-        @jobs = []
+        init_pagination
+        init_filter
       end
 
       def update(jobs:)
-        @jobs = jobs
-        @selected_row = @selected_row.clamp(0, [@jobs.size - 1, 0].max)
-        @table_state.select(@selected_row)
+        update_items(jobs)
+      end
+
+      def append(jobs:)
+        append_items(jobs)
       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)
+        if filter_mode?
+          handle_filter_input(event)
+        else
+          handle_normal_input(event)
+        end
+      end
+
+      def bindings
+        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
+        @filters.empty? ? "blocked" : "blocked:filtered"
+      end
+
+      private
+
+      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 render_table(frame, area)
         columns = [
           { key: :id,              label: "ID",              width: 8 },
           { key: :queue_name,      label: "QUEUE",            width: 14 },
@@ -28,7 +102,7 @@ module SolidQueueTui
           { key: :blocked_since,   label: "BLOCKED SINCE",    width: 14 }
         ]
 
-        rows = @jobs.map do |job|
+        rows = items.map do |job|
           {
             id: job.id,
             queue_name: job.queue_name,
@@ -42,80 +116,17 @@ module SolidQueueTui
 
         table = Components::JobTable.new(
           @tui,
-          title: "Blocked",
+          title: filter_title("Blocked"),
           columns: columns,
           rows: rows,
           selected_row: @selected_row,
-          empty_message: "No blocked jobs"
+          total_count: @total_count,
+          empty_message: @filters.empty? ? "No blocked jobs" : "No blocked jobs matching filters"
         )
 
         table.render(frame, area, @table_state)
       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
-        else
-          nil
-        end
-      end
-
-      def selected_item
-        return nil if @jobs.empty? || @selected_row >= @jobs.size
-        @jobs[@selected_row]
-      end
-
-      def bindings
-        [
-          { key: "j/k", action: "Navigate" },
-          { key: "Enter", action: "Detail" },
-          { key: "G/g", action: "Bottom/Top" }
-        ]
-      end
-
-      def breadcrumb = "blocked"
-
-      private
-
-      def move_selection(delta)
-        return if @jobs.empty?
-        @selected_row = (@selected_row + delta).clamp(0, @jobs.size - 1)
-        @table_state.select(@selected_row)
-      end
-
-      def jump_to_top
-        @selected_row = 0
-        @table_state.select(0)
-      end
-
-      def jump_to_bottom
-        return if @jobs.empty?
-        @selected_row = @jobs.size - 1
-        @table_state.select(@selected_row)
-      end
-
-      def format_time(time)
-        return "n/a" unless time
-        time.strftime("%Y-%m-%d %H:%M:%S")
-      end
-
-      def time_ago(time)
-        return "n/a" unless time
-        seconds = (Time.now.utc - time).to_i
-        case seconds
-        when 0..59       then "#{seconds}s ago"
-        when 60..3599    then "#{seconds / 60}m ago"
-        when 3600..86399 then "#{seconds / 3600}h ago"
-        else "#{seconds / 86400}d ago"
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    module Confirmable
+      def init_confirm
+        @confirm_action = nil
+      end
+
+      def confirm_mode? = !!@confirm_action
+
+      def confirm_bindings
+        [{ key: "y", action: "Confirm" }, { key: "n/Esc", action: "Cancel" }]
+      end
+
+      def handle_confirm_input(event)
+        case event
+        in { type: :key, code: "y" }
+          action = @confirm_action
+          @confirm_action = nil
+          execute_confirm_action(action)
+        in { type: :key, code: "n" } | { type: :key, code: "esc" }
+          @confirm_action = nil
+          nil
+        else
+          nil
+        end
+      end
+
+      def render_confirm_popup(frame, area)
+        popup_area = area.centered(
+          @tui.constraint_percentage(50),
+          @tui.constraint_length(5)
+        )
+        frame.render_widget(@tui.clear(), popup_area)
+        frame.render_widget(
+          @tui.paragraph(
+            text: " #{confirm_message}",
+            style: @tui.style(fg: :yellow, modifiers: [:bold]),
+            block: @tui.block(
+              title: " Confirm ",
+              title_style: @tui.style(fg: :red, modifiers: [:bold]),
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :red)
+            )
+          ),
+          popup_area
+        )
+      end
+    end
+  end
+end

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/concerns/paginatable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    module Paginatable
+      LOAD_THRESHOLD = 10
+
+      def init_pagination
+        @table_state = RatatuiRuby::TableState.new(nil)
+        @table_state.select(0)
+        @selected_row = 0
+        @items = []
+        @total_count = nil
+        @all_loaded = false
+      end
+
+      def items = @items
+
+      def selected_item
+        return nil if @items.empty? || @selected_row >= @items.size
+        @items[@selected_row]
+      end
+
+      def total_count=(count)
+        @total_count = count
+      end
+
+      def current_offset
+        @items.size
+      end
+
+      def reset_pagination!
+        @items = []
+        @total_count = nil
+        @all_loaded = false
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      private
+
+      def update_items(new_items)
+        @selected_row = 0 if @selected_row >= new_items.size
+        @items = new_items
+        @all_loaded = new_items.size < SolidQueueTui.page_size
+        @selected_row = @selected_row.clamp(0, [@items.size - 1, 0].max)
+        @table_state.select(@selected_row)
+      end
+
+      def append_items(more_items)
+        @items.concat(more_items)
+        @all_loaded = more_items.size < SolidQueueTui.page_size
+      end
+
+      def needs_more?
+        !@all_loaded && @selected_row >= @items.size - LOAD_THRESHOLD
+      end
+
+      def move_selection(delta)
+        return if @items.empty?
+        @selected_row = (@selected_row + delta).clamp(0, @items.size - 1)
+        @table_state.select(@selected_row)
+        :load_more if needs_more?
+      end
+
+      def jump_to_top
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      def jump_to_bottom
+        return if @items.empty?
+        @selected_row = @items.size - 1
+        @table_state.select(@selected_row)
+        :load_more if needs_more?
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/views/dashboard_view.rb

@@ -3,6 +3,8 @@
 module SolidQueueTui
   module Views
     class DashboardView
+      include FormattingHelpers
+
       def initialize(tui)
         @tui = tui
         @selected_row = 0
@@ -36,7 +38,8 @@ module SolidQueueTui
 
       def bindings
         [
-          { key: "Tab", action: "Next View" }
+          { key: "Tab", action: "Next View" },
+          { key: "Shift Tab", action: "Prev View" },
         ]
       end
 
@@ -178,10 +181,6 @@ module SolidQueueTui
         ])
       end
 
-      def format_number(n)
-        return "0" if n.nil? || n == 0
-        n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
-      end
     end
   end
 end