class Tryouts::ExpectationEvaluators::Boolean

  • Uses #=|> syntax to visually represent OR logic (true OR false)
    - Part of unified #= prefix convention for all expectation types
    - Expression evaluation provides boolean logic testing with flexibility
    - Clear expected display explains the dual acceptance requirement
    - Flexible boolean matching allows either true or false values
    DESIGN DECISIONS:
    - Distinguishes from regular expectations through boolean type validation
    - Actual display shows the evaluated expression result
    - Expected display shows ‘true or false’ indicating flexible acceptance
    - Expression has access to ‘result` and `_` variables (actual_result)
    IMPLEMENTATION DETAILS:
    - More lenient than True/False evaluators but stricter than truthy/falsy
    - Uses Ruby’s Array#include? for boolean type checking
    - Fails for nil, 0, “”, [], {}, or any non-boolean value
    - Only passes when expression evaluates to exactly true OR exactly false
    BOOLEAN STRICTNESS:
    [] #=|> result.first # Fail: expression is nil (falsy but not boolean)
    [1, 2, 3] #=|> result.length # Fail: expression is 3 (truthy but not boolean)
    [1, 2, 3] #=|> result.include?(5) # Pass: expression is false
    [1, 2, 3] #=|> result.include?(2) # Pass: expression is true
    [] #=|> result.empty? # Pass: expression is true
    [1, 2, 3] #=|> result.empty? # Pass: expression is false
    Examples:
    SYNTAX: #=|> boolean_expression
    - Distinguishes from strict true/false evaluators that require specific values
    - Provides lenient boolean validation accepting both true and false values
    - Validates that an expression evaluates to either true or false (not truthy/falsy)
    PURPOSE:
    Evaluator for flexible boolean expectations using syntax: #=|> expression

def self.handles?(expectation_type) 

def self.handles?(expectation_type)
  expectation_type == :boolean
end

def evaluate(actual_result = nil) 

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