itent-types

Signed-off-by: yaacov <[email protected]>

Author: yaacov

v6/pkg/walkers/semantics/dates.go

@@ -7,8 +7,12 @@ func toDate(value interface{}) (time.Time, bool) {
 	case time.Time:
 		return v, true
 	case string:
-		date, err := time.Parse(time.RFC3339, v)
-		if err == nil {
+		// try full RFC3339 first
+		if date, err := time.Parse(time.RFC3339, v); err == nil {
+			return date, true
+		}
+		// then try short date format YYYY-MM-DD
+		if date, err := time.Parse("2006-01-02", v); err == nil {
 			return date, true
 		}
 	}

v6/pkg/walkers/semantics/evaluators.go

@@ -9,6 +9,29 @@ import (
 	"github.com/yaacov/tree-search-language/v6/pkg/tsl"
 )
 
+// processArray applies processItem over all elements
+func processArray(arr []interface{}) []interface{} {
+	out := make([]interface{}, len(arr))
+	for i, it := range arr {
+		out[i], _ = processValue(it)
+	}
+	return out
+}
+
+// processValue dispatches on value type: array, string/date, number, or other
+func processValue(value interface{}) (interface{}, error) {
+	if arr, ok := value.([]interface{}); ok {
+		return processArray(arr), nil
+	}
+	if date, ok := toDate(value); ok {
+		return date, nil
+	}
+	if num, ok := toFloat64(value); ok {
+		return num, nil
+	}
+	return value, nil
+}
+
 // handleIdentifier evaluates an identifier node using the provided eval function
 func handleIdentifier(n *tsl.TSLNode, eval EvalFunc) (interface{}, error) {
 	if n == nil {
@@ -32,14 +55,7 @@ func handleIdentifier(n *tsl.TSLNode, eval EvalFunc) (interface{}, error) {
 		return nil, tsl.KeyNotFoundError{Key: identName}
 	}
 
-	// Check if value is a string and matches ISO date and time format
-	if strValue, ok := value.(string); ok {
-		if t, err := time.Parse(time.RFC3339, strValue); err == nil {
-			return t, nil
-		}
-	}
-
-	return value, nil
+	return processValue(value)
 }
 
 // isValueInArray checks if a value is in a list of values

v6/pkg/walkers/semantics/walk.go

@@ -133,9 +133,13 @@ func evaluateBinaryExpression(operator tsl.Operator, leftVal, rightVal interface
 
 	switch operator {
 	case tsl.OpEQ:
-		return leftVal == rightVal, nil
+		return evaluateEquality(leftVal, rightVal)
 	case tsl.OpNE:
-		return leftVal != rightVal, nil
+		matched, err := evaluateEquality(leftVal, rightVal)
+		if err != nil {
+			return nil, err
+		}
+		return !matched, nil
 	case tsl.OpLT, tsl.OpLE, tsl.OpGT, tsl.OpGE:
 		return evaluateCompareExpressions(operator, leftVal, rightVal)
 	case tsl.OpREQ:
@@ -183,6 +187,30 @@ func evaluateBinaryExpression(operator tsl.Operator, leftVal, rightVal interface
 	}
 }
 
+// evaluateEquality performs a type‑aware equality check.
+func evaluateEquality(leftVal, rightVal interface{}) (bool, error) {
+	// Numeric comparison
+	if leftNumber, leftIsNumber := toFloat64(leftVal); leftIsNumber {
+		if rightNumber, rightIsNumber := toFloat64(rightVal); rightIsNumber {
+			return leftNumber == rightNumber, nil
+		}
+	}
+	// Date/time comparison
+	if leftDateValue, leftIsDate := toDate(leftVal); leftIsDate {
+		if rightDateValue, rightIsDate := toDate(rightVal); rightIsDate {
+			return leftDateValue.Equal(rightDateValue), nil
+		}
+	}
+	// String comparison
+	if leftStringValue, leftIsString := leftVal.(string); leftIsString {
+		if rightStringValue, rightIsString := rightVal.(string); rightIsString {
+			return leftStringValue == rightStringValue, nil
+		}
+	}
+	// Fallback to Go’s built‑in equality for identical types
+	return leftVal == rightVal, nil
+}
+
 func evaluateMathExpression(operator tsl.Operator, leftVal, rightVal interface{}) (interface{}, error) {
 	leftNum, ok := toFloat64(leftVal)
 	if !ok {

v6/pkg/walkers/semantics/walk_test.go

@@ -36,16 +36,18 @@ var _ = Describe("Walk", func() {
 	// This is the record that we will use for all the tests:
 	date, _ := time.Parse(time.RFC3339, "2020-01-01T00:00:00Z")
 	record := map[string]interface{}{
-		"title":       "A good book",
-		"author":      "Joe",
-		"spec.pages":  14.0,
-		"spec.rating": 5.0,
-		"loaned":      true,
-		"date":        date,
-		"tags":        []interface{}{"fiction", "bestseller"},
-		"price":       29.99,
-		"numbers":     []interface{}{1.0, 2.0, 3.0},
-		"booleans":    []interface{}{true, false, true},
+		"title":        "A good book",
+		"author":       "Joe",
+		"spec.pages":   14.0,
+		"spec.rating":  5.0,
+		"loaned":       true,
+		"date":         date,
+		"tags":         []interface{}{"fiction", "bestseller"},
+		"price":        29.99,
+		"numbers":      []interface{}{1.0, 2.0, 3.0},
+		"booleans":     []interface{}{true, false, true},
+		"dateStr":      "2020-01-01T00:00:00Z", // full ISO string
+		"shortDateStr": "2020-01-01",           // short date
 	}
 
 	// This is the evaluation function that we will use:
@@ -197,6 +199,21 @@ var _ = Describe("Walk", func() {
 		Entry("sum identifier array", "sum numbers", 6.0),
 		Entry("sum on computed array", "sum (numbers * 2)", 12.0),
 		Entry("sum in expression", "sum numbers + 4", 10.0),
+
+		// Numeric literal on left
+		Entry("literal equals number (int/float mix)", "14 = spec.pages", true),
+		Entry("literal equals number (float literal)", "14.0 = spec.pages", true),
+
+		// Date‐string identifiers
+		Entry("full‐string date identifier", "dateStr", date),
+		Entry("short‐string date identifier", "shortDateStr", date),
+
+		// Date comparisons with string‐based fields
+		Entry("string date equals full literal", "dateStr = '2020-01-01T00:00:00Z'", true),
+		Entry("string date equals short literal", "shortDateStr = '2020-01-01'", true),
+		Entry("literal full date = identifier", "'2020-01-01T00:00:00Z' = dateStr", true),
+		Entry("literal short date = identifier", "'2020-01-01' = shortDateStr", true),
+		Entry("string date > earlier literal", "dateStr > '2019-12-31T00:00:00Z'", true),
 	)
 })