tryouts 3.1.2 → 3.2.0

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

@@ -0,0 +1,138 @@
+# lib/tryouts/cli/formatters/live_status_manager.rb
+
+require_relative 'test_run_state'
+require_relative 'tty_status_display'
+
+class Tryouts
+  class CLI
+    # Centralized manager for live status display across all formatters
+    # Replaces the decorator pattern with native integration
+    class LiveStatusManager
+      def initialize(formatter, options = {})
+        @formatter  = formatter
+        @enabled    = should_enable_live_status?(formatter, options)
+        @show_debug = options.fetch(:debug, false)
+
+        return unless @enabled
+
+        # Initialize state tracking and display
+        @state           = TestRunState.empty
+        @display         = TTYStatusDisplay.new(@formatter.stdout, options)
+        @status_reserved = false
+
+        debug_log('LiveStatusManager: Enabled with native integration')
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      # Check if formatter and environment support live status
+      def should_enable_live_status?(formatter, options)
+        # Must be explicitly requested
+        return false unless options[:live_status] || options[:live]
+
+        # Check formatter capabilities
+        capabilities = formatter.live_status_capabilities
+        return false unless capabilities[:supports_coordination]
+
+        # Check TTY availability
+        require_relative '../tty_detector'
+        tty_check = TTYDetector.check_tty_support(debug: options[:debug])
+
+        unless tty_check[:available]
+          debug_log("Live status disabled: #{tty_check[:reason]}")
+          return false
+        end
+
+        true
+      end
+
+      # Main event handling - called by OutputManager for each formatter event
+      def handle_event(event_type, *args, **)
+        return unless @enabled
+
+        # Update state based on the event
+        @state = @state.update_from_event(event_type, *args, **)
+
+        # Handle special events that need display coordination
+        case event_type
+        when :phase_header
+          message, file_count, level = args
+          if level == 0 && message.include?('PROCESSING') && file_count
+            reserve_status_area
+          end
+        when :file_start, :file_end, :test_result
+          update_display
+        when :batch_summary
+          # Clear status area before showing batch summary to avoid interference
+          clear_status_area
+        when :grand_total
+          # Ensure status area is cleared (redundant safety check)
+          clear_status_area if @status_reserved
+        end
+      end
+
+      # Allow formatter to directly update live status (optional integration point)
+      def update_status(state_updates = {})
+        return unless @enabled
+
+        @state = @state.with(**state_updates) unless state_updates.empty?
+        update_display
+      end
+
+      # Output coordination methods
+      def write_output
+        return yield unless @enabled
+
+        # If status area is reserved, coordinate the output
+        if @status_reserved
+          @display.write_scrolling(yield)
+        else
+          yield
+        end
+      end
+
+      def write_string(text)
+        return @formatter.stdout.print(text) unless @enabled
+
+        if @status_reserved
+          @display.write_scrolling(text)
+        else
+          @formatter.stdout.print(text)
+        end
+      end
+
+      private
+
+      def reserve_status_area
+        return unless @enabled && @display.available?
+
+        debug_log('Reserving status area for live display')
+        @display.reserve_status_area
+        @status_reserved = true
+        update_display
+      end
+
+      def update_display
+        return unless @enabled && @status_reserved
+
+        @display.update_status(@state)
+      end
+
+      def clear_status_area
+        return unless @enabled && @status_reserved
+
+        debug_log('Clearing status area for final output')
+        @display.clear_status_area
+        @status_reserved = false
+      end
+
+      def debug_log(message)
+        return unless @show_debug
+
+        @formatter.stderr.puts "DEBUG: #{message}"
+      end
+    end
+  end
+end

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

@@ -1,91 +1,114 @@
 # lib/tryouts/cli/formatters/output_manager.rb
 
+require_relative 'live_status_manager'
+
 class Tryouts
   class CLI
     # Output manager that coordinates all output through formatters
     class OutputManager
-      attr_reader :formatter
+      attr_reader :formatter, :live_status_manager
+
+      def initialize(formatter, options = {})
+        @formatter = formatter
+        @live_status_manager = LiveStatusManager.new(formatter, options)
 
-      def initialize(formatter)
-        @formatter    = formatter
-        @indent_level = 0
+        # Connect the formatter to the live status manager
+        @formatter.set_live_status_manager(@live_status_manager)
       end
 
       # Phase-level methods
-      def processing_phase(file_count, level = 0)
-        @formatter.phase_header("PROCESSING #{file_count} FILES", file_count, level)
+      def processing_phase(file_count)
+        message = "PROCESSING #{file_count} FILES"
+        @live_status_manager.handle_event(:phase_header, message, file_count, 0)
+        @formatter.phase_header(message, file_count: file_count)
       end
 
-      def execution_phase(test_count, level = 1)
-        @formatter.phase_header("EXECUTING #{test_count} TESTS", test_count, level)
+      def execution_phase(test_count)
+        message = "EXECUTING #{test_count} TESTS"
+        @live_status_manager.handle_event(:phase_header, message, test_count, 1)
+        @formatter.phase_header(message, file_count: test_count)
       end
 
-      def error_phase(level = 1)
-        @formatter.phase_header('ERROR DETAILS', level)
+      def error_phase
+        message = 'ERROR DETAILS'
+        @live_status_manager.handle_event(:phase_header, message, nil, 2)
+        @formatter.phase_header(message)
       end
 
       # File-level methods
       def file_start(file_path, framework: :direct, context: :fresh)
         context_info = { framework: framework, context: context }
-        @formatter.file_start(file_path, context_info)
+        @live_status_manager.handle_event(:file_start, file_path, context_info)
+        @formatter.file_start(file_path, context_info: context_info)
       end
 
       def file_end(file_path, framework: :direct, context: :fresh)
         context_info = { framework: framework, context: context }
-        @formatter.file_end(file_path, context_info)
+        @live_status_manager.handle_event(:file_end, file_path, context_info)
+        @formatter.file_end(file_path, context_info: context_info)
       end
 
       def file_parsed(file_path, test_count, setup_present: false, teardown_present: false)
-        with_indent(1) do
-          @formatter.file_parsed(file_path, test_count,
-            setup_present: setup_present,
-            teardown_present: teardown_present
-          )
-        end
+        @formatter.file_parsed(
+          file_path,
+          test_count: test_count,
+          setup_present: setup_present,
+          teardown_present: teardown_present
+        )
       end
 
       def file_execution_start(file_path, test_count, context_mode)
-        @formatter.file_execution_start(file_path, test_count, context_mode)
+        @formatter.file_execution_start(
+          file_path,
+          test_count: test_count,
+          context_mode: context_mode
+        )
       end
 
       def file_success(file_path, total_tests, failed_count, error_count, elapsed_time)
-        with_indent(1) do
-          @formatter.file_result(file_path, total_tests, failed_count, error_count, elapsed_time)
-        end
+        @formatter.file_result(
+          file_path,
+          total_tests: total_tests,
+          failed_count: failed_count,
+          error_count: error_count,
+          elapsed_time: elapsed_time
+        )
       end
 
       def file_failure(file_path, error_message, backtrace = nil)
-        with_indent(1) do
-          @formatter.error_message("#{Console.pretty_path(file_path)}: #{error_message}", backtrace)
-        end
+        @formatter.error_message(
+          "#{Console.pretty_path(file_path)}: #{error_message}",
+          backtrace: backtrace
+        )
       end
 
       # Test-level methods
       def test_start(test_case, index, total)
-        with_indent(2) do
-          @formatter.test_start(test_case, index, total)
-        end
+        @live_status_manager.handle_event(:test_start, test_case, index, total)
+        @formatter.test_start(test_case: test_case, index: index, total: total)
       end
 
       def test_end(test_case, index, total)
-        with_indent(2) do
-          @formatter.test_end(test_case, index, total)
-        end
+        @live_status_manager.handle_event(:test_end, test_case, index, total)
+        @formatter.test_end(test_case: test_case, index: index, total: total)
       end
 
       def test_result(result_packet)
+        @live_status_manager.handle_event(:test_result, result_packet)
         @formatter.test_result(result_packet)
       end
 
-      def test_output(test_case, output_text)
-        @formatter.test_output(test_case, output_text)
+      def test_output(test_case, output_text, result_packet)
+        @formatter.test_output(
+          test_case: test_case,
+          output_text: output_text,
+          result_packet: result_packet
+        )
       end
 
       # Setup/teardown methods
       def setup_start(line_range)
-        with_indent(2) do
-          @formatter.setup_start(line_range)
-        end
+        @formatter.setup_start(line_range: line_range)
       end
 
       def setup_output(output_text)
@@ -93,9 +116,7 @@ class Tryouts
       end
 
       def teardown_start(line_range)
-        with_indent(2) do
-          @formatter.teardown_start(line_range)
-        end
+        @formatter.teardown_start(line_range: line_range)
       end
 
       def teardown_output(output_text)
@@ -103,48 +124,39 @@ class Tryouts
       end
 
       # Summary methods
-      def batch_summary(total_tests, failed_count, elapsed_time)
-        @formatter.batch_summary(total_tests, failed_count, elapsed_time)
+      def batch_summary(failure_collector)
+        @live_status_manager.handle_event(:batch_summary, failure_collector)
+        @formatter.batch_summary(failure_collector)
       end
 
       def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
-        @formatter.grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+        @live_status_manager.handle_event(:grand_total, total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+        @formatter.grand_total(
+          total_tests: total_tests,
+          failed_count: failed_count,
+          error_count: error_count,
+          successful_files: successful_files,
+          total_files: total_files,
+          elapsed_time: elapsed_time
+        )
       end
 
       # Debug methods
       def info(message, level = 0)
-        with_indent(level) do
-          @formatter.debug_info(message, level)
-        end
+        @formatter.debug_info(message, level: level)
       end
 
       def trace(message, level = 0)
-        with_indent(level) do
-          @formatter.trace_info(message, level)
-        end
+        @formatter.trace_info(message, level: level)
       end
 
       def error(message, backtrace = nil)
-        @formatter.error_message(message, backtrace)
-      end
-
-      # Utility methods
-      def raw(text)
-        @formatter.raw_output(text)
+        @formatter.error_message(message, backtrace: backtrace)
       end
 
-      def separator(style = :light)
-        @formatter.separator(style)
-      end
-
-      private
-
-      def with_indent(level)
-        old_level     = @indent_level
-        @indent_level = level
-        yield
-      ensure
-        @indent_level = old_level
+      # Raw output method (bypasses formatting)
+      def raw(message)
+        @formatter.stdout.puts(message)
       end
     end
   end

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

@@ -7,102 +7,50 @@ class Tryouts
       include FormatterInterface
 
       def initialize(options = {})
+        super
         @show_errors        = options.fetch(:show_errors, true)
         @show_final_summary = options.fetch(:show_final_summary, true)
         @current_file       = nil
       end
 
-      # Phase-level output - silent
-      def phase_header(message, file_count = nil, level = nil)
-        # Silent in quiet mode
-      end
-
-      # File-level operations - minimal
-      def file_start(file_path, context_info = {})
-        # Silent in quiet mode
-      end
-
-      def file_end(_file_path, _context_info = {}, io = $stderr)
-        io.puts # add newline after all dots
-      end
-
-      def file_parsed(file_path, test_count, setup_present: false, teardown_present: false)
-        # Silent in quiet mode
-      end
-
-      def file_execution_start(file_path, _test_count, _context_mode)
+      def file_execution_start(file_path, test_count:, context_mode:)
         @current_file = file_path
       end
 
-      def file_result(file_path, total_tests, failed_count, error_count, elapsed_time)
-        # Silent in quiet mode - results shown in batch_summary
-      end
-
-      # Test-level operations - dot notation
-      def test_start(test_case, index, total)
-        # Silent in quiet mode
-      end
-
-      def test_end(test_case, index, total, io = $stderr)
-        # Silent in quiet mode
-      end
-
-      def test_result(result_packet, io = $stderr)
-        case result_packet.status
-        when :passed
-          io.print Console.color(:green, '.')
-        when :failed
-          io.print Console.color(:red, 'F')
-        when :error
-          io.print Console.color(:red, 'E')
-        when :skipped
-          io.print Console.color(:yellow, 'S')
-        else
-          io.print '?'
-        end
-        io.flush
-      end
-
-      def test_output(test_case, output_text)
-        # Silent in quiet mode - could optionally show output for failed tests only
-        # For now, keeping it completely silent
-      end
-
-      # Setup/teardown operations - silent
-      def setup_start(line_range)
-        # Silent in quiet mode
-      end
-
-      def setup_output(output_text)
-        # Silent in quiet mode
-      end
-
-      def teardown_start(line_range)
-        # Silent in quiet mode
-      end
-
-      def teardown_output(output_text)
-        # Silent in quiet mode
-      end
-
-      # Summary operations - show results
-      def batch_summary(total_tests, failed_count, elapsed_time, io = $stderr)
-        return unless @show_final_summary
-
-        if failed_count > 0
-          passed   = total_tests - failed_count
-          time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
-          io.puts "#{failed_count} failed, #{passed} passed#{time_str}"
-        else
-          time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
-          io.puts "#{total_tests} passed#{time_str}"
-        end
+      def file_end(_file_path, context_info: {})
+        # Always use coordinated output through puts() method
+        # puts # add newline after all dots
       end
 
-      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+      def test_result(result_packet)
+        char = case result_packet.status
+               when :passed
+                 Console.color(:green, '.')
+               when :failed
+                 Console.color(:red, 'F')
+               when :error
+                 Console.color(:red, 'E')
+               when :skipped
+                 Console.color(:yellow, 'S')
+               else
+                 '?'
+               end
+
+        # Always use coordinated output through write() method
+        write(char)
+      end
+
+      # Summary operations - quiet mode skips failure summary
+      def batch_summary(failure_collector)
+        # Quiet formatter defaults to no failure summary
+        # Users can override with --failure-summary if needed
+      end
+
+      def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
         return unless @show_final_summary
 
         puts
+        puts # Add newline after dots
 
         time_str = if elapsed_time < 2
                      "#{(elapsed_time * 1000).to_i}ms"
@@ -126,29 +74,25 @@ class Tryouts
         end
       end
 
-      # Debug and diagnostic output - silent unless errors
-      def debug_info(message, level = 0)
-        # Silent in quiet mode
-      end
-
-      def trace_info(message, level = 0)
-        # Silent in quiet mode
-      end
-
-      def error_message(message, _details = nil)
+      def error_message(message, backtrace: nil)
         return unless @show_errors
 
-        puts
-        puts Console.color(:red, "ERROR: #{message}")
-      end
+        @stderr.puts
+        @stderr.puts Console.color(:red, "ERROR: #{message}")
+
+        return unless backtrace && @show_debug
 
-      # Utility methods
-      def raw_output(text)
-        puts text if @show_final_summary
+        backtrace.first(3).each do |line|
+          @stderr.puts "  #{line.chomp}"
+        end
       end
 
-      def separator(style = :light)
-        # Silent in quiet mode
+      def live_status_capabilities
+        {
+          supports_coordination: true,     # Quiet can work with coordinated output
+          output_frequency: :low,          # Very minimal output, mainly dots
+          requires_tty: false,             # Works without TTY
+        }
       end
     end
 
@@ -160,6 +104,14 @@ class Tryouts
 
         super
       end
+
+      def live_status_capabilities
+        {
+          supports_coordination: true,     # QuietFails can work with coordinated output
+          output_frequency: :low,          # Very minimal output
+          requires_tty: false,             # Works without TTY
+        }
+      end
     end
   end
 end

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

@@ -0,0 +1,122 @@
+# lib/tryouts/cli/formatters/test_run_state.rb
+
+class Tryouts
+  class CLI
+    # Immutable state tracking for test runs using modern Ruby Data.define
+    class TestRunState < Data.define(
+      :total_tests,
+      :passed,
+      :failed,
+      :errors,
+      :files_completed,
+      :total_files,
+      :current_file,
+      :current_test,
+      :start_time,
+    )
+      def self.empty
+        new(
+          total_tests: 0,
+          passed: 0,
+          failed: 0,
+          errors: 0,
+          files_completed: 0,
+          total_files: 0,
+          current_file: nil,
+          current_test: nil,
+          start_time: nil,
+        )
+      end
+
+      def self.initial(total_files: 0)
+        empty.with(
+          total_files: total_files,
+          start_time: Time.now,
+        )
+      end
+
+      # Update state based on formatter events using pattern matching
+      def update_from_event(event_type, *args, **_kwargs)
+        case event_type
+        in :phase_header
+          _, file_count, level = args
+          if level == 0 && file_count
+            with(total_files: file_count, start_time: Time.now)
+          else
+            self
+          end
+
+        in :file_start
+          file_path   = args[0]
+          pretty_path = Console.pretty_path(file_path)
+          with(current_file: pretty_path)
+
+        in :file_end
+          with(
+            files_completed: files_completed + 1,
+            current_file: nil,
+          )
+
+        in :test_start
+          test_case = args[0]
+          desc      = test_case.description.to_s
+          desc      = "test #{args[1]}" if desc.empty?
+          with(current_test: desc)
+
+        in :test_end
+          with(current_test: nil)
+
+        in :test_result
+          result_packet = args[0]
+          updated_state = with(total_tests: total_tests + 1)
+
+          case result_packet.status
+          when :passed
+            updated_state.with(passed: passed + 1)
+          when :failed
+            updated_state.with(failed: failed + 1)
+          when :error
+            updated_state.with(errors: errors + 1)
+          else
+            updated_state
+          end
+
+        else
+          # Unknown event, return unchanged state
+          self
+        end
+      end
+
+      # Computed properties
+      def elapsed_time
+        start_time ? Time.now - start_time : 0
+      end
+
+      def issues_count
+        failed + errors
+      end
+
+      def passed_count
+        total_tests - issues_count
+      end
+
+      def has_issues?
+        issues_count > 0
+      end
+
+      def tests_run?
+        total_tests > 0
+      end
+
+      def files_remaining
+        total_files - files_completed
+      end
+
+      def completion_percentage
+        return 0 if total_files == 0
+
+        (files_completed.to_f / total_files * 100).round(1)
+      end
+    end
+  end
+end