class Tryouts::ExpectationEvaluators::Regular

  • Enables expectations like: #=> result.upcase, #=> _.first, #=> result * 2
    - ‘_`: shorthand alias for the same actual result value
    - `result`: contains the actual test result value
    VARIABLE ACCESS:
    - Serves as fallback when no specialized evaluator applies
    - Part of unified #= prefix convention for all expectation types
    - Evaluated expected display prevents confusion with literal text content
    - Uses #=> syntax as the canonical expectation notation
    - Expression evaluation enables dynamic expectations (result.length, etc.)
    - Standard equality provides intuitive testing behavior
    DESIGN DECISIONS:
    - Most flexible evaluator supporting arbitrary Ruby expressions
    - Actual display shows the test result value
    - Expected display shows the evaluated expression result (not raw content)
    - Expression has access to `result` and `_` variables (actual_result)
    IMPLEMENTATION DETAILS:
    - Reference-independent: compares values not object identity
    - Type-sensitive: 2 != “2”, [1] != 1, nil != false
    - Supports all Ruby types: primitives, collections, objects
    - Uses Ruby’s == operator for equality comparison
    EQUALITY SEMANTICS:
    1 + 1 #=> result # Pass: 2 == 2 (result variable access)
    { a: 1 } #=> { a: 1 } # Pass: hash equality
    [1, 2, 3] #=> result.sort # Pass: [1,2,3] == [1,2,3]
    “hello” #=> “hello” # Pass: string equality
    [1, 2, 3] #=> [1, 2, 3] # Pass: array equality
    [1, 2, 3] #=> result.length # Pass: [1,2,3] == 3 (fails, different types)
    1 + 1 #=> 2 # Pass: 2 == 2
    Examples:
    SYNTAX: #=> expression
    - Serves as the default and most commonly used expectation type
    - Provides the fundamental equality-based testing mechanism
    - Validates that test result equals the evaluated expectation expression
    PURPOSE:
    Evaluator for standard equality expectations using syntax: #=> expression

def self.handles?(expectation_type) 

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

def evaluate(actual_result = nil) 

def evaluate(actual_result = nil)
  expectation_result = ExpectationResult.from_result(actual_result)
  expected_value     = eval_expectation_content(@expectation.content, expectation_result)
  build_result(
    passed: actual_result == expected_value,
    actual: actual_result,
    expected: expected_value,
  )
rescue StandardError => ex
  handle_evaluation_error(ex, actual_result)
end