tryouts 2.4.1 → 3.0.0.pre2

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

@@ -0,0 +1,246 @@
+# lib/tryouts/cli/formatters/compact.rb
+
+class Tryouts
+  class CLI
+    # Compact single-line formatter focused on results
+    class CompactFormatter
+      include FormatterInterface
+
+      def initialize(options = {})
+        @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)
+        # Skip execution phase headers in compact mode - they create unwanted empty lines
+        return if level >= 1
+
+        text       = "#{message}..."
+        puts indent_text(text, level)
+      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)
+
+        puts indent_text("Running: #{pretty_path} (#{framework}/#{context})", 1)
+      end
+
+      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
+
+        extras = []
+        extras << 'setup' if setup_present
+        extras << 'teardown' if teardown_present
+        suffix = extras.empty? ? '' : " +#{extras.join(',')}"
+
+        puts indent_text("Parsed #{test_count} tests#{suffix}", 1)
+      end
+
+      def file_execution_start(file_path, test_count, _context_mode)
+        pretty_path = Console.pretty_path(file_path)
+        puts
+        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
+          status = Console.color(:red, '✗')
+          detail << "#{failed_count}/#{total_tests} failed"
+        else
+          status = Console.color(:green, '✓')
+          detail << "#{total_tests} passed"
+        end
+
+        if error_count > 0
+          status = Console.color(:yellow, '⚠') if failed_count == 0
+          detail << "#{error_count} errors"
+        end
+
+        time_str = if elapsed_time
+                     if elapsed_time < 2
+                       " (#{(elapsed_time * 1000).to_i}ms)"
+                     else
+                       " (#{elapsed_time.round(2)}s)"
+                     end
+                   else
+                     ''
+                   end
+        puts "  #{status} #{detail.join(', ')}#{time_str}"
+      end
+
+      # Test-level operations - only show in debug mode for compact
+      def test_start(test_case, index, _total)
+        return unless @show_debug
+
+        desc = test_case.description.to_s
+        desc = "test #{index}" if desc.empty?
+        puts "    Running: #{desc}"
+      end
+
+      def test_result(test_case, result_status, actual_results = [], _elapsed_time = nil)
+        # Only show failed tests in compact mode unless show_passed is true
+        return if result_status == :passed && !@show_passed
+
+        desc = test_case.description.to_s
+        desc = 'unnamed test' if desc.empty?
+
+        case result_status
+        when :passed
+          status = Console.color(:green, '✓')
+        when :failed
+          status = Console.color(:red, '✗')
+          if actual_results.any?
+            failure_info = " (got: #{actual_results.first.inspect})"
+            desc        += failure_info
+          end
+        when :skipped
+          status = Console.color(:yellow, '-')
+        else
+          status = '?'
+        end
+
+        puts indent_text("#{status} #{desc}", 1)
+      end
+
+      def test_output(test_case, output_text)
+        # 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"
+        if output_text.lines.count <= 3
+          output_text.lines.each do |line|
+            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}"
+        end
+      end
+
+      # Setup/teardown operations - minimal output
+      def setup_start(_line_range)
+        # No file setup start output for compact
+      end
+
+      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
+        puts "    Setup output (#{lines} lines)"
+      end
+
+      def teardown_start(_line_range)
+        return unless @show_debug
+
+        puts '    Teardown...'
+      end
+
+      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
+        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
+
+        issues_count = failed_count + error_count
+        if issues_count > 0
+          passed  = total_tests - issues_count
+          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")
+        else
+          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
+
+        puts "Total: #{result} (#{time_str})"
+        puts "Files: #{successful_files} of #{total_files} successful"
+      end
+
+      # Debug and diagnostic output - minimal in compact mode
+      def debug_info(message, level = 0)
+        return unless @show_debug
+
+        puts indent_text("DEBUG: #{message}", level)
+      end
+
+      def trace_info(message, level = 0)
+        return unless @show_trace
+
+        puts indent_text("TRACE: #{message}", level)
+      end
+
+      def error_message(message, backtrace = nil)
+        puts Console.color(:red, "ERROR: #{message}")
+
+        return unless backtrace && @show_debug
+
+        backtrace.first(3).each do |line|
+          puts indent_text(line.chomp, 1)
+        end
+      end
+
+      # Utility methods
+      def raw_output(text)
+        puts text
+      end
+
+      def separator(style = :light)
+        case style
+        when :heavy
+          puts '=' * 50
+        when :light
+          puts '-' * 50
+        when :dotted
+          puts '.' * 50
+        else
+          puts '-' * 50
+        end
+      end
+    end
+
+    # Compact formatter that only shows failures and errors
+    class CompactFailsFormatter < CompactFormatter
+      def initialize(options = {})
+        super(options.merge(show_passed: false))
+      end
+
+      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
+        # Only show failed/error tests
+        return if result_status == :passed
+
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# lib/tryouts/cli/formatters/factory.rb
+
+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)
+      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
+        when :verbose
+          if options[:fails_only]
+            VerboseFailsFormatter.new(options)
+          else
+            VerboseFormatter.new(options)
+          end
+        when :compact
+          if options[:fails_only]
+            CompactFailsFormatter.new(options)
+          else
+            CompactFormatter.new(options)
+          end
+        when :quiet
+          if options[:fails_only]
+            QuietFailsFormatter.new(options)
+          else
+            QuietFormatter.new(options)
+          end
+        else
+          VerboseFormatter.new(options) # Default to verbose
+        end
+      end
+
+      class << self
+        private
+
+        def determine_format_from_flags(options)
+          return :quiet if options[:quiet]
+          return :verbose if options[:verbose]
+
+          :compact # Default
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# lib/tryouts/cli/formatters/output_manager.rb
+
+class Tryouts
+  class CLI
+    # Output manager that coordinates all output through formatters
+    class OutputManager
+      attr_reader :formatter
+
+      def initialize(formatter)
+        @formatter    = formatter
+        @indent_level = 0
+      end
+
+      # Phase-level methods
+      def processing_phase(file_count, level = 0)
+        @formatter.phase_header("PROCESSING #{file_count} FILES", file_count, level)
+      end
+
+      def execution_phase(test_count, level = 1)
+        @formatter.phase_header("EXECUTING #{test_count} TESTS", test_count, level)
+      end
+
+      def error_phase(level = 1)
+        @formatter.phase_header('ERROR DETAILS', level)
+      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)
+      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
+      end
+
+      def file_execution_start(file_path, test_count, context_mode)
+        @formatter.file_execution_start(file_path, test_count, 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
+      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
+      end
+
+      # Test-level methods
+      def test_start(test_case, index, total)
+        with_indent(2) do
+          @formatter.test_start(test_case, index, total)
+        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)
+      end
+
+      def test_output(test_case, output_text)
+        @formatter.test_output(test_case, output_text)
+      end
+
+      # Setup/teardown methods
+      def setup_start(line_range)
+        with_indent(2) do
+          @formatter.setup_start(line_range)
+        end
+      end
+
+      def setup_output(output_text)
+        @formatter.setup_output(output_text)
+      end
+
+      def teardown_start(line_range)
+        with_indent(2) do
+          @formatter.teardown_start(line_range)
+        end
+      end
+
+      def teardown_output(output_text)
+        @formatter.teardown_output(output_text)
+      end
+
+      # Summary methods
+      def batch_summary(total_tests, failed_count, elapsed_time)
+        @formatter.batch_summary(total_tests, failed_count, elapsed_time)
+      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)
+      end
+
+      # Debug methods
+      def info(message, level = 0)
+        with_indent(level) do
+          @formatter.debug_info(message, level)
+        end
+      end
+
+      def trace(message, level = 0)
+        with_indent(level) do
+          @formatter.trace_info(message, level)
+        end
+      end
+
+      def error(message, backtrace = nil)
+        @formatter.error_message(message, backtrace)
+      end
+
+      # Utility methods
+      def raw(text)
+        @formatter.raw_output(text)
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# lib/tryouts/cli/formatters/quiet.rb
+
+class Tryouts
+  class CLI
+    # Minimal output formatter - only shows essential information
+    class QuietFormatter
+      include FormatterInterface
+
+      def initialize(options = {})
+        @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_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)
+        @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_result(_test_case, result_status, _actual_results = [], _elapsed_time = nil)
+        case result_status
+        when :passed
+          print Console.color(:green, '.')
+        when :failed
+          print Console.color(:red, 'F')
+        when :error
+          print Console.color(:red, 'E')
+        when :skipped
+          print Console.color(:yellow, 'S')
+        else
+          print '?'
+        end
+        $stdout.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)
+        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}"
+        else
+          time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
+          puts "#{total_tests} passed#{time_str}"
+        end
+      end
+
+      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+        return unless @show_final_summary
+
+        puts
+
+        time_str = if elapsed_time < 2
+                     "#{(elapsed_time * 1000).to_i}ms"
+                   else
+                     "#{elapsed_time.round(2)}s"
+                   end
+
+        issues_count = failed_count + error_count
+        if issues_count > 0
+          passed = total_tests - issues_count
+          details = []
+          details << "#{failed_count} failed" if failed_count > 0
+          details << "#{error_count} errors" if error_count > 0
+          puts Console.color(:red, "Total: #{details.join(', ')}, #{passed} passed (#{time_str})")
+        else
+          puts Console.color(:green, "Total: #{total_tests} passed (#{time_str})")
+        end
+
+        if total_files > 1
+          puts "Files: #{successful_files} of #{total_files} successful"
+        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)
+        return unless @show_errors
+
+        puts
+        puts Console.color(:red, "ERROR: #{message}")
+      end
+
+      # Utility methods
+      def raw_output(text)
+        puts text if @show_final_summary
+      end
+
+      def separator(style = :light)
+        # Silent in quiet mode
+      end
+    end
+
+    # 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)
+        # Only show non-pass dots in fails mode
+        return if result_status == :passed
+
+        super
+      end
+    end
+  end
+end