Refactor: Modularize evaluator, unified parser, and 100% test compatibility

- Split function_parser.go into expressions.go, function_eval.go, and function_parser.go
- Implement unified ExpressionEvaluator for all predicate types
- Add Debug flag to Options for detailed execution tracing
- Fix NodeSet truthiness and text node dot predicate parsing
- Fix nested predicate parsing bug in FunctionParser
- Achieve 100% pass rate on comprehensive test suite

Author: AbdulRashidReshamwala

internal/evaluator/conditions.go

@@ -13,8 +13,10 @@ import (
 
 // Evaluator handles XPath expression evaluation
 type Evaluator struct {
-	parser     *parser.Parser
-	htmlParser *utils.HTMLParser
+	parser          *parser.Parser
+	htmlParser      *utils.HTMLParser
+	contextPosition int
+	contextSize     int
 }
 
 // NewEvaluator creates a new XPath evaluator

internal/evaluator/evaluator.go

@@ -1,7 +1,6 @@
 package evaluator
 
 import (
-	"fmt"
 	"strconv"
 	"strings"
 
@@ -25,7 +24,7 @@ func (ee *ExpressionEvaluator) EvaluateExpression(expr string, node *types.Node)
 	Trace("ExpressionEvaluator.EvaluateExpression: '%s'", expr)
 
 	parser := NewFunctionParser(expr)
-	parsedExpr, err := parser.ParseExpression()
+	parsedExpr, err := parser.Parse()
 	if err != nil {
 		Trace("Expression parsing failed: %v", err)
 		return "", err
@@ -40,103 +39,27 @@ func (ee *ExpressionEvaluator) EvaluateExpression(expr string, node *types.Node)
 func (ee *ExpressionEvaluator) EvaluateComparison(expr string, node *types.Node) (bool, error) {
 	Trace("ExpressionEvaluator.EvaluateComparison: '%s'", expr)
 
-	// Handle boolean operators first
-	if strings.Contains(expr, " and ") {
-		return ee.evaluateAndExpression(expr, node)
-	}
-	if strings.Contains(expr, " or ") {
-		return ee.evaluateOrExpression(expr, node)
-	}
-
-	// Find comparison operator
-	operators := []string{">=", "<=", "!=", "=", ">", "<"}
-	var operator string
-	var leftExpr, rightExpr string
-
-	for _, op := range operators {
-		if idx := strings.Index(expr, op); idx != -1 {
-			operator = op
-			leftExpr = strings.TrimSpace(expr[:idx])
-			rightExpr = strings.TrimSpace(expr[idx+len(op):])
-			break
-		}
-	}
-
-	if operator == "" {
-		// No comparison operator, treat as boolean expression
-		result, err := ee.EvaluateExpression(expr, node)
-		if err != nil {
-			return false, err
-		}
-		// Non-empty string or non-zero number is true
-		if result == "" || result == "0" || result == "false" {
-			return false, nil
-		}
-		return true, nil
-	}
-
-	// Evaluate left and right sides
-	leftResult, err := ee.EvaluateExpression(leftExpr, node)
+	result, err := ee.EvaluateExpression(expr, node)
 	if err != nil {
-		Trace("Left expression evaluation failed: %v", err)
 		return false, err
 	}
 
-	rightResult, err := ee.EvaluateExpression(rightExpr, node)
-	if err != nil {
-		Trace("Right expression evaluation failed: %v", err)
-		return false, err
+	// In XPath, non-empty strings and non-zero numbers are true
+	// Our EvaluateExpression returns "true", "false", or a value
+	if result == "true" {
+		return true, nil
 	}
-
-	Trace("Comparison: '%s' %s '%s'", leftResult, operator, rightResult)
-
-	// Perform comparison
-	result := ee.performComparison(leftResult, operator, rightResult)
-	Trace("Comparison result: %v", result)
-	return result, nil
-}
-
-// performComparison performs the actual comparison
-func (ee *ExpressionEvaluator) performComparison(left, operator, right string) bool {
-	// Try numeric comparison first
-	leftNum, leftErr := strconv.ParseFloat(left, 64)
-	rightNum, rightErr := strconv.ParseFloat(right, 64)
-
-	if leftErr == nil && rightErr == nil {
-		// Numeric comparison
-		switch operator {
-		case ">":
-			return leftNum > rightNum
-		case ">=":
-			return leftNum >= rightNum
-		case "<":
-			return leftNum < rightNum
-		case "<=":
-			return leftNum <= rightNum
-		case "=":
-			return leftNum == rightNum
-		case "!=":
-			return leftNum != rightNum
-		}
+	if result == "false" || result == "" || result == "0" {
+		return false, nil
 	}
 
-	// String comparison
-	switch operator {
-	case "=":
-		return left == right
-	case "!=":
-		return left != right
-	case ">":
-		return left > right
-	case ">=":
-		return left >= right
-	case "<":
-		return left < right
-	case "<=":
-		return left <= right
+	// If it's a number != 0, it's true
+	if num, err := strconv.ParseFloat(result, 64); err == nil {
+		return num != 0, nil
 	}
 
-	return false
+	// Non-empty string is true
+	return len(result) > 0, nil
 }
 
 // IsComplexFunctionExpression checks if an expression contains function calls
@@ -156,44 +79,6 @@ func IsComplexFunctionExpression(expr string) bool {
 	return false
 }
 
-// evaluateAndExpression handles "and" boolean expressions
-func (ee *ExpressionEvaluator) evaluateAndExpression(expr string, node *types.Node) (bool, error) {
-	parts := strings.Split(expr, " and ")
-	if len(parts) < 2 {
-		return false, fmt.Errorf("invalid and expression")
-	}
-
-	for _, part := range parts {
-		result, err := ee.EvaluateComparison(strings.TrimSpace(part), node)
-		if err != nil {
-			return false, err
-		}
-		if !result {
-			return false, nil // Short-circuit
-		}
-	}
-	return true, nil
-}
-
-// evaluateOrExpression handles "or" boolean expressions
-func (ee *ExpressionEvaluator) evaluateOrExpression(expr string, node *types.Node) (bool, error) {
-	parts := strings.Split(expr, " or ")
-	if len(parts) < 2 {
-		return false, fmt.Errorf("invalid or expression")
-	}
-
-	for _, part := range parts {
-		result, err := ee.EvaluateComparison(strings.TrimSpace(part), node)
-		if err != nil {
-			return false, err
-		}
-		if result {
-			return true, nil // Short-circuit
-		}
-	}
-	return false, nil
-}
-
 // HasArithmeticOperations checks if expression has arithmetic
 func HasArithmeticOperations(expr string) bool {
 	operators := []string{" + ", " - ", " * ", " / ", " div ", " mod "}