tryouts 3.3.0 → 3.3.2

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,11 +1,14 @@
 # lib/tryouts/test_runner.rb
 
-require_relative 'prism_parser'
+require 'concurrent'
+require_relative 'parsers/prism_parser'
+require_relative 'parsers/enhanced_parser'
 require_relative 'test_batch'
 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
@@ -34,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
 
@@ -69,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|
@@ -92,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.0'
+  VERSION = '3.3.2'
 end

data/lib/tryouts.rb

@@ -8,7 +8,8 @@ TRYOUTS_LIB_HOME = __dir__ unless defined?(TRYOUTS_LIB_HOME)
 require_relative 'tryouts/console'
 require_relative 'tryouts/test_batch'
 require_relative 'tryouts/version'
-require_relative 'tryouts/prism_parser'
+require_relative 'tryouts/parsers/prism_parser'
+require_relative 'tryouts/parsers/enhanced_parser'
 require_relative 'tryouts/cli'
 
 class Tryouts
@@ -22,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.0
+  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
@@ -137,13 +151,13 @@ files:
 - lib/tryouts/cli/opts.rb
 - lib/tryouts/cli/tty_detector.rb
 - lib/tryouts/console.rb
-- lib/tryouts/enhanced_parser.rb
 - lib/tryouts/expectation_evaluators/base.rb
 - lib/tryouts/expectation_evaluators/boolean.rb
 - lib/tryouts/expectation_evaluators/exception.rb
 - 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
@@ -153,10 +167,14 @@ files:
 - lib/tryouts/expectation_evaluators/true.rb
 - lib/tryouts/failure_collector.rb
 - lib/tryouts/file_processor.rb
-- lib/tryouts/prism_parser.rb
+- lib/tryouts/parsers/base_parser.rb
+- lib/tryouts/parsers/enhanced_parser.rb
+- lib/tryouts/parsers/prism_parser.rb
+- lib/tryouts/parsers/shared_methods.rb
 - 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