Arithmetic Expressions Support

.gitignore

@@ -30,3 +30,6 @@ out/
 `
 
 gradle.properties
+
+*.DS_Store
+**/.DS_Store

README.md

@@ -4,15 +4,15 @@ A Boolean Expression Parser for Java
 The library can help parse complex and nested boolean expressions.
 The expressions are in SQL-like syntax, where you can use boolean operators and parentheses to combine individual expressions.
 
-An expression can be as simple as `name = Sidhant`.
+An expression can be as simple as `name = 'Sidhant'`.
 A Complex expression is formed by combining these small expressions by logical operators and giving precedence using parenthesis
 
 ### Examples
 #### Textual Equality
 
 Format: `${attributeName} = ${value}`
 
-Example: `name = john`
+Example: `name = 'john'`
 
 #### Numeric Comparisons
 
@@ -34,7 +34,7 @@ Example: `price 5.99 TO 100`
 
 Example:
 
-`price < 10 AND (category:Book OR NOT category:Ebook)`
+`price < 10 AND (category:'Book' OR NOT category:'Ebook')`
 
 Individual filters can be combined via boolean operators. The following operators are supported:
 
@@ -45,9 +45,12 @@ Individual filters can be combined via boolean operators. The following operator
 Parentheses, `(` and `)`, can be used for grouping.
 
 #### Usage Notes
+* String must be enclosed either in single or double quotes.
+* Variables substitution is supported by passing the name of the variable without the quotes.
 * Phrases that includes quotes, like `content = "It's a wonderful day"`
 * Phrases that includes quotes, like `attribute = 'She said "Hello World"'`
 * For nested keys in data map you can use the dot notation, like `person.age`
+* There are two implementations for the parser, Boolparser and CachedBoolParser. CachedBoolParser takes input the max cache size.
 
 ## Usage
 POM
@@ -56,22 +59,22 @@ POM
         <dependency>
             <groupId>com.github.sidhant92</groupId>
             <artifactId>bool-parser-java</artifactId>
-            <version>1.0.0</version>
+            <version>2.0.0</version>
         </dependency>
     </dependencies>
 ```
 Gradle
 ```
 dependencies {
-	implementation "com.github.sidhant92:bool-parser-java:1.0.0"
+	implementation "com.github.sidhant92:bool-parser-java:2.0.0"
 }
 ```
 
 
 Code
 ```
 final BoolParser boolParser = new BoolParser();
-final Try<Node> nodeOptional = boolParser.parseExpression("name = test");
+final Try<Node> nodeOptional = boolParser.parseExpression("name = 'test'");
 ```
 
 ### Node Types Post Parsing
@@ -119,12 +122,18 @@ private final DataType dataType;
 private final Object value;
 ```
 
+####
+FieldNode
+```
+private final String field;
+```
+
 ####
 InNode
 ```
 private final String field;
 
-private final List<Pair<DataType, Object>> items;
+private final List<Node> items;
 ```
 
 
@@ -142,49 +151,126 @@ The following Data Types are supported:
 5. Boolean
 6. Semantic Version
 
+---
+**NOTE**
+
+Decimal will internally use BigDecimal for storage.
+
+---
+
 Usage examples:
 
 Simple Numerical Comparison
 ```
-final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator();
+final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new Boolparser());
 final Map<String, Object> data = new HashMap<>();
 data.put("age", 26);
-final Try<Boolean> result = booleanExpressionEvaluator.evaluate("age >= 27", data);
-assertTrue(booleanOptional.isPresent());
-assertFalse(booleanOptional.get());
+final Try<Boolean> resultOptional = booleanExpressionEvaluator.evaluate("age >= 27", data);
+assertTrue(resultOptional.isPresent());
+assertFalse(resultOptional.get());
 ```
 Boolean Comparison
 ```
-final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator();
+final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new Boolparser());
 final Map<String, Object> data = new HashMap<>();
 data.put("age", 25);
 data.put("name", "sid");
-final Try<Boolean> result = booleanExpressionEvaluator.evaluate("name = sid AND age = 25", data);
-assertTrue(booleanOptional.isPresent());
-assertTrue(booleanOptional.get());
+final Try<Boolean> resultOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND age = 25", data);
+assertTrue(resultOptional.isPresent());
+assertTrue(resultOptional.get());
 ```
 Nested Boolean Comparison
 ```
-final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator();
+final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new Boolparser());
 final Map<String, Object> data = new HashMap<>();
 data.put("age", 25);
 data.put("name", "sid");
 data.put("num", 45);
-final Try<Boolean> result = booleanExpressionEvaluator.evaluate("name:sid AND (age = 25 OR num = 44)", data);
-assertTrue(booleanOptional.isPresent());
-assertTrue(booleanOptional.get());
+final Try<Boolean> resultOptional = booleanExpressionEvaluator.evaluate("name = sid AND (age = 25 OR num = 44)", data);
+assertTrue(resultOptional.isPresent());
+assertTrue(resultOptional.get());
 ```
 App Version Comparison
 ```
-final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator();
+final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new Boolparser());
 final Map<String, Object> data = new HashMap<>();
 data.put("app_version", "1.5.9");
-final Try<Boolean> result = booleanExpressionEvaluator.evaluate("app_version < 1.5.10", data);
-assertTrue(booleanOptional.isPresent());
-assertTrue(booleanOptional.get());
+final Try<Boolean> resultOptional = booleanExpressionEvaluator.evaluate("app_version < 1.5.10", data);
+assertTrue(resultOptional.isPresent());
+assertTrue(resultOptional.get());
 ```
 
 The return type is `Try<Boolean>`. Failure means that parsing has failed and any fallback can be used.
 
 
-[For a complete list of examples please check out the test file](src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java)
+[For a complete list of examples please check out the test file](src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java)
+
+
+### Arithmetic Expression Evaluator
+
+The library can be used to evaluate a arithmetic expression.
+It supports both numbers and variables which will be substituted from the passed data.
+The passed variables can also be passed using the dot notation to access nested fields from the input data.
+
+The following Data Types are supported:
+1. String
+2. Integer
+3. Long
+4. Decimal
+
+The following Operators are supported:
+1. Addition (+)
+2. Subtraction (-)
+3. Multiplication (*)
+4. Division (/)
+5. Modulus (%)
+6. Exponent (^)
+
+The following functions are supported:
+1. Minimum (min)
+2. Maximum (max)
+3. Average (avg)
+4. Sum (sum)
+5. Mean (mean)
+6. Mode (mode)
+7. Median (median)
+8. Integer (int) - converts the input to integer
+9. Length (len) - Returns length of the give array
+
+Syntax For using functions
+Format: `${FunctionIdentifier} (item1, item2...)`
+
+Example: `min (1,2,3)` or with variable substitution `min (a,b,c)`
+
+Usage examples:
+
+Simple Addition Operation
+```
+final ArithmeticExpressionEvaluator evaluator = new ArithmeticExpressionEvaluator(new Boolparser());
+final Map<String, Object> data = new HashMap<>();
+data.put("a", 10);
+final Try<Object> resultOptional = evaluator.evaluate("a + 5", data);
+assertTrue(resultOptional.isPresent());
+assertTrue(resultOptional.get(), 15);
+```
+
+Complex Arithmetic Operation
+```
+final ArithmeticExpressionEvaluator evaluator = new ArithmeticExpressionEvaluator(new Boolparser());
+final Map<String, Object> data = new HashMap<>();
+data.put("a", 10);
+final Try<Object> resultOptional = evaluator.evaluate("((5 * 2) + a) * 2 + (1 + 3 * (a / 2))", data);
+assertTrue(resultOptional.isPresent());
+assertTrue(resultOptional.get(), 56);
+```
+Function Usage
+```
+final ArithmeticExpressionEvaluator evaluator = new ArithmeticExpressionEvaluator(new Boolparser());
+final Map<String, Object> data = new HashMap<>();
+data.put("a", 10);
+final Try<Object> resultOptional = arithmeticExpressionEvaluator.evaluate("min (1,2,3)", data);
+assertTrue(resultOptional.isSuccess());
+assertEquals(resultOptional.get(), 1);
+```
+
+[For a complete list of examples please check out the test file](src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java)

build.gradle

@@ -22,7 +22,7 @@ sourceCompatibility = 1.8
 targetCompatibility = 1.8
 
 group 'com.github.sidhant92'
-version = "1.2.1"
+version = "2.0.0"
 
 apply plugin: "com.dipien.semantic-version"
 
@@ -31,10 +31,6 @@ repositories {
 }
 
 dependencies {
-    implementation 'ch.qos.logback:logback-classic:1.2.3'
-    implementation 'ch.qos.logback.contrib:logback-json-classic:0.1.5'
-    implementation 'ch.qos.logback.contrib:logback-jackson:0.1.5'
-    implementation 'net.logstash.logback:logstash-logback-encoder:5.2'
     implementation 'org.apache.maven:maven-artifact:3.5.2'
     implementation 'org.antlr:antlr4-runtime:4.13.1'
     implementation 'io.vavr:vavr:0.10.4'
@@ -122,7 +118,7 @@ nexusPublishing {
 
 ext.genOutputDir = file("$buildDir/generated-resources")
 
-task generateVersionTxt()  {
+task generateVersionTxt() {
     ext.outputFile = file("$genOutputDir/version.txt")
     outputs.file(outputFile)
     doLast {

src/main/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluator.java

@@ -0,0 +1,122 @@
+package com.github.sidhant92.boolparser.application;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+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.EvaluatedNode;
+import com.github.sidhant92.boolparser.domain.FieldNode;
+import com.github.sidhant92.boolparser.domain.arithmetic.UnaryNode;
+import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode;
+import com.github.sidhant92.boolparser.domain.logical.Node;
+import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticFunctionNode;
+import com.github.sidhant92.boolparser.exception.DataNotFoundException;
+import com.github.sidhant92.boolparser.exception.UnsupportedToken;
+import com.github.sidhant92.boolparser.function.FunctionEvaluatorService;
+import com.github.sidhant92.boolparser.operator.OperatorService;
+import com.github.sidhant92.boolparser.parser.BoolExpressionParser;
+import com.github.sidhant92.boolparser.util.ValueUtils;
+import io.vavr.control.Try;
+
+/**
+ * @author sidhant.aggarwal
+ * @since 15/03/2024
+ */
+public class ArithmeticExpressionEvaluator {
+    private final BoolExpressionParser boolExpressionParser;
+
+    private final OperatorService operatorService;
+
+    private final FunctionEvaluatorService functionEvaluatorService;
+
+    public ArithmeticExpressionEvaluator(final BoolExpressionParser boolExpressionParser) {
+        this.boolExpressionParser = boolExpressionParser;
+        operatorService = new OperatorService();
+        functionEvaluatorService = new FunctionEvaluatorService();
+    }
+
+    public Try<Object> evaluate(final String expression, final Map<String, Object> data) {
+        final Try<Node> tokenOptional = boolExpressionParser.parseExpression(expression, null);
+        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:
+                return evaluateArithmeticToken((ArithmeticNode) node, data);
+            case ARITHMETIC_FUNCTION:
+                return evaluateArithmeticFunctionToken((ArithmeticFunctionNode) node, data);
+            case UNARY:
+                return evaluateUnaryToken((UnaryNode) node, data);
+            case FIELD:
+                return evaluateFieldToken((FieldNode) node, data);
+            default:
+                throw new UnsupportedToken(node.getTokenType().name());
+        }
+    }
+
+    private Object evaluateFieldToken(final FieldNode fieldNode, final Map<String, Object> data) {
+        final Optional<Object> value = ValueUtils.getValueFromMap(fieldNode.getField(), data);
+        if (!value.isPresent()) {
+            throw new DataNotFoundException(fieldNode.getField());
+        }
+        return value.get();
+    }
+
+    private Object evaluateUnaryToken(final UnaryNode unaryNode, final Map<String, Object> data) {
+        return unaryNode.getValue();
+    }
+
+    private Object evaluateArithmeticFunctionToken(final ArithmeticFunctionNode arithmeticFunctionNode, final Map<String, Object> data) {
+        final List<Object> resolvedValues = arithmeticFunctionNode.getItems()
+                .stream()
+                .map(item -> evaluate(item, data))
+                .collect(Collectors.toList());
+        final List<EvaluatedNode> flattenedValues = ValueUtils.mapToEvaluatedNodes(resolvedValues);
+        return functionEvaluatorService.evaluateArithmeticFunction(arithmeticFunctionNode.getFunctionType(), flattenedValues);
+    }
+
+    private Object evaluateArithmeticToken(final ArithmeticNode arithmeticNode, final Map<String, Object> data) {
+        final Object leftValue = evaluateToken(arithmeticNode.getLeft(), data);
+        if (arithmeticNode.getOperator().equals(Operator.UNARY)) {
+            if (leftValue instanceof EvaluatedNode) {
+                final EvaluatedNode left = (EvaluatedNode) leftValue;
+                return operatorService.evaluateArithmeticOperator(left.getValue(), left.getDataType(), null, null, arithmeticNode.getOperator(),
+                                                                  ContainerDataType.PRIMITIVE);
+            } else {
+                final DataType leftDataType = ValueUtils.getDataType(leftValue);
+                return operatorService.evaluateArithmeticOperator(leftValue, leftDataType, null, null, arithmeticNode.getOperator(),
+                                                                  ContainerDataType.PRIMITIVE);
+            }
+        }
+        final Object rightValue = evaluateToken(arithmeticNode.getRight(), data);
+        if (leftValue instanceof EvaluatedNode && rightValue instanceof EvaluatedNode) {
+            final EvaluatedNode left = (EvaluatedNode) leftValue;
+            final EvaluatedNode right = (EvaluatedNode) rightValue;
+            return operatorService.evaluateArithmeticOperator(left.getValue(), left.getDataType(), right.getValue(), right.getDataType(),
+                                                              arithmeticNode.getOperator(), ContainerDataType.PRIMITIVE);
+        } else if (leftValue instanceof EvaluatedNode) {
+            final EvaluatedNode left = (EvaluatedNode) leftValue;
+            final DataType rightDataType = ValueUtils.getDataType(rightValue);
+            return operatorService.evaluateArithmeticOperator(left.getValue(), left.getDataType(), rightValue, rightDataType,
+                                                              arithmeticNode.getOperator(), ContainerDataType.PRIMITIVE);
+        } else if (rightValue instanceof EvaluatedNode) {
+            final EvaluatedNode right = (EvaluatedNode) rightValue;
+            final DataType leftDataType = ValueUtils.getDataType(leftValue);
+            return operatorService.evaluateArithmeticOperator(leftValue, leftDataType, right.getValue(), right.getDataType(),
+                                                              arithmeticNode.getOperator(), ContainerDataType.PRIMITIVE);
+        } else {
+            final DataType leftDataType = ValueUtils.getDataType(leftValue);
+            final DataType rightDataType = ValueUtils.getDataType(rightValue);
+            return operatorService.evaluateArithmeticOperator(leftValue, leftDataType, rightValue, rightDataType, arithmeticNode.getOperator(),
+                                                              ContainerDataType.PRIMITIVE);
+        }
+    }
+}