making it possible to pre-define a schema by URI before schema loading

erosb · erosb · commit ea8b9ad74196 · 2019-01-20T20:57:09.000+01:00
Reference: section 8.3.1 of json schema core draft-7 says: "Such URIs and schemas can be supplied to an implementation prior to processing instances" So here if the caller associates a raw schema to an URI using `SchemaLoaderBuilder#registerSchemaByURI()` then the loader will recognize this URI and load the associated raw schema without hitting the network or any external protocols. This was originally requested in #38.
diff --git a/core/src/main/java/org/everit/json/schema/loader/JsonPointerEvaluator.java b/core/src/main/java/org/everit/json/schema/loader/JsonPointerEvaluator.java
@@ -10,7 +10,6 @@
 import java.io.InputStreamReader;
 import java.io.UncheckedIOException;
 import java.io.UnsupportedEncodingException;
-import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URLDecoder;
 import java.nio.charset.Charset;
@@ -111,30 +110,22 @@ static final JsonPointerEvaluator forDocument(JsonObject document, String fragme
     private static JsonObject configureBasedOnState(JsonObject obj, LoadingState callingState, String id) {
         obj.ls = new LoadingState(callingState.config,
                 callingState.pointerSchemas, obj, obj,
-                validateURI(callingState, id),
+                validateURI(callingState, id).asJavaURI(),
                 SchemaLocation.empty());
         return obj;
     }
 
     static final JsonPointerEvaluator forURL(SchemaClient schemaClient, String url, LoadingState callingState) {
-        int poundIdx = url.indexOf('#');
-        String fragment;
-        String toBeQueried;
-        if (poundIdx == -1) {
-            toBeQueried = url;
-            fragment = "";
-        } else {
-            fragment = url.substring(poundIdx);
-            toBeQueried = url.substring(0, poundIdx);
-        }
-        validateURI(callingState, toBeQueried);
-        return new JsonPointerEvaluator(() -> configureBasedOnState(executeWith(schemaClient, toBeQueried), callingState, toBeQueried),
-                fragment);
+        Uri uri = validateURI(callingState, url);
+        return new JsonPointerEvaluator(
+                () -> configureBasedOnState(executeWith(schemaClient, uri.toBeQueried.toString()), callingState,
+                        uri.toBeQueried.toString()),
+                uri.fragment);
     }
 
-    private static URI validateURI(LoadingState callingState, String toBeQueried) {
+    private static Uri validateURI(LoadingState callingState, String toBeQueried) {
         try {
-            return new URI(toBeQueried);
+            return Uri.parse(toBeQueried);
         } catch (URISyntaxException e) {
             throw callingState.createSchemaException(e);
         }
diff --git a/core/src/main/java/org/everit/json/schema/loader/LoaderConfig.java b/core/src/main/java/org/everit/json/schema/loader/LoaderConfig.java
@@ -1,8 +1,11 @@
 package org.everit.json.schema.loader;
 
+import static java.util.Collections.emptyMap;
 import static java.util.Objects.requireNonNull;
 import static org.everit.json.schema.loader.SpecificationVersion.DRAFT_4;
 
+import java.net.URI;
+import java.util.HashMap;
 import java.util.Map;
 
 import org.everit.json.schema.FormatValidator;
@@ -23,6 +26,8 @@ static LoaderConfig defaultV4Config() {
 
     final Map<String, FormatValidator> formatValidators;
 
+    final Map<URI, Object> schemasByURI;
+
     final SpecificationVersion specVersion;
 
     final boolean useDefaults;
@@ -33,14 +38,20 @@ static LoaderConfig defaultV4Config() {
 
     LoaderConfig(SchemaClient schemaClient, Map<String, FormatValidator> formatValidators,
             SpecificationVersion specVersion, boolean useDefaults) {
-        this(schemaClient, formatValidators, specVersion, useDefaults, false, new JavaUtilRegexpFactory());
+        this(schemaClient, formatValidators, emptyMap(), specVersion, useDefaults, false, new JavaUtilRegexpFactory());
     }
 
     LoaderConfig(SchemaClient schemaClient, Map<String, FormatValidator> formatValidators,
+            Map<URI, Object> schemasByURI,
             SpecificationVersion specVersion, boolean useDefaults, boolean nullableSupport,
             RegexpFactory regexpFactory) {
         this.schemaClient = requireNonNull(schemaClient, "schemaClient cannot be null");
         this.formatValidators = requireNonNull(formatValidators, "formatValidators cannot be null");
+        if (schemasByURI == null) {
+            this.schemasByURI = new HashMap<>();
+        } else {
+            this.schemasByURI = schemasByURI;
+        }
         this.specVersion = requireNonNull(specVersion, "specVersion cannot be null");
         this.useDefaults = useDefaults;
         this.nullableSupport = nullableSupport;
diff --git a/core/src/main/java/org/everit/json/schema/loader/ReferenceLookup.java b/core/src/main/java/org/everit/json/schema/loader/ReferenceLookup.java
@@ -151,16 +151,13 @@ Schema.Builder<?> lookup(String relPointerString, JsonObject ctx) {
             return refBuilder;
         }
 
-        boolean isInternal = isSameDocumentRef(absPointerString);
-        JsonPointerEvaluator pointer = isInternal
-                ? JsonPointerEvaluator.forDocument(ls.rootSchemaJson(), absPointerString)
-                : JsonPointerEvaluator.forURL(schemaClient, absPointerString, ls);
+        JsonPointerEvaluator pointer = createPointerEvaluator(absPointerString);
         ReferenceSchema.Builder refBuilder = ReferenceSchema.builder()
                 .refValue(relPointerString);
         ls.pointerSchemas.put(absPointerString, refBuilder);
         JsonPointerEvaluator.QueryResult result = pointer.query();
 
-        URI resolutionScope = !isInternal ? withoutFragment(absPointerString) : ls.id;
+        URI resolutionScope = !isSameDocumentRef(absPointerString) ? withoutFragment(absPointerString) : ls.id;
         JsonObject containingDocument = result.getContainingDocument();
         SchemaLoader childLoader = ls.initChildLoader()
                 .pointerToCurrentObj(SchemaLocation.parseURI(absPointerString))
@@ -173,6 +170,31 @@ Schema.Builder<?> lookup(String relPointerString, JsonObject ctx) {
         return refBuilder;
     }
 
+    private JsonObject initJsonObjectWithId(Object rawObject, URI id) {
+        JsonObject o = JsonValue.of(ls.config.schemasByURI.get(id)).requireObject();
+        new LoadingState(ls.config, ls.pointerSchemas, o, o, id, SchemaLocation.parseURI(id.toString()));
+        return o;
+    }
+
+    private JsonPointerEvaluator createPointerEvaluator(String absPointerString) {
+        if (isSameDocumentRef(absPointerString)) {
+            return JsonPointerEvaluator.forDocument(ls.rootSchemaJson(), absPointerString);
+        }
+        try {
+            Uri uri = Uri.parse(absPointerString);
+            if (ls.config.schemasByURI.containsKey(uri.asJavaURI())) {
+                JsonObject o = initJsonObjectWithId(ls.config.schemasByURI.get(uri.asJavaURI()), uri.asJavaURI());
+                return JsonPointerEvaluator.forDocument(o, "#");
+            } else if (ls.config.schemasByURI.containsKey(uri.toBeQueried)) {
+                JsonObject o = initJsonObjectWithId(ls.config.schemasByURI.get(uri.toBeQueried), uri.toBeQueried);
+                return JsonPointerEvaluator.forDocument(o, uri.fragment);
+            }
+        } catch (URISyntaxException e) {
+            throw ls.createSchemaException(e);
+        }
+        return JsonPointerEvaluator.forURL(schemaClient, absPointerString, ls);
+    }
+
     private boolean isSameDocumentRef(String ref) {
         return ref.startsWith("#");
     }
diff --git a/core/src/main/java/org/everit/json/schema/loader/SchemaLoader.java b/core/src/main/java/org/everit/json/schema/loader/SchemaLoader.java
@@ -71,6 +71,8 @@ public static class SchemaLoaderBuilder {
 
         RegexpFactory regexpFactory = new JavaUtilRegexpFactory();
 
+        Map<URI, Object> schemasByURI = null;
+
         public SchemaLoaderBuilder() {
             setSpecVersion(DRAFT_4);
         }
@@ -237,6 +239,14 @@ public SchemaLoaderBuilder regexpFactory(RegexpFactory regexpFactory) {
             this.regexpFactory = regexpFactory;
             return this;
         }
+
+        public SchemaLoaderBuilder registerSchemaByURI(URI uri, Object schema) {
+            if (schemasByURI == null) {
+                schemasByURI = new HashMap<>();
+            }
+            schemasByURI.put(uri, schema);
+            return this;
+        }
     }
 
     public static SchemaLoaderBuilder builder() {
@@ -307,6 +317,7 @@ public SchemaLoader(SchemaLoaderBuilder builder) {
         }
         this.config = new LoaderConfig(builder.schemaClient,
                 builder.formatValidators,
+                builder.schemasByURI,
                 specVersion,
                 builder.useDefaults,
                 builder.nullableSupport,
diff --git a/core/src/main/java/org/everit/json/schema/loader/Uri.java b/core/src/main/java/org/everit/json/schema/loader/Uri.java
@@ -0,0 +1,42 @@
+package org.everit.json.schema.loader;
+
+import static java.util.Objects.requireNonNull;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+class Uri {
+
+    static Uri parse(String str) throws URISyntaxException {
+        URI rawUri = new URI(str);
+        int poundIdx = str.indexOf('#');
+        String fragment;
+        URI toBeQueried;
+        if (poundIdx == -1) {
+            toBeQueried = rawUri;
+            fragment = "";
+        } else {
+            fragment = str.substring(poundIdx);
+            toBeQueried = new URI(str.substring(0, poundIdx));
+        }
+        return new Uri(toBeQueried, fragment);
+    }
+
+    URI toBeQueried;
+
+    String fragment;
+
+    private Uri(URI toBeQueried, String fragment) {
+        this.toBeQueried = requireNonNull(toBeQueried, "toBeQueried cannot be null");
+        this.fragment = requireNonNull(fragment, "fragment cannot be null");
+    }
+
+    URI asJavaURI() {
+        try {
+            return new URI(toBeQueried + fragment);
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}
diff --git a/core/src/test/java/org/everit/json/schema/loader/RegisteredURIResolutionTest.java b/core/src/test/java/org/everit/json/schema/loader/RegisteredURIResolutionTest.java
@@ -0,0 +1,63 @@
+package org.everit.json.schema.loader;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import org.everit.json.schema.ReferenceSchema;
+import org.everit.json.schema.ResourceLoader;
+import org.junit.Test;
+
+public class RegisteredURIResolutionTest {
+
+    private static final ResourceLoader LOADER = new ResourceLoader("/org/everit/jsonvalidator/registered-uris/");
+
+    @Test
+    public void success() throws URISyntaxException {
+        SchemaClient mock = mock(SchemaClient.class);
+        SchemaLoader loader = SchemaLoader.builder()
+                .schemaClient(mock)
+                .schemaJson(LOADER.readObj("ref-urn.json"))
+                .registerSchemaByURI(new URI("urn:uuid:a773c7a2-1a13-4f6a-a70d-694befe0ce63"), LOADER.readObj("schema-by-urn.json"))
+                .build();
+
+        ReferenceSchema actual = (ReferenceSchema) loader.load().build();
+
+        assertEquals("schema-by-urn", actual.getReferredSchema().getTitle());
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void urnWithFragment() throws URISyntaxException {
+        SchemaClient mock = mock(SchemaClient.class);
+        SchemaLoader loader = SchemaLoader.builder()
+                .schemaClient(mock)
+                .schemaJson(LOADER.readObj("ref-urn-fragment.json"))
+                .registerSchemaByURI(new URI("urn:uuid:a773c7a2-1a13-4f6a-a70d-694befe0ce63"), LOADER.readObj("schema-by-urn.json"))
+                .build();
+
+        ReferenceSchema actual = (ReferenceSchema) loader.load().build();
+
+        assertEquals("subschema-by-urn", actual.getReferredSchema().getTitle());
+        verifyNoMoreInteractions(mock);
+    }
+
+    @Test
+    public void httpURL() throws URISyntaxException {
+        SchemaClient mock = mock(SchemaClient.class);
+        SchemaLoader loader = SchemaLoader.builder()
+                .schemaClient(mock)
+                .schemaJson(LOADER.readObj("ref-example-org.json"))
+                .registerSchemaByURI(new URI("http://example.org"), LOADER.readObj("schema-by-urn.json"))
+                .build();
+
+        ReferenceSchema actual = (ReferenceSchema) loader.load().build();
+
+        assertEquals("schema-by-urn", actual.getReferredSchema().getTitle());
+        verifyNoMoreInteractions(mock);
+    }
+
+}
diff --git a/core/src/test/resources/org/everit/jsonvalidator/registered-uris/ref-example-org.json b/core/src/test/resources/org/everit/jsonvalidator/registered-uris/ref-example-org.json
@@ -0,0 +1,3 @@
+{
+  "$ref": "http://example.org"
+}
diff --git a/core/src/test/resources/org/everit/jsonvalidator/registered-uris/ref-urn-fragment.json b/core/src/test/resources/org/everit/jsonvalidator/registered-uris/ref-urn-fragment.json
@@ -0,0 +1,3 @@
+{
+  "$ref": "urn:uuid:a773c7a2-1a13-4f6a-a70d-694befe0ce63#/definitions/A"
+}
diff --git a/core/src/test/resources/org/everit/jsonvalidator/registered-uris/ref-urn.json b/core/src/test/resources/org/everit/jsonvalidator/registered-uris/ref-urn.json
@@ -0,0 +1,3 @@
+{
+  "$ref": "urn:uuid:a773c7a2-1a13-4f6a-a70d-694befe0ce63"
+}
diff --git a/core/src/test/resources/org/everit/jsonvalidator/registered-uris/schema-by-urn.json b/core/src/test/resources/org/everit/jsonvalidator/registered-uris/schema-by-urn.json
@@ -0,0 +1,8 @@
+{
+  "title": "schema-by-urn",
+  "definitions": {
+    "A": {
+      "title": "subschema-by-urn"
+    }
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "$ref": "http://example.org"`
	`3`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "$ref": "urn:uuid:a773c7a2-1a13-4f6a-a70d-694befe0ce63#/definitions/A"`
	`3`	`+}`