139 lines
4.0 KiB
Python
139 lines
4.0 KiB
Python
#!/usr/bin/env python3.9
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
JFinal Compare - Comparison Expression
|
|
"""
|
|
|
|
from .Expr import Expr
|
|
|
|
class Compare(Expr):
|
|
"""Comparison expression"""
|
|
|
|
EQ = "=="
|
|
NE = "!="
|
|
GT = ">"
|
|
GTE = ">="
|
|
LT = "<"
|
|
LTE = "<="
|
|
|
|
def __init__(self, left: Expr, operator: str, right: Expr):
|
|
"""
|
|
Initialize comparison
|
|
|
|
Args:
|
|
left: Left expression
|
|
operator: Comparison operator
|
|
right: Right expression
|
|
"""
|
|
self._left = left
|
|
self._operator = operator
|
|
self._right = right
|
|
|
|
def eval(self, scope):
|
|
"""Evaluate comparison"""
|
|
left_val = self._left.eval(scope)
|
|
right_val = self._right.eval(scope)
|
|
|
|
# Handle None comparisons
|
|
if left_val is None and right_val is None:
|
|
return self._operator == Compare.EQ
|
|
if left_val is None or right_val is None:
|
|
return self._operator == Compare.NE
|
|
|
|
# Perform comparison based on operator
|
|
if self._operator == Compare.EQ:
|
|
return left_val == right_val
|
|
elif self._operator == Compare.NE:
|
|
return left_val != right_val
|
|
elif self._operator == Compare.GT:
|
|
return left_val > right_val
|
|
elif self._operator == Compare.GTE:
|
|
return left_val >= right_val
|
|
elif self._operator == Compare.LT:
|
|
return left_val < right_val
|
|
elif self._operator == Compare.LTE:
|
|
return left_val <= right_val
|
|
else:
|
|
raise ValueError(f"Unknown operator: {self._operator}")
|
|
|
|
@property
|
|
def operator(self) -> str:
|
|
"""Get operator"""
|
|
return self._operator
|
|
|
|
def __repr__(self) -> str:
|
|
return f"Compare({self._left} {self._operator} {self._right})"
|
|
|
|
|
|
class Logic(Expr):
|
|
"""Logical expression (and, or, not)"""
|
|
|
|
AND = "&&"
|
|
OR = "||"
|
|
NOT = "!"
|
|
|
|
def __init__(self, operator: str, *expressions: Expr):
|
|
"""
|
|
Initialize logical expression
|
|
|
|
Args:
|
|
operator: Logical operator
|
|
expressions: Expressions to operate on
|
|
"""
|
|
self._operator = operator
|
|
self._expressions = expressions
|
|
|
|
def eval(self, scope):
|
|
"""Evaluate logical expression"""
|
|
if self._operator == Logic.NOT:
|
|
# Unary NOT
|
|
if not self._expressions:
|
|
return True
|
|
return not self._expressions[0].eval(scope)
|
|
else:
|
|
# Binary AND/OR
|
|
results = [expr.eval(scope) for expr in self._expressions]
|
|
|
|
if self._operator == Logic.AND:
|
|
return all(results)
|
|
elif self._operator == Logic.OR:
|
|
return any(results)
|
|
else:
|
|
raise ValueError(f"Unknown operator: {self._operator}")
|
|
|
|
def __repr__(self) -> str:
|
|
expr_str = f" {self._operator} ".join(str(expr) for expr in self._expressions)
|
|
if self._operator == Logic.NOT:
|
|
return f"NOT({expr_str})"
|
|
return f"({expr_str})"
|
|
|
|
|
|
class Ternary(Expr):
|
|
"""Ternary conditional expression (condition ? true_val : false_val)"""
|
|
|
|
def __init__(self, condition: Expr, true_expr: Expr, false_expr: Expr):
|
|
"""
|
|
Initialize ternary expression
|
|
|
|
Args:
|
|
condition: Condition expression
|
|
true_expr: Expression when condition is true
|
|
false_expr: Expression when condition is false
|
|
"""
|
|
self._condition = condition
|
|
self._true_expr = true_expr
|
|
self._false_expr = false_expr
|
|
|
|
def eval(self, scope):
|
|
"""Evaluate ternary expression"""
|
|
cond_val = self._condition.eval(scope)
|
|
|
|
# Convert to boolean (handle None, 0, empty strings, etc.)
|
|
if cond_val:
|
|
return self._true_expr.eval(scope)
|
|
else:
|
|
return self._false_expr.eval(scope)
|
|
|
|
def __repr__(self) -> str:
|
|
return f"Ternary({self._condition} ? {self._true_expr} : {self._false_expr})"
|