added entity detection in conditions

Author: shivasurya

sourcecode-parser/antlr/evaluator.go

@@ -3,9 +3,20 @@ package parser
 import (
 	"fmt"
 	"strings"
+
 	"github.com/expr-lang/expr"
 )
 
+// ComparisonType represents the type of comparison in an expression
+type ComparisonType string
+
+const (
+	// SINGLE_ENTITY represents comparison between one entity and a static value
+	SINGLE_ENTITY ComparisonType = "SINGLE_ENTITY"
+	// DUAL_ENTITY represents comparison between two different entities
+	DUAL_ENTITY ComparisonType = "DUAL_ENTITY"
+)
+
 // EvaluateExpressionTree evaluates the expression tree against input data
 // and returns filtered data based on the expression conditions
 func EvaluateExpressionTree(tree *ExpressionNode, data []map[string]interface{}) ([]map[string]interface{}, error) {
@@ -19,7 +30,7 @@ func EvaluateExpressionTree(tree *ExpressionNode, data []map[string]interface{})
 		if err != nil {
 			return nil, fmt.Errorf("evaluation error: %w", err)
 		}
-		
+
 		// Only include items that match the expression
 		if matches.(bool) {
 			result = append(result, item)
@@ -57,16 +68,73 @@ func evaluateNode(node *ExpressionNode, data map[string]interface{}) (interface{
 }
 
 // nodeToExprString converts an ExpressionNode to an expr-lang expression string
+// DetectComparisonType analyzes a binary expression node and determines if it's comparing
+// a single entity with a static value or comparing two different entities
+func DetectComparisonType(node *ExpressionNode) (ComparisonType, error) {
+	if node == nil {
+		return "", fmt.Errorf("nil node")
+	}
+
+	// Only analyze binary nodes
+	if node.Type != "binary" {
+		return "", fmt.Errorf("not a binary node")
+	}
+
+	// Get entity names from left and right sides
+	leftEntity, err := getEntityName(node.Left)
+	if err != nil {
+		return "", fmt.Errorf("failed to get left entity: %w", err)
+	}
+
+	rightEntity, err := getEntityName(node.Right)
+	if err != nil {
+		return "", fmt.Errorf("failed to get right entity: %w", err)
+	}
+
+	// If either side is empty (literal/static value) or they're the same entity,
+	// it's a SINGLE_ENTITY comparison
+	if leftEntity == "" || rightEntity == "" || leftEntity == rightEntity {
+		return SINGLE_ENTITY, nil
+	}
+
+	// Different entities are being compared
+	return DUAL_ENTITY, nil
+}
+
+// getEntityName extracts the entity name from a node.
+// Returns empty string for literals and static values.
+func getEntityName(node *ExpressionNode) (string, error) {
+	if node == nil {
+		return "", fmt.Errorf("nil node")
+	}
+
+	switch node.Type {
+	case "variable":
+		return node.Value, nil
+	case "method_call":
+		// For method calls, consider the target object as the entity
+		parts := strings.Split(node.Value, ".")
+		if len(parts) > 0 {
+			return parts[0], nil
+		}
+		return "", nil
+	case "literal":
+		return "", nil // Literals are static values
+	default:
+		return "", fmt.Errorf("unsupported node type: %s", node.Type)
+	}
+}
+
 func nodeToExprString(node *ExpressionNode) (string, error) {
 	switch node.Type {
 	case "binary":
 		left, err := nodeToExprString(node.Left)
 		if err != nil {
-		return "", err
+			return "", err
 		}
 		right, err := nodeToExprString(node.Right)
 		if err != nil {
-		return "", err
+			return "", err
 		}
 		return fmt.Sprintf("(%s %s %s)", left, node.Operator, right), nil
 
@@ -111,5 +179,3 @@ func nodeToExprString(node *ExpressionNode) (string, error) {
 		return "", fmt.Errorf("unknown node type: %s", node.Type)
 	}
 }
-
-

sourcecode-parser/antlr/evaluator_test.go

@@ -175,6 +175,111 @@ func TestEvaluateExpressionTree(t *testing.T) {
 	}
 }
 
+func TestDetectComparisonType(t *testing.T) {
+	tests := []struct {
+		name     string
+		node     *ExpressionNode
+		expected ComparisonType
+		wantErr  bool
+	}{
+		{
+			name: "single entity with literal",
+			node: &ExpressionNode{
+				Type:     "binary",
+				Operator: ">",
+				Left: &ExpressionNode{
+					Type:  "variable",
+					Value: "age",
+				},
+				Right: &ExpressionNode{
+					Type:  "literal",
+					Value: "25",
+				},
+			},
+			expected: SINGLE_ENTITY,
+			wantErr:  false,
+		},
+		{
+			name: "dual entity comparison",
+			node: &ExpressionNode{
+				Type:     "binary",
+				Operator: "==",
+				Left: &ExpressionNode{
+					Type:  "variable",
+					Value: "age",
+				},
+				Right: &ExpressionNode{
+					Type:  "variable",
+					Value: "count",
+				},
+			},
+			expected: DUAL_ENTITY,
+			wantErr:  false,
+		},
+		{
+			name: "single entity method call",
+			node: &ExpressionNode{
+				Type:     "binary",
+				Operator: ">",
+				Left: &ExpressionNode{
+					Type:  "method_call",
+					Value: "method.complexity",
+				},
+				Right: &ExpressionNode{
+					Type:  "literal",
+					Value: "10",
+				},
+			},
+			expected: SINGLE_ENTITY,
+			wantErr:  false,
+		},
+		{
+			name: "dual entity method calls",
+			node: &ExpressionNode{
+				Type:     "binary",
+				Operator: "==",
+				Left: &ExpressionNode{
+					Type:  "method_call",
+					Value: "method1.complexity",
+				},
+				Right: &ExpressionNode{
+					Type:  "method_call",
+					Value: "method2.complexity",
+				},
+			},
+			expected: DUAL_ENTITY,
+			wantErr:  false,
+		},
+		{
+			name: "non-binary node",
+			node: &ExpressionNode{
+				Type:  "literal",
+				Value: "25",
+			},
+			expected: "",
+			wantErr:  true,
+		},
+		{
+			name: "nil node",
+			node:     nil,
+			expected: "",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := DetectComparisonType(tt.node)
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, got)
+		})
+	}
+}
+
 func TestEvaluateNode(t *testing.T) {
 	// Mock data with method and predicate functions
 	testData := map[string]interface{}{