tryouts 3.0.0.pre2 → 3.1.0

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

@@ -33,7 +33,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 }
@@ -56,19 +74,40 @@ class Tryouts
     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 +115,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 +161,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 +340,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)
@@ -286,7 +363,27 @@ class Tryouts
         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,

data/lib/tryouts/test_executor.rb

@@ -38,6 +38,7 @@ class Tryouts
         global_tally: @global_tally,
       )
 
+      # TestBatch handles file output, so don't duplicate it here
       unless @options[:verbose]
         context_mode = @options[:shared_context] ? 'shared' : 'fresh'
         @output_manager.file_execution_start(@file, @testrun.total_tests, context_mode)
@@ -49,15 +50,16 @@ class Tryouts
         test_results << last_result if last_result
       end
 
-      file_failed_count                 = test_results.count { |r| r[:status] == :failed }
-      file_error_count                  = test_results.count { |r| r[:status] == :error }
-      @global_tally[:total_tests]      += batch.size
+      file_failed_count                 = test_results.count { |r| r.failed? }
+      file_error_count                  = test_results.count { |r| r.error? }
+      executed_test_count               = test_results.size
+      @global_tally[:total_tests]      += executed_test_count
       @global_tally[:total_failed]     += file_failed_count
       @global_tally[:total_errors]     += file_error_count
       @global_tally[:successful_files] += 1 if success
 
       duration = Time.now.to_f - @file_start.to_f
-      @output_manager.file_success(@file, batch.size, file_failed_count, file_error_count, duration)
+      @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)

data/lib/tryouts/test_runner.rb

@@ -79,7 +79,7 @@ class Tryouts
     def process_files
       failure_count = 0
 
-      @files.each do |file|
+      @files.each_with_index do |file, idx|
         result         = process_file(file)
         failure_count += result unless result.zero?
         status         = result.zero? ? Console.color(:green, 'PASS') : Console.color(:red, 'FAIL')