tryouts 3.0.0.pre2 → 3.1.0

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

@@ -13,26 +13,32 @@ class Tryouts
       end
 
       # Phase-level output - minimal for compact mode
-      def phase_header(message, _file_count = nil, level = 0)
-        # Skip execution phase headers in compact mode - they create unwanted empty lines
-        return if level >= 1
-
-        text       = "#{message}..."
-        puts indent_text(text, level)
+      def phase_header(message, file_count = nil, level = 0, io = $stderr)
+        # Show processing header but skip execution phase headers to avoid empty lines
+        case level
+        when 0
+          # Main processing header
+          text = file_count ? "#{message}" : "#{message}..."
+          io.puts text
+        when 1
+          # Skip execution phase headers - they create unwanted empty lines
+          return
+        else
+          # Other phase headers with minimal formatting
+          io.puts indent_text(message, level - 1)
+        end
       end
 
       # File-level operations - compact single lines
-      def file_start(file_path, context_info = {})
-        return unless @show_debug
-
-        framework   = context_info[:framework] || :direct
-        context     = context_info[:context] || :fresh
-        pretty_path = Console.pretty_path(file_path)
+      def file_start(file_path, _context_info = {}, io = $stderr)
+        # See file_execution_start
+      end
 
-        puts indent_text("Running: #{pretty_path} (#{framework}/#{context})", 1)
+      def file_end(file_path, context_info = {}, io = $stderr)
+        # No output in compact mode
       end
 
-      def file_parsed(_file_path, test_count, setup_present: false, teardown_present: false)
+      def file_parsed(_file_path, test_count, io = $stderr, setup_present: false, teardown_present: false)
         # Don't show parsing info in compact mode unless debug
         return unless @show_debug
 
@@ -41,90 +47,119 @@ class Tryouts
         extras << 'teardown' if teardown_present
         suffix = extras.empty? ? '' : " +#{extras.join(',')}"
 
-        puts indent_text("Parsed #{test_count} tests#{suffix}", 1)
+        io.puts indent_text("Parsed #{test_count} tests#{suffix}", 1)
       end
 
-      def file_execution_start(file_path, test_count, _context_mode)
+      def file_execution_start(file_path, test_count, _context_mode, io = $stderr)
         pretty_path = Console.pretty_path(file_path)
-        puts
-        puts "#{pretty_path}: #{test_count} tests"
+        io.puts "#{pretty_path}: #{test_count} tests"
       end
 
-      def file_result(_file_path, total_tests, failed_count, error_count, elapsed_time)
-        detail = []
-        if failed_count > 0
+      # Summary operations
+      def batch_summary(total_tests, failed_count, elapsed_time)
+        # Skip - file_result already shows this information with better alignment
+      end
+
+      def file_result(_file_path, total_tests, failed_count, error_count, elapsed_time, io = $stdout)
+        issues_count = failed_count + error_count
+        passed_count = total_tests - issues_count
+        details      = [
+          # "#{passed_count} passed",
+        ]
+
+        if issues_count > 0
           status = Console.color(:red, '✗')
-          detail << "#{failed_count}/#{total_tests} failed"
+          details << "#{passed_count}/#{total_tests} passed"
         else
           status = Console.color(:green, '✓')
-          detail << "#{total_tests} passed"
+          details << "#{total_tests} passed"
         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
-          detail << "#{error_count} errors"
+          details << "#{failed_count} failed"
         end
 
         time_str = if elapsed_time
-                     if elapsed_time < 2
-                       " (#{(elapsed_time * 1000).to_i}ms)"
-                     else
-                       " (#{elapsed_time.round(2)}s)"
-                     end
+                     format_timing(elapsed_time)
                    else
                      ''
                    end
-        puts "  #{status} #{detail.join(', ')}#{time_str}"
+        io.puts "  #{status} #{details.join(', ')}#{time_str}"
       end
 
       # Test-level operations - only show in debug mode for compact
-      def test_start(test_case, index, _total)
+      def test_start(test_case, index, _total, io = $stdout)
         return unless @show_debug
 
         desc = test_case.description.to_s
         desc = "test #{index}" if desc.empty?
-        puts "    Running: #{desc}"
+
+        io.puts "    Running: #{desc}"
+      end
+
+      def test_end(test_case, index, _total, io = $stdout)
+        # No output for test end
       end
 
-      def test_result(test_case, result_status, actual_results = [], _elapsed_time = nil)
+      def test_result(result_packet, io = $stdout)
         # Only show failed tests in compact mode unless show_passed is true
-        return if result_status == :passed && !@show_passed
+        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?
 
-        case result_status
+        case result_packet.status
         when :passed
           status = Console.color(:green, '✓')
+          io.puts indent_text("#{status} #{desc}", 1)
         when :failed
           status = Console.color(:red, '✗')
-          if actual_results.any?
-            failure_info = " (got: #{actual_results.first.inspect})"
-            desc        += failure_info
+          io.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)
+          end
+
+          # Show 1-2 lines of test context if available
+          if test_case.source_lines && test_case.source_lines.size <= 3
+            test_case.source_lines.each do |line|
+              next if line.strip.empty? || line.strip.start_with?('#')
+              io.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)
         else
           status = '?'
+          io.puts indent_text("#{status} #{desc}", 1)
         end
-
-        puts indent_text("#{status} #{desc}", 1)
       end
 
-      def test_output(test_case, output_text)
+      def test_output(_test_case, output_text, io = $stdout)
         # 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
 
-        puts "    Output: #{output_text.lines.count} lines"
+        io.puts "    Output: #{output_text.lines.count} lines"
         if output_text.lines.count <= 3
           output_text.lines.each do |line|
-            puts "      #{line.chomp}"
+            io.puts "      #{line.chomp}"
           end
         else
-          puts "      #{output_text.lines.first.chomp}"
-          puts "      ... (#{output_text.lines.count - 2} more lines)"
-          puts "      #{output_text.lines.last.chomp}"
+          io.puts "      #{output_text.lines.first.chomp}"
+          io.puts "      ... (#{output_text.lines.count - 2} more lines)"
+          io.puts "      #{output_text.lines.last.chomp}"
         end
       end
 
@@ -133,42 +168,37 @@ class Tryouts
         # No file setup start output for compact
       end
 
-      def setup_output(output_text)
+      def setup_output(output_text, io = $stderr)
         return if output_text.strip.empty?
         return unless @show_debug
 
         # In compact mode, just show that there was output
         lines = output_text.lines.count
-        puts "    Setup output (#{lines} lines)"
+        io.puts "    Setup output (#{lines} lines)"
       end
 
-      def teardown_start(_line_range)
+      def teardown_start(_line_range, io = $stderr)
         return unless @show_debug
 
-        puts '    Teardown...'
+        io.puts '    Teardown...'
       end
 
-      def teardown_output(output_text)
+      def teardown_output(output_text, io = $stderr)
         return if output_text.strip.empty?
         return unless @show_debug
 
         # In compact mode, just show that there was output
         lines = output_text.lines.count
-        puts "    Teardown output (#{lines} lines)"
+        io.puts "    Teardown output (#{lines} lines)"
       end
 
-      # Summary operations
-      def batch_summary(total_tests, failed_count, elapsed_time)
-        # Skip - file_result already shows this information with better alignment
-      end
-
-      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
-        puts
-        puts '=' * 50
+      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time, io = $stderr)
+        io.puts
+        io.puts '=' * 50
 
         issues_count = failed_count + error_count
         if issues_count > 0
-          passed  = total_tests - issues_count
+          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
@@ -177,54 +207,62 @@ class Tryouts
           result = Console.color(:green, "#{total_tests} tests passed")
         end
 
-        time_str = if elapsed_time < 2
-                     "#{(elapsed_time * 1000).to_i}ms"
-                   else
-                     "#{elapsed_time.round(2)}s"
-                   end
+        time_str = format_timing(elapsed_time)
 
-        puts "Total: #{result} (#{time_str})"
-        puts "Files: #{successful_files} of #{total_files} successful"
+        io.puts "Total: #{result} (#{time_str})"
+        io.puts "Files: #{successful_files} of #{total_files} successful"
       end
 
       # Debug and diagnostic output - minimal in compact mode
-      def debug_info(message, level = 0)
+      def debug_info(message, level = 0, io = $stderr)
         return unless @show_debug
 
-        puts indent_text("DEBUG: #{message}", level)
+        io.puts indent_text("DEBUG: #{message}", level)
       end
 
-      def trace_info(message, level = 0)
+      def trace_info(message, level = 0, io = $stderr)
         return unless @show_trace
 
-        puts indent_text("TRACE: #{message}", level)
+        io.puts indent_text("TRACE: #{message}", level)
       end
 
-      def error_message(message, backtrace = nil)
-        puts Console.color(:red, "ERROR: #{message}")
+      def error_message(message, backtrace = nil, io = $stderr)
+        io.puts Console.color(:red, "ERROR: #{message}")
 
         return unless backtrace && @show_debug
 
         backtrace.first(3).each do |line|
-          puts indent_text(line.chomp, 1)
+          io.puts indent_text(line.chomp, 1)
         end
       end
 
       # Utility methods
-      def raw_output(text)
-        puts text
+      def raw_output(text, io = $stdout)
+        io.puts text
       end
 
-      def separator(style = :light)
+      def separator(style = :light, io = $stdout)
         case style
         when :heavy
-          puts '=' * 50
+          io.puts '=' * 50
         when :light
-          puts '-' * 50
+          io.puts '-' * 50
         when :dotted
-          puts '.' * 50
+          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
-          puts '-' * 50
+          " (#{elapsed_time.round(2)}s)"
         end
       end
     end
@@ -235,9 +273,9 @@ class Tryouts
         super(options.merge(show_passed: false))
       end
 
-      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
+      def test_result(result_packet)
         # Only show failed/error tests
-        return if result_status == :passed
+        return if result_packet.passed?
 
         super
       end

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

@@ -33,7 +33,7 @@ class Tryouts
             QuietFormatter.new(options)
           end
         else
-          VerboseFormatter.new(options) # Default to verbose
+          CompactFormatter.new(options) # Default to compact
         end
       end
 

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

@@ -30,6 +30,11 @@ class Tryouts
         @formatter.file_start(file_path, 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)
+      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,
@@ -62,8 +67,14 @@ class Tryouts
         end
       end
 
-      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
-        @formatter.test_result(test_case, result_status, actual_results, elapsed_time)
+      def test_end(test_case, index, total)
+        with_indent(2) do
+          @formatter.test_end(test_case, index, total)
+        end
+      end
+
+      def test_result(result_packet)
+        @formatter.test_result(result_packet)
       end
 
       def test_output(test_case, output_text)

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

@@ -22,6 +22,10 @@ class Tryouts
         # 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
@@ -39,20 +43,24 @@ class Tryouts
         # Silent in quiet mode
       end
 
-      def test_result(_test_case, result_status, _actual_results = [], _elapsed_time = nil)
-        case result_status
+      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
-          print Console.color(:green, '.')
+          io.print Console.color(:green, '.')
         when :failed
-          print Console.color(:red, 'F')
+          io.print Console.color(:red, 'F')
         when :error
-          print Console.color(:red, 'E')
+          io.print Console.color(:red, 'E')
         when :skipped
-          print Console.color(:yellow, 'S')
+          io.print Console.color(:yellow, 'S')
         else
-          print '?'
+          io.print '?'
         end
-        $stdout.flush
+        io.flush
       end
 
       def test_output(test_case, output_text)
@@ -78,18 +86,16 @@ class Tryouts
       end
 
       # Summary operations - show results
-      def batch_summary(total_tests, failed_count, elapsed_time)
+      def batch_summary(total_tests, failed_count, elapsed_time, io = $stderr)
         return unless @show_final_summary
 
-        puts # New line after dots
-
         if failed_count > 0
           passed   = total_tests - failed_count
           time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
-          puts "#{failed_count} failed, #{passed} passed#{time_str}"
+          io.puts "#{failed_count} failed, #{passed} passed#{time_str}"
         else
           time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
-          puts "#{total_tests} passed#{time_str}"
+          io.puts "#{total_tests} passed#{time_str}"
         end
       end
 
@@ -106,7 +112,7 @@ class Tryouts
 
         issues_count = failed_count + error_count
         if issues_count > 0
-          passed = total_tests - issues_count
+          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
@@ -148,9 +154,9 @@ class Tryouts
 
     # Quiet formatter that only shows dots for failures and errors
     class QuietFailsFormatter < QuietFormatter
-      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
+      def test_result(result_packet)
         # Only show non-pass dots in fails mode
-        return if result_status == :passed
+        return if result_packet.passed?
 
         super
       end