tryouts 3.3.0 → 3.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7ef307bf73a8bd6c70f52c47337d550ae7715e0b64d15c7f708c9fd407f3df2
-  data.tar.gz: ccd166f03573bee1d31e3843ff95964cf5065ab4a1b2386e9769ec065a6958f5
+  metadata.gz: b8d7c33ad6377a7fb1c64c83e24e643c434643aa09e5451ad42bbe80c65b9c9d
+  data.tar.gz: 89cfe371c0fd575614a56702c904d0c5140db2a3a2af41d22777e459de1f4d8a
 SHA512:
-  metadata.gz: 22b0d458cfadd632495c4df95f41cca3c06c6e6b3e219b18afb0fd21bfc14d1d9a872b165fcd2dd1c26052a9f57b84dad77c4a5a14c3efa08f62d74f0ab34467
-  data.tar.gz: 8cd6db263235736e26163b84568ad870de5835da3002e6f71226d961fc21e19d9eaef3cf2e02598a3907cb2701665e72a7e21ecea05b540f10ba37daa530a391
+  metadata.gz: 174645930ab03bc8332e415e9dde67e6c261a66ec2aa4f5572a31841a339cb244d15da75f6d314e3e2ec2d987fb5439e03c34d35d244b37d8b81a7e5b4dbc55d
+  data.tar.gz: 524ded2d4d670ed5fce810ef363faaba2459e56979fc13e61cdd7fbad6a3cffe2cadef7e7c8f1be0901ed1d26b44185f05f8be524c0ebe60a76e3bb841be5b37

data/exe/try

@@ -17,7 +17,7 @@ if ENV['COVERAGE'] || ENV['SIMPLECOV']
     add_group 'Core', 'lib/tryouts.rb'
     add_group 'CLI', 'lib/tryouts/cli'
     add_group 'Formatters', 'lib/tryouts/cli/formatters'
-    add_group 'Parsers', 'lib/tryouts/prism_parser.rb'
+    add_group 'Parsers', 'lib/tryouts/parsers'
     add_group 'Data Structures', ['lib/tryouts/testcase.rb', 'lib/tryouts/testbatch.rb']
     add_group 'Translators', 'lib/tryouts/translators'
     add_group 'Execution', ['lib/tryouts/test_executor.rb', 'lib/tryouts/test_runner.rb', 'lib/tryouts/file_processor.rb']

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
@@ -57,6 +58,8 @@ class Tryouts
         puts Console.color(:red, 'Failed Tests:')
         puts
 
+        # Number failures sequentially across all files instead of per-file
+        failure_number = 1
         failure_collector.failures_by_file.each do |file_path, failures|
           failures.each do |failure|
             pretty_path = Console.pretty_path(file_path)
@@ -68,10 +71,11 @@ class Tryouts
               pretty_path
             end
 
-            puts "  #{location}"
+            puts "  #{failure_number}) #{location}"
             puts "    #{Console.color(:red, '✗')} #{failure.description}"
             puts "      #{failure.failure_reason}"
             puts
+            failure_number += 1
           end
         end
       end
@@ -235,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
@@ -56,8 +57,10 @@ class Tryouts
         puts
         puts Console.color(:red, 'Failed Tests:')
 
+        # Number failures sequentially across all files instead of per-file
+        failure_number = 1
         failure_collector.failures_by_file.each do |file_path, failures|
-          failures.each_with_index do |failure, index|
+          failures.each do |failure|
             pretty_path = Console.pretty_path(file_path)
 
             # Include line number with file path for easy copying/clicking
@@ -69,7 +72,7 @@ class Tryouts
 
             puts
             puts Console.color(:yellow, location)
-            puts "  #{index + 1}) #{failure.description}"
+            puts "  #{failure_number}) #{failure.description}"
             puts "     #{Console.color(:red, 'Failure:')} #{failure.failure_reason}"
 
             # Show source context in verbose mode
@@ -80,6 +83,7 @@ class Tryouts
               end
             end
             puts
+            failure_number += 1
           end
         end
       end
@@ -241,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,19 +65,29 @@ 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') { options[:parser] = :enhanced }
-          opts.on('--legacy-parser', 'Use legacy parser (current default)') { options[:parser] = :prism }
+          opts.on('--enhanced-parser', 'Use enhanced parser with inhouse comment extraction (default)') { options[:parser] = :enhanced }
+          opts.on('--legacy-parser', 'Use legacy prism parser') { options[:parser] = :prism }
 
           opts.separator "\nInspection Options:"
           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/regex_match.rb

@@ -40,9 +40,17 @@ class Tryouts
         expectation_result = ExpectationResult.from_result(actual_result)
         pattern            = eval_expectation_content(@expectation.content, expectation_result)
 
-        # Convert actual_result to string for regex matching
-        string_result = actual_result.to_s
-        match_result  = string_result =~ pattern
+        # Auto-detect exceptions and use message for regex matching
+        # This allows #=~> /pattern/ to work naturally with exception messages
+        string_result = if actual_result.is_a?(Exception)
+                          # Make error available in context for manual access if needed
+                          @context.define_singleton_method(:error) { actual_result }
+                          actual_result.message  # Match against error message
+                        else
+                          actual_result.to_s     # Normal case: convert to string
+                        end
+
+        match_result = string_result =~ pattern
 
         build_result(
           passed: !match_result.nil?,

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/expectation_evaluators/result_type.rb

@@ -36,7 +36,15 @@ class Tryouts
 
       def evaluate(actual_result = nil)
         expectation_result = ExpectationResult.from_result(actual_result)
-        expected_class     = eval_expectation_content(@expectation.content, expectation_result)
+
+        # Try to evaluate in test context first, then fallback to global context for constants
+        begin
+          expected_class = eval_expectation_content(@expectation.content, expectation_result)
+        rescue NameError => e
+          # If we can't find the constant in test context, try global context
+          # This is common for exception classes like ArgumentError, StandardError, etc.
+          expected_class = Object.const_get(@expectation.content.strip)
+        end
 
         build_result(
           passed: actual_result.is_a?(expected_class),

data/lib/tryouts/file_processor.rb

@@ -1,7 +1,7 @@
 # lib/tryouts/file_processor.rb
 
-require_relative 'prism_parser'
-require_relative 'enhanced_parser'
+require_relative 'parsers/prism_parser'
+require_relative 'parsers/enhanced_parser'
 require_relative 'test_executor'
 require_relative 'cli/modes/inspect'
 require_relative 'cli/modes/generate'
@@ -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]
@@ -39,7 +39,7 @@ class Tryouts
     private
 
     def create_parser(file, options)
-      parser_type = options[:parser] || :prism  # default to legacy for safe rollout
+      parser_type = options[:parser] || :enhanced  # enhanced parser is now the default
 
       unless PARSER_TYPES.include?(parser_type)
         raise ArgumentError, "Unknown parser: #{parser_type}. Allowed types: #{PARSER_TYPES.join(', ')}"
@@ -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/base_parser.rb

@@ -0,0 +1,23 @@
+# lib/tryouts/parsers/base_parser.rb
+
+require 'prism'
+
+require_relative 'shared_methods'
+
+class Tryouts
+  # Fixed PrismParser with pattern matching for robust token filtering
+  module Parsers
+    class BaseParser
+      include Tryouts::Parsers::SharedMethods
+
+      def initialize(source_path)
+        @source_path  = source_path
+        @source       = File.read(source_path)
+        @lines        = @source.lines.map(&:chomp)
+        @prism_result = Prism.parse(@source)
+        @parsed_at    = Time.now
+      end
+
+    end
+  end
+end

data/lib/tryouts/parsers/enhanced_parser.rb

@@ -0,0 +1,115 @@
+# lib/tryouts/parsers/enhanced_parser.rb
+
+# Enhanced parser using Prism's inhouse comment extraction capabilities
+# Drop-in replacement for PrismParser that eliminates HEREDOC parsing issues
+
+require_relative '../test_case'
+require_relative 'base_parser'
+
+class Tryouts
+  # Enhanced parser that replaces manual line-by-line parsing with inhouse Prism APIs
+  # while maintaining full compatibility with the original parser's logic structure
+  class EnhancedParser < Tryouts::Parsers::BaseParser
+
+    def parse
+      return handle_syntax_errors if @prism_result.failure?
+
+      # Use inhouse comment extraction instead of line-by-line regex parsing
+      # This automatically excludes HEREDOC content!
+      tokens           = tokenize_content_with_inhouse_extraction
+      test_boundaries  = find_test_case_boundaries(tokens)
+      tokens           = classify_potential_descriptions_with_boundaries(tokens, test_boundaries)
+      test_blocks      = group_into_test_blocks(tokens)
+      process_test_blocks(test_blocks)
+    end
+
+    private
+
+    # Inhouse comment extraction - replaces the manual regex parsing
+    def tokenize_content_with_inhouse_extraction
+      tokens = []
+
+      # Get all comments using inhouse Prism extraction
+      comments        = Prism.parse_comments(@source)
+      comment_by_line = comments.group_by { |comment| comment.location.start_line }
+
+      # Process each line, handling multiple comments per line
+      @lines.each_with_index do |line, index|
+        line_number = index + 1
+
+        if (comments_for_line = comment_by_line[line_number]) && !comments_for_line.empty?
+          emitted_code = false
+          comments_for_line.sort_by! { |c| c.location.start_column }
+          comments_for_line.each do |comment|
+            comment_content = comment.slice.strip
+            if comment.location.start_column > 0
+              unless emitted_code
+                tokens << { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
+                emitted_code = true
+              end
+              # Inline comment may carry expectations; classify it too
+              tokens << classify_comment_inhousely(comment_content, line_number)
+            else
+              tokens << classify_comment_inhousely(comment_content, line_number)
+            end
+          end
+          next
+        end
+
+        # Handle non-comment lines (blank lines and code)
+        token = case line
+                when /^\s*$/
+                  { type: :blank, line: index }
+                else
+                  { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
+                end
+        tokens << token
+      end
+
+      tokens
+    end
+
+    # Inhouse comment classification - replaces complex regex patterns
+    def classify_comment_inhousely(content, line_number)
+      case content
+      when /^##\s*(.*)$/
+        { type: :description, content: $1.strip, line: line_number - 1 }
+      when /^#\s*TEST\s*\d*:\s*(.*)$/
+        { type: :description, content: $1.strip, line: line_number - 1 }
+      when /^#\s*=!>\s*(.*)$/
+        { type: :exception_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=<>\s*(.*)$/
+        { type: :intentional_failure_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*==>\s*(.*)$/
+        { type: :true_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when %r{^#\s*=/=>\s*(.*)$}
+        { 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*(.*)$/
+        { type: :regex_match_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=%>\s*(.*)$/
+        { type: :performance_time_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=(\d+)>\s*(.*)$/
+        { type: :output_expectation, content: $2.strip, pipe: $1.to_i, line: line_number - 1, ast: parse_expectation($2.strip) }
+      when /^#\s*=>\s*(.*)$/
+        { type: :expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^##\s*=>\s*(.*)$/
+        { type: :comment, content: '=>' + $1.strip, line: line_number - 1 }
+      when /^#\s*(.*)$/
+        { type: :potential_description, content: $1.strip, line: line_number - 1 }
+      else
+        { type: :comment, content: content.sub(/^#\s*/, ''), line: line_number - 1 }
+      end
+    end
+
+    # Parser type identification for metadata
+    def parser_type
+      :enhanced
+    end
+  end
+end