support arithmetic in logical and substitute node

sidhant92 · sidhant92 · commit 797980ab84cc · 2024-03-16T22:26:27.000+05:30
diff --git a/src/main/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluator.java b/src/main/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluator.java
@@ -6,6 +6,7 @@
 import com.github.sidhant92.boolparser.constant.ContainerDataType;
 import com.github.sidhant92.boolparser.constant.DataType;
 import com.github.sidhant92.boolparser.constant.Operator;
+import com.github.sidhant92.boolparser.domain.StringNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticLeafNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticUnaryNode;
@@ -37,6 +38,10 @@ public Try<Object> evaluate(final String expression, final Map<String, Object> d
         return tokenOptional.map(node -> evaluateToken(node, data));
     }
 
+    protected Object evaluate(final Node node, final Map<String, Object> data) {
+        return evaluateToken(node, data);
+    }
+
     private Object evaluateToken(final Node node, final Map<String, Object> data) {
         switch (node.getTokenType()) {
             case ARITHMETIC:
@@ -45,12 +50,18 @@ private Object evaluateToken(final Node node, final Map<String, Object> data) {
                 return evaluateArithmeticLeafToken((ArithmeticLeafNode) node, data);
             case ARITHMETIC_UNARY:
                 return evaluateUnaryArithmeticToken((ArithmeticUnaryNode) node, data);
+            case STRING:
+                return evaluateStringToken((StringNode) node, data);
             default:
                 log.error("unsupported token {}", node.getTokenType());
                 throw new UnsupportedToken();
         }
     }
 
+    private Object evaluateStringToken(final StringNode stringNode, final Map<String, Object> data) {
+        return ValueUtils.getValueFromMap(stringNode.getField(), data).orElse(stringNode.getField());
+    }
+
     private Pair<Object, DataType> evaluateArithmeticLeafToken(final ArithmeticLeafNode arithmeticLeafNode, final Map<String, Object> data) {
         final Optional<Object> fetchedValue = ValueUtils.getValueFromMap(arithmeticLeafNode.getOperand().toString(), data);
         return fetchedValue
diff --git a/src/main/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluator.java b/src/main/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluator.java
@@ -12,6 +12,7 @@
 import com.github.sidhant92.boolparser.domain.ComparisonNode;
 import com.github.sidhant92.boolparser.domain.Node;
 import com.github.sidhant92.boolparser.domain.UnaryNode;
+import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticBaseNode;
 import com.github.sidhant92.boolparser.exception.DataNotFoundException;
 import com.github.sidhant92.boolparser.exception.HeterogeneousArrayException;
 import com.github.sidhant92.boolparser.exception.InvalidUnaryOperand;
@@ -31,9 +32,12 @@ public class BooleanExpressionEvaluator {
 
     private final OperatorService operatorService;
 
+    private final ArithmeticExpressionEvaluator arithmeticExpressionEvaluator;
+
     public BooleanExpressionEvaluator(final BoolExpressionParser boolExpressionParser) {
         this.boolExpressionParser = boolExpressionParser;
         operatorService = new OperatorService();
+        arithmeticExpressionEvaluator = new ArithmeticExpressionEvaluator(boolExpressionParser);
     }
 
     public Try<Boolean> evaluate(final String expression, final Map<String, Object> data, final String defaultField) {
@@ -66,8 +70,10 @@ private boolean evaluateToken(final Node node, final Map<String, Object> data) {
 
     private boolean evaluateComparisonToken(final ComparisonNode comparisonToken, final Map<String, Object> data) {
         final Object fieldData = ValueUtils.getValueFromMap(comparisonToken.getField(), data).orElseThrow(DataNotFoundException::new);
+        final Object value = comparisonToken.getValue() instanceof ArithmeticBaseNode ? arithmeticExpressionEvaluator.evaluate(
+                (Node) comparisonToken.getValue(), data) : comparisonToken.getValue();
         return operatorService.evaluateLogicalOperator(comparisonToken.getOperator(), ContainerDataType.PRIMITIVE, comparisonToken.getDataType(),
-                                                       fieldData, comparisonToken.getValue());
+                                                       fieldData, value);
     }
 
     private boolean evaluateNumericRangeToken(final NumericRangeNode numericRangeToken, final Map<String, Object> data) {
diff --git a/src/main/java/com/github/sidhant92/boolparser/constant/NodeType.java b/src/main/java/com/github/sidhant92/boolparser/constant/NodeType.java
@@ -13,5 +13,6 @@ public enum NodeType {
     UNARY,
     ARITHMETIC,
     ARITHMETIC_LEAF,
-    ARITHMETIC_UNARY
+    ARITHMETIC_UNARY,
+    STRING
 }
diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/StringNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/StringNode.java
@@ -0,0 +1,24 @@
+package com.github.sidhant92.boolparser.domain;
+
+import com.github.sidhant92.boolparser.constant.NodeType;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @author sidhant.aggarwal
+ * @since 16/03/2024
+ */
+@AllArgsConstructor
+@Getter
+@Setter
+@Builder
+public class StringNode extends Node {
+    private final String field;
+
+    @Override
+    public NodeType getTokenType() {
+        return NodeType.STRING;
+    }
+}
diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticBaseNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticBaseNode.java
@@ -0,0 +1,9 @@
+package com.github.sidhant92.boolparser.domain.arithmetic;
+
+import com.github.sidhant92.boolparser.domain.Node;
+
+/**
+ * @author sidhant.aggarwal
+ * @since 16/03/2024
+ */
+public abstract class ArithmeticBaseNode extends Node {}
diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticLeafNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticLeafNode.java
@@ -16,7 +16,7 @@
 @Getter
 @Setter
 @Builder
-public class ArithmeticLeafNode extends Node {
+public class ArithmeticLeafNode extends ArithmeticBaseNode {
     private Object operand;
 
     private DataType dataType;
diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticNode.java
@@ -16,7 +16,7 @@
 @Getter
 @Setter
 @Builder
-public class ArithmeticNode extends Node {
+public class ArithmeticNode extends ArithmeticBaseNode {
     private Node left;
 
     private Node right;
diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticUnaryNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticUnaryNode.java
@@ -15,7 +15,7 @@
 @Getter
 @Setter
 @Builder
-public class ArithmeticUnaryNode extends Node {
+public class ArithmeticUnaryNode extends ArithmeticBaseNode {
     private Node operand;
 
     @Override
diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterListener.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterListener.java
@@ -4,13 +4,15 @@
 import java.util.Objects;
 import java.util.Stack;
 import java.util.stream.Collectors;
+import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import com.github.sidhant92.boolparser.constant.DataType;
 import com.github.sidhant92.boolparser.constant.LogicalOperationType;
 import com.github.sidhant92.boolparser.constant.Operator;
+import com.github.sidhant92.boolparser.domain.StringNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticLeafNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticUnaryNode;
@@ -33,6 +35,8 @@ public class BooleanFilterListener extends BooleanExpressionBaseListener {
 
     private org.antlr.v4.runtime.Token lastToken;
 
+    private int tokenCount;
+
     private String defaultField;
 
     public BooleanFilterListener(final String defaultField) {
@@ -207,6 +211,9 @@ public void exitParse(BooleanExpressionParser.ParseContext ctx) {
                 this.node = ArithmeticUnaryNode.builder().operand(secondNode).build();
             }
         }
+        if (this.node == null && tokenCount == 1 && lastToken instanceof CommonToken) {
+            this.node = StringNode.builder().field((lastToken.getText())).build();
+        }
         if (this.node == null) {
             log.error("Error parsing expression for the string {}", ctx.getText());
             throw new InvalidExpressionException();
@@ -232,6 +239,7 @@ public void exitNotExpression(BooleanExpressionParser.NotExpressionContext ctx)
 
     @Override
     public void exitTypesExpression(BooleanExpressionParser.TypesExpressionContext ctx) {
+        tokenCount++;
         this.lastToken = ctx.start;
     }
 
diff --git a/src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java b/src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java
@@ -133,6 +133,16 @@ public void testSimpleExponentOperationWithVariable() {
         assertEquals(resultOptional.get(), 100000);
     }
 
+    @Test
+    public void testStringConcatenation() {
+        final Map<String, Object> data = new HashMap<>();
+        data.put("a", "first");
+        data.put("b", "second");
+        final Try<Object> resultOptional = arithmeticExpressionEvaluator.evaluate("a + \" \" + b", data);
+        assertTrue(resultOptional.isSuccess());
+        assertEquals(resultOptional.get(), "first second");
+    }
+
     @Test
     public void testExpressionWithParenthesisNoVariable() {
         final Map<String, Object> data = new HashMap<>();
@@ -177,4 +187,13 @@ public void testExpressionWithNestedUnaryNode() {
         assertTrue(resultOptional.isSuccess());
         assertEquals(resultOptional.get(), -15);
     }
+
+    @Test
+    public void testExpressionWithNestedUnaryNode1() {
+        final Map<String, Object> data = new HashMap<>();
+        data.put("a", "test");
+        final Try<Object> resultOptional = arithmeticExpressionEvaluator.evaluate("a", data);
+        assertTrue(resultOptional.isSuccess());
+        assertEquals(resultOptional.get(), "test");
+    }
 }
diff --git a/src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java b/src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java
@@ -514,4 +514,32 @@ public void testContainsAllFalseCondition() {
         assertTrue(booleanOptional.isSuccess());
         assertFalse(booleanOptional.get());
     }
+
+    @Test
+    public void testComparisonWithArithmeticTrueCondition() {
+        final Map<String, Object> data = new HashMap<>();
+        data.put("age", "20");
+        final Try<Boolean> booleanOptional = booleanExpressionEvaluator.evaluate("age > (5 + 10)", data);
+        assertTrue(booleanOptional.isSuccess());
+        assertTrue(booleanOptional.get());
+    }
+
+    @Test
+    public void testComparisonWithArithmeticFalseCondition() {
+        final Map<String, Object> data = new HashMap<>();
+        data.put("age", "20");
+        final Try<Boolean> booleanOptional = booleanExpressionEvaluator.evaluate("age > (5 + 20)", data);
+        assertTrue(booleanOptional.isSuccess());
+        assertFalse(booleanOptional.get());
+    }
+
+    @Test
+    public void testComparisonWithArithmeticFalseCondition1() {
+        final Map<String, Object> data = new HashMap<>();
+        data.put("age", "20");
+        data.put("a", 20);
+        final Try<Boolean> booleanOptional = booleanExpressionEvaluator.evaluate("age > (5 + a)", data);
+        assertTrue(booleanOptional.isSuccess());
+        assertFalse(booleanOptional.get());
+    }
 }
diff --git a/src/test/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterBoolParserTest.java b/src/test/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterBoolParserTest.java
@@ -9,6 +9,7 @@
 import com.github.sidhant92.boolparser.constant.LogicalOperationType;
 import com.github.sidhant92.boolparser.constant.NodeType;
 import com.github.sidhant92.boolparser.constant.Operator;
+import com.github.sidhant92.boolparser.domain.StringNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticLeafNode;
 import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode;
 import com.github.sidhant92.boolparser.domain.ArrayNode;
@@ -324,10 +325,10 @@ public void testStringList2() {
     }
 
     @Test
-    public void testInvalidExpression() {
+    public void testSingleToken() {
         final Try<Node> nodeOptional = boolExpressionBoolParser.parseExpression("a");
-        assertTrue(nodeOptional.isFailure());
-        assertTrue(nodeOptional.getCause() instanceof InvalidExpressionException);
+        assertTrue(nodeOptional.isSuccess());
+        assertTrue(nodeOptional.get() instanceof StringNode);
     }
 
     @Test
@@ -405,6 +406,20 @@ public void testAddOperatorBool() {
         assertEquals(((ArithmeticNode) nodeOptional.get()).getOperator(), Operator.ADD);
     }
 
+    @Test
+    public void testComparisonWithArithmetic() {
+        final Try<Node> nodeOptional = boolExpressionBoolParser.parseExpression("a > (10 + 20)");
+        assertTrue(nodeOptional.isSuccess());
+        assertEquals(nodeOptional.get().getTokenType(), NodeType.COMPARISON);
+        assertEquals((((ComparisonNode) nodeOptional.get()).getField()), "a");
+        final ArithmeticNode arithmeticNode = (ArithmeticNode) ((ComparisonNode) nodeOptional.get()).getValue();
+        assertEquals(((ArithmeticLeafNode)(arithmeticNode.getLeft())).getOperand(), 10);
+        assertEquals(((ArithmeticLeafNode)(arithmeticNode.getLeft())).getDataType(), DataType.INTEGER);
+        assertEquals(((ArithmeticLeafNode)(arithmeticNode.getRight())).getOperand(), 20);
+        assertEquals(((ArithmeticLeafNode)(arithmeticNode.getRight())).getDataType(), DataType.INTEGER);
+        assertEquals(arithmeticNode.getOperator(), Operator.ADD);
+    }
+
     private void verifyStringToken(final ComparisonNode stringToken, final String field, final String value) {
         assertEquals(stringToken.getTokenType().name(), NodeType.COMPARISON.name());
         assertEquals(stringToken.getField(), field);

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,6 @@ public enum NodeType {`
`13`	`13`	`UNARY,`
`14`	`14`	`ARITHMETIC,`
`15`	`15`	`ARITHMETIC_LEAF,`
`16`		`- ARITHMETIC_UNARY`
	`16`	`+ ARITHMETIC_UNARY,`
	`17`	`+ STRING`
`17`	`18`	`}`