Checks

Author: justin-tay

src/main/java/com/networknt/schema/ExecutionContext.java

@@ -19,12 +19,14 @@
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 
 import com.networknt.schema.annotation.Annotations;
 import com.networknt.schema.keyword.DiscriminatorState;
+import com.networknt.schema.keyword.KeywordValidator;
 import com.networknt.schema.path.NodePath;
 import com.networknt.schema.result.InstanceResults;
 import com.networknt.schema.walk.WalkConfig;
@@ -45,6 +47,7 @@ public class ExecutionContext {
 
     final ArrayDeque<Object> evaluationPath = new ArrayDeque<>(64);
     final ArrayDeque<Schema> evaluationSchema = new ArrayDeque<>(64);
+    final ArrayDeque<Object> evaluationSchemaPath = new ArrayDeque<>(64);
 
     public ArrayDeque<Object> getEvaluationPath() {
         return evaluationPath;
@@ -53,6 +56,10 @@ public ArrayDeque<Object> getEvaluationPath() {
     public ArrayDeque<Schema> getEvaluationSchema() {
         return evaluationSchema;
     }
+    
+    public ArrayDeque<Object> getEvaluationSchemaPath() {
+        return evaluationSchemaPath;
+    }
 
     public Map<NodePath, DiscriminatorState> getDiscriminatorMapping() {
 		return discriminatorMapping;

src/main/java/com/networknt/schema/Schema.java

@@ -723,10 +723,12 @@ public void validate(ExecutionContext executionContext, JsonNode jsonNode, JsonN
             int currentErrors = executionContext.getErrors().size();
             for (KeywordValidator v : getValidators()) {
                 executionContext.evaluationPath.addLast(v.getKeyword());
+                executionContext.evaluationSchemaPath.addLast(v.getKeyword());
                 try {
                     v.validate(executionContext, jsonNode, rootNode, instanceLocation);
                 } finally {
                     executionContext.evaluationPath.removeLast();
+                    executionContext.evaluationSchemaPath.removeLast();
                 }
             }
             if (executionContext.getErrors().size() > currentErrors) {

src/main/java/com/networknt/schema/keyword/AbstractKeywordValidator.java

@@ -16,12 +16,16 @@
 
 package com.networknt.schema.keyword;
 
+import java.util.ArrayDeque;
+import java.util.Iterator;
 import java.util.function.Consumer;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.networknt.schema.ExecutionContext;
+import com.networknt.schema.Schema;
 import com.networknt.schema.SchemaLocation;
 import com.networknt.schema.annotation.Annotation;
+import com.networknt.schema.path.EvaluationPath;
 import com.networknt.schema.path.NodePath;
 
 /**
@@ -122,4 +126,58 @@ protected void putAnnotation(ExecutionContext executionContext, Consumer<Annotat
         customizer.accept(builder);
         executionContext.getAnnotations().put(builder.build());
     }
+
+    
+    /**
+     * Determines if the keyword exists adjacent in the evaluation path.
+     * <p>
+     * This does not check if the keyword exists in the current meta schema as this
+     * can be a cross-draft case where the properties keyword is in a Draft 7 schema
+     * and the unevaluatedProperties keyword is in an outer Draft 2020-12 schema.
+     * <p>
+     * The fact that the validator exists in the evaluation path implies that the
+     * keyword was valid in whatever meta schema for that schema it was created for.
+     * 
+     * @param keyword the keyword to check
+     * @return true if found
+     */
+    protected boolean hasAdjacentKeywordInEvaluationPath(ExecutionContext executionContext, String keyword) {
+        Iterator<Object> evaluationSchemaPathIterator = executionContext.getEvaluationSchemaPath().descendingIterator();
+        Iterator<Schema> evaluationSchemaIterator = executionContext.getEvaluationSchema().descendingIterator();
+
+        ArrayDeque<Object> current = executionContext.getEvaluationSchemaPath().clone();
+
+        // Skip the first as this is the path pointing to the current keyword eg. properties eg /$ref/properties
+        // What is needed is the evaluationPath pointing to the current evaluationSchema eg /$ref
+        if (evaluationSchemaPathIterator.hasNext()) {
+            evaluationSchemaPathIterator.next();
+            
+            current.removeLast();
+        }
+
+        while (evaluationSchemaIterator.hasNext()) {
+            Schema schema = evaluationSchemaIterator.next();
+            for (KeywordValidator validator : schema.getValidators()) {
+                if (keyword.equals(validator.getKeyword())) {
+                    return true;
+                }
+            }
+            String newPath = new EvaluationPath(current).toString();
+            String oldPath = schema.getEvaluationPath().toString(); 
+            if (!oldPath.equals(newPath)) {
+                System.out.println("OLD: "+oldPath);
+                System.out.println("NEW: "+newPath);
+            }
+
+            if (evaluationSchemaPathIterator.hasNext()) {
+                Object evaluationPath = evaluationSchemaPathIterator.next();
+                current.removeLast();
+                if ("properties".equals(evaluationPath) || "items".equals(evaluationPath)) {
+                    // If there is a change in instance location then return false
+                    return false;
+                }
+            }
+        }
+        return false;
+    }
 }

src/main/java/com/networknt/schema/keyword/PropertiesValidator.java

@@ -65,7 +65,7 @@ public void validate(ExecutionContext executionContext, JsonNode node, JsonNode
     protected void validate(ExecutionContext executionContext, JsonNode node, JsonNode rootNode,
             NodePath instanceLocation, boolean walk) {
 
-
+        boolean c = hasAdjacentKeywordInEvaluationPath(executionContext, "unevaluatedProperties");
         Set<String> matchedInstancePropertyNames = null;
         boolean collectAnnotations = collectAnnotations() || collectAnnotations(executionContext);
         for (Entry<String, Schema> entry : this.schemas.entrySet()) {