log_bench 0.1.0

data/lib/log_bench/app/input_handler.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class InputHandler
+      include Curses
+
+      # Key codes
+      TAB = 9
+      CTRL_F = 6          # Page down
+      CTRL_B = 2          # Page up
+      CTRL_D = 4          # Half page down
+      CTRL_U = 21         # Half page up
+      CTRL_C = 3          # Quit
+      ESC = 27            # Escape
+
+      # UI constants
+      DEFAULT_VISIBLE_HEIGHT = 20
+
+      def initialize(state)
+        self.state = state
+      end
+
+      def handle_input
+        ch = getch
+        return if ch == -1 || ch.nil?
+
+        if filter_mode_active?
+          handle_filter_input(ch)
+        else
+          handle_navigation_input(ch)
+        end
+      end
+
+      private
+
+      attr_accessor :state
+
+      def filter_mode_active?
+        state.filter_mode || state.detail_filter_mode
+      end
+
+      def handle_filter_input(ch)
+        case ch
+        when 10, 13  # Enter - exit filter mode but keep filter text
+          if state.filter_mode
+            state.filter_mode = false
+          elsif state.detail_filter_mode
+            state.detail_filter_mode = false
+          end
+        when 27  # ESC - exit filter mode and clear filter
+          state.exit_filter_mode
+        when Curses::KEY_UP, "k", "K"
+          state.exit_filter_mode
+          state.navigate_up
+        when Curses::KEY_DOWN, "j", "J"
+          state.exit_filter_mode
+          state.navigate_down
+        when 127, 8  # Backspace
+          state.backspace_filter
+        else
+          add_character_to_filter(ch)
+        end
+      end
+
+      def add_character_to_filter(ch)
+        return unless printable_character?(ch)
+
+        char_to_add = if ch.is_a?(String)
+          ch
+        else
+          ch.chr
+        end
+
+        state.add_to_filter(char_to_add)
+        reset_selection_if_main_filter
+      end
+
+      def printable_character?(ch)
+        if ch.is_a?(String)
+          ch.length == 1 && ch.ord >= 32 && ch.ord <= 126
+        elsif ch.is_a?(Integer)
+          ch.between?(32, 126)
+        else
+          false
+        end
+      end
+
+      def reset_selection_if_main_filter
+        return unless state.filter_mode
+
+        state.selected = 0
+        state.scroll_offset = 0
+      end
+
+      def handle_navigation_input(ch)
+        case ch
+        when Curses::KEY_LEFT, "h", "H"
+          state.switch_to_left_pane
+        when Curses::KEY_RIGHT, "l", "L"
+          state.switch_to_right_pane
+        when TAB
+          toggle_pane_focus
+        when Curses::KEY_UP, "k", "K"
+          handle_up_navigation
+        when Curses::KEY_DOWN, "j", "J"
+          handle_down_navigation
+        when CTRL_F
+          handle_page_down
+        when CTRL_B
+          handle_page_up
+        when CTRL_D
+          handle_half_page_down
+        when CTRL_U
+          handle_half_page_up
+        when "g"
+          handle_go_to_top
+        when "G"
+          handle_go_to_bottom
+        when "a", "A"
+          state.toggle_auto_scroll
+        when "f", "F", "/"
+          state.enter_filter_mode
+        when "c", "C"
+          if state.left_pane_focused?
+            state.clear_filter
+          else
+            state.clear_detail_filter
+          end
+        when "s", "S"
+          state.cycle_sort_mode
+        when "q", "Q", CTRL_C
+          state.stop!
+        when ESC
+          handle_escape
+        end
+      end
+
+      def toggle_pane_focus
+        if state.left_pane_focused?
+          state.switch_to_right_pane
+        else
+          state.switch_to_left_pane
+        end
+      end
+
+      def handle_up_navigation
+        state.navigate_up
+        state.adjust_scroll_for_selection(visible_height) if state.left_pane_focused?
+      end
+
+      def handle_down_navigation
+        if state.left_pane_focused?
+          max_index = state.filtered_requests.size - 1
+          state.selected = [state.selected + 1, max_index].min
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          state.navigate_down
+        end
+      end
+
+      def handle_page_down
+        if state.left_pane_focused?
+          page_size = visible_height
+          max_index = state.filtered_requests.size - 1
+          state.selected = [state.selected + page_size, max_index].min
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          state.detail_scroll_offset += visible_height
+        end
+      end
+
+      def handle_page_up
+        if state.left_pane_focused?
+          page_size = visible_height
+          state.selected = [state.selected - page_size, 0].max
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          state.detail_scroll_offset = [state.detail_scroll_offset - visible_height, 0].max
+        end
+      end
+
+      def handle_half_page_down
+        if state.left_pane_focused?
+          half_page = visible_height / 2
+          max_index = state.filtered_requests.size - 1
+          state.selected = [state.selected + half_page, max_index].min
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          state.detail_scroll_offset += visible_height / 2
+        end
+      end
+
+      def handle_half_page_up
+        if state.left_pane_focused?
+          half_page = visible_height / 2
+          state.selected = [state.selected - half_page, 0].max
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          state.detail_scroll_offset = [state.detail_scroll_offset - visible_height / 2, 0].max
+        end
+      end
+
+      def handle_go_to_top
+        if state.left_pane_focused?
+          state.selected = 0
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          state.detail_scroll_offset = 0
+        end
+      end
+
+      def handle_go_to_bottom
+        if state.left_pane_focused?
+          max_index = state.filtered_requests.size - 1
+          state.selected = [max_index, 0].max
+          state.auto_scroll = false
+          state.adjust_scroll_for_selection(visible_height)
+        else
+          # Calculate max scroll for detail pane
+          state.detail_scroll_offset = 999  # Will be adjusted by renderer
+        end
+      end
+
+      def handle_escape
+        if state.filter_mode || state.detail_filter_mode
+          state.exit_filter_mode
+        else
+          state.clear_filter
+        end
+      end
+
+      def visible_height
+        # Approximate visible height for calculations
+        DEFAULT_VISIBLE_HEIGHT
+      end
+    end
+  end
+end

data/lib/log_bench/app/main.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "curses"
+
+module LogBench
+  module App
+    class Main
+      include Curses
+
+      # Default log file paths
+      DEFAULT_LOG_PATHS = %w[log/development.log].freeze
+
+      # Timing
+      MAIN_LOOP_SLEEP_INTERVAL = 0.05
+
+      # Error messages
+      LOG_FILE_NOT_FOUND = "Error: No log file found at %s!"
+      RAILS_PROJECT_HINT = "Please run from a Rails project directory or specify a valid log file"
+
+      def initialize(log_file_path = "log/development.log")
+        self.log_file_path = find_log_file(log_file_path)
+        self.state = State.new
+        validate_log_file!
+      end
+
+      def run
+        setup_screen
+        setup_components
+        load_initial_data
+        initial_draw
+        start_monitoring
+        main_loop
+      ensure
+        cleanup
+      end
+
+      private
+
+      def find_log_file(path)
+        candidates = [path] + DEFAULT_LOG_PATHS
+        candidates.find { |candidate| File.exist?(candidate) } || path
+      end
+
+      def validate_log_file!
+        unless File.exist?(log_file_path)
+          puts LOG_FILE_NOT_FOUND % log_file_path
+          puts RAILS_PROJECT_HINT
+          exit 1
+        end
+      end
+
+      def setup_screen
+        self.screen = Screen.new
+        screen.setup
+      end
+
+      def setup_components
+        self.input_handler = InputHandler.new(state)
+        self.renderer = Renderer::Main.new(screen, state)
+      end
+
+      def load_initial_data
+        log_file = Log::File.new(log_file_path)
+        state.requests = log_file.requests
+      end
+
+      def initial_draw
+        renderer.draw
+      end
+
+      def start_monitoring
+        self.monitor = Monitor.new(log_file_path, state)
+        monitor.start
+      end
+
+      def main_loop
+        loop do
+          break unless state.running?
+
+          renderer.draw
+          input_handler.handle_input
+          sleep MAIN_LOOP_SLEEP_INTERVAL
+        end
+      end
+
+      def cleanup
+        monitor&.stop
+        screen&.cleanup
+      end
+
+      private
+
+      attr_accessor :log_file_path, :state, :screen, :monitor, :input_handler, :renderer
+    end
+  end
+end

data/lib/log_bench/app/monitor.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class Monitor
+      def initialize(log_file_path, state)
+        self.log_file_path = log_file_path
+        self.state = state
+        self.running = false
+      end
+
+      def start
+        return if running
+
+        self.running = true
+        self.thread = Thread.new { monitor_loop }
+      end
+
+      def stop
+        self.running = false
+        thread&.kill
+      end
+
+      private
+
+      attr_accessor :log_file_path, :state, :thread, :running
+
+      def monitor_loop
+        log_file = Log::File.new(log_file_path)
+
+        loop do
+          break unless running
+
+          begin
+            log_file.watch do |new_collection|
+              add_new_requests(new_collection.requests)
+            end
+          rescue
+            # Log error but continue monitoring
+            # In a real app, you might want to handle this differently
+            sleep 1
+          end
+        end
+      end
+
+      def add_new_requests(new_requests)
+        return if new_requests.empty?
+
+        state.requests.concat(new_requests)
+        keep_recent_requests
+      end
+
+      def keep_recent_requests
+        # Keep only the last 1000 requests to prevent memory issues
+        state.requests = state.requests.last(1000) if state.requests.size > 1000
+      end
+    end
+  end
+end

data/lib/log_bench/app/renderer/ansi.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    module Renderer
+      class Ansi
+        include Curses
+
+        def initialize(screen)
+          self.screen = screen
+        end
+
+        def has_ansi_codes?(text)
+          text.match?(/\e\[[0-9;]*m/)
+        end
+
+        def parse_and_render(text, win)
+          # Parse ANSI escape codes and render with proper colors
+          parts = text.split(/(\e\[[0-9;]*m)/)
+          current_color = nil
+
+          parts.each do |part|
+            if part =~ /\e\[([0-9;]*)m/
+              # ANSI escape code
+              codes = $1.split(";").map(&:to_i)
+              current_color = ansi_to_curses_color(codes)
+            elsif current_color && !part.empty?
+              # Text content
+              win.attron(current_color) { win.addstr(part) }
+            elsif !part.empty?
+              win.addstr(part)
+            end
+          end
+        end
+
+        def wrap_ansi_text(text, max_width)
+          # For ANSI text, we need to preserve color state across chunks
+          clean_text = text.gsub(/\e\[[0-9;]*m/, "")
+
+          if clean_text.length <= max_width
+            [text]
+          else
+            chunks = []
+            remaining = text
+            active_colors = []
+
+            # Extract initial color state
+            text.scan(/\e\[[0-9;]*m/) do |ansi_code|
+              if /\e\[0m/.match?(ansi_code)
+                active_colors.clear
+              else
+                active_colors << ansi_code
+              end
+            end
+
+            while remaining.length > 0
+              clean_remaining = remaining.gsub(/\e\[[0-9;]*m/, "")
+
+              if clean_remaining.length <= max_width
+                # Last chunk
+                chunks << if active_colors.any? && !remaining.start_with?(*active_colors)
+                  active_colors.join("") + remaining
+                else
+                  remaining
+                end
+                break
+              else
+                # Find break point and preserve color state
+                break_point = max_width
+                original_pos = 0
+                clean_pos = 0
+                chunk_colors = active_colors.dup
+
+                remaining.each_char.with_index do |char, idx|
+                  if /^\e\[[0-9;]*m/.match?(remaining[idx..])
+                    # Found ANSI sequence
+                    ansi_match = remaining[idx..].match(/^(\e\[[0-9;]*m)/)
+                    ansi_code = ansi_match[1]
+
+                    if /\e\[0m/.match?(ansi_code)
+                      chunk_colors.clear
+                      active_colors.clear
+                    else
+                      chunk_colors << ansi_code unless chunk_colors.include?(ansi_code)
+                      active_colors << ansi_code unless active_colors.include?(ansi_code)
+                    end
+
+                    original_pos += ansi_code.length
+                    idx + ansi_code.length - 1
+                  else
+                    clean_pos += 1
+                    original_pos += 1
+
+                    if clean_pos >= break_point
+                      break
+                    end
+                  end
+                end
+
+                chunk_text = remaining[0...original_pos]
+                chunks << if active_colors.any? && !chunk_text.start_with?(*active_colors)
+                  active_colors.join("") + chunk_text
+                else
+                  chunk_text
+                end
+
+                remaining = remaining[original_pos..]
+              end
+            end
+
+            chunks
+          end
+        end
+
+        def wrap_plain_text(text, max_width)
+          # Simple text wrapping for plain text
+          if text.length <= max_width
+            [text]
+          else
+            chunks = []
+            remaining = text
+
+            while remaining.length > 0
+              if remaining.length <= max_width
+                chunks << remaining
+                break
+              else
+                # Find a good break point (try to break on spaces)
+                break_point = max_width
+                if remaining[0...max_width].include?(" ")
+                  # Find the last space within the limit
+                  break_point = remaining[0...max_width].rindex(" ") || max_width
+                end
+
+                chunks << remaining[0...break_point]
+                remaining = remaining[break_point..].lstrip
+              end
+            end
+
+            chunks
+          end
+        end
+
+        private
+
+        attr_accessor :screen
+
+        def ansi_to_curses_color(codes)
+          # Convert ANSI color codes to curses color pairs
+          return nil if codes.empty? || codes == [0]
+
+          # Handle common ANSI codes
+          codes.each do |code|
+            case code
+            when 1 then return color_pair(7) | A_BOLD  # Bold/bright
+            when 30 then return color_pair(8) # Black
+            when 31 then return color_pair(6) # Red
+            when 32 then return color_pair(3) # Green
+            when 33 then return color_pair(4) # Yellow
+            when 34 then return color_pair(5) # Blue
+            when 35 then return color_pair(9) # Magenta
+            when 36 then return color_pair(1) # Cyan
+            when 37 then return nil           # White (default)
+            end
+          end
+
+          nil
+        end
+
+        def color_pair(n)
+          screen.color_pair(n)
+        end
+      end
+    end
+  end
+end