using URI instances instead of Strings for representing URIs

Author: erosb

core/src/main/java/org/everit/json/schema/loader/SchemaLoader.java

@@ -15,6 +15,8 @@
  */
 package org.everit.json.schema.loader;
 
+import java.net.URI;
+import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -86,7 +88,7 @@ public static class SchemaLoaderBuilder {
 
     Map<String, ReferenceSchema.Builder> pointerSchemas = new HashMap<>();
 
-    String id;
+    URI id;
 
     Map<String, FormatValidator> formatValidators = new HashMap<>();
 
@@ -118,7 +120,23 @@ public SchemaLoaderBuilder httpClient(final SchemaClient httpClient) {
       return this;
     }
 
-    SchemaLoaderBuilder id(final String id) {
+    /**
+     * Sets the initial resolution scope of the schema. {@code id} and {@code $ref} attributes
+     * accuring in the schema will be resolved against this value.
+     *
+     * @param id
+     *          the initial (absolute) URI, used as the resolution scope.
+     * @return {@code this}
+     */
+    public SchemaLoaderBuilder resolutionScope(final String id) {
+      try {
+        return resolutionScope(new URI(id));
+      } catch (URISyntaxException e) {
+        throw new RuntimeException(e);
+      }
+    }
+
+    public SchemaLoaderBuilder resolutionScope(final URI id) {
       this.id = id;
       return this;
     }
@@ -198,7 +216,7 @@ public static Schema load(final JSONObject schemaJson) {
    */
   public static Schema load(final JSONObject schemaJson, final SchemaClient httpClient) {
     String schemaId = schemaJson.optString("id");
-    SchemaLoader loader = builder().id(schemaId)
+    SchemaLoader loader = builder().resolutionScope(schemaId)
         .schemaJson(schemaJson)
         .httpClient(httpClient)
         .build();
@@ -207,7 +225,7 @@ public static Schema load(final JSONObject schemaJson, final SchemaClient httpCl
 
   private final SchemaClient httpClient;
 
-  private String id = null;
+  private URI id = null;
 
   private final Map<String, ReferenceSchema.Builder> pointerSchemas;
 
@@ -250,7 +268,7 @@ public SchemaLoader(final SchemaLoaderBuilder builder) {
       final SchemaClient httpClient) {
     this(builder().schemaJson(schemaJson)
         .rootSchemaJson(rootSchemaJson)
-        .id(id)
+        .resolutionScope(id)
         .httpClient(httpClient)
         .pointerSchemas(pointerSchemas));
   }
@@ -517,7 +535,7 @@ private Schema.Builder<?> loadForType(final Object type) {
    * Returns a schema builder instance after looking up the JSON pointer.
    */
   private Schema.Builder<?> lookupReference(final String relPointerString, final JSONObject ctx) {
-    String absPointerString = ReferenceResolver.resolve(id, relPointerString);
+    String absPointerString = ReferenceResolver.resolve(id, relPointerString).toString();
     if (pointerSchemas.containsKey(absPointerString)) {
       return pointerSchemas.get(absPointerString);
     }
@@ -551,7 +569,7 @@ private boolean schemaHasAnyOf(final Collection<String> propNames) {
   }
 
   private SchemaLoaderBuilder selfBuilder() {
-    SchemaLoaderBuilder rval = builder().id(id).schemaJson(schemaJson)
+    SchemaLoaderBuilder rval = builder().resolutionScope(id).schemaJson(schemaJson)
         .rootSchemaJson(rootSchemaJson)
         .pointerSchemas(pointerSchemas)
         .httpClient(httpClient)

core/src/main/java/org/everit/json/schema/loader/internal/ReferenceResolver.java

@@ -15,9 +15,8 @@
  */
 package org.everit.json.schema.loader.internal;
 
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.Objects;
+import java.net.URI;
+import java.net.URISyntaxException;
 
 /**
  * Resolves an {@code id} or {@code ref} against a parent scope.
@@ -37,63 +36,30 @@ public final class ReferenceResolver {
    *          the new segment (complete URI, path, fragment etc) which must be resolved
    * @return the resolved URI
    */
-  public static String resolve(final String parentScope, final String encounteredSegment) {
-    return new ReferenceResolver(parentScope, encounteredSegment).resolve();
-  }
-
-  private final String parentScope;
-
-  private final String encounteredSegment;
-
-  private ReferenceResolver(final String parentScope, final String encounteredSegment) {
-    this.parentScope = Objects.requireNonNull(parentScope, "parentScope cannot be null");
-    this.encounteredSegment = Objects.requireNonNull(encounteredSegment,
-        "encounteredSegment cannot be null");
-  }
-
-  private String concat() {
-    return parentScope + encounteredSegment;
+  public static URI resolve(final URI parentScope, final String encounteredSegment) {
+    return parentScope.resolve(encounteredSegment);
   }
 
-  private String handlePathIdAttr() {
-    try {
-      URL parentScopeURL = new URL(parentScope);
-      StringBuilder newIdBuilder = new StringBuilder().append(parentScopeURL.getProtocol())
-          .append("://")
-          .append(parentScopeURL.getHost());
-      if (parentScopeURL.getPort() > -1) {
-        newIdBuilder.append(":").append(parentScopeURL.getPort());
-      }
-      newIdBuilder.append(removeTrailingSegmentFrom(parentScopeURL.getPath()))
-          .append("/")
-          .append(encounteredSegment);
-      return newIdBuilder.toString();
-    } catch (MalformedURLException e1) {
-      return concat();
-    }
-  }
-
-  private String nonfragmentIdAttr() {
+  /**
+   * Creates an absolute JSON pointer string based on a parent scope and a newly encountered pointer
+   * segment ({@code id} or {@code ref} value).
+   *
+   * @param parentScope
+   *          the most immediate parent scope that the resolution should be performed against
+   * @param encounteredSegment
+   *          the new segment (complete URI, path, fragment etc) which must be resolved
+   * @return the resolved URI
+   */
+  public static String resolve(final String parentScope, final String encounteredSegment) {
     try {
-      URL url = new URL(encounteredSegment);
-      return url.toExternalForm();
-    } catch (MalformedURLException e) {
-      return handlePathIdAttr();
-    }
-  }
-
-  private String removeTrailingSegmentFrom(final String path) {
-    if (path.isEmpty() || "/".equals(path)) {
-      return "";
+      return new URI(parentScope).resolve(encounteredSegment).toString();
+    } catch (URISyntaxException e) {
+      throw new RuntimeException(e);
     }
-    return path.substring(0, path.lastIndexOf('/'));
+    // return new ReferenceResolver(parentScope, encounteredSegment).resolve();
   }
 
-  private String resolve() {
-    if (encounteredSegment.startsWith("#")) {
-      return concat();
-    }
-    return nonfragmentIdAttr();
+  private ReferenceResolver() {
   }
 
 }

core/src/main/java/org/everit/json/schema/loader/internal/ResolutionScopeChangeListener.java

@@ -15,19 +15,20 @@
  */
 package org.everit.json.schema.loader.internal;
 
+import java.net.URI;
 import java.util.function.Consumer;
 
 /**
  * Event handler interface used by {@link TypeBasedMultiplexer} to notify client(s) (which is
  * currently a schema loader instance) about resolution scope changes.
  */
 @FunctionalInterface
-public interface ResolutionScopeChangeListener extends Consumer<String> {
+public interface ResolutionScopeChangeListener extends Consumer<URI> {
 
   @Override
-  default void accept(final String t) {
+  default void accept(final URI t) {
     resolutionScopeChanged(t);
   }
 
-  void resolutionScopeChanged(String newResolutionScope);
+  void resolutionScopeChanged(URI newResolutionScope);
 }

core/src/main/java/org/everit/json/schema/loader/internal/TypeBasedMultiplexer.java

@@ -15,6 +15,7 @@
  */
 package org.everit.json.schema.loader.internal;
 
+import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -68,7 +69,7 @@ private class IdModifyingTypeConsumerImpl extends OnTypeConsumerImpl<JSONObject>
     public TypeBasedMultiplexer then(final Consumer<JSONObject> consumer) {
       Consumer<JSONObject> wrapperConsumer = obj -> {
         if (obj.has("id") && obj.get("id") instanceof String) {
-          String origId = id;
+          URI origId = id;
           String idAttr = obj.getString("id");
           id = ReferenceResolver.resolve(id, idAttr);
           triggerResolutionScopeChange();
@@ -135,7 +136,7 @@ public TypeBasedMultiplexer then(final Consumer<E> consumer) {
 
   private final Object obj;
 
-  private String id = "";
+  private URI id;
 
   private final Collection<ResolutionScopeChangeListener> scopeChangeListeners = new ArrayList<>(1);
 
@@ -176,10 +177,10 @@ public TypeBasedMultiplexer(final String keyOfObj, final Object obj) {
    * @param id
    *          the scope id at the point where the multiplexer is initialized.
    */
-  public TypeBasedMultiplexer(final String keyOfObj, final Object obj, final String id) {
+  public TypeBasedMultiplexer(final String keyOfObj, final Object obj, final URI id) {
     this.keyOfObj = keyOfObj;
     this.obj = Objects.requireNonNull(obj, "obj cannot be null");
-    this.id = id == null ? "" : id;
+    this.id = id;
   }
 
   public void addResolutionScopeChangeListener(

core/src/test/java/org/everit/json/schema/loader/internal/TypeBasedMultiplexerTest.java

@@ -15,7 +15,13 @@
  */
 package org.everit.json.schema.loader.internal;
 
+import java.net.URI;
+import java.net.URISyntaxException;
+
 import org.everit.json.schema.SchemaException;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.junit.Test;
@@ -29,28 +35,52 @@ public void differentPortNum() {
         "http://x.y.z:8080/rootschema.json");
   }
 
+  private URI uri(final String uri) {
+    try {
+      return new URI(uri);
+    } catch (URISyntaxException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   @Test
   public void dispatchesIdChangeEvent() {
     JSONObject scopeChangingObj = objectWithId("changedId");
-    TypeBasedMultiplexer subject = new TypeBasedMultiplexer(null, scopeChangingObj, "orig");
+    TypeBasedMultiplexer subject =
+        new TypeBasedMultiplexer(null, scopeChangingObj, uri("http://orig"));
     ResolutionScopeChangeListener mockListener = Mockito.mock(ResolutionScopeChangeListener.class);
     subject.addResolutionScopeChangeListener(mockListener);
     subject.ifObject().then(o -> {
     }).requireAny();
-    Mockito.verify(mockListener).resolutionScopeChanged("origchangedId");
-    Mockito.verify(mockListener).resolutionScopeChanged("orig");
+    Mockito.verify(mockListener).resolutionScopeChanged(
+        Mockito.argThat(uriAsString("http://origchangedId")));
+    Mockito.verify(mockListener).resolutionScopeChanged(uri("http://orig"));
   }
 
   private void expectScopeChanges(final JSONObject subjectOfMultiplexing, final String newScope,
       final String origScope) {
     TypeBasedMultiplexer subject = new TypeBasedMultiplexer(null, subjectOfMultiplexing,
-        origScope);
+        uri(origScope));
     ResolutionScopeChangeListener mockListener = Mockito.mock(ResolutionScopeChangeListener.class);
     subject.addResolutionScopeChangeListener(mockListener);
     subject.ifObject().then(o -> {
     }).requireAny();
-    Mockito.verify(mockListener).resolutionScopeChanged(newScope);
-    Mockito.verify(mockListener).resolutionScopeChanged(origScope);
+    Mockito.verify(mockListener).resolutionScopeChanged(Mockito.argThat(uriAsString(newScope)));
+    Mockito.verify(mockListener).resolutionScopeChanged(uri(origScope));
+  }
+
+  private Matcher<URI> uriAsString(final String uri) {
+    return new TypeSafeMatcher<URI>() {
+
+      @Override
+      public void describeTo(final Description arg0) {
+      }
+
+      @Override
+      protected boolean matchesSafely(final URI actual) {
+        return actual.toString().equals(uri);
+      }
+    };
   }
 
   @Test
@@ -84,21 +114,25 @@ public void relpathThenFragment() {
     JSONObject innerObj = objectWithId("#bar");
     outerObj.put("innerObj", innerObj);
     TypeBasedMultiplexer outerMultiplexer = new TypeBasedMultiplexer(null, outerObj,
-        "http://x.y.z/rootschema.json");
+        uri("http://x.y.z/rootschema.json"));
     ResolutionScopeChangeListener outerListener = Mockito.mock(ResolutionScopeChangeListener.class);
     ResolutionScopeChangeListener innerListener = Mockito.mock(ResolutionScopeChangeListener.class);
     outerMultiplexer.addResolutionScopeChangeListener(outerListener);
-    outerMultiplexer.ifObject().then(obj -> {
-      TypeBasedMultiplexer innerMultiplexer = new TypeBasedMultiplexer(null, obj.get("innerObj"),
-          "http://x.y.z/otherschema.json");
-      innerMultiplexer.addResolutionScopeChangeListener(innerListener);
-      innerMultiplexer.ifObject().then(o -> {
-      }).requireAny();
-    }).requireAny();
-    Mockito.verify(outerListener).resolutionScopeChanged("http://x.y.z/otherschema.json");
-    Mockito.verify(innerListener).resolutionScopeChanged("http://x.y.z/otherschema.json#bar");
-    Mockito.verify(innerListener).resolutionScopeChanged("http://x.y.z/otherschema.json");
-    Mockito.verify(outerListener).resolutionScopeChanged("http://x.y.z/rootschema.json");
+    outerMultiplexer
+        .ifObject()
+        .then(
+            obj -> {
+              TypeBasedMultiplexer innerMultiplexer =
+                  new TypeBasedMultiplexer(null, obj.get("innerObj"),
+                      uri("http://x.y.z/otherschema.json"));
+              innerMultiplexer.addResolutionScopeChangeListener(innerListener);
+              innerMultiplexer.ifObject().then(o -> {
+              }).requireAny();
+            }).requireAny();
+    Mockito.verify(outerListener).resolutionScopeChanged(uri("http://x.y.z/otherschema.json"));
+    Mockito.verify(innerListener).resolutionScopeChanged(uri("http://x.y.z/otherschema.json#bar"));
+    Mockito.verify(innerListener).resolutionScopeChanged(uri("http://x.y.z/otherschema.json"));
+    Mockito.verify(outerListener).resolutionScopeChanged(uri("http://x.y.z/rootschema.json"));
   }
 
   @Test