tryouts 3.3.1 → 3.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adb9f46213aee10ed4b9d2a1b9b8d5c9e385ea23f996445debc7458b43351512
-  data.tar.gz: 8d6abfed42e73bb340e13a62991b4855b8c0c18efa3092b4e3244a822a1612c1
+  metadata.gz: b8d7c33ad6377a7fb1c64c83e24e643c434643aa09e5451ad42bbe80c65b9c9d
+  data.tar.gz: 89cfe371c0fd575614a56702c904d0c5140db2a3a2af41d22777e459de1f4d8a
 SHA512:
-  metadata.gz: 571410ed483879bd035b14c053a5c3496d51ad2248cff2534cf40fc06a72ece1aea13a7e61ae2c29b1e1f1768f19d3c5ede8c4e4a30a977c29aacb502c616988
-  data.tar.gz: 6b5186131242edf826ba44303daaee716ce1ec364683e521df5224818d796067209a9a0ae66cacc85d15796cfee92df2349372fc5df762ced52b8753e1196c0e
+  metadata.gz: 174645930ab03bc8332e415e9dde67e6c261a66ec2aa4f5572a31841a339cb244d15da75f6d314e3e2ec2d987fb5439e03c34d35d244b37d8b81a7e5b4dbc55d
+  data.tar.gz: 524ded2d4d670ed5fce810ef363faaba2459e56979fc13e61cdd7fbad6a3cffe2cadef7e7c8f1be0901ed1d26b44185f05f8be524c0ebe60a76e3bb841be5b37

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

@@ -11,6 +11,7 @@ class Tryouts
         @show_debug  = options.fetch(:debug, false)
         @show_trace  = options.fetch(:trace, false)
         @show_passed = options.fetch(:show_passed, true)
+        @show_stack_traces = options.fetch(:stack_traces, false) || options.fetch(:debug, false)
       end
 
       # Phase-level output - minimal for compact mode
@@ -238,10 +239,10 @@ class Tryouts
       def error_message(message, backtrace: nil)
         @stderr.puts Console.color(:red, "ERROR: #{message}")
 
-        return unless backtrace && @show_debug
+        return unless backtrace && @show_stack_traces
 
-        backtrace.first(3).each do |line|
-          @stderr.puts indent_text(line.chomp, 1)
+        Console.pretty_backtrace(backtrace, limit: 3).each do |line|
+          @stderr.puts indent_text(line, 1)
         end
       end
 

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

@@ -10,6 +10,7 @@ class Tryouts
         super
         @show_errors        = options.fetch(:show_errors, true)
         @show_final_summary = options.fetch(:show_final_summary, true)
+        @show_stack_traces  = options.fetch(:stack_traces, false) || options.fetch(:debug, false)
         @current_file       = nil
       end
 
@@ -80,10 +81,10 @@ class Tryouts
         @stderr.puts
         @stderr.puts Console.color(:red, "ERROR: #{message}")
 
-        return unless backtrace && @show_debug
+        return unless backtrace && @show_stack_traces
 
-        backtrace.first(3).each do |line|
-          @stderr.puts "  #{line.chomp}"
+        Console.pretty_backtrace(backtrace, limit: 3).each do |line|
+          @stderr.puts "  #{line}"
         end
       end
 

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

@@ -12,6 +12,7 @@ class Tryouts
         @show_passed    = options.fetch(:show_passed, true)
         @show_debug     = options.fetch(:debug, false)
         @show_trace     = options.fetch(:trace, false)
+        @show_stack_traces = options.fetch(:stack_traces, false) || options.fetch(:debug, false)
       end
 
       # Phase-level output
@@ -244,11 +245,11 @@ class Tryouts
         error_msg = Console.color(:red, "ERROR: #{message}")
         puts indent_text(error_msg, 1)
 
-        return unless backtrace && @show_debug
+        return unless backtrace && @show_stack_traces
 
         puts indent_text('Details:', 2)
         # Show first 10 lines of backtrace to avoid overwhelming output
-        backtrace.first(10).each do |line|
+        Console.pretty_backtrace(backtrace, limit: 10).each do |line|
           puts indent_text(line, 3)
         end
         puts indent_text("... (#{backtrace.length - 10} more lines)", 3) if backtrace.length > 10

data/lib/tryouts/cli/opts.rb

@@ -26,8 +26,8 @@ class Tryouts
 
         #=>   Value equality        #==> Must be true         #=/=> Must be false
         #=|>  True OR false         #=!>  Must raise error    #=:>  Type matching
-        #=~>  Regex matching        #=%>  Time constraints    #=1>  STDOUT content
-        #=2>  STDERR content        #=<>  Intentional failure
+        #=~>  Regex matching        #=%>  Time constraints    #=*>  Non-nil result
+        #=1>  STDOUT content        #=2>  STDERR content      #=<>  Intentional failure
     HELP
 
     class << self
@@ -65,6 +65,10 @@ class Tryouts
           opts.on('-q', '--quiet', 'Minimal output (dots and summary only)') { options[:quiet]            = true }
           opts.on('-c', '--compact', 'Compact single-line output') { options[:compact]                    = true }
           opts.on('-l', '--live', 'Live status display') { options[:live_status]                          = true }
+          opts.on('-j', '--parallel [THREADS]', 'Run test files in parallel (optional thread count)') do |threads|
+            options[:parallel] = true
+            options[:parallel_threads] = threads.to_i if threads && threads.to_i > 0
+          end
 
           opts.separator "\nParser Options:"
           opts.on('--enhanced-parser', 'Use enhanced parser with inhouse comment extraction (default)') { options[:parser] = :enhanced }
@@ -74,10 +78,16 @@ class Tryouts
           opts.on('-i', '--inspect', 'Inspect file structure without running tests') { options[:inspect] = true }
 
           opts.separator "\nGeneral Options:"
+          opts.on('-s', '--stack-traces', 'Show stack traces for exceptions') do
+            options[:stack_traces] = true
+            Tryouts.stack_traces = true
+          end
           opts.on('-V', '--version', 'Show version') { options[:version] = true }
           opts.on('-D', '--debug', 'Enable debug mode') do
             options[:debug] = true
+            options[:stack_traces] = true  # Debug mode auto-enables stack traces
             Tryouts.debug   = true
+            Tryouts.stack_traces = true
           end
           opts.on('-h', '--help', 'Show this help') do
             puts opts

data/lib/tryouts/console.rb

@@ -161,12 +161,40 @@ class Tryouts
       # directory. This simplifies logging and error reporting by showing
       # only the relevant parts of file paths instead of lengthy absolute paths.
       #
-      def pretty_path(file)
-        return nil if file.nil?
+      def pretty_path(filepath)
+        return nil if filepath.nil? || filepath.empty?
 
-        file     = File.expand_path(file) # be absolutely sure
         basepath = Dir.pwd
-        Pathname.new(file).relative_path_from(basepath).to_s
+        begin
+          relative_path = Pathname.new(filepath).relative_path_from(basepath)
+          if relative_path.to_s.start_with?('..')
+            File.basename(filepath)
+          else
+            relative_path.to_s
+          end
+        rescue ArgumentError
+          # Handle cases where filepath cannot be relativized (e.g., empty paths, different roots)
+          File.basename(filepath)
+        end
+      end
+
+      # Format backtrace entries with pretty file paths
+      def pretty_backtrace(backtrace, limit: 10)
+        return [] unless backtrace&.any?
+
+        backtrace.first(limit).map do |frame|
+          # Split the frame to get file path and line info
+          # Use non-greedy match and more specific pattern to prevent ReDoS
+          if frame.match(/^([^:]+(?::[^:0-9][^:]*)*):(\d+):(.*)$/)
+            file_part = $1
+            line_part = $2
+            method_part = $3
+            pretty_file = pretty_path(file_part) || File.basename(file_part)
+            "#{pretty_file}:#{line_part}#{method_part}"
+          else
+            frame
+          end
+        end
       end
     end
   end

data/lib/tryouts/expectation_evaluators/exception.rb

@@ -9,8 +9,14 @@ class Tryouts
         expectation_type == :exception
       end
 
-      def evaluate(_actual_result = nil)
-        execute_test_code_and_evaluate_exception
+      def evaluate(_actual_result = nil, caught_exception: nil)
+        if caught_exception
+          # Use the pre-caught exception to avoid double execution
+          evaluate_exception_condition(caught_exception)
+        else
+          # Fallback for direct calls - shouldn't happen in normal flow
+          execute_test_code_and_evaluate_exception
+        end
       end
 
       private

data/lib/tryouts/expectation_evaluators/non_nil.rb

@@ -0,0 +1,77 @@
+# lib/tryouts/expectation_evaluators/non_nil.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for non-nil expectations using syntax: #=*>
+    #
+    # PURPOSE:
+    # - Validates that the test result is not nil and no exception occurred
+    # - Provides a simple "anything goes" expectation for existence checks
+    # - Useful for API responses, object creation, method return values
+    #
+    # SYNTAX: #=*>
+    # Examples:
+    #   user = User.create(name: "test")
+    #   #=*>                              # Pass: user object exists (not nil)
+    #
+    #   response = api_call()
+    #   #=*>                              # Pass: got some response (not nil)
+    #
+    #   nil
+    #   #=*>                              # Fail: result is nil
+    #
+    #   raise StandardError.new("error")
+    #   #=*>                              # Fail: exception occurred
+    #
+    # VALIDATION LOGIC:
+    # - Passes when result is not nil AND no exception was raised during execution
+    # - Fails when result is nil OR an exception occurred
+    # - Does not evaluate any additional expression (unlike other expectation types)
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Simple existence check without complex evaluation
+    # - No expression parsing needed - syntax is just #=*>
+    # - Expected display shows "non-nil result with no exception"
+    # - Actual display shows the actual result value or exception
+    #
+    # DESIGN DECISIONS:
+    # - Uses #=*> syntax where * represents "anything"
+    # - Part of unified #= prefix convention for all expectation types
+    # - Complements existing boolean and equality expectations
+    # - Provides simple alternative to complex conditional expressions
+    # - Useful for integration tests where exact values are unpredictable
+    #
+    # VARIABLE ACCESS:
+    # - No special variables needed since no expression is evaluated
+    # - Works purely on the actual test result value
+    class NonNil < Base
+      def self.handles?(expectation_type)
+        expectation_type == :non_nil
+      end
+
+      def evaluate(actual_result = nil, caught_exception: nil)
+        # Check if an exception occurred during test execution
+        if caught_exception
+          return build_result(
+            passed: false,
+            actual: "(#{caught_exception.class}) #{caught_exception.message}",
+            expected: 'non-nil result with no exception',
+          )
+        end
+
+        # Check if result is nil
+        passed = !actual_result.nil?
+
+        build_result(
+          passed: passed,
+          actual: actual_result,
+          expected: 'non-nil result',
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/registry.rb

@@ -12,6 +12,7 @@ require_relative 'regex_match'
 require_relative 'performance_time'
 require_relative 'intentional_failure'
 require_relative 'output'
+require_relative 'non_nil'
 
 class Tryouts
   module ExpectationEvaluators
@@ -61,6 +62,7 @@ class Tryouts
       register(PerformanceTime)
       register(IntentionalFailure)
       register(Output)
+      register(NonNil)
     end
   end
 end

data/lib/tryouts/file_processor.rb

@@ -20,7 +20,7 @@ class Tryouts
 
     def process
       testrun                     = create_parser(@file, @options).parse
-      @global_tally[:file_count] += 1
+      @global_tally[:aggregator].increment_total_files
       @output_manager.file_parsed(@file, testrun.total_tests)
 
       if @options[:inspect]
@@ -76,7 +76,11 @@ class Tryouts
     end
 
     def handle_general_error(ex)
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :file_processing, @file, ex.message, ex
+        )
+      end
       @output_manager.file_failure(@file, ex.message, ex.backtrace)
       1
     end

data/lib/tryouts/parsers/enhanced_parser.rb

@@ -86,6 +86,8 @@ class Tryouts
         { type: :false_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
       when /^#\s*=\|>\s*(.*)$/
         { type: :boolean_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=\*>\s*(.*)$/
+        { type: :non_nil_expectation, content: $1.strip, line: line_number - 1 }
       when /^#\s*=:>\s*(.*)$/
         { type: :result_type_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
       when /^#\s*=~>\s*(.*)$/

data/lib/tryouts/parsers/prism_parser.rb

@@ -39,6 +39,8 @@ class Tryouts
                   { type: :false_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
                 in /^#\s*=\|>\s*(.*)$/ # Boolean (true or false) expectation
                   { type: :boolean_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=\*>\s*(.*)$/ # Non-nil expectation
+                  { type: :non_nil_expectation, content: $1.strip, line: index }
                 in /^#\s*=:>\s*(.*)$/ # Result type expectation
                   { type: :result_type_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
                 in /^#\s*=~>\s*(.*)$/ # Regex match expectation

data/lib/tryouts/parsers/shared_methods.rb

@@ -86,6 +86,9 @@ class Tryouts
           in [_, { type: :boolean_expectation }]
             current_block[:expectations] << token
 
+          in [_, { type: :non_nil_expectation }]
+            current_block[:expectations] << token
+
           in [_, { type: :result_type_expectation }]
             current_block[:expectations] << token
 
@@ -192,7 +195,7 @@ class Tryouts
           :expectation, :exception_expectation, :intentional_failure_expectation,
           :true_expectation, :false_expectation, :boolean_expectation,
           :result_type_expectation, :regex_match_expectation,
-          :performance_time_expectation, :output_expectation
+          :performance_time_expectation, :output_expectation, :non_nil_expectation
         ].include?(type)
       end
 
@@ -368,6 +371,7 @@ class Tryouts
                      when :regex_match_expectation then :regex_match
                      when :performance_time_expectation then :performance_time
                      when :output_expectation then :output
+                     when :non_nil_expectation then :non_nil
                      else :regular
                      end
 

data/lib/tryouts/test_batch.rb

@@ -244,7 +244,7 @@ class Tryouts
         end
 
         expectations_result = execute_with_timeout(test_timeout, test_case) do
-          evaluate_expectations(test_case, caught_exception, container)
+          evaluate_expectations(test_case, caught_exception, container, nil, nil, nil, caught_exception)
         end
         build_test_result(test_case, caught_exception, expectations_result)
       else
@@ -330,7 +330,7 @@ class Tryouts
     end
 
     # Evaluate expectations using new object-oriented evaluation system
-    def evaluate_expectations(test_case, actual_result, context, execution_time_ns = nil, stdout_content = nil, stderr_content = nil)
+    def evaluate_expectations(test_case, actual_result, context, execution_time_ns = nil, stdout_content = nil, stderr_content = nil, caught_exception = nil)
       return { passed: true, actual_results: [], expected_results: [] } if test_case.expectations.empty?
 
       evaluation_results = test_case.expectations.map do |expectation|
@@ -341,6 +341,9 @@ class Tryouts
           evaluator.evaluate(actual_result, execution_time_ns)
         elsif expectation.output? && (stdout_content || stderr_content)
           evaluator.evaluate(actual_result, stdout_content, stderr_content)
+        elsif expectation.exception? && caught_exception
+          # Pass caught exception to avoid double execution
+          evaluator.evaluate(actual_result, caught_exception: caught_exception)
         else
           evaluator.evaluate(actual_result)
         end
@@ -385,13 +388,14 @@ class Tryouts
     def process_test_result(result)
       @results << result
 
+      # Add all test results to the aggregator for centralized counting
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_test_result(@testrun.source_file, result)
+      end
+
+      # Update local batch counters for batch-level logic
       if result.failed? || result.error?
         @failed_count += 1
-
-        # Collect failure details for end-of-run summary
-        if @global_tally && @global_tally[:failure_collector]
-          @global_tally[:failure_collector].add_failure(@testrun.source_file, result)
-        end
       end
 
       show_test_result(result)
@@ -418,7 +422,11 @@ class Tryouts
       end
     rescue StandardError => ex
       @setup_failed                 = true
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :setup, @testrun.source_file, ex.message, ex
+        )
+      end
 
       # Classify error and handle appropriately
       error_type = Tryouts.classify_error(ex)
@@ -455,7 +463,11 @@ class Tryouts
       end
     rescue StandardError => ex
       @setup_failed                 = true
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :setup, @testrun.source_file, ex.message, ex
+        )
+      end
 
       # Classify error and handle appropriately
       error_type = Tryouts.classify_error(ex)
@@ -488,7 +500,11 @@ class Tryouts
         @output_manager&.teardown_output(captured_output) if captured_output && !captured_output.empty?
       end
     rescue StandardError => ex
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :teardown, @testrun.source_file, ex.message, ex
+        )
+      end
 
       # Classify error and handle appropriately
       error_type = Tryouts.classify_error(ex)

data/lib/tryouts/test_case.rb

@@ -154,9 +154,9 @@ class Tryouts
     def self.from_error(test_case, error, captured_output: nil, elapsed_time: nil, metadata: {})
       error_message = error ? error.message : '<exception is nil>'
 
-      # Include backtrace in error message when in debug/verbose mode
-      error_display = if error && Tryouts.debug?
-        backtrace_preview = error.backtrace&.first(3)&.join("\n    ")
+      # Include backtrace in error message when stack traces are enabled
+      error_display = if error && Tryouts.stack_traces?
+        backtrace_preview = Console.pretty_backtrace(error.backtrace, limit: 3).join("\n    ")
         "(#{error.class}) #{error_message}\n    #{backtrace_preview}"
       else
         "(#{error.class}) #{error_message}"

data/lib/tryouts/test_executor.rb

@@ -53,10 +53,12 @@ class Tryouts
       file_failed_count                 = test_results.count { |r| r.failed? }
       file_error_count                  = test_results.count { |r| r.error? }
       executed_test_count               = test_results.size
-      @global_tally[:total_tests]      += executed_test_count
-      @global_tally[:total_failed]     += file_failed_count
-      @global_tally[:total_errors]     += file_error_count
-      @global_tally[:successful_files] += 1 if success
+
+      # Note: Individual test results are added to the aggregator in TestBatch
+      # Here we just update the file success count atomically
+      if success
+        @global_tally[:aggregator].increment_successful_files
+      end
 
       duration = Time.now.to_f - @file_start.to_f
       @output_manager.file_success(@file, executed_test_count, file_failed_count, file_error_count, duration)

data/lib/tryouts/test_result_aggregator.rb

@@ -0,0 +1,138 @@
+# lib/tryouts/test_result_aggregator.rb
+
+require_relative 'failure_collector'
+require 'concurrent'
+
+class Tryouts
+  # Centralized test result aggregation to ensure counting consistency
+  # across all formatters and eliminate counting discrepancies
+  class TestResultAggregator
+    def initialize
+      @failure_collector = FailureCollector.new
+      # Use thread-safe atomic counters
+      @test_counts = {
+        total_tests: Concurrent::AtomicFixnum.new(0),
+        passed: Concurrent::AtomicFixnum.new(0),
+        failed: Concurrent::AtomicFixnum.new(0),
+        errors: Concurrent::AtomicFixnum.new(0)
+      }
+      @infrastructure_failures = Concurrent::Array.new
+      @file_counts = {
+        total: Concurrent::AtomicFixnum.new(0),
+        successful: Concurrent::AtomicFixnum.new(0)
+      }
+    end
+
+    attr_reader :failure_collector
+
+    # Add a test-level result (from individual test execution)
+    def add_test_result(file_path, result_packet)
+      @test_counts[:total_tests].increment
+
+      if result_packet.passed?
+        @test_counts[:passed].increment
+      elsif result_packet.failed?
+        @test_counts[:failed].increment
+        @failure_collector.add_failure(file_path, result_packet)
+      elsif result_packet.error?
+        @test_counts[:errors].increment
+        @failure_collector.add_failure(file_path, result_packet)
+      end
+    end
+
+    # Add an infrastructure-level failure (setup, teardown, file-level)
+    def add_infrastructure_failure(type, file_path, error_message, exception = nil)
+      @infrastructure_failures << {
+        type: type,           # :setup, :teardown, :file_processing
+        file_path: file_path,
+        error_message: error_message,
+        exception: exception
+      }
+    end
+
+    # Atomic increment methods for file-level operations
+    def increment_total_files
+      @file_counts[:total].increment
+    end
+
+    def increment_successful_files
+      @file_counts[:successful].increment
+    end
+
+
+    # Get counts that should be displayed in numbered failure lists
+    # These match what actually appears in the failure summary
+    def get_display_counts
+      {
+        total_tests: @test_counts[:total_tests].value,
+        passed: @test_counts[:passed].value,
+        failed: @failure_collector.failure_count,
+        errors: @failure_collector.error_count,
+        total_issues: @failure_collector.total_issues
+      }
+    end
+
+    # Get total counts including infrastructure failures
+    # These represent all issues that occurred during test execution
+    def get_total_counts
+      display = get_display_counts
+      {
+        total_tests: display[:total_tests],
+        passed: display[:passed],
+        failed: display[:failed],
+        errors: display[:errors],
+        infrastructure_failures: @infrastructure_failures.size,
+        total_issues: display[:total_issues] + @infrastructure_failures.size
+      }
+    end
+
+    # Get file-level statistics
+    def get_file_counts
+      {
+        total: @file_counts[:total].value,
+        successful: @file_counts[:successful].value
+      }
+    end
+
+    # Get infrastructure failures for detailed reporting
+    def get_infrastructure_failures
+      @infrastructure_failures.dup
+    end
+
+    # Check if there are any failures at all
+    def any_failures?
+      @failure_collector.any_failures? || !@infrastructure_failures.empty?
+    end
+
+    # Check if there are displayable failures (for numbered lists)
+    def any_display_failures?
+      @failure_collector.any_failures?
+    end
+
+    # Reset for testing purposes
+    def clear
+      @failure_collector.clear
+      @test_counts[:total_tests].update { |_| 0 }
+      @test_counts[:passed].update { |_| 0 }
+      @test_counts[:failed].update { |_| 0 }
+      @test_counts[:errors].update { |_| 0 }
+      @infrastructure_failures.clear
+      @file_counts[:total].update { |_| 0 }
+      @file_counts[:successful].update { |_| 0 }
+    end
+
+    # Provide a summary string for debugging
+    def summary
+      display = get_display_counts
+      total = get_total_counts
+
+      parts = []
+      parts << "#{display[:passed]} passed" if display[:passed] > 0
+      parts << "#{display[:failed]} failed" if display[:failed] > 0
+      parts << "#{display[:errors]} errors" if display[:errors] > 0
+      parts << "#{total[:infrastructure_failures]} infrastructure failures" if total[:infrastructure_failures] > 0
+
+      parts.empty? ? "All tests passed" : parts.join(', ')
+    end
+  end
+end

data/lib/tryouts/test_runner.rb

@@ -1,5 +1,6 @@
 # lib/tryouts/test_runner.rb
 
+require 'concurrent'
 require_relative 'parsers/prism_parser'
 require_relative 'parsers/enhanced_parser'
 require_relative 'test_batch'
@@ -7,6 +8,7 @@ require_relative 'translators/rspec_translator'
 require_relative 'translators/minitest_translator'
 require_relative 'file_processor'
 require_relative 'failure_collector'
+require_relative 'test_result_aggregator'
 
 class Tryouts
   class TestRunner
@@ -35,7 +37,7 @@ class Tryouts
 
       result = process_files
       show_failure_summary
-      show_grand_total if @global_tally[:file_count] > 1
+      show_grand_total if @global_tally[:aggregator].get_file_counts[:total] > 1
       result
     end
 
@@ -70,17 +72,20 @@ class Tryouts
 
     def initialize_global_tally
       {
-        total_tests: 0,
-        total_failed: 0,
-        total_errors: 0,
-        file_count: 0,
         start_time: Time.now,
-        successful_files: 0,
-        failure_collector: FailureCollector.new,
+        aggregator: TestResultAggregator.new,
       }
     end
 
     def process_files
+      if @options[:parallel] && @files.length > 1
+        process_files_parallel
+      else
+        process_files_sequential
+      end
+    end
+
+    def process_files_sequential
       failure_count = 0
 
       @files.each_with_index do |file, _idx|
@@ -93,37 +98,87 @@ class Tryouts
       failure_count
     end
 
-    def process_file(file)
-      file = FileProcessor.new(
-        file: file,
+    def process_files_parallel
+      # Determine thread pool size
+      pool_size = @options[:parallel_threads] || Concurrent.processor_count
+      @output_manager.info "Running #{@files.length} files in parallel (#{pool_size} threads)", 1
+
+      # Create thread pool executor
+      executor = Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: pool_size,
+        max_queue: pool_size * 2, # Reasonable queue size
+        fallback_policy: :abort # Raise exception if pool and queue are exhausted
+      )
+
+      # Submit all file processing tasks to the thread pool
+      futures = @files.map do |file|
+        Concurrent::Future.execute(executor: executor) do
+          process_file(file)
+        end
+      end
+
+      # Wait for all tasks to complete and collect results
+      failure_count = 0
+      futures.each_with_index do |future, idx|
+        begin
+          result = future.value # This blocks until the future completes
+          failure_count += result unless result.zero?
+
+          status = result.zero? ? Console.color(:green, 'PASS') : Console.color(:red, 'FAIL')
+          file = @files[idx]
+          @output_manager.info "#{status} #{Console.pretty_path(file)} (#{result} failures)", 1
+        rescue StandardError => ex
+          failure_count += 1
+          file = @files[idx]
+          @output_manager.info "#{Console.color(:red, 'ERROR')} #{Console.pretty_path(file)} (#{ex.message})", 1
+        end
+      end
+
+      # Shutdown the thread pool
+      executor.shutdown
+      executor.wait_for_termination(10) # Wait up to 10 seconds for clean shutdown
+
+      failure_count
+    end
+
+    def process_file(file_path)
+      processor = FileProcessor.new(
+        file: file_path,
         options: @options,
         output_manager: @output_manager,
         translator: @translator,
         global_tally: @global_tally,
       )
-      file.process
+      processor.process
     rescue StandardError => ex
       handle_file_error(ex)
-      @global_tally[:total_errors] += 1
+      @global_tally[:aggregator].add_infrastructure_failure(
+        :file_processing, file_path, ex.message, ex
+      )
       1
     end
 
     def show_failure_summary
       # Show failure summary if any failures exist
-      if @global_tally[:failure_collector].any_failures?
-        @output_manager.batch_summary(@global_tally[:failure_collector])
+      aggregator = @global_tally[:aggregator]
+      if aggregator.any_display_failures?
+        @output_manager.batch_summary(aggregator.failure_collector)
       end
     end
 
     def show_grand_total
       elapsed_time = Time.now - @global_tally[:start_time]
+      aggregator = @global_tally[:aggregator]
+      display_counts = aggregator.get_display_counts
+      file_counts = aggregator.get_file_counts
 
       @output_manager.grand_total(
-        @global_tally[:total_tests],
-        @global_tally[:total_failed],
-        @global_tally[:total_errors],
-        @global_tally[:successful_files],
-        @global_tally[:file_count],
+        display_counts[:total_tests],
+        display_counts[:failed],
+        display_counts[:errors],
+        file_counts[:successful],
+        file_counts[:total],
         elapsed_time,
       )
     end

data/lib/tryouts/version.rb

@@ -1,5 +1,5 @@
 # lib/tryouts/version.rb
 
 class Tryouts
-  VERSION = '3.3.1'
+  VERSION = '3.3.2'
 end

data/lib/tryouts.rb

@@ -23,13 +23,17 @@ class Tryouts
 
   module ClassMethods
     attr_accessor :container, :quiet, :noisy, :fails
-    attr_writer :debug
+    attr_writer :debug, :stack_traces
     attr_reader :cases, :testcase_io
 
     def debug?
       @debug == true
     end
 
+    def stack_traces?
+      @stack_traces == true || debug?  # Debug mode auto-enables stack traces
+    end
+
     def update_load_path(lib_glob)
       Dir.glob(lib_glob).each { |dir| $LOAD_PATH.unshift(dir) }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tryouts
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 3.3.2
 platform: ruby
 authors:
 - Delano Mandelbaum
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +157,7 @@ files:
 - lib/tryouts/expectation_evaluators/expectation_result.rb
 - lib/tryouts/expectation_evaluators/false.rb
 - lib/tryouts/expectation_evaluators/intentional_failure.rb
+- lib/tryouts/expectation_evaluators/non_nil.rb
 - lib/tryouts/expectation_evaluators/output.rb
 - lib/tryouts/expectation_evaluators/performance_time.rb
 - lib/tryouts/expectation_evaluators/regex_match.rb
@@ -159,6 +174,7 @@ files:
 - lib/tryouts/test_batch.rb
 - lib/tryouts/test_case.rb
 - lib/tryouts/test_executor.rb
+- lib/tryouts/test_result_aggregator.rb
 - lib/tryouts/test_runner.rb
 - lib/tryouts/translators/minitest_translator.rb
 - lib/tryouts/translators/rspec_translator.rb