Add deferred future validation

Author: zhossain-info

src/main/java/com/relogiclabs/json/schema/function/FunctionBase.java

@@ -1,6 +1,5 @@
 package com.relogiclabs.json.schema.function;
 
-import com.relogiclabs.json.schema.exception.JsonSchemaException;
 import com.relogiclabs.json.schema.tree.RuntimeContext;
 import com.relogiclabs.json.schema.types.JFunction;
 import lombok.Getter;
@@ -9,15 +8,13 @@
 @Getter
 public abstract class FunctionBase {
     protected final RuntimeContext runtime;
-
-    @Setter
-    protected JFunction function;
+    @Setter protected JFunction function;
 
     public FunctionBase(RuntimeContext runtime) {
         this.runtime = runtime;
     }
 
-    protected boolean failWith(JsonSchemaException exception) {
+    protected boolean failWith(RuntimeException exception) {
         return runtime.failWith(exception);
     }
 }

src/main/java/com/relogiclabs/json/schema/function/FutureValidator.java

@@ -0,0 +1,6 @@
+package com.relogiclabs.json.schema.function;
+
+@FunctionalInterface
+public interface FutureValidator {
+    boolean validate();
+}

src/main/java/com/relogiclabs/json/schema/tree/DataTree.java

@@ -0,0 +1,10 @@
+package com.relogiclabs.json.schema.tree;
+
+import com.relogiclabs.json.schema.types.JRoot;
+
+public interface DataTree {
+    boolean match(DataTree dataTree);
+    RuntimeContext getRuntime();
+    JRoot getRoot();
+    TreeType getType();
+}

src/main/java/com/relogiclabs/json/schema/tree/JsonTree.java

@@ -10,17 +10,33 @@
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 
+import static com.relogiclabs.json.schema.tree.TreeType.JSON_TREE;
+
 @Getter
-public final class JsonTree {
+public final class JsonTree implements DataTree {
+    private final RuntimeContext runtime;
     private final JRoot root;
 
-    public JsonTree(RuntimeContext context, String input) {
+    public JsonTree(RuntimeContext runtime, String input) {
+        this.runtime = runtime;
         var jsonLexer = new JsonLexer(CharStreams.fromString(input));
         jsonLexer.removeErrorListeners();
         jsonLexer.addErrorListener(LexerErrorListener.JSON);
         var jsonParser = new JsonParser(new CommonTokenStream(jsonLexer));
         jsonParser.removeErrorListeners();
         jsonParser.addErrorListener(ParserErrorListener.JSON);
-        root = (JRoot) new JsonTreeVisitor(context).visit(jsonParser.json());
+        root = (JRoot) new JsonTreeVisitor(runtime).visit(jsonParser.json());
+    }
+
+    @Override
+    public boolean match(DataTree dataTree) {
+        var result = root.match(dataTree.getRoot());
+        result &= runtime.invokeValidators();
+        return result;
+    }
+
+    @Override
+    public TreeType getType() {
+        return JSON_TREE;
     }
 }

src/main/java/com/relogiclabs/json/schema/tree/RuntimeContext.java

@@ -1,22 +1,26 @@
 package com.relogiclabs.json.schema.tree;
 
 import com.relogiclabs.json.schema.exception.DuplicateDefinitionException;
-import com.relogiclabs.json.schema.internal.tree.FunctionManager;
-import com.relogiclabs.json.schema.internal.tree.PragmaManager;
+import com.relogiclabs.json.schema.function.FutureValidator;
+import com.relogiclabs.json.schema.internal.tree.ExceptionRegistry;
+import com.relogiclabs.json.schema.internal.tree.FunctionRegistry;
+import com.relogiclabs.json.schema.internal.tree.PragmaRegistry;
 import com.relogiclabs.json.schema.message.MessageFormatter;
 import com.relogiclabs.json.schema.types.JAlias;
 import com.relogiclabs.json.schema.types.JDefinition;
 import com.relogiclabs.json.schema.types.JFunction;
 import com.relogiclabs.json.schema.types.JInclude;
 import com.relogiclabs.json.schema.types.JNode;
 import com.relogiclabs.json.schema.types.JPragma;
+import com.relogiclabs.json.schema.types.JReceiver;
 import com.relogiclabs.json.schema.types.JValidator;
 import lombok.Getter;
 
+import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
-import java.util.Queue;
+import java.util.UUID;
 import java.util.function.Supplier;
 
 import static com.relogiclabs.json.schema.internal.util.StringHelper.concat;
@@ -25,27 +29,28 @@
 
 
 public final class RuntimeContext {
-    private final FunctionManager functionManager;
-    private final PragmaManager pragmaManager;
-    private int disableException = 0;
-
+    @Getter private final FunctionRegistry functions;
+    @Getter private final PragmaRegistry pragmas;
     @Getter private final Map<JAlias, JValidator> definitions;
-    @Getter private final boolean throwException;
-    @Getter private final Queue<Exception> exceptions;
+    @Getter private final ExceptionRegistry exceptions;
+    @Getter private final Map<String, FutureValidator> validators;
+    @Getter private final Map<JReceiver, List<JNode>> receivers;
+    @Getter private final Map<String, Object> storage;
     @Getter private final MessageFormatter messageFormatter;
 
-
     public RuntimeContext(MessageFormatter messageFormatter, boolean throwException) {
         this.messageFormatter = messageFormatter;
-        this.throwException = throwException;
         this.definitions = new HashMap<>();
-        this.functionManager = new FunctionManager(this);
-        this.pragmaManager = new PragmaManager();
-        this.exceptions = new LinkedList<>();
+        this.functions = new FunctionRegistry(this);
+        this.pragmas = new PragmaRegistry();
+        this.exceptions = new ExceptionRegistry(throwException);
+        this.receivers = new HashMap<>();
+        this.storage = new HashMap<>();
+        this.validators = new HashMap<>();
     }
 
     public JPragma addPragma(JPragma pragma) {
-        return pragmaManager.addPragma(pragma);
+        return pragmas.addPragma(pragma);
     }
 
     public JInclude addClass(JInclude include) {
@@ -54,7 +59,7 @@ public JInclude addClass(JInclude include) {
     }
 
     public void addClass(String className, Context context) {
-        functionManager.addClass(className, context);
+        functions.addClass(className, context);
     }
 
     public JDefinition addDefinition(JDefinition definition) {
@@ -68,38 +73,49 @@ DEFI01, concat("Duplicate definition of ", quote(definition.getAlias()),
         return definition;
     }
 
-    public boolean getIgnoreUndefinedProperties() {
-        return pragmaManager.getIgnoreUndefinedProperties();
+    public boolean invokeFunction(JFunction function, JNode target) {
+        return functions.invokeFunction(function, target);
     }
 
-    public double getFloatingPointTolerance() {
-        return pragmaManager.getFloatingPointTolerance();
+    public boolean areEqual(double value1, double value2) {
+        return Math.abs(value1 - value2) < pragmas.getFloatingPointTolerance();
     }
 
-    public boolean getIgnoreObjectPropertyOrder() {
-        return pragmaManager.getIgnoreObjectPropertyOrder();
+    public <T> T tryExecute(Supplier<T> function) {
+        return exceptions.tryExecute(function);
     }
 
-    public boolean invokeFunction(JFunction function, JNode target) {
-        return functionManager.invokeFunction(function, target);
+    public void register(List<JReceiver> list) {
+        for(var r : list) receivers.put(r, new ArrayList<>());
     }
 
-    public boolean areEqual(double value1, double value2) {
-        return Math.abs(value1 - value2) < getFloatingPointTolerance();
+    public void receive(List<JReceiver> list, JNode node) {
+        for(var r : list) receivers.get(r).add(node);
     }
 
-    public <T> T tryMatch(Supplier<T> function) {
-        try {
-            disableException += 1;
-            return function.get();
-        } finally {
-            disableException -= 1;
-        }
+    public List<JNode> fetch(JReceiver receiver) {
+        return receivers.get(receiver);
+    }
+
+    public boolean addValidator(FutureValidator validator) {
+        return validators.put(UUID.randomUUID().toString(), validator) == null;
+    }
+
+    public boolean invokeValidators() {
+        var result = true;
+        for(var v : validators.values()) result &= v.validate();
+        return result;
     }
 
     public boolean failWith(RuntimeException exception) {
-        if(throwException && disableException == 0) throw exception;
-        if(disableException == 0) exceptions.add(exception);
+        exceptions.tryThrow(exception);
+        exceptions.tryAdd(exception);
         return false;
     }
+
+    public void clear() {
+        exceptions.clear();
+        storage.clear();
+        for(var v : receivers.values()) v.clear();
+    }
 }

src/main/java/com/relogiclabs/json/schema/tree/SchemaTree.java

@@ -10,17 +10,33 @@
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 
+import static com.relogiclabs.json.schema.tree.TreeType.SCHEMA_TREE;
+
 @Getter
-public final class SchemaTree {
+public final class SchemaTree implements DataTree {
+    private final RuntimeContext runtime;
     private final JRoot root;
 
-    public SchemaTree(RuntimeContext context, String input) {
+    public SchemaTree(RuntimeContext runtime, String input) {
+        this.runtime = runtime;
         var schemaLexer = new SchemaLexer(CharStreams.fromString(input));
         schemaLexer.removeErrorListeners();
         schemaLexer.addErrorListener(LexerErrorListener.SCHEMA);
         var schemaParser = new SchemaParser(new CommonTokenStream(schemaLexer));
         schemaParser.removeErrorListeners();
         schemaParser.addErrorListener(ParserErrorListener.SCHEMA);
-        root = (JRoot) new SchemaTreeVisitor(context).visit(schemaParser.schema());
+        root = (JRoot) new SchemaTreeVisitor(runtime).visit(schemaParser.schema());
+    }
+
+    @Override
+    public boolean match(DataTree dataTree) {
+        var result = root.match(dataTree.getRoot());
+        result &= runtime.invokeValidators();
+        return result;
+    }
+
+    @Override
+    public TreeType getType() {
+        return SCHEMA_TREE;
     }
 }

src/main/java/com/relogiclabs/json/schema/tree/TreeType.java

@@ -0,0 +1,20 @@
+package com.relogiclabs.json.schema.tree;
+
+import lombok.Getter;
+
+@Getter
+public enum TreeType {
+    SCHEMA_TREE("Schema"),
+    JSON_TREE("Json");
+
+    private final String name;
+
+    TreeType(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}