tryouts 3.1.1 → 3.2.0

data/lib/tryouts/cli/formatters/tty_status_display.rb

@@ -0,0 +1,273 @@
+# lib/tryouts/cli/formatters/tty_status_display.rb
+
+require 'tty-cursor'
+require 'tty-screen'
+require 'pastel'
+require 'io/console'
+
+class Tryouts
+  class CLI
+    # Encapsulates TTY manipulation for live status display with fallback
+    class TTYStatusDisplay
+      STATUS_LINES = 5  # Lines reserved for fixed status display (4 content + 1 separator)
+
+      def initialize(io = $stdout, options = {})
+        @io         = io
+        @available  = check_tty_availability
+        @show_debug = options.fetch(:debug, false)
+        @cleanup_registered = false
+
+        return unless @available
+
+        @cursor        = TTY::Cursor
+        @pastel        = Pastel.new
+        @status_active = false
+        @original_cursor_position = nil
+
+        register_cleanup_handlers
+      end
+
+      def available?
+        @available
+      end
+
+      def reserve_status_area
+        return unless @available && !@status_active
+
+        with_terminal_safety do
+          # Store original cursor position if possible
+          @original_cursor_position = get_cursor_position
+
+          # Simply print empty lines to push content up and make room at bottom
+          STATUS_LINES.times { @io.print "\n" }
+
+          @status_active = true
+        end
+      end
+
+      def write_scrolling(text)
+        return @io.print(text) unless @available
+
+        # Always write content normally - the status will be updated separately
+        @io.print text
+      end
+
+      def update_status(state)
+        return unless @available && @status_active
+
+        with_terminal_safety do
+          # Move to status area (bottom of screen) and update in place
+          current_row, current_col = get_cursor_position
+
+          # Move to status area at bottom
+          @io.print @cursor.move_to(0, TTY::Screen.height - STATUS_LINES + 1)
+
+          # Clear and write status content
+          STATUS_LINES.times do
+            @io.print @cursor.clear_line
+            @io.print @cursor.down(1) unless STATUS_LINES == 1
+          end
+
+          # Move back to start of status area and write content
+          @io.print @cursor.move_to(0, TTY::Screen.height - STATUS_LINES + 1)
+          write_status_content(state)
+
+          # Move cursor back to where content should continue (just before status area)
+          @io.print @cursor.move_to(0, TTY::Screen.height - STATUS_LINES)
+          @io.flush
+        end
+      end
+
+      def clear_status_area
+        return unless @available && @status_active
+
+        with_terminal_safety do
+          # Move to status area and clear it completely - start from first status line
+          @io.print @cursor.move_to(0, TTY::Screen.height - STATUS_LINES + 1)
+
+          # Clear each line thoroughly
+          STATUS_LINES.times do |i|
+            @io.print @cursor.clear_line
+            @io.print @cursor.down(1) if i < STATUS_LINES - 1  # Don't go down after last line
+          end
+
+          # Move cursor to a clean area for final output - position it well above the cleared area
+          # This ensures no interference with the cleared status content
+          target_row = TTY::Screen.height - STATUS_LINES - 2  # Leave some buffer space
+          @io.print @cursor.move_to(0, target_row)
+          @io.print "\n"  # Add a clean line for final output to start
+          @io.flush
+        end
+
+        @status_active = false
+      end
+
+      # Explicit cleanup method for manual invocation
+      def cleanup!
+        return unless @available
+
+        with_terminal_safety do
+          if @status_active
+            # Clear the status area completely
+            @io.print @cursor.move_to(0, TTY::Screen.height - STATUS_LINES + 1)
+            STATUS_LINES.times do |i|
+              @io.print @cursor.clear_line
+              @io.print @cursor.down(1) if i < STATUS_LINES - 1
+            end
+          end
+
+          # Reset cursor to a safe position (start of line below cleared area)
+          @io.print @cursor.move_to(0, TTY::Screen.height - STATUS_LINES)
+          @io.print "\n"
+          @io.flush
+        end
+
+        @status_active = false
+      end
+
+      private
+
+      def get_cursor_position
+        # Simple approximation - in a real terminal this would query cursor position
+        # For now, return reasonable defaults
+        [10, 0]
+      end
+
+      def check_tty_availability
+        # Check if we have a real TTY
+        return false unless @io.respond_to?(:tty?) && @io.tty?
+
+        # Check if we can get screen dimensions
+        return false unless TTY::Screen.width > 0 && TTY::Screen.height > STATUS_LINES + 5
+
+        # Check if TERM environment variable suggests terminal capabilities
+        term = ENV.fetch('TERM', nil)
+        return false if term.nil? || term == 'dumb'
+
+        # Check if we're likely in a CI environment (common CI env vars)
+        ci_vars = %w[CI CONTINUOUS_INTEGRATION BUILD_NUMBER JENKINS_URL GITHUB_ACTIONS]
+        return false if ci_vars.any? { |var| ENV[var] }
+
+        true
+      rescue StandardError => ex
+        # If any TTY detection fails, assume not available
+        if @show_debug
+          @io.puts "TTY detection failed: #{ex.message}"
+        end
+        false
+      end
+
+      def write_status_content(state)
+        return unless @available
+
+        # Line 1: Empty separator line
+        @io.print "\n"
+
+        # Line 2: Current progress
+        if state.current_file
+          current_info  = "Running: #{state.current_file}"
+          current_info += " → #{state.current_test}" if state.current_test
+          @io.print current_info
+        else
+          @io.print 'Ready'
+        end
+        @io.print "\n"
+
+        # Line 3: Test counts
+        parts = []
+        parts << @pastel.green("#{state.passed} passed") if state.passed > 0
+        parts << @pastel.red("#{state.failed} failed") if state.failed > 0
+        parts << @pastel.yellow("#{state.errors} errors") if state.errors > 0
+
+        if parts.any?
+          @io.print "Tests: #{parts.join(', ')}"
+        else
+          @io.print 'Tests: 0 run'
+        end
+        @io.print "\n"
+
+        # Line 4: File progress
+        files_info  = "Files: #{state.files_completed}"
+        files_info += "/#{state.total_files}" if state.total_files > 0
+        files_info += ' completed'
+        @io.print files_info
+        @io.print "\n"
+
+        # Line 5: Timing
+        @io.print "Time: #{format_timing(state.elapsed_time)}"
+      end
+
+      def format_timing(elapsed_time)
+        if elapsed_time < 0.001
+          "#{(elapsed_time * 1_000_000).round}μs"
+        elsif elapsed_time < 1
+          "#{(elapsed_time * 1000).round}ms"
+        else
+          "#{elapsed_time.round(2)}s"
+        end
+      end
+
+      # Register cleanup handlers for various termination scenarios
+      def register_cleanup_handlers
+        return if @cleanup_registered
+
+        # Handle common termination signals
+        %w[INT TERM QUIT HUP].each do |signal|
+          begin
+            Signal.trap(signal) do
+              cleanup!
+              # Re-raise the signal with default handler
+              Signal.trap(signal, 'DEFAULT')
+              Process.kill(signal, Process.pid)
+            end
+          rescue ArgumentError
+            # Signal not supported on this platform, skip it
+            debug_log("Signal #{signal} not supported, skipping cleanup handler")
+          end
+        end
+
+        # Register at_exit handler as final fallback
+        at_exit { cleanup! }
+
+        @cleanup_registered = true
+        debug_log('TTY cleanup handlers registered')
+      end
+
+      # Wrap terminal operations with exception handling
+      def with_terminal_safety
+        yield
+      rescue StandardError => e
+        debug_log("Terminal operation failed: #{e.message}")
+        # Attempt basic cleanup on any terminal operation failure
+        begin
+          @io.print "\n" if @io.respond_to?(:print)
+          @io.flush if @io.respond_to?(:flush)
+        rescue StandardError
+          # If even basic cleanup fails, there's nothing more we can do
+        end
+        @status_active = false
+      end
+
+      def debug_log(message)
+        return unless @show_debug
+
+        # Use stderr to avoid interfering with TTY operations on stdout
+        $stderr.puts "TTY DEBUG: #{message}"
+      end
+    end
+
+    # No-op implementation for when TTY is not available
+    class NoOpStatusDisplay
+      def initialize(io = $stdout, _options = {})
+        @io = io
+      end
+
+      def available? = false
+      def reserve_status_area; end
+      def write_scrolling(text) = @io.print(text)
+      def update_status(state); end
+      def clear_status_area; end
+      def cleanup!; end  # No-op cleanup for consistency
+    end
+  end
+end

data/lib/tryouts/cli/formatters/verbose.rb

@@ -7,117 +7,119 @@ class Tryouts
       include FormatterInterface
 
       def initialize(options = {})
+        super
         @line_width     = options.fetch(:line_width, 70)
         @show_passed    = options.fetch(:show_passed, true)
         @show_debug     = options.fetch(:debug, false)
         @show_trace     = options.fetch(:trace, false)
-        @current_indent = 0
       end
 
       # Phase-level output
-      def phase_header(message, _file_count = nil, level = 0)
-        return if level.equal?(1)
-
-        separators = [
-          { char: '=', width: @line_width },      # Major phases
-          { char: '-', width: @line_width - 10 }, # Sub-phases
-          { char: '.', width: @line_width - 20 }, # Details
-          { char: '~', width: @line_width - 30 }, # Minor items
-        ]
-
-        config = separators[level] || separators.last
+      def phase_header(message, file_count: nil)
+        return if message.include?('EXECUTING') # Skip execution phase headers
 
-        separator_line = config[:char] * config[:width]
-        header_line    = message.center(config[:width])
-
-        output = case level
-        when 0, 1
-          [separator_line, header_line, separator_line]
-        else
-          [header_line, separator_line]
-        end
+        header_line = message.center(@line_width)
+        separator_line = '=' * @line_width
 
-        with_indent(level) do
-          puts output.join("\n")
-        end
+        puts(separator_line)
+        puts(header_line)
+        puts(separator_line)
       end
 
       # File-level operations
-      def file_start(file_path, _context_info = {})
-        puts file_header_visual(file_path)
-      end
-
-      def file_end(_file_path, _context_info = {})
-        # No output in verbose mode
+      def file_start(file_path, context_info: {})
+        puts(file_header_visual(file_path))
       end
 
-      def file_parsed(_file_path, _test_count, setup_present: false, teardown_present: false)
+      def file_parsed(_file_path, test_count:, setup_present: false, teardown_present: false)
         message = ''
 
-        extras   = []
+        extras = []
         extras << 'setup' if setup_present
         extras << 'teardown' if teardown_present
         message += " (#{extras.join(', ')})" unless extras.empty?
 
-        puts indent_text(message, 2)
+        puts(indent_text(message, 2))
       end
 
-      def file_execution_start(_file_path, test_count, context_mode)
+      def file_execution_start(_file_path, test_count:, context_mode:)
         message = "Running #{test_count} tests with #{context_mode} context"
-        puts indent_text(message, 1)
+        puts(indent_text(message, 1))
       end
 
-      # Summary operations
-      #
-      # Called right before file_result
-      def batch_summary(total_tests, failed_count, elapsed_time)
-        # No output in verbose mode
+      # Summary operations - show detailed failure summary
+      def batch_summary(failure_collector)
+        return unless failure_collector.any_failures?
+
+        puts
+        write '=' * 50
+        puts Console.color(:red, 'Failed Tests:')
+
+        failure_collector.failures_by_file.each do |file_path, failures|
+          failures.each_with_index do |failure, index|
+            pretty_path = Console.pretty_path(file_path)
+
+            # Include line number with file path for easy copying/clicking
+            if failure.line_number > 0
+              location = "#{pretty_path}:#{failure.line_number}"
+            else
+              location = pretty_path
+            end
+
+            puts
+            puts Console.color(:yellow, location)
+            puts "  #{index + 1}) #{failure.description}"
+            puts "     #{Console.color(:red, 'Failure:')} #{failure.failure_reason}"
+
+            # Show source context in verbose mode
+            if failure.source_context.any?
+              puts "     #{Console.color(:cyan, 'Source:')}"
+              failure.source_context.each do |line|
+                puts "       #{line.strip}"
+              end
+            end
+            puts
+          end
+        end
       end
 
-      def file_result(_file_path, total_tests, failed_count, error_count, elapsed_time)
+      def file_result(_file_path, total_tests:, failed_count:, error_count:, elapsed_time: nil)
         issues_count = failed_count + error_count
         passed_count = total_tests - issues_count
-        details      = [
-          "#{passed_count} passed",
-        ]
+        details = ["#{passed_count} passed"]
 
+        puts
         if issues_count > 0
           details << "#{failed_count} failed" if failed_count > 0
           details << "#{error_count} errors" if error_count > 0
           details_str = details.join(', ')
-          color       = :red
+          color = :red
 
           time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
-          message  = "✗ Out of #{total_tests} tests: #{details_str}#{time_str}"
+          message = "✗ Out of #{total_tests} tests: #{details_str}#{time_str}"
           puts indent_text(Console.color(color, message), 2)
         else
           message = "#{total_tests} tests passed"
-          color   = :green
+          color = :green
           puts indent_text(Console.color(color, "✓ #{message}"), 2)
         end
 
         return unless elapsed_time
 
         time_msg = "Completed in #{format_timing(elapsed_time).strip.tr('()', '')}"
-
         puts indent_text(Console.color(:dim, time_msg), 2)
       end
 
       # Test-level operations
-      def test_start(test_case, index, total)
-        desc    = test_case.description.to_s
-        desc    = 'Unnamed test' if desc.empty?
+      def test_start(test_case:, index:, total:)
+        desc = test_case.description.to_s
+        desc = 'Unnamed test' if desc.empty?
         message = "Test #{index}/#{total}: #{desc}"
         puts indent_text(Console.color(:dim, message), 2)
       end
 
-      def test_end(_test_case, _index, _total)
-        # No output in verbose mode
-      end
-
       def test_result(result_packet)
         should_show = @show_passed || !result_packet.passed?
-
         return unless should_show
 
         status_line = case result_packet.status
@@ -150,7 +152,7 @@ class Tryouts
         end
       end
 
-      def test_output(_test_case, output_text)
+      def test_output(test_case:, output_text:, result_packet:)
         return if output_text.nil? || output_text.strip.empty?
 
         puts indent_text('Test Output:', 3)
@@ -165,7 +167,7 @@ class Tryouts
       end
 
       # Setup/teardown operations
-      def setup_start(line_range)
+      def setup_start(line_range:)
         message = "Executing global setup (lines #{line_range.first}..#{line_range.last})"
         puts indent_text(Console.color(:cyan, message), 2)
       end
@@ -178,9 +180,10 @@ class Tryouts
         end
       end
 
-      def teardown_start(line_range)
+      def teardown_start(line_range:)
         message = "Executing teardown (lines #{line_range.first}..#{line_range.last})"
         puts indent_text(Console.color(:cyan, message), 2)
+        puts
       end
 
       def teardown_output(output_text)
@@ -191,21 +194,20 @@ class Tryouts
         end
       end
 
-      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+      def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
         puts
         puts '=' * @line_width
         puts 'Grand Total:'
 
         issues_count = failed_count + error_count
-        time_str     =
-          if elapsed_time < 2.0
-            " (#{(elapsed_time * 1000).round}ms)"
-          else
-            " (#{elapsed_time.round(2)}s)"
-          end
+        time_str = if elapsed_time < 2.0
+          " (#{(elapsed_time * 1000).round}ms)"
+        else
+          " (#{elapsed_time.round(2)}s)"
+        end
 
         if issues_count > 0
-          passed  = [total_tests - issues_count, 0].max  # Ensure passed never goes negative
+          passed = [total_tests - issues_count, 0].max  # Ensure passed never goes negative
           details = []
           details << "#{failed_count} failed" if failed_count > 0
           details << "#{error_count} errors" if error_count > 0
@@ -214,12 +216,12 @@ class Tryouts
           puts "#{total_tests} tests passed#{time_str}"
         end
 
-        puts "Files processed: #{successful_files} of #{total_files} successful"
+        puts "Files: #{successful_files} of #{total_files} successful"
         puts '=' * @line_width
       end
 
       # Debug and diagnostic output
-      def debug_info(message, level = 0)
+      def debug_info(message, level: 0)
         return unless @show_debug
 
         prefix = Console.color(:cyan, 'INFO ')
@@ -227,14 +229,14 @@ class Tryouts
         puts indent_text("#{prefix} #{message}", level + 1)
       end
 
-      def trace_info(message, level = 0)
+      def trace_info(message, level: 0)
         return unless @show_trace
 
         prefix = Console.color(:dim, 'TRACE')
         puts indent_text("#{prefix} #{message}", level + 1)
       end
 
-      def error_message(message, backtrace = nil)
+      def error_message(message, backtrace: nil)
         error_msg = Console.color(:red, "ERROR: #{message}")
         puts indent_text(error_msg, 1)
 
@@ -248,22 +250,12 @@ class Tryouts
         puts indent_text("... (#{backtrace.length - 10} more lines)", 3) if backtrace.length > 10
       end
 
-      # Utility methods
-      def raw_output(text)
-        puts text
-      end
-
-      def separator(style = :light)
-        case style
-        when :heavy
-          puts '=' * @line_width
-        when :light
-          puts '-' * @line_width
-        when :dotted
-          puts '.' * @line_width
-        else # rubocop:disable Lint/DuplicateBranch
-          puts '-' * @line_width
-        end
+      def live_status_capabilities
+        {
+          supports_coordination: true,     # Verbose can work with coordinated output
+          output_frequency: :high,         # Outputs frequently for each test
+          requires_tty: false,             # Works without TTY
+        }
       end
 
       private
@@ -295,11 +287,11 @@ class Tryouts
         start_line = test_case.line_range.first
 
         test_case.source_lines.each_with_index do |line_content, index|
-          line_num     = start_line + index
+          line_num = start_line + index
           line_display = format('%3d: %s', line_num + 1, line_content)
 
           # Highlight expectation lines by checking if this line contains any expectation syntax
-          if line_content.match?(/^\s*#\s*=(!|<|=|\/=|\||:|~|%|\d+)?>\s*/)
+          if line_content.match?(%r{^\s*#\s*=(!|<|=|/=|\||:|~|%|\d+)?>\s*})
             line_display = Console.color(:yellow, line_display)
           end
 
@@ -312,19 +304,20 @@ class Tryouts
         return if actual_results.empty?
 
         actual_results.each_with_index do |actual, idx|
-          expected      = expected_results[idx] if expected_results && idx < expected_results.length
+          expected = expected_results[idx] if expected_results && idx < expected_results.length
           expected_line = test_case.expectations[idx] if test_case.expectations
 
           if !expected.nil?
             # Use the evaluated expected value from the evaluator
             puts indent_text("Expected: #{Console.color(:green, expected.inspect)}", 4)
             puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
-          elsif expected_line
-            # Fallback to raw expectation content
+          elsif expected_line && !expected_results.empty?
+            # Only show raw expectation content if we have expected_results (non-error case)
             puts indent_text("Expected: #{Console.color(:green, expected_line.content)}", 4)
             puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
           else
-            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
+            # For error cases (empty expected_results), just show the error
+            puts indent_text("Error:   #{Console.color(:red, actual.inspect)}", 4)
           end
 
           # Show difference if both are strings
@@ -345,10 +338,10 @@ class Tryouts
       end
 
       def file_header_visual(file_path)
-        pretty_path    = Console.pretty_path(file_path)
+        pretty_path = Console.pretty_path(file_path)
         header_content = ">>>>>  #{pretty_path}  "
         padding_length = [@line_width - header_content.length, 0].max
-        padding        = '<' * padding_length
+        padding = '<' * padding_length
 
         [
           indent_text('-' * @line_width, 1),
@@ -356,16 +349,6 @@ class Tryouts
           indent_text('-' * @line_width, 1),
         ].join("\n")
       end
-
-      def format_timing(elapsed_time)
-        if elapsed_time < 0.001
-          " (#{(elapsed_time * 1_000_000).round}μs)"
-        elsif elapsed_time < 1
-          " (#{(elapsed_time * 1000).round}ms)"
-        else
-          " (#{elapsed_time.round(2)}s)"
-        end
-      end
     end
 
     # Verbose formatter that only shows failures and errors
@@ -374,12 +357,27 @@ class Tryouts
         super(options.merge(show_passed: false))
       end
 
+      def test_output(test_case:, output_text:, result_packet:)
+        # Only show output for failed tests
+        return if result_packet.passed?
+
+        super
+      end
+
       def test_result(result_packet)
         # Only show failed/error tests, but with full source code
         return if result_packet.passed?
 
         super
       end
+
+      def live_status_capabilities
+        {
+          supports_coordination: true,     # Verbose can work with coordinated output
+          output_frequency: :high,         # Outputs frequently for each test
+          requires_tty: false,             # Works without TTY
+        }
+      end
     end
   end
 end

data/lib/tryouts/cli/formatters.rb

@@ -4,3 +4,6 @@ require_relative 'formatters/base'
 require_relative 'formatters/compact'
 require_relative 'formatters/quiet'
 require_relative 'formatters/verbose'
+require_relative 'formatters/test_run_state'
+require_relative 'formatters/tty_status_display'
+require_relative 'formatters/factory'