tryouts 3.5.1 → 3.5.2

data/lib/tryouts/parsers/enhanced_parser.rb

@@ -1,16 +1,74 @@
 # 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
+  # Enhanced parser using Prism's native comment extraction for robust parsing
+  #
+  # The EnhancedParser is the default parser that provides syntax-aware comment
+  # extraction by leveraging Ruby's official Prism parser. This approach eliminates
+  # common parsing issues found in regex-based parsers, particularly with complex
+  # Ruby syntax.
+  #
+  # @example Basic usage
+  #   parser = Tryouts::EnhancedParser.new(source_code, file_path)
+  #   testrun = parser.parse
+  #   puts testrun.test_cases.length
+  #
+  # @example Problematic code that EnhancedParser handles correctly
+  #   source = <<~RUBY
+  #     ## Test HEREDOC handling
+  #     sql = <<~SQL
+  #       SELECT * FROM users
+  #       -- This is NOT a tryout comment
+  #       #=> This is NOT a tryout expectation
+  #     SQL
+  #     puts sql.length
+  #     #=> Integer  # This IS a real expectation
+  #   RUBY
+  #
+  # @!attribute [r] parser_type
+  #   @return [Symbol] Returns :enhanced to identify parser type
+  #
+  # ## Key Benefits over LegacyParser
+  #
+  # ### 1. HEREDOC Safety
+  # - Uses Prism's `parse_comments()` to extract only actual Ruby comments
+  # - Automatically excludes content inside string literals, HEREDOCs, and interpolation
+  # - Prevents false positive expectation detection
+  #
+  # ### 2. Inline Comment Handling
+  # - Correctly handles lines with both code and comments
+  # - Supports multiple comments per line with proper positioning
+  # - Emits separate tokens for code and comment content
+  #
+  # ### 3. Syntax Awareness
+  # - Leverages Ruby's official parser for accurate code understanding
+  # - Handles complex Ruby syntax edge cases reliably
+  # - More robust than regex-based parsing approaches
+  #
+  # ### 4. Performance
+  # - Uses optimized C-based Prism parsing for comment extraction
+  # - Efficient handling of large files with complex syntax
+  #
+  # ## Pattern Matching
+  # Uses Ruby 3.4+ pattern matching (`case/in`) for token classification,
+  # providing clean, modern syntax for expectation type detection.
+  #
+  # @see LegacyParser For simpler regex-based parsing (legacy compatibility)
+  # @see BaseParser For shared parsing functionality
+  # @since 3.2.0
   class EnhancedParser < Tryouts::Parsers::BaseParser
 
+    # Parse source code into a Testrun using Prism-based comment extraction
+    #
+    # This method provides the main parsing logic that converts raw Ruby source
+    # code containing tryout syntax into structured test cases. Uses Prism's
+    # native comment extraction to avoid HEREDOC 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?
 
@@ -25,7 +83,20 @@ class Tryouts
 
     private
 
-    # Inhouse comment extraction - replaces the manual regex parsing
+    # Extract and tokenize comments using Prism's native comment extraction
+    #
+    # This method replaces manual line-by-line regex parsing with Prism's
+    # built-in comment extraction capabilities. The key benefit is that
+    # `Prism.parse_comments()` only returns actual Ruby comments, automatically
+    # excluding content inside string literals, HEREDOCs, and interpolations.
+    #
+    # @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> }
+    #   ]
     def tokenize_content_with_inhouse_extraction
       tokens = []
 
@@ -47,8 +118,8 @@ class Tryouts
                 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)
+              # Inline comment (after code) - treat as regular comment, not expectation
+              tokens << { type: :comment, content: comment_content.sub(/^#\s*/, ''), line: line_number - 1 }
             else
               tokens << classify_comment_inhousely(comment_content, line_number)
             end
@@ -69,44 +140,125 @@ class Tryouts
       tokens
     end
 
-    # Inhouse comment classification - replaces complex regex patterns
+    # Classify comment content into specific token types using pattern matching
+    #
+    # Takes a raw comment string and determines what type of tryout token it
+    # represents (description, expectation, etc.). Uses Ruby 3.4+ pattern matching
+    # for clean, maintainable classification logic.
+    #
+    # @param content [String] The comment content (including # prefix)
+    # @param line_number [Integer] 1-based line number for error reporting
+    # @return [Hash] Token hash with :type, :content, :line and other type-specific keys
+    #
+    # @example Valid expectation
+    #   classify_comment_inhousely("#=> 42", 10)
+    #   # => { type: :expectation, content: "42", line: 9, ast: <Prism::Node> }
+    #
+    # @example Malformed expectation (triggers warning)
+    #   classify_comment_inhousely("#=INVALID> 42", 10)
+    #   # => { type: :malformed_expectation, syntax: "INVALID", content: "42", line: 9 }
+    #   # Also adds warning to parser's warning collection
+    #
+    # @example Test description
+    #   classify_comment_inhousely("## Test basic math", 5)
+    #   # => { type: :description, content: "Test basic math", line: 4 }
     def classify_comment_inhousely(content, line_number)
       case content
-      when /^##\s*(.*)$/
+      in /^##\s*(.*)$/ # Test description format: ## description
         { type: :description, content: $1.strip, line: line_number - 1 }
-      when /^#\s*TEST\s*\d*:\s*(.*)$/
+      in /^#\s*TEST\s*\d*:\s*(.*)$/  # rubocop:disable Lint/DuplicateBranch
         { type: :description, content: $1.strip, line: line_number - 1 }
-      when /^#\s*=!>\s*(.*)$/
+      in /^#\s*=!>\s*(.*)$/ # Exception expectation
         { type: :exception_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*=<>\s*(.*)$/
+      in /^#\s*=<>\s*(.*)$/ # Intentional failure expectation
         { type: :intentional_failure_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*==>\s*(.*)$/
+      in /^#\s*==>\s*(.*)$/ # Boolean true expectation
         { type: :true_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when %r{^#\s*=/=>\s*(.*)$}
+      in %r{^#\s*=/=>\s*(.*)$} # Boolean false expectation
         { type: :false_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*=\|>\s*(.*)$/
+      in /^#\s*=\|>\s*(.*)$/ # Boolean (true or false) expectation
         { type: :boolean_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*=\*>\s*(.*)$/
+      in /^#\s*=\*>\s*(.*)$/ # Non-nil expectation
         { type: :non_nil_expectation, content: $1.strip, line: line_number - 1 }
-      when /^#\s*=:>\s*(.*)$/
+      in /^#\s*=:>\s*(.*)$/ # Result type expectation
         { type: :result_type_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*=~>\s*(.*)$/
+      in /^#\s*=~>\s*(.*)$/ # Regex match expectation
         { type: :regex_match_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*=%>\s*(.*)$/
+      in /^#\s*=%>\s*(.*)$/ # Performance time expectation
         { type: :performance_time_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^#\s*=(\d+)>\s*(.*)$/
+      in /^#\s*=(\d+)>\s*(.*)$/ # Output expectation (stdout/stderr with pipe number)
         { type: :output_expectation, content: $2.strip, pipe: $1.to_i, line: line_number - 1, ast: parse_expectation($2.strip) }
-      when /^#\s*=>\s*(.*)$/
+      in /^#\s*=>\s*(.*)$/ # Regular expectation
         { type: :expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
-      when /^##\s*=>\s*(.*)$/
+      in /^#\s*=([^>=:!~%*|\/\s]+)>\s*(.*)$/ # Malformed expectation - invalid characters between = and >
+        syntax = $1
+        content_part = $2.strip
+        add_warning(ParserWarning.malformed_expectation(
+          line_number: line_number,
+          syntax: syntax,
+          context: content.strip
+        ))
+        { type: :malformed_expectation, syntax: syntax, content: content_part, line: line_number - 1 }
+      in /^##\s*=>\s*(.*)$/ # Commented out expectation (should be ignored)
         { type: :comment, content: '=>' + $1.strip, line: line_number - 1 }
-      when /^#\s*(.*)$/
+      in content if looks_like_malformed_expectation?(content) # Comprehensive malformed expectation detection
+        detected_syntax = extract_malformed_syntax(content)
+        add_warning(ParserWarning.malformed_expectation(
+          line_number: line_number,
+          syntax: detected_syntax,
+          context: content.strip
+        ))
+        { type: :malformed_expectation, syntax: detected_syntax, content: content.strip, line: line_number - 1 }
+      in /^#\s*(.*)$/ # Single hash comment - potential description
         { type: :potential_description, content: $1.strip, line: line_number - 1 }
-      else
+      else # Unknown comment format
         { type: :comment, content: content.sub(/^#\s*/, ''), line: line_number - 1 }
       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.)
+    #
+    # Only flags as malformed if it starts with patterns that look like expectation syntax,
+    # not just any comment that happens to contain equals signs in natural language.
+    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
+
+      # Only flag as malformed if it looks like an expectation attempt at the start
+      # Patterns that suggest malformed expectation syntax:
+      # - Starts with #= but doesn't match valid patterns
+      # - Has multiple = or > characters in suspicious positions near the start
+      # - Looks like broken expectation syntax (not natural language)
+
+      return true if content.match?(/^#\s*=\s*>/) # "# = >" (spaces in wrong places)
+      return true if content.match?(/^#\s*==+>/) # "# ==> " (wrong number of =)
+      return true if content.match?(/^#\s*=[^=:!~%*|\/>\s][^>]*>/) # "# =X> " (invalid chars between = and >)
+      return true if content.match?(/^#\s*>[^=]/) # "# >something" (starts with >)
+      return true if content.match?(/^#\s*<[^=]/) # "# <something" (starts with <)
+
+      false # Regular comments with = signs in natural language are OK
+    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
       :enhanced

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