feat: add exceptions and adjust rule maker evaluate (#37)

Adjust rule maker and add exceptions

Co-authored-by: kalisar <[email protected]>

Author: art920

src/main/java/com/hlag/rulemaker/RuleMaker.java

@@ -3,8 +3,14 @@
 import com.google.common.base.Preconditions;
 import com.google.gson.*;
 import com.google.gson.reflect.TypeToken;
+import com.hlag.rulemaker.exception.RuleMakerEvaluationException;
+import com.hlag.rulemaker.exception.RuleMakerException;
+import com.hlag.rulemaker.exception.RuleMakerMissingVariablesException;
+import com.hlag.rulemaker.exception.RuleMakerParseExpressionException;
 import io.github.jamsesso.jsonlogic.JsonLogic;
 import io.github.jamsesso.jsonlogic.JsonLogicException;
+import io.github.jamsesso.jsonlogic.ast.JsonLogicParseException;
+import io.github.jamsesso.jsonlogic.evaluator.JsonLogicEvaluationException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -502,37 +508,37 @@ public String toJson() {
         return gson.toJson(expression);
     }
 
+    public Object evaluate(Object data) {
+        return evaluate(toJson(), data);
+    }
+
     /**
      * Evaluates the JSON expression with the given data.
      *
      * @param data The data to evaluate the JSON expression with.
      * @return The result of the evaluation.
      */
     @SuppressWarnings({"squid:S1166", "squid:S112"})
-    public Object evaluate(Object data) {
-        Object result = null;
+    public static Object evaluate(String expression, Object data) {
         try {
-            String json = toJson();
             // TODO a strange behavior, need to investigate it further
             if (data instanceof Map) {
                 Map<String, Object> normalizedMap = gson.fromJson(gson.toJson(data), type);
-                Set<String> missingVariables = findMissingVariables(normalizedMap);
+                Set<String> missingVariables = findMissingVariables(expression, normalizedMap);
                 if (!missingVariables.isEmpty()) {
-                    throw new IllegalArgumentException("Missing variables: " + missingVariables);
+                    throw new RuleMakerMissingVariablesException(missingVariables);
                 }
-                result = jsonLogic.apply(json, normalizedMap);
+                return jsonLogic.apply(expression, normalizedMap);
             } else {
-                result = jsonLogic.apply(json, data);
+                return jsonLogic.apply(expression, data);
             }
-        } catch (NullPointerException e) {
-            return null; // bad data
+        } catch (JsonLogicParseException e) {
+            throw new RuleMakerParseExpressionException(e.getMessage(), e);
+        } catch (JsonLogicEvaluationException e) {
+            throw new RuleMakerEvaluationException(e.getMessage(), e);
         } catch (JsonLogicException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-        if (log.isDebugEnabled()) {
-            log.debug("RuleMaker: {} -> {}", toJson(), result);
+            throw new RuleMakerException(e.getMessage(), e);
         }
-        return result;
     }
 
     /**
@@ -580,8 +586,8 @@ private static void findVarFields(JsonElement element, List<String> fields) {
      * @param data The data map to check for variable presence.
      * @return A set of variables that are missing in the data map.
      */
-    private Set<String> findMissingVariables(Map<String, Object> data) {
-        return findVariables(toJson()).stream()
+    private static Set<String> findMissingVariables(String expression, Map<String, Object> data) {
+        return findVariables(expression).stream()
             .filter(variable -> !isVariablePresent(data, variable))
             .collect(Collectors.toSet());
     }
@@ -596,7 +602,7 @@ private Set<String> findMissingVariables(Map<String, Object> data) {
      * @return true if the variable is present in the data map; false otherwise.
      */
     @SuppressWarnings("unchecked")
-    private boolean isVariablePresent(Map<String, Object> data, String variable) {
+    private static boolean isVariablePresent(Map<String, Object> data, String variable) {
         if (variable == null || variable.isBlank()) {
             return true;
         }

src/main/java/com/hlag/rulemaker/exception/RuleMakerEvaluationException.java

@@ -0,0 +1,15 @@
+package com.hlag.rulemaker.exception;
+
+public class RuleMakerEvaluationException extends RuleMakerException {
+    public RuleMakerEvaluationException(String msg) {
+        super(msg);
+    }
+
+    public RuleMakerEvaluationException(Throwable cause) {
+        super(cause);
+    }
+
+    public RuleMakerEvaluationException(String msg, Throwable cause) {
+        super(msg, cause);
+    }
+}

src/main/java/com/hlag/rulemaker/exception/RuleMakerException.java

@@ -0,0 +1,19 @@
+package com.hlag.rulemaker.exception;
+
+public class RuleMakerException extends RuntimeException {
+
+    private RuleMakerException() {
+    }
+
+    public RuleMakerException(String msg) {
+        super(msg);
+    }
+
+    public RuleMakerException(Throwable cause) {
+        super(cause);
+    }
+
+    public RuleMakerException(String msg, Throwable cause) {
+        super(msg, cause);
+    }
+}

src/main/java/com/hlag/rulemaker/exception/RuleMakerMissingVariablesException.java

@@ -0,0 +1,16 @@
+package com.hlag.rulemaker.exception;
+
+import lombok.Getter;
+
+import java.util.Set;
+
+@Getter
+public class RuleMakerMissingVariablesException extends RuleMakerException {
+
+    private final Set<String> missingVariables;
+
+    public RuleMakerMissingVariablesException(Set<String> missingVariables) {
+        super("Missing variables: " + missingVariables);
+        this.missingVariables = missingVariables;
+    }
+}

src/main/java/com/hlag/rulemaker/exception/RuleMakerParseExpressionException.java

@@ -0,0 +1,15 @@
+package com.hlag.rulemaker.exception;
+
+public class RuleMakerParseExpressionException extends RuleMakerException {
+    public RuleMakerParseExpressionException(String msg) {
+        super(msg);
+    }
+
+    public RuleMakerParseExpressionException(Throwable cause) {
+        super(cause);
+    }
+
+    public RuleMakerParseExpressionException(String msg, Throwable cause) {
+        super(msg, cause);
+    }
+}