tryouts 3.5.0 → 3.5.2

data/lib/tryouts/parsers/legacy_parser.rb

@@ -0,0 +1,254 @@
+# lib/tryouts/parsers/legacy_parser.rb
+
+require_relative '../test_case'
+require_relative 'base_parser'
+
+class Tryouts
+  # Legacy parser using line-by-line regex parsing for compatibility
+  #
+  # The LegacyParser provides a simpler, more straightforward approach to parsing
+  # tryout files using sequential line-by-line processing with pattern matching.
+  # While less sophisticated than the EnhancedParser, it offers predictable behavior
+  # and serves as a fallback option for edge cases.
+  #
+  # @example Basic usage
+  #   parser = Tryouts::LegacyParser.new(source_code, file_path)
+  #   testrun = parser.parse
+  #   puts testrun.test_cases.length
+  #
+  # @example Using legacy parser explicitly
+  #   # In CLI: tryouts --legacy-parser my_test.rb
+  #   # Or programmatically:
+  #   parser = Tryouts::LegacyParser.new(source, file)
+  #   result = parser.parse
+  #
+  # @!attribute [r] parser_type
+  #   @return [Symbol] Returns :legacy to identify parser type
+  #
+  # ## Characteristics
+  #
+  # ### 1. Simple Line-by-Line Processing
+  # - Processes each line sequentially with pattern matching
+  # - Straightforward regex-based approach
+  # - Easy to understand and debug parsing logic
+  #
+  # ### 2. Pattern Matching Classification
+  # - Uses Ruby 3.4+ pattern matching (`case/in`) for token classification
+  # - Modern syntax while maintaining simple parsing approach
+  # - Consistent with EnhancedParser's classification logic
+  #
+  # ### 3. Compatibility Focus
+  # - Maintains backward compatibility with older tryout files
+  # - Provides fallback parsing when EnhancedParser encounters issues
+  # - Useful for debugging parser-specific problems
+  #
+  # ## Limitations
+  #
+  # ### 1. HEREDOC Vulnerability
+  # - Cannot distinguish between real comments and content inside HEREDOCs
+  # - May incorrectly parse string content as tryout syntax
+  # - Requires careful handling of complex Ruby syntax
+  #
+  # ### 2. Limited Inline Comment Support
+  # - Basic handling of lines with both code and comments
+  # - Less sophisticated than EnhancedParser's multi-comment support
+  #
+  # ## When to Use
+  #
+  # - **Debugging**: When EnhancedParser produces unexpected results
+  # - **Compatibility**: With older Ruby versions or edge cases
+  # - **Simplicity**: When predictable line-by-line behavior is preferred
+  # - **Fallback**: As a secondary parsing option
+  #
+  # @see EnhancedParser For robust syntax-aware parsing (recommended default)
+  # @see BaseParser For shared parsing functionality
+  # @since 3.0.0
+  class LegacyParser < Tryouts::Parsers::BaseParser
+
+    # Parse source code into a Testrun using line-by-line processing
+    #
+    # This method provides sequential line-by-line parsing that processes each
+    # line with pattern matching to classify tokens. While simpler than
+    # EnhancedParser, it may be vulnerable to HEREDOC content parsing issues.
+    #
+    # @return [Tryouts::Testrun] Structured test data with setup, test cases, teardown, and warnings
+    # @raise [Tryouts::TryoutSyntaxError] If source contains syntax errors or strict mode violations
+    def parse
+      return handle_syntax_errors if @prism_result.failure?
+
+      tokens           = tokenize_content
+      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
+
+    # Tokenize content using sequential line-by-line pattern matching
+    #
+    # Processes each line of source code individually, applying pattern matching
+    # to classify it as code, comment, expectation, etc. This approach is simple
+    # and predictable but cannot distinguish between real comments and content
+    # inside string literals or HEREDOCs.
+    #
+    # @return [Array<Hash>] Array of token hashes with keys :type, :content, :line, etc.
+    # @example Token structure
+    #   [
+    #     { type: :description, content: "Test case description", line: 5 },
+    #     { type: :code, content: "result = calculate(x)", line: 6 },
+    #     { type: :expectation, content: "42", line: 7, ast: <Prism::Node> }
+    #   ]
+    # @note Potential_descriptions are later reclassified based on test boundaries
+    def tokenize_content
+      tokens = []
+
+      @lines.each_with_index do |line, index|
+        token = case line
+                in /^##\s*(.*)$/ # Test description format: ## description
+                  { type: :description, content: $1.strip, line: index }
+                in /^#\s*TEST\s*\d*:\s*(.*)$/  # rubocop:disable Lint/DuplicateBranch
+                  { type: :description, content: $1.strip, line: index }
+                in /^#\s*=!>\s*(.*)$/ # Exception expectation (updated for consistency)
+                  { type: :exception_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=<>\s*(.*)$/ # Intentional failure expectation
+                  { type: :intentional_failure_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*==>\s*(.*)$/ # Boolean true expectation
+                  { type: :true_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in %r{^#\s*=/=>\s*(.*)$} # Boolean false expectation
+                  { 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
+                  { type: :regex_match_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=%>\s*(.*)$/ # Performance time expectation
+                  { type: :performance_time_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=(\d+)>\s*(.*)$/ # Output expectation (stdout/stderr with pipe number)
+                  { type: :output_expectation, content: $2.strip, pipe: $1.to_i, line: index, ast: parse_expectation($2.strip) }
+                in /^#\s*=>\s*(.*)$/ # Regular expectation
+                  { type: :expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=([^>=:!~%*|\/\s]+)>\s*(.*)$/ # Malformed expectation - invalid characters between = and >
+                  syntax = $1
+                  content_part = $2.strip
+                  add_warning(ParserWarning.malformed_expectation(
+                    line_number: index + 1,
+                    syntax: syntax,
+                    context: line.strip
+                  ))
+                  { type: :malformed_expectation, syntax: syntax, content: content_part, line: index }
+                in /^##\s*=>\s*(.*)$/ # Commented out expectation (should be ignored)
+                  { type: :comment, content: '=>' + $1.strip, line: index }
+                in line if looks_like_malformed_expectation?(line) # Comprehensive malformed expectation detection
+                  detected_syntax = extract_malformed_syntax(line)
+                  add_warning(ParserWarning.malformed_expectation(
+                    line_number: index + 1,
+                    syntax: detected_syntax,
+                    context: line.strip
+                  ))
+                  { type: :malformed_expectation, syntax: detected_syntax, content: line.strip, line: index }
+                in /^#\s*(.*)$/ # Single hash comment - potential description
+                  { type: :potential_description, content: $1.strip, line: index }
+                in /^\s*$/ # Blank line
+                  { type: :blank, line: index }
+                else # Ruby code
+                  { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
+                end
+
+        tokens << token
+      end
+
+      # Return tokens with potential_descriptions - they'll be classified later with test boundaries
+      tokens
+    end
+
+
+    # Convert potential_descriptions to descriptions or comments based on context
+    def classify_potential_descriptions(tokens)
+      tokens.map.with_index do |token, index|
+        if token[:type] == :potential_description
+          # Check if this looks like a test description based on content and context
+          content = token[:content].strip
+
+          # Skip if it's clearly just a regular comment (short, lowercase, etc.)
+          # Test descriptions are typically longer and more descriptive
+          looks_like_regular_comment = content.length < 20 &&
+                                       content.downcase == content &&
+                                       !content.match?(/test|example|demonstrate|show/i)
+
+          # Check if there's code immediately before this (suggesting it's mid-test)
+          prev_token      = index > 0 ? tokens[index - 1] : nil
+          has_code_before = prev_token && prev_token[:type] == :code
+
+          if looks_like_regular_comment || has_code_before
+            # Treat as regular comment
+            token.merge(type: :comment)
+          else
+            # Look ahead for test pattern: code + at least one expectation within reasonable distance
+            following_tokens = tokens[(index + 1)..]
+
+            # Skip blanks and comments to find meaningful content
+            meaningful_following = following_tokens.reject { |t| [:blank, :comment].include?(t[:type]) }
+
+            # Look for test pattern: at least one code token followed by at least one expectation
+            # within the next 10 meaningful tokens (to avoid matching setup/teardown)
+            test_window     = meaningful_following.first(10)
+            has_code        = test_window.any? { |t| t[:type] == :code }
+            has_expectation = test_window.any? { |t| is_expectation_type?(t[:type]) }
+
+            if has_code && has_expectation
+              token.merge(type: :description)
+            else
+              token.merge(type: :comment)
+            end
+          end
+        else
+          token
+        end
+      end
+    end
+
+    # Detect if a comment looks like a malformed expectation attempt
+    # This catches patterns that suggest someone tried to write an expectation
+    # but got the syntax wrong (missing parts, wrong spacing, extra characters, etc.)
+    def looks_like_malformed_expectation?(content)
+      # Skip if it's already handled by specific patterns above
+      return false if content.match?(/^##\s*/) # Description
+      return false if content.match?(/^#\s*TEST\s*\d*:\s*/) # TEST format
+      return false if content.match?(/^##\s*=>\s*/) # Commented out expectation
+
+      # Look for patterns that suggest expectation attempts:
+      # 1. Contains = and/or > in suspicious positions
+      # 2. Has spaces around = or > suggesting misunderstanding
+      # 3. Missing > or = from what looks like expectation syntax
+      # 4. Extra characters in expectation-like patterns
+
+      content.match?(/^#\s*([=><]|.*[=><])/) && # Contains =, >, or < after #
+      !content.match?(/^#\s*[^=><]*$/) # Not just a regular comment without expectation chars
+    end
+
+    # Extract the malformed syntax portion for warning display
+    def extract_malformed_syntax(content)
+      # Try to identify what the user was attempting to write
+      case content
+      when /^#\s*([=><][^=><]*[=><].*?)(\s|$)/ # Pattern with expectation chars
+        $1.strip
+      when /^#\s*([=><].*?)(\s|$)/ # Simple pattern starting with expectation char
+        $1.strip
+      when /^#\s*(.*?[=><].*?)(\s|$)/ # Pattern containing expectation chars
+        $1.strip
+      else
+        # Fallback: show the part after #
+        content.sub(/^#\s*/, '').split(/\s/).first || 'unknown'
+      end
+    end
+
+    # Parser type identification for metadata
+    def parser_type
+      :legacy
+    end
+  end
+end

data/lib/tryouts/parsers/shared_methods.rb

@@ -103,6 +103,9 @@ class Tryouts
           in [_, { type: :output_expectation }]
             current_block[:expectations] << token
 
+          in [_, { type: :malformed_expectation }]
+            current_block[:expectations] << token
+
           in [_, { type: :comment | :blank }]
             add_context_to_block(current_block, token)
           end
@@ -197,7 +200,8 @@ 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, :non_nil_expectation
+          :performance_time_expectation, :output_expectation, :non_nil_expectation,
+          :malformed_expectation
         ].include?(type)
       end
 

data/lib/tryouts/test_batch.rb

@@ -436,7 +436,7 @@ class Tryouts
 
       # For non-catastrophic errors, we still stop batch execution
       unless Tryouts.batch_stopping_error?(ex)
-        @output_manager&.error("Global setup failed: #{ex.message}")
+        @output_manager&.error("Global setup error: #{ex.message}")
         return
       end
 

data/lib/tryouts/test_executor.rb

@@ -11,7 +11,6 @@ class Tryouts
       @output_manager = output_manager
       @translator     = translator
       @global_tally   = global_tally
-
     end
 
     def execute
@@ -29,7 +28,6 @@ class Tryouts
 
     private
 
-
     def execute_direct_mode
       batch = TestBatch.new(
         @testrun,
@@ -56,7 +54,7 @@ class Tryouts
       file_error_count                  = test_results.count { |r| r.error? }
       executed_test_count               = test_results.size
 
-      # Note: Individual test results are added to the aggregator in TestBatch
+      # 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
@@ -66,7 +64,17 @@ class Tryouts
       @output_manager.file_success(@file, executed_test_count, file_failed_count, file_error_count, duration)
 
       # Combine failures and errors to determine the exit code.
-      success ? 0 : (file_failed_count + file_error_count)
+      # Include infrastructure failures (setup/teardown errors) in exit code calculation
+      if success
+        0
+      else
+        # Check for infrastructure failures when no test cases executed
+        infrastructure_failure_count = @global_tally[:aggregator].infrastructure_failure_count
+        total_failure_count          = file_failed_count + file_error_count
+
+        # If no tests ran but there are infrastructure failures, count those as failures
+        total_failure_count.zero? && infrastructure_failure_count > 0 ? infrastructure_failure_count : total_failure_count
+      end
     end
 
     def execute_rspec_mode

data/lib/tryouts/test_result_aggregator.rb

@@ -8,18 +8,18 @@ class Tryouts
   # across all formatters and eliminate counting discrepancies
   class TestResultAggregator
     def initialize
-      @failure_collector = FailureCollector.new
+      @failure_collector       = FailureCollector.new
       # Use thread-safe atomic counters
-      @test_counts = {
+      @test_counts             = {
         total_tests: Concurrent::AtomicFixnum.new(0),
         passed: Concurrent::AtomicFixnum.new(0),
         failed: Concurrent::AtomicFixnum.new(0),
-        errors: Concurrent::AtomicFixnum.new(0)
+        errors: Concurrent::AtomicFixnum.new(0),
       }
       @infrastructure_failures = Concurrent::Array.new
-      @file_counts = {
+      @file_counts             = {
         total: Concurrent::AtomicFixnum.new(0),
-        successful: Concurrent::AtomicFixnum.new(0)
+        successful: Concurrent::AtomicFixnum.new(0),
       }
     end
 
@@ -46,7 +46,7 @@ class Tryouts
         type: type,           # :setup, :teardown, :file_processing
         file_path: file_path,
         error_message: error_message,
-        exception: exception
+        exception: exception,
       }
     end
 
@@ -59,6 +59,10 @@ class Tryouts
       @file_counts[:successful].increment
     end
 
+    # Get count of infrastructure failures
+    def infrastructure_failure_count
+      @infrastructure_failures.size
+    end
 
     # Get counts that should be displayed in numbered failure lists
     # These match what actually appears in the failure summary
@@ -68,7 +72,7 @@ class Tryouts
         passed: @test_counts[:passed].value,
         failed: @failure_collector.failure_count,
         errors: @failure_collector.error_count,
-        total_issues: @failure_collector.total_issues
+        total_issues: @failure_collector.total_issues,
       }
     end
 
@@ -82,7 +86,7 @@ class Tryouts
         failed: display[:failed],
         errors: display[:errors],
         infrastructure_failures: @infrastructure_failures.size,
-        total_issues: display[:total_issues] + @infrastructure_failures.size
+        total_issues: display[:total_issues] + @infrastructure_failures.size,
       }
     end
 
@@ -90,7 +94,7 @@ class Tryouts
     def get_file_counts
       {
         total: @file_counts[:total].value,
-        successful: @file_counts[:successful].value
+        successful: @file_counts[:successful].value,
       }
     end
 
@@ -124,7 +128,7 @@ class Tryouts
     # Provide a summary string for debugging
     def summary
       display = get_display_counts
-      total = get_total_counts
+      total   = get_total_counts
 
       parts = []
       parts << "#{display[:passed]} passed" if display[:passed] > 0
@@ -132,7 +136,7 @@ class Tryouts
       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(', ')
+      parts.empty? ? 'All tests passed' : parts.join(', ')
     end
   end
 end

data/lib/tryouts/test_runner.rb

@@ -1,7 +1,7 @@
 # lib/tryouts/test_runner.rb
 
 require 'concurrent'
-require_relative 'parsers/prism_parser'
+require_relative 'parsers/legacy_parser'
 require_relative 'parsers/enhanced_parser'
 require_relative 'test_batch'
 require_relative 'translators/rspec_translator'
@@ -24,11 +24,11 @@ class Tryouts
     }.freeze
 
     def initialize(files:, options:, output_manager:)
-      @files          = files
-      @options        = apply_framework_defaults(options)
-      @output_manager = output_manager
-      @translator     = initialize_translator
-      @global_tally   = initialize_global_tally
+      @files           = files
+      @options         = apply_framework_defaults(options)
+      @output_manager  = output_manager
+      @translator      = initialize_translator
+      @global_tally    = initialize_global_tally
       @file_line_specs = options[:file_line_specs] || {}
     end
 
@@ -44,8 +44,11 @@ class Tryouts
       end
 
       # For agent critical mode, only count errors as failures
-      if @options[:agent] && (@options[:agent_focus] == :critical || @options[:agent_focus] == 'critical')
-        @global_tally[:aggregator].get_display_counts[:errors]
+      if @options[:agent] && ([:critical, 'critical'].include?(@options[:agent_focus]))
+        # Include infrastructure failures as errors for agent critical mode
+        display_errors        = @global_tally[:aggregator].get_display_counts[:errors]
+        infrastructure_errors = @global_tally[:aggregator].infrastructure_failure_count
+        display_errors + infrastructure_errors
       else
         result
       end
@@ -118,7 +121,7 @@ class Tryouts
         min_threads: 1,
         max_threads: pool_size,
         max_queue: @files.length, # Queue size must accommodate all files
-        fallback_policy: :abort # Raise exception if pool and queue are exhausted
+        fallback_policy: :abort, # Raise exception if pool and queue are exhausted
       )
 
       # Submit all file processing tasks to the thread pool
@@ -132,15 +135,15 @@ class Tryouts
       failure_count = 0
       futures.each_with_index do |future, idx|
         begin
-          result = future.value # This blocks until the future completes
+          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]
+          file   = @files[idx]
           @output_manager.info "#{status} #{Console.pretty_path(file)} (#{result} failures)", 1
         rescue StandardError => ex
           failure_count += 1
-          file = @files[idx]
+          file           = @files[idx]
           @output_manager.info "#{Console.color(:red, 'ERROR')} #{Console.pretty_path(file)} (#{ex.message})", 1
         end
       end
@@ -184,10 +187,10 @@ class Tryouts
     end
 
     def show_grand_total
-      elapsed_time = Time.now - @global_tally[:start_time]
-      aggregator = @global_tally[:aggregator]
+      elapsed_time   = Time.now - @global_tally[:start_time]
+      aggregator     = @global_tally[:aggregator]
       display_counts = aggregator.get_display_counts
-      file_counts = aggregator.get_file_counts
+      file_counts    = aggregator.get_file_counts
 
       @output_manager.grand_total(
         display_counts[:total_tests],

data/lib/tryouts/version.rb

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

data/lib/tryouts.rb

@@ -8,7 +8,7 @@ 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/parsers/prism_parser'
+require_relative 'tryouts/parsers/legacy_parser'
 require_relative 'tryouts/parsers/enhanced_parser'
 require_relative 'tryouts/cli'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tryouts
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.5.2
 platform: ruby
 authors:
 - Delano Mandelbaum
@@ -171,9 +171,10 @@ files:
 - lib/tryouts/failure_collector.rb
 - lib/tryouts/file_processor.rb
 - lib/tryouts/parser_warning.rb
+- lib/tryouts/parsers/CLAUDE.md
 - lib/tryouts/parsers/base_parser.rb
 - lib/tryouts/parsers/enhanced_parser.rb
-- lib/tryouts/parsers/prism_parser.rb
+- lib/tryouts/parsers/legacy_parser.rb
 - lib/tryouts/parsers/shared_methods.rb
 - lib/tryouts/test_batch.rb
 - lib/tryouts/test_case.rb

data/lib/tryouts/parsers/prism_parser.rb

@@ -1,122 +0,0 @@
-# lib/tryouts/parsers/prism_parser.rb
-
-require_relative '../test_case'
-require_relative 'base_parser'
-
-class Tryouts
-  # Fixed PrismParser with pattern matching for robust token filtering
-  class PrismParser < Tryouts::Parsers::BaseParser
-
-    def parse
-      return handle_syntax_errors if @prism_result.failure?
-
-      tokens           = tokenize_content
-      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
-
-    # Tokenize content using pattern matching for clean line classification
-    def tokenize_content
-      tokens = []
-
-      @lines.each_with_index do |line, index|
-        token = case line
-                in /^##\s*(.*)$/ # Test description format: ## description
-                  { type: :description, content: $1.strip, line: index }
-                in /^#\s*TEST\s*\d*:\s*(.*)$/  # rubocop:disable Lint/DuplicateBranch
-                  { type: :description, content: $1.strip, line: index }
-                in /^#\s*=!>\s*(.*)$/ # Exception expectation (updated for consistency)
-                  { type: :exception_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
-                in /^#\s*=<>\s*(.*)$/ # Intentional failure expectation
-                  { type: :intentional_failure_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
-                in /^#\s*==>\s*(.*)$/ # Boolean true expectation
-                  { type: :true_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
-                in %r{^#\s*=/=>\s*(.*)$} # Boolean false expectation
-                  { 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
-                  { type: :regex_match_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
-                in /^#\s*=%>\s*(.*)$/ # Performance time expectation
-                  { type: :performance_time_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
-                in /^#\s*=(\d+)>\s*(.*)$/ # Output expectation (stdout/stderr with pipe number)
-                  { type: :output_expectation, content: $2.strip, pipe: $1.to_i, line: index, ast: parse_expectation($2.strip) }
-                in /^#\s*=>\s*(.*)$/ # Regular expectation
-                  { type: :expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
-                in /^##\s*=>\s*(.*)$/ # Commented out expectation (should be ignored)
-                  { type: :comment, content: '=>' + $1.strip, line: index }
-                in /^#\s*(.*)$/ # Single hash comment - potential description
-                  { type: :potential_description, content: $1.strip, line: index }
-                in /^\s*$/ # Blank line
-                  { type: :blank, line: index }
-                else # Ruby code
-                  { type: :code, content: line, line: index, ast: parse_ruby_line(line) }
-                end
-
-        tokens << token
-      end
-
-      # Return tokens with potential_descriptions - they'll be classified later with test boundaries
-      tokens
-    end
-
-
-    # Convert potential_descriptions to descriptions or comments based on context
-    def classify_potential_descriptions(tokens)
-      tokens.map.with_index do |token, index|
-        if token[:type] == :potential_description
-          # Check if this looks like a test description based on content and context
-          content = token[:content].strip
-
-          # Skip if it's clearly just a regular comment (short, lowercase, etc.)
-          # Test descriptions are typically longer and more descriptive
-          looks_like_regular_comment = content.length < 20 &&
-                                       content.downcase == content &&
-                                       !content.match?(/test|example|demonstrate|show/i)
-
-          # Check if there's code immediately before this (suggesting it's mid-test)
-          prev_token      = index > 0 ? tokens[index - 1] : nil
-          has_code_before = prev_token && prev_token[:type] == :code
-
-          if looks_like_regular_comment || has_code_before
-            # Treat as regular comment
-            token.merge(type: :comment)
-          else
-            # Look ahead for test pattern: code + at least one expectation within reasonable distance
-            following_tokens = tokens[(index + 1)..]
-
-            # Skip blanks and comments to find meaningful content
-            meaningful_following = following_tokens.reject { |t| [:blank, :comment].include?(t[:type]) }
-
-            # Look for test pattern: at least one code token followed by at least one expectation
-            # within the next 10 meaningful tokens (to avoid matching setup/teardown)
-            test_window     = meaningful_following.first(10)
-            has_code        = test_window.any? { |t| t[:type] == :code }
-            has_expectation = test_window.any? { |t| is_expectation_type?(t[:type]) }
-
-            if has_code && has_expectation
-              token.merge(type: :description)
-            else
-              token.merge(type: :comment)
-            end
-          end
-        else
-          token
-        end
-      end
-    end
-
-    # Parser type identification for metadata
-    def parser_type
-      :prism_v2_fixed
-    end
-  end
-end