tryouts 3.0.0 → 3.1.1

data/lib/tryouts/cli/formatters/verbose.rb

@@ -32,15 +32,14 @@ class Tryouts
 
         output = case level
         when 0, 1
-          ['', separator_line, header_line, separator_line]
+          [separator_line, header_line, separator_line]
         else
-          ['', header_line, separator_line]
+          [header_line, separator_line]
         end
 
         with_indent(level) do
           puts output.join("\n")
         end
-        puts
       end
 
       # File-level operations
@@ -48,6 +47,10 @@ class Tryouts
         puts file_header_visual(file_path)
       end
 
+      def file_end(_file_path, _context_info = {})
+        # No output in verbose mode
+      end
+
       def file_parsed(_file_path, _test_count, setup_present: false, teardown_present: false)
         message = ''
 
@@ -64,28 +67,39 @@ class Tryouts
         puts indent_text(message, 1)
       end
 
+      # Summary operations
+      #
+      # Called right before file_result
+      def batch_summary(total_tests, failed_count, elapsed_time)
+        # No output in verbose mode
+      end
+
       def file_result(_file_path, total_tests, failed_count, error_count, elapsed_time)
         issues_count = failed_count + error_count
-        details      = []
+        passed_count = total_tests - issues_count
+        details      = [
+          "#{passed_count} passed",
+        ]
 
-        status = if issues_count > 0
+        if issues_count > 0
           details << "#{failed_count} failed" if failed_count > 0
           details << "#{error_count} errors" if error_count > 0
           details_str = details.join(', ')
-          Console.color(:red, "✗ #{issues_count}/#{total_tests} tests had issues (#{details_str})")
+          color       = :red
+
+          time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
+          message  = "✗ Out of #{total_tests} tests: #{details_str}#{time_str}"
+          puts indent_text(Console.color(color, message), 2)
         else
-          Console.color(:green, "✓ #{total_tests} tests passed")
+          message = "#{total_tests} tests passed"
+          color   = :green
+          puts indent_text(Console.color(color, "✓ #{message}"), 2)
         end
 
-        puts indent_text(status, 2)
         return unless elapsed_time
 
-        time_msg =
-          if elapsed_time < 2.0
-            "Completed in #{(elapsed_time * 1000).round}ms"
-          else
-            "Completed in #{elapsed_time.round(3)}s"
-          end
+        time_msg = "Completed in #{format_timing(elapsed_time).strip.tr('()', '')}"
+
         puts indent_text(Console.color(:dim, time_msg), 2)
       end
 
@@ -97,33 +111,42 @@ class Tryouts
         puts indent_text(Console.color(:dim, message), 2)
       end
 
-      def test_result(test_case, result_status, actual_results = [], _elapsed_time = nil)
-        should_show = @show_passed || result_status != :passed
+      def test_end(_test_case, _index, _total)
+        # No output in verbose mode
+      end
+
+      def test_result(result_packet)
+        should_show = @show_passed || !result_packet.passed?
 
         return unless should_show
 
-        status_line = case result_status
-                      when :passed
+        status_line = case result_packet.status
+        when :passed
           Console.color(:green, 'PASSED')
-                      when :failed
+        when :failed
           Console.color(:red, 'FAILED')
-                      when :error
+        when :error
           Console.color(:red, 'ERROR')
-                      when :skipped
+        when :skipped
           Console.color(:yellow, 'SKIPPED')
         else
           'UNKNOWN'
-                      end
+        end
 
-        location = "#{Console.pretty_path(test_case.path)}:#{test_case.line_range.first + 1}"
-        puts indent_text("#{status_line} #{test_case.description} @ #{location}", 2)
+        test_case = result_packet.test_case
+        location = "#{Console.pretty_path(test_case.path)}:#{test_case.first_expectation_line + 1}"
+        puts
+        puts indent_text("#{status_line} @ #{location}", 2)
 
         # Show source code for verbose mode
         show_test_source_code(test_case)
 
         # Show failure details for failed tests
-        if [:failed, :error].include?(result_status)
-          show_failure_details(test_case, actual_results)
+        if result_packet.failed? || result_packet.error?
+          show_failure_details(test_case, result_packet.actual_results, result_packet.expected_results)
+        # Show exception details for passed exception expectations
+        elsif result_packet.passed? && has_exception_expectations?(test_case)
+          show_exception_details(test_case, result_packet.actual_results, result_packet.expected_results)
         end
       end
 
@@ -168,29 +191,13 @@ class Tryouts
         end
       end
 
-      # Summary operations
-      def batch_summary(total_tests, failed_count, elapsed_time)
-        if failed_count > 0
-          passed  = total_tests - failed_count
-          message = "#{failed_count} failed, #{passed} passed"
-          color   = :red
-        else
-          message = "#{total_tests} tests passed"
-          color   = :green
-        end
-
-        time_str = elapsed_time ? " (#{elapsed_time.round(2)}s)" : ''
-        summary  = Console.color(color, "#{message}#{time_str}")
-        puts summary
-      end
-
       def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
         puts
         puts '=' * @line_width
         puts 'Grand Total:'
 
         issues_count = failed_count + error_count
-        time_str =
+        time_str     =
           if elapsed_time < 2.0
             " (#{(elapsed_time * 1000).round}ms)"
           else
@@ -198,7 +205,7 @@ class Tryouts
           end
 
         if issues_count > 0
-          passed  = total_tests - issues_count
+          passed  = [total_tests - issues_count, 0].max  # Ensure passed never goes negative
           details = []
           details << "#{failed_count} failed" if failed_count > 0
           details << "#{error_count} errors" if error_count > 0
@@ -216,6 +223,7 @@ class Tryouts
         return unless @show_debug
 
         prefix = Console.color(:cyan, 'INFO ')
+        puts
         puts indent_text("#{prefix} #{message}", level + 1)
       end
 
@@ -260,9 +268,29 @@ class Tryouts
 
       private
 
-      def show_test_source_code(test_case)
-        puts indent_text('Source code:', 3)
+      def has_exception_expectations?(test_case)
+        test_case.expectations.any? { |exp| exp.type == :exception }
+      end
+
+      def show_exception_details(test_case, actual_results, expected_results = [])
+        return if actual_results.empty?
+
+        puts indent_text('Exception Details:', 4)
+
+        actual_results.each_with_index do |actual, idx|
+          expected = expected_results[idx] if expected_results && idx < expected_results.length
+          expectation = test_case.expectations[idx] if test_case.expectations
 
+          if expectation&.type == :exception
+            puts indent_text("Caught: #{Console.color(:blue, actual.inspect)}", 5)
+            puts indent_text("Expectation: #{Console.color(:green, expectation.content)}", 5)
+            puts indent_text("Result: #{Console.color(:green, expected.inspect)}", 5) if expected
+          end
+        end
+        puts
+      end
+
+      def show_test_source_code(test_case)
         # Use pre-captured source lines from parsing
         start_line = test_case.line_range.first
 
@@ -270,9 +298,8 @@ class Tryouts
           line_num     = start_line + index
           line_display = format('%3d: %s', line_num + 1, line_content)
 
-          # Highlight expectation lines by checking if this line
-          # contains the expectation syntax
-          if line_content.match?(/^\s*#\s*=>\s*/)
+          # Highlight expectation lines by checking if this line contains any expectation syntax
+          if line_content.match?(/^\s*#\s*=(!|<|=|\/=|\||:|~|%|\d+)?>\s*/)
             line_display = Console.color(:yellow, line_display)
           end
 
@@ -281,24 +308,28 @@ class Tryouts
         puts
       end
 
-      def show_failure_details(test_case, actual_results)
+      def show_failure_details(test_case, actual_results, expected_results = [])
         return if actual_results.empty?
 
-        puts indent_text('Expected vs Actual:', 3)
-
         actual_results.each_with_index do |actual, idx|
+          expected      = expected_results[idx] if expected_results && idx < expected_results.length
           expected_line = test_case.expectations[idx] if test_case.expectations
 
-          if expected_line
-            puts indent_text("Expected: #{Console.color(:green, expected_line)}", 4)
+          if !expected.nil?
+            # Use the evaluated expected value from the evaluator
+            puts indent_text("Expected: #{Console.color(:green, expected.inspect)}", 4)
+            puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
+          elsif expected_line
+            # Fallback to raw expectation content
+            puts indent_text("Expected: #{Console.color(:green, expected_line.content)}", 4)
             puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
           else
             puts indent_text("Actual:   #{Console.color(:red, actual.inspect)}", 4)
           end
 
           # Show difference if both are strings
-          if expected_line && actual.is_a?(String) && expected_line.is_a?(String)
-            show_string_diff(expected_line, actual)
+          if !expected.nil? && actual.is_a?(String) && expected.is_a?(String)
+            show_string_diff(expected, actual)
           end
 
           puts
@@ -320,11 +351,21 @@ class Tryouts
         padding        = '<' * padding_length
 
         [
-          '-' * @line_width,
-          header_content + padding,
-          '-' * @line_width,
+          indent_text('-' * @line_width, 1),
+          indent_text(header_content + padding, 1),
+          indent_text('-' * @line_width, 1),
         ].join("\n")
       end
+
+      def format_timing(elapsed_time)
+        if elapsed_time < 0.001
+          " (#{(elapsed_time * 1_000_000).round}μs)"
+        elsif elapsed_time < 1
+          " (#{(elapsed_time * 1000).round}ms)"
+        else
+          " (#{elapsed_time.round(2)}s)"
+        end
+      end
     end
 
     # Verbose formatter that only shows failures and errors
@@ -333,9 +374,9 @@ class Tryouts
         super(options.merge(show_passed: false))
       end
 
-      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
+      def test_result(result_packet)
         # Only show failed/error tests, but with full source code
-        return if result_status == :passed
+        return if result_packet.passed?
 
         super
       end

data/lib/tryouts/console.rb

@@ -76,49 +76,85 @@ class Tryouts
       end
     end
     class << self
-      def bright(str)
-        str = [style(ATTRIBUTES[:bright]), str, default_style].join
+      def bright(str, io = $stdout)
+        str = [style(ATTRIBUTES[:bright], io: io), str, default_style(io)].join
         str.extend Console::InstanceMethods
         str
       end
 
-      def underline(str)
-        str = [style(ATTRIBUTES[:underline]), str, default_style].join
+      def underline(str, io = $stdout)
+        str = [style(ATTRIBUTES[:underline], io: io), str, default_style(io)].join
         str.extend Console::InstanceMethods
         str
       end
 
-      def reverse(str)
-        str = [style(ATTRIBUTES[:reverse]), str, default_style].join
+      def reverse(str, io = $stdout)
+        str = [style(ATTRIBUTES[:reverse], io: io), str, default_style(io)].join
         str.extend Console::InstanceMethods
         str
       end
 
-      def color(col, str)
-        str = [style(COLOURS[col]), str, default_style].join
+      def color(col, str, io = $stdout)
+        str = [style(COLOURS[col], io: io), str, default_style(io)].join
         str.extend Console::InstanceMethods
         str
       end
 
-      def att(name, str)
-        str = [style(ATTRIBUTES[name]), str, default_style].join
+      def att(name, str, io = $stdout)
+        str = [style(ATTRIBUTES[name], io: io), str, default_style(io)].join
         str.extend Console::InstanceMethods
         str
       end
 
-      def bgcolor(col, str)
-        str = [style(ATTRIBUTES[col]), str, default_style].join
+      def bgcolor(col, str, io = $stdout)
+        str = [style(ATTRIBUTES[col], io: io), str, default_style(io)].join
         str.extend Console::InstanceMethods
         str
       end
 
-      def style(*att)
-        # => \e[8;34;42m
-        "\e[%sm" % att.join(';')
+      def style(*att, io: nil)
+        # Only output ANSI codes if colors are supported
+        target_io = io || $stdout
+
+        # Explicit color control via environment variables
+        # FORCE_COLOR/CLICOLOR_FORCE override NO_COLOR
+        return "\e[%sm" % att.join(';') if ENV['FORCE_COLOR'] || ENV['CLICOLOR_FORCE']
+        return '' if ENV['NO_COLOR']
+
+        # Check if we're outputting to a real TTY
+        tty_output = (target_io.respond_to?(:tty?) && target_io.tty?) ||
+                     ($stdout.respond_to?(:tty?) && $stdout.tty?) ||
+                     ($stderr.respond_to?(:tty?) && $stderr.tty?)
+
+        # If we have a real TTY, always use colors
+        return "\e[%sm" % att.join(';') if tty_output
+
+        # For environments like Claude Code where TTY detection fails but we want colors
+        # Check if output appears to be redirected to a file/pipe
+        if ENV['TERM'] && ENV['TERM'] != 'dumb'
+          # Check if stdout/stderr look like they're redirected using file stats
+          begin
+            stdout_stat = $stdout.stat
+            stderr_stat = $stderr.stat
+
+            # If either stdout or stderr looks like a regular file or pipe, disable colors
+            stdout_redirected = stdout_stat.file? || stdout_stat.pipe?
+            stderr_redirected = stderr_stat.file? || stderr_stat.pipe?
+
+            # Enable colors if neither appears redirected
+            return "\e[%sm" % att.join(';') unless stdout_redirected || stderr_redirected
+          rescue
+            # If stat fails, fall back to enabling colors with TERM set
+            return "\e[%sm" % att.join(';')
+          end
+        end
+
+        # Default: no colors
+        ''
       end
 
-      def default_style
-        style(ATTRIBUTES[:default], COLOURS[:default], BGCOLOURS[:default])
+      def default_style(io = $stdout)
+        style(ATTRIBUTES[:default], COLOURS[:default], BGCOLOURS[:default], io: io)
       end
 
       # Converts an absolute file path to a path relative to the current working

data/lib/tryouts/expectation_evaluators/base.rb

@@ -0,0 +1,101 @@
+# lib/tryouts/expectation_evaluators/base.rb
+
+class Tryouts
+  module ExpectationEvaluators
+    # Base class for all expectation evaluators
+    class Base
+      attr_reader :expectation, :test_case, :context
+
+      # @param expectation_type [Symbol] the type of expectation to check
+      # @return [Boolean] whether this evaluator can handle the given expectation type
+      def self.handles?(expectation_type)
+        raise NotImplementedError, "#{self} must implement handles? class method"
+      end
+
+      # @param expectation [Object] the expectation object containing content and metadata
+      # @param test_case [Object] the test case being evaluated
+      # @param context [Object] the context in which to evaluate expectations
+      def initialize(expectation, test_case, context)
+        @expectation = expectation
+        @test_case   = test_case
+        @context     = context
+      end
+
+      # Evaluates the expectation against the actual result
+      # @param actual_result [Object] the result to evaluate against the expectation
+      # @return [Hash] evaluation result with passed status and details
+      def evaluate(actual_result = nil)
+        raise NotImplementedError, "#{self.class} must implement evaluate method"
+      end
+
+      protected
+
+      # Evaluates expectation content in the test context with predefined variables
+      #
+      # This method is the core of the expectation evaluation system, providing context-aware
+      # variable access for different expectation types:
+      #
+      # VARIABLE AVAILABILITY:
+      # - `result`: contains actual_result (regular) or timing_ms (performance)
+      # - `_`: shorthand alias for the same data as result
+      #
+      # DESIGN DECISIONS:
+      # - Add new values to ExpectationResult to avoid method signature changes
+      # - Use define_singleton_method for clean variable injection
+      # - Using instance_eval for evaluation provides:
+      #     - Full access to test context (instance variables, methods)
+      #     - Clean variable injection (result, _)
+      #     - Proper file/line reporting for debugging
+      #     - Support for complex Ruby expressions in expectations
+      #
+      #   Potential enhancements (without breaking changes):
+      #     - Add more variables to ExpectationResult (memory usage, etc.)
+      #     - Provide additional helper methods in evaluation context
+      #     - Enhanced error reporting with better stack traces
+      #
+      # @param content [String] the expectation code to evaluate
+      # @param expectation_result [ExpectationResult] container with actual_result and timing data
+      # @return [Object] the result of evaluating the content
+      def eval_expectation_content(content, expectation_result = nil)
+        path  = @test_case.path
+        range = @test_case.line_range
+
+        if expectation_result
+          # For performance expectations, timing data takes precedence for result/_
+          if expectation_result.execution_time_ns
+            timing_ms = expectation_result.execution_time_ms
+            @context.define_singleton_method(:result) { timing_ms }
+            @context.define_singleton_method(:_) { timing_ms }
+          elsif expectation_result.actual_result
+            # For regular expectations, use actual_result
+            @context.define_singleton_method(:result) { expectation_result.actual_result }
+            @context.define_singleton_method(:_) { expectation_result.actual_result }
+          end
+        end
+
+        @context.instance_eval(content, path, range.first + 1)
+      end
+
+      def build_result(passed:, actual:, expected:, expectation: @expectation.content, error: nil)
+        result         = {
+          passed: passed,
+          actual: actual,
+          expected: expected,
+          expectation: expectation,
+        }
+        result[:error] = error if error
+        result
+      end
+
+      def handle_evaluation_error(error, actual_result)
+        build_result(
+          passed: false,
+          actual: actual_result,
+          expected: "EXPECTED: #{error.message}",
+          expectation: @expectation.content,
+          error: error,
+        )
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/boolean.rb

@@ -0,0 +1,60 @@
+# lib/tryouts/expectation_evaluators/boolean.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for flexible boolean expectations using syntax: #=|> expression
+    #
+    # PURPOSE:
+    # - Validates that an expression evaluates to either true or false (not truthy/falsy)
+    # - Provides lenient boolean validation accepting both true and false values
+    # - Distinguishes from strict true/false evaluators that require specific values
+    #
+    # SYNTAX: #=|> boolean_expression
+    # Examples:
+    #   [1, 2, 3]  #=|> result.empty?             # Pass: expression is false
+    #   []         #=|> result.empty?             # Pass: expression is true
+    #   [1, 2, 3]  #=|> result.include?(2)        # Pass: expression is true
+    #   [1, 2, 3]  #=|> result.include?(5)        # Pass: expression is false
+    #   [1, 2, 3]  #=|> result.length             # Fail: expression is 3 (truthy but not boolean)
+    #   []         #=|> result.first              # Fail: expression is nil (falsy but not boolean)
+    #
+    # BOOLEAN STRICTNESS:
+    # - Only passes when expression evaluates to exactly true OR exactly false
+    # - Fails for nil, 0, "", [], {}, or any non-boolean value
+    # - Uses Ruby's Array#include? for boolean type checking
+    # - More lenient than True/False evaluators but stricter than truthy/falsy
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Expression has access to `result` and `_` variables (actual_result)
+    # - Expected display shows 'true or false' indicating flexible acceptance
+    # - Actual display shows the evaluated expression result
+    # - Distinguishes from regular expectations through boolean type validation
+    #
+    # DESIGN DECISIONS:
+    # - Flexible boolean matching allows either true or false values
+    # - Clear expected display explains the dual acceptance requirement
+    # - Expression evaluation provides boolean logic testing with flexibility
+    # - Part of unified #= prefix convention for all expectation types
+    # - Uses #=|> syntax to visually represent OR logic (true OR false)
+    class Boolean < Base
+      def self.handles?(expectation_type)
+        expectation_type == :boolean
+      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: [true, false].include?(expression_result),
+          actual: expression_result,
+          expected: 'true or false',
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/exception.rb

@@ -0,0 +1,61 @@
+# lib/tryouts/expectation_evaluators/exception.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    class Exception < Base
+      def self.handles?(expectation_type)
+        expectation_type == :exception
+      end
+
+      def evaluate(_actual_result = nil)
+        execute_test_code_and_evaluate_exception
+      end
+
+      private
+
+      def execute_test_code_and_evaluate_exception
+        path  = @test_case.path
+        range = @test_case.line_range
+        @context.instance_eval(@test_case.code, path, range.first + 1)
+
+        # Create result packet for evaluation to show what was expected
+        expectation_result = ExpectationResult.from_result(nil)
+        expected_value = eval_expectation_content(@expectation.content, expectation_result)
+
+        build_result(
+          passed: false,
+          actual: 'No exception was raised',
+          expected: expected_value,
+        )
+      rescue SystemStackError, NoMemoryError, SecurityError, ScriptError => ex
+        # Handle system-level exceptions that don't inherit from StandardError
+        # ScriptError includes: LoadError, SyntaxError, NotImplementedError
+        evaluate_exception_condition(ex)
+      rescue StandardError => ex
+        evaluate_exception_condition(ex)
+      end
+
+      def evaluate_exception_condition(caught_error)
+        @context.define_singleton_method(:error) { caught_error }
+
+        expectation_result = ExpectationResult.from_result(caught_error)
+        expected_value = eval_expectation_content(@expectation.content, expectation_result)
+
+        build_result(
+          passed: !!expected_value,
+          actual: caught_error.message,
+          expected: expected_value,
+        )
+      rescue StandardError => ex
+        build_result(
+          passed: false,
+          actual: caught_error.message,
+          expected: "EXPECTED: #{ex.message}",
+          error: ex,
+        )
+      end
+    end
+  end
+end