tryouts 3.1.2 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2dea4f111f12c35d204df54313a62045bd9e8841710b19323454e5a626ac4fd
-  data.tar.gz: 275b234c7ce6ca2debd28e9d861053bc041e825443683078fee710de2b45e0cf
+  metadata.gz: 95b7078a356f605ba8df53a52afcb2209d260c473787692c4b70c0d88e8c5620
+  data.tar.gz: f6d47e78b51ee13d754c03525329a1857a44767324abc6237a4896f81688ecc2
 SHA512:
-  metadata.gz: 6c704d75d9bed36875b843b6014508df36292247e9c03bbc68892f1d7318db0cfd8ff9907c9c45d71d45441e9512dd5550e4c47b84a9075285ccf8980474c4b9
-  data.tar.gz: 0230e782d3a214bb92e647d2beb38e3b3ce1d3bbc129f6628ca14b0b7cef1430fee94ee7746bda55e78a8236da5df1fbf7b6270a8f0a186646f5a01662d0d667
+  metadata.gz: e49a47fd56ba73dc0a80deeb0d3559558b4dbefcc31904c21358a906e7f542d6a8caa7479b8d95e66af6e52f7ea4760d3df76e7e0b310f037f3a369adc9f3cbf
+  data.tar.gz: 8de293b074a3599af4c543b05b3d49d58508b154eb4cce396e55027343042fb5289020cbdd8277d03abf667303ec935d59d3ece8f3e50ec308e150b9541dbda8

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

@@ -1,118 +1,180 @@
 # lib/tryouts/cli/formatters/base.rb
 
-require_relative 'factory'
 require_relative 'output_manager'
 
 class Tryouts
   class CLI
     # Enhanced interface for all test output formatting
     module FormatterInterface
-      attr_reader :current_indent
+      attr_reader :stdout, :stderr, :current_indent
+
+      def initialize(options = {})
+        @stdout = options.fetch(:stdout, $stdout)
+        @stderr = options.fetch(:stderr, $stderr)
+        @current_indent = 0
+        @options = options
+      end
 
       # Phase-level output (major sections)
-      def phase_header(message, file_count = nil, level = 0, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #phase_header"
+      def phase_header(message, file_count: nil)
+        # Default: no output
       end
 
       # File-level operations
-      def file_start(file_path, context_info = {}, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #file_start"
+      def file_start(file_path, context_info: {})
+        # Default: no output
       end
 
-      def file_end(file_path, context_info = {}, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #file_end"
+      def file_end(file_path, context_info: {})
+        # Default: no output
       end
 
-      def file_parsed(file_path, test_count, io = $stdout, setup_present: false, teardown_present: false)
-        raise NotImplementedError, "#{self.class} must implement #file_parsed"
+      def file_parsed(file_path, test_count:, setup_present: false, teardown_present: false)
+        # Default: no output
       end
 
-      def file_execution_start(file_path, test_count, context_mode, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #file_execution_start"
+      def file_execution_start(file_path, test_count:, context_mode:)
+        # Default: no output
       end
 
-      def file_result(file_path, total_tests, failed_count, error_count, elapsed_time, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #file_result"
+      def file_result(file_path, total_tests:, failed_count:, error_count:, elapsed_time: nil)
+        # Default: no output
       end
 
       # Test-level operations
-      def test_start(test_case, index, total, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #test_start"
+      def test_start(test_case:, index:, total:)
+        # Default: no output
       end
 
-      def test_end(test_case, index, total, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #test_end"
+      def test_end(test_case:, index:, total:)
+        # Default: no output
       end
 
-      def test_result(result_packet, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #test_result"
+      def test_result(result_packet)
+        # Default: no output
       end
 
-      def test_output(test_case, output_text, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #test_output"
+      def test_output(test_case:, output_text:, result_packet:)
+        # Default: no output
       end
 
       # Setup/teardown operations
-      def setup_start(line_range, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #setup_start"
+      def setup_start(line_range:)
+        # Default: no output
       end
 
-      def setup_output(output_text, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #setup_output"
+      def setup_output(output_text)
+        # Default: no output
       end
 
-      def teardown_start(line_range, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #teardown_start"
+      def teardown_start(line_range:)
+        # Default: no output
       end
 
-      def teardown_output(output_text, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #teardown_output"
+      def teardown_output(output_text)
+        # Default: no output
       end
 
       # Summary operations
-      def batch_summary(total_tests, failed_count, elapsed_time, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #batch_summary"
+      def batch_summary(failure_collector)
+        # Default: no output
       end
 
-      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #grand_total"
+      def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
+        # Default: no output
       end
 
       # Debug and diagnostic output
-      def debug_info(message, level = 0, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #debug_info"
+      def debug_info(message, level: 0)
+        # Default: no output
+      end
+
+      def trace_info(message, level: 0)
+        # Default: no output
       end
 
-      def trace_info(message, level = 0, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #trace_info"
+      def error_message(message, backtrace: nil)
+        # Default: no output
       end
 
-      def error_message(message, details = nil, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #error_message"
+      # Live status capability negotiation
+      def live_status_capabilities
+        {
+          supports_coordination: false,    # Can work with coordinated output
+          output_frequency: :medium,       # :low, :medium, :high
+          requires_tty: false,             # Must have TTY to function
+        }
       end
 
-      # Utility methods
-      def raw_output(text, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #raw_output"
+      # Live status integration (optional methods)
+      def set_live_status_manager(manager)
+        @live_status_manager = manager
       end
 
-      def separator(style = :light, io = $stdout)
-        raise NotImplementedError, "#{self.class} must implement #separator"
+      def live_status_manager
+        @live_status_manager
       end
 
+      # Standard output methods that coordinate with live status automatically
+      def write(text)
+        if @live_status_manager&.enabled?
+          @live_status_manager.write_string(text)
+        else
+          @stdout.print(text)
+        end
+      end
+
+      def puts(text = '')
+        write("#{text}\n")
+      end
+
+      # Optional: formatters can implement this to provide custom live status updates
+      def update_live_status(state_updates = {})
+        @live_status_manager&.update_status(state_updates)
+      end
+
+      protected
+
+      # Utility methods for formatters to use
       def indent_text(text, level = nil)
         level ||= current_indent || 0
-        indent  = '  ' * level
+        indent = '  ' * level
         "#{indent}#{text}"
       end
 
       def with_indent(level)
-        old_indent      = @current_indent
+        old_indent = @current_indent
         @current_indent = level
         yield
       ensure
         @current_indent = old_indent
       end
+
+      def separator(style = :light)
+        width = @options.fetch(:line_width, 70)
+        case style
+        when :heavy
+          '=' * width
+        when :light
+          '-' * width
+        when :dotted
+          '.' * width
+        else
+          '-' * width
+        end
+      end
+
+      def format_timing(elapsed_time)
+        return '' unless 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
   end
 end

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

@@ -7,38 +7,31 @@ class Tryouts
       include FormatterInterface
 
       def initialize(options = {})
-        @show_debug        = options.fetch(:debug, false)
-        @show_trace        = options.fetch(:trace, false)
-        @show_passed       = options.fetch(:show_passed, true)
+        super
+        @show_debug  = options.fetch(:debug, false)
+        @show_trace  = options.fetch(:trace, false)
+        @show_passed = options.fetch(:show_passed, true)
       end
 
       # Phase-level output - minimal for compact mode
-      def phase_header(message, file_count = nil, level = 0, io = $stderr)
+      def phase_header(message, file_count: nil)
         # Show processing header but skip execution phase headers to avoid empty lines
-        case level
-        when 0
+        if message.include?('PROCESSING')
           # Main processing header
           text = file_count ? "#{message}" : "#{message}..."
-          io.puts text
-        when 1
-          # Skip execution phase headers - they create unwanted empty lines
-          nil
-        else
+          @stderr.puts text
+        elsif !message.include?('EXECUTING')
           # Other phase headers with minimal formatting
-          io.puts indent_text(message, level - 1)
+          @stderr.puts message
         end
       end
 
       # File-level operations - compact single lines
-      def file_start(file_path, _context_info = {}, io = $stderr)
-        # See file_execution_start
-      end
-
-      def file_end(file_path, context_info = {}, io = $stderr)
-        # No output in compact mode
+      def file_start(file_path, context_info: {})
+        # Output handled in file_execution_start for compact mode
       end
 
-      def file_parsed(_file_path, test_count, io = $stderr, setup_present: false, teardown_present: false)
+      def file_parsed(_file_path, test_count:, setup_present: false, teardown_present: false)
         # Don't show parsing info in compact mode unless debug
         return unless @show_debug
 
@@ -47,25 +40,46 @@ class Tryouts
         extras << 'teardown' if teardown_present
         suffix = extras.empty? ? '' : " +#{extras.join(',')}"
 
-        io.puts indent_text("Parsed #{test_count} tests#{suffix}", 1)
+        @stderr.puts indent_text("Parsed #{test_count} tests#{suffix}", 1)
       end
 
-      def file_execution_start(file_path, test_count, _context_mode, io = $stderr)
+      def file_execution_start(file_path, test_count:, context_mode:)
         pretty_path = Console.pretty_path(file_path)
-        io.puts "#{pretty_path}: #{test_count} tests"
+        @stderr.puts "#{pretty_path}: #{test_count} tests"
       end
 
-      # Summary operations
-      def batch_summary(total_tests, failed_count, elapsed_time)
-        # Skip - file_result already shows this information with better alignment
+      # Summary operations - show failure summary
+      def batch_summary(failure_collector)
+        return unless failure_collector.any_failures?
+
+        puts
+        puts separator
+        puts Console.color(:red, 'Failed Tests:')
+        puts
+
+        failure_collector.failures_by_file.each do |file_path, failures|
+          failures.each do |failure|
+            pretty_path = Console.pretty_path(file_path)
+
+            # Include line number with file path for easy copying/clicking
+            location = if failure.line_number > 0
+              "#{pretty_path}:#{failure.line_number}"
+            else
+              pretty_path
+                       end
+
+            puts "  #{location}"
+            puts "    #{Console.color(:red, '✗')} #{failure.description}"
+            puts "      #{failure.failure_reason}"
+            puts
+          end
+        end
       end
 
-      def file_result(_file_path, total_tests, failed_count, error_count, elapsed_time, io = $stdout)
+      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 = []
 
         if issues_count > 0
           status = Console.color(:red, '✗')
@@ -76,57 +90,47 @@ class Tryouts
         end
 
         if error_count > 0
-          status = Console.color(:yellow, '⚠') if error_count == 0
           details << "#{error_count} errors"
         end
 
         if failed_count > 0
-          status = Console.color(:yellow, '⚠') if failed_count == 0
           details << "#{failed_count} failed"
         end
 
-        time_str = if elapsed_time
-                     format_timing(elapsed_time)
-                   else
-                     ''
-                   end
-        io.puts "  #{status} #{details.join(', ')}#{time_str}"
+        time_str = format_timing(elapsed_time)
+        puts "  #{status} #{details.join(', ')}#{time_str}"
       end
 
       # Test-level operations - only show in debug mode for compact
-      def test_start(test_case, index, _total, io = $stdout)
+      def test_start(test_case:, index:, total:)
         return unless @show_debug
 
         desc = test_case.description.to_s
         desc = "test #{index}" if desc.empty?
 
-        io.puts "    Running: #{desc}"
-      end
-
-      def test_end(test_case, index, _total, io = $stdout)
-        # No output for test end
+        puts "    Running: #{desc}"
       end
 
-      def test_result(result_packet, io = $stdout)
+      def test_result(result_packet)
         # Only show failed tests in compact mode unless show_passed is true
         return if result_packet.passed? && !@show_passed
 
         test_case = result_packet.test_case
-        desc      = test_case.description.to_s
-        desc      = 'unnamed test' if desc.empty?
+        desc = test_case.description.to_s
+        desc = 'unnamed test' if desc.empty?
 
         case result_packet.status
         when :passed
           status = Console.color(:green, '✓')
-          io.puts indent_text("#{status} #{desc}", 1)
+          puts indent_text("#{status} #{desc}", 1)
         when :failed
           status = Console.color(:red, '✗')
-          io.puts indent_text("#{status} #{desc}", 1)
+          puts indent_text("#{status} #{desc}", 1)
 
           # Show minimal context for failures
           if result_packet.actual_results.any?
             failure_info = "got: #{result_packet.first_actual.inspect}"
-            io.puts indent_text("    #{failure_info}", 1)
+            puts indent_text("    #{failure_info}", 1)
           end
 
           # Show 1-2 lines of test context if available
@@ -134,137 +138,116 @@ class Tryouts
             test_case.source_lines.each do |line|
               next if line.strip.empty? || line.strip.start_with?('#')
 
-              io.puts indent_text("    #{line.strip}", 1)
+              puts indent_text("    #{line.strip}", 1)
               break # Only show first relevant line
             end
           end
         when :skipped
           status = Console.color(:yellow, '-')
-          io.puts indent_text("#{status} #{desc}", 1)
+          puts indent_text("#{status} #{desc}", 1)
         else
           status = '?'
-          io.puts indent_text("#{status} #{desc}", 1)
+          puts indent_text("#{status} #{desc}", 1)
         end
       end
 
-      def test_output(_test_case, output_text, io = $stdout)
+      def test_output(test_case:, output_text:, result_packet:)
         # In compact mode, only show output for failed tests and only if debug mode is enabled
         return if output_text.nil? || output_text.strip.empty?
         return unless @show_debug
+        return if result_packet.passed?
 
-        io.puts "    Output: #{output_text.lines.count} lines"
+        puts "    Output: #{output_text.lines.count} lines"
         if output_text.lines.count <= 3
           output_text.lines.each do |line|
-            io.puts "      #{line.chomp}"
+            puts "      #{line.chomp}"
           end
         else
-          io.puts "      #{output_text.lines.first.chomp}"
-          io.puts "      ... (#{output_text.lines.count - 2} more lines)"
-          io.puts "      #{output_text.lines.last.chomp}"
+          puts "      #{output_text.lines.first.chomp}"
+          puts "      ... (#{output_text.lines.count - 2} more lines)"
+          puts "      #{output_text.lines.last.chomp}"
         end
       end
 
       # Setup/teardown operations - minimal output
-      def setup_start(_line_range)
+      def setup_start(line_range:)
         # No file setup start output for compact
       end
 
-      def setup_output(output_text, io = $stderr)
+      def setup_output(output_text)
         return if output_text.strip.empty?
         return unless @show_debug
 
         # In compact mode, just show that there was output
         lines = output_text.lines.count
-        io.puts "    Setup output (#{lines} lines)"
+        @stderr.puts "    Setup output (#{lines} lines)"
       end
 
-      def teardown_start(_line_range, io = $stderr)
+      def teardown_start(line_range:)
         return unless @show_debug
 
-        io.puts '    Teardown...'
+        @stderr.puts '    Teardown...'
       end
 
-      def teardown_output(output_text, io = $stderr)
+      def teardown_output(output_text)
         return if output_text.strip.empty?
         return unless @show_debug
 
         # In compact mode, just show that there was output
         lines = output_text.lines.count
-        io.puts "    Teardown output (#{lines} lines)"
+        @stderr.puts "    Teardown output (#{lines} lines)"
       end
 
-      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time, io = $stderr)
-        io.puts
-        io.puts '=' * 50
+      def grand_total(total_tests:, failed_count:, error_count:, successful_files:, total_files:, elapsed_time:)
+        @stderr.puts
+        @stderr.puts '=' * 50
 
         issues_count = failed_count + error_count
         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
-          result  = Console.color(:red, "#{details.join(', ')}, #{passed} passed")
+          result = Console.color(:red, "#{details.join(', ')}, #{passed} passed")
         else
           result = Console.color(:green, "#{total_tests} tests passed")
         end
 
         time_str = format_timing(elapsed_time)
 
-        io.puts "Total: #{result} #{time_str}"
-        io.puts "Files: #{successful_files} of #{total_files} successful"
+        @stderr.puts "Total: #{result}#{time_str}"
+        @stderr.puts "Files: #{successful_files} of #{total_files} successful"
       end
 
       # Debug and diagnostic output - minimal in compact mode
-      def debug_info(message, level = 0, io = $stderr)
+      def debug_info(message, level: 0)
         return unless @show_debug
 
-        io.puts indent_text("DEBUG: #{message}", level)
+        @stderr.puts indent_text("DEBUG: #{message}", level)
       end
 
-      def trace_info(message, level = 0, io = $stderr)
+      def trace_info(message, level: 0)
         return unless @show_trace
 
-        io.puts indent_text("TRACE: #{message}", level)
+        @stderr.puts indent_text("TRACE: #{message}", level)
       end
 
-      def error_message(message, backtrace = nil, io = $stderr)
-        io.puts Console.color(:red, "ERROR: #{message}")
+      def error_message(message, backtrace: nil)
+        @stderr.puts Console.color(:red, "ERROR: #{message}")
 
         return unless backtrace && @show_debug
 
         backtrace.first(3).each do |line|
-          io.puts indent_text(line.chomp, 1)
+          @stderr.puts indent_text(line.chomp, 1)
         end
       end
 
-      # Utility methods
-      def raw_output(text, io = $stdout)
-        io.puts text
-      end
-
-      def separator(style = :light, io = $stdout)
-        case style
-        when :heavy
-          io.puts '=' * 50
-        when :light
-          io.puts '-' * 50
-        when :dotted
-          io.puts '.' * 50
-        else
-          io.puts '-' * 50
-        end
-      end
-
-      private
-
-      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
+      def live_status_capabilities
+        {
+          supports_coordination: true,     # Compact can work with coordinated output
+          output_frequency: :medium,       # Outputs at medium frequency
+          requires_tty: false,             # Works without TTY
+        }
       end
     end
 
@@ -280,6 +263,14 @@ class Tryouts
 
         super
       end
+
+      def live_status_capabilities
+        {
+          supports_coordination: true,     # Compact can work with coordinated output
+          output_frequency: :low,          # Outputs infrequently, mainly summaries
+          requires_tty: false,             # Works without TTY
+        }
+      end
     end
   end
 end

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

@@ -1,19 +1,22 @@
 # lib/tryouts/cli/formatters/factory.rb
 
+require_relative '../tty_detector'
+
 class Tryouts
   class CLI
     # Factory for creating formatters and output managers
     class FormatterFactory
       def self.create_output_manager(options = {})
         formatter = create_formatter(options)
-        OutputManager.new(formatter)
+        OutputManager.new(formatter, options)
       end
 
       def self.create_formatter(options = {})
         # Map boolean flags to format symbols if format not explicitly set
         format = options[:format]&.to_sym || determine_format_from_flags(options)
 
-        case format
+        # Create base formatter first
+        base_formatter = case format
         when :verbose
           if options[:fails_only]
             VerboseFailsFormatter.new(options)
@@ -35,6 +38,9 @@ class Tryouts
         else
           CompactFormatter.new(options) # Default to compact
         end
+
+        # Return base formatter - live status is now handled by OutputManager/LiveStatusManager
+        base_formatter
       end
 
       class << self