tryouts 3.0.0 → 3.1.1

data/lib/tryouts/expectation_evaluators/true.rb

@@ -0,0 +1,58 @@
+# lib/tryouts/expectation_evaluators/true.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for boolean true expectations using syntax: #==> expression
+    #
+    # PURPOSE:
+    # - Validates that an expression evaluates to exactly true (not truthy)
+    # - Provides explicit boolean validation for documentation-style tests
+    # - Distinguishes between true/false and truthy/falsy values
+    #
+    # SYNTAX: #==> boolean_expression
+    # Examples:
+    #   [1, 2, 3]  #==> result.length == 3        # Pass: expression is true
+    #   [1, 2, 3]  #==> result.include?(2)        # Pass: expression is true
+    #   []         #==> result.empty?             # Pass: expression is true
+    #   [1, 2, 3]  #==> result.empty?             # Fail: expression is false
+    #   [1, 2, 3]  #==> result.length             # Fail: expression is 3 (truthy but not true)
+    #
+    # BOOLEAN STRICTNESS:
+    # - Only passes when expression evaluates to exactly true (not truthy)
+    # - Fails for false, nil, 0, "", [], {}, or any non-true value
+    # - Uses Ruby's === comparison for exact boolean matching
+    # - Encourages explicit boolean expressions in documentation
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Expression has access to `result` and `_` variables (actual_result)
+    # - Expected display shows 'true (exactly)' for clarity
+    # - Actual display shows the evaluated expression result
+    # - Distinguishes from regular expectations through strict true matching
+    #
+    # DESIGN DECISIONS:
+    # - Strict true matching prevents accidental truthy value acceptance
+    # - Clear expected display explains the exact requirement
+    # - Expression evaluation provides flexible boolean logic testing
+    # - Part of unified #= prefix convention for all expectation types
+    class True < Base
+      def self.handles?(expectation_type)
+        expectation_type == :true # rubocop:disable Lint/BooleanSymbol
+      end
+
+      def evaluate(actual_result = nil)
+        expectation_result     = ExpectationResult.from_result(actual_result)
+        expression_result = eval_expectation_content(@expectation.content, expectation_result)
+
+        build_result(
+          passed: expression_result == true,
+          actual: expression_result,
+          expected: true,
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/prism_parser.rb

@@ -1,7 +1,7 @@
 # Modern Ruby 3.4+ solution for the teardown bug
 
 require 'prism'
-require_relative 'testcase'
+require_relative 'test_case'
 
 class Tryouts
   # Fixed PrismParser with pattern matching for robust token filtering
@@ -16,8 +16,10 @@ class Tryouts
     def parse
       return handle_syntax_errors if @prism_result.failure?
 
-      tokens      = tokenize_content
-      test_blocks = group_into_test_blocks(tokens)
+      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
 
@@ -33,7 +35,25 @@ class Tryouts
                   { 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*(.*)$/ # Expectation
+                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*(.*)$/ # 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 }
@@ -48,27 +68,146 @@ class Tryouts
         tokens << token
       end
 
-      # Post-process to convert potential_descriptions to descriptions or comments
-      classify_potential_descriptions(tokens)
+      # Return tokens with potential_descriptions - they'll be classified later with test boundaries
+      tokens
+    end
+
+    # Find actual test case boundaries by looking for ## descriptions or # TEST: patterns
+    # followed by code and expectations
+    def find_test_case_boundaries(tokens)
+      boundaries = []
+
+      tokens.each_with_index do |token, index|
+        # Look for explicit test descriptions (## or # TEST:)
+        if token[:type] == :description
+          # Find the end of this test case by looking for the last expectation
+          # before the next description or end of file
+          start_line = token[:line]
+          end_line = find_test_case_end(tokens, index)
+
+          boundaries << { start: start_line, end: end_line } if end_line
+        end
+      end
+
+      boundaries
+    end
+
+    # Find where a test case ends by looking for the last expectation
+    # before the next test description or end of tokens
+    def find_test_case_end(tokens, start_index)
+      last_expectation_line = nil
+
+      # Look forward from the description for expectations
+      (start_index + 1).upto(tokens.length - 1) do |i|
+        token = tokens[i]
+
+        # Stop if we hit another test description
+        break if token[:type] == :description
+
+        # Track the last expectation we see
+        if is_expectation_type?(token[:type])
+          last_expectation_line = token[:line]
+        end
+      end
+
+      last_expectation_line
+    end
+
+    # Convert potential_descriptions to descriptions or comments using test case boundaries
+    def classify_potential_descriptions_with_boundaries(tokens, test_boundaries)
+      tokens.map.with_index do |token, index|
+        if token[:type] == :potential_description
+          # Check if this comment falls within any test case boundary
+          line_num = token[:line]
+          within_test_case = test_boundaries.any? { |boundary|
+            line_num >= boundary[:start] && line_num <= boundary[:end]
+          }
+
+          if within_test_case
+            # This comment is within a test case, treat as regular comment
+            token.merge(type: :comment)
+          else
+            # For comments outside test boundaries, be more conservative
+            # Only treat as description if it immediately precedes a test pattern AND
+            # looks like a test description
+            content = token[:content].strip
+
+            # Check if this looks like a test description based on content
+            looks_like_test_description = content.match?(/test|example|demonstrate|show|should|when|given/i) &&
+                                        content.length > 10
+
+            # 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 has_code_before || !looks_like_test_description
+              # Treat as regular comment
+              token.merge(type: :comment)
+            else
+              # Look ahead for IMMEDIATE test pattern (stricter than before)
+              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 within next 5 tokens (more restrictive)
+              test_window = meaningful_following.first(5)
+              has_code = test_window.any? { |t| t[:type] == :code }
+              has_expectation = test_window.any? { |t| is_expectation_type?(t[:type]) }
+
+              # Only promote to description if BOTH code and expectation are found nearby
+              # AND it looks like a test description
+              if has_code && has_expectation && looks_like_test_description
+                token.merge(type: :description)
+              else
+                token.merge(type: :comment)
+              end
+            end
+          end
+        else
+          token
+        end
+      end
     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
-          # Look ahead strictly for the pattern: [optional blanks] code expectation
-          following_tokens = tokens[(index + 1)..]
+          # Check if this looks like a test description based on content and context
+          content = token[:content].strip
 
-          # Skip blanks and find next non-blank tokens
-          non_blank_following = following_tokens.reject { |t| t[:type] == :blank }
+          # 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)
 
-          # Must have: code immediately followed by expectation (with possible blanks between)
-          if non_blank_following.size >= 2 &&
-             non_blank_following[0][:type] == :code &&
-             non_blank_following[1][:type] == :expectation
-            token.merge(type: :description)
-          else
+          # 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
@@ -76,6 +215,16 @@ class Tryouts
       end
     end
 
+    # Check if token type represents any kind of expectation
+    def is_expectation_type?(type)
+      [
+        :expectation, :exception_expectation, :intentional_failure_expectation,
+        :true_expectation, :false_expectation, :boolean_expectation,
+        :result_type_expectation, :regex_match_expectation,
+        :performance_time_expectation, :output_expectation
+      ].include?(type)
+    end
+
     # Group tokens into logical test blocks using pattern matching
     def group_into_test_blocks(tokens)
       blocks        = []
@@ -112,6 +261,33 @@ class Tryouts
         in [_, { type: :expectation }]
           current_block[:expectations] << token
 
+        in [_, { type: :exception_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :intentional_failure_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :true_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :false_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :boolean_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :result_type_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :regex_match_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :performance_time_expectation }]
+          current_block[:expectations] << token
+
+        in [_, { type: :output_expectation }]
+          current_block[:expectations] << token
+
         in [_, { type: :comment | :blank }]
           add_context_to_block(current_block, token)
         end
@@ -264,10 +440,11 @@ class Tryouts
     end
 
     def calculate_end_line(block)
-      last_tokens = [*block[:code], *block[:expectations], *block[:comments]]
-      return block[:start_line] if last_tokens.empty?
+      # Only consider actual content (code and expectations), not blank lines/comments
+      content_tokens = [*block[:code], *block[:expectations]]
+      return block[:start_line] if content_tokens.empty?
 
-      last_tokens.map { |token| token[:line] }.max || block[:start_line]
+      content_tokens.map { |token| token[:line] }.max || block[:start_line]
     end
 
     def build_test_case(block)
@@ -283,13 +460,37 @@ class Tryouts
         # Extract source lines from the original source during parsing
         source_lines = @lines[start_line..end_line]
 
+        # Find the first expectation line for better error reporting
+        first_expectation_line = exp_tokens.empty? ? start_line : exp_tokens.first[:line]
+
         TestCase.new(
           description: desc,
           code: extract_code_content(code_tokens),
-          expectations: exp_tokens.map { |token| token[:content] },
+          expectations: exp_tokens.map { |token|
+            type = case token[:type]
+                   when :exception_expectation then :exception
+                   when :intentional_failure_expectation then :intentional_failure
+                   when :true_expectation then :true
+                   when :false_expectation then :false
+                   when :boolean_expectation then :boolean
+                   when :result_type_expectation then :result_type
+                   when :regex_match_expectation then :regex_match
+                   when :performance_time_expectation then :performance_time
+                   when :output_expectation then :output
+                   else :regular
+                   end
+
+            # For output expectations, we need to preserve the pipe number
+            if token[:type] == :output_expectation
+              OutputExpectation.new(content: token[:content], type: type, pipe: token[:pipe])
+            else
+              Expectation.new(content: token[:content], type: type)
+            end
+          },
           line_range: start_line..end_line,
           path: @source_path,
           source_lines: source_lines,
+          first_expectation_line: first_expectation_line,
         )
       else
         raise "Invalid test block structure: #{block}"