added ReferenceSchema for handling self-schema references. 263/261 tests passing, all needs a cleanup

Author: erosb

core/src/main/java/org/everit/jsonvalidator/EmptySchema.java

@@ -22,8 +22,12 @@ public class EmptySchema extends Schema {
 
   public static final EmptySchema INSTANCE = new EmptySchema(builder());
 
-  public static class Builder extends Schema.Builder {
+  /**
+   * Builder class for {@link EmptySchema}.
+   */
+  public static class Builder extends Schema.Builder<EmptySchema> {
 
+    @Override
     public EmptySchema build() {
       return new EmptySchema(this);
     }

core/src/main/java/org/everit/jsonvalidator/ReferenceSchema.java

@@ -0,0 +1,48 @@
+package org.everit.jsonvalidator;
+
+public class ReferenceSchema extends Schema {
+
+  public static class Builder extends Schema.Builder {
+
+    private ReferenceSchema retval;
+
+    @Override
+    public ReferenceSchema build() {
+      if (retval == null) {
+        retval = new ReferenceSchema(this);
+      }
+      return retval;
+    }
+
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  private Schema referredSchema;
+
+  public ReferenceSchema(final Builder builder) {
+    super(builder);
+  }
+
+  @Override
+  void validate(final Object subject) {
+    if (referredSchema == null) {
+      throw new IllegalStateException("referredSchema must be injected before validation");
+    }
+    referredSchema.validate(subject);
+  }
+
+  public Schema getReferredSchema() {
+    return referredSchema;
+  }
+
+  public void setReferredSchema(final Schema referredSchema) {
+    if (this.referredSchema != null) {
+      throw new IllegalStateException("referredSchema can be injected only once");
+    }
+    this.referredSchema = referredSchema;
+  }
+
+}

core/src/main/java/org/everit/jsonvalidator/loader/SchemaLoader.java

@@ -41,6 +41,7 @@
 import org.everit.jsonvalidator.NumberSchema;
 import org.everit.jsonvalidator.ObjectSchema;
 import org.everit.jsonvalidator.ObjectSchema.Builder;
+import org.everit.jsonvalidator.ReferenceSchema;
 import org.everit.jsonvalidator.Schema;
 import org.everit.jsonvalidator.SchemaException;
 import org.everit.jsonvalidator.StringSchema;
@@ -82,7 +83,11 @@ public class SchemaLoader {
   }
 
   public static Schema load(final JSONObject schemaJson) {
-    return new SchemaLoader(schemaJson.optString("id"), schemaJson, schemaJson).load().build();
+    SchemaLoader loader = new SchemaLoader(schemaJson.optString("id"), schemaJson, schemaJson, null);
+    Schema.Builder<?> schemaBuilder = loader.load();
+    Schema schema = schemaBuilder.build();
+    loader.rootReferences.forEach(ref -> ref.build().setReferredSchema(schema));
+    return schema;
 
   }
 
@@ -183,17 +188,20 @@ TypeBasedMultiplexer typeMultiplexer(final String keyOfObj, final Object obj) {
     return new TypeBasedMultiplexer(keyOfObj, obj);
   }
 
+  private final Collection<ReferenceSchema.Builder> rootReferences;
+
   private String id = null;
 
   private final JSONObject schemaJson;
 
   private final JSONObject rootSchemaJson;
 
   public SchemaLoader(final String id, final JSONObject schemaJson,
-      final JSONObject rootSchemaJson) {
+      final JSONObject rootSchemaJson, final Collection<ReferenceSchema.Builder> rootReferences) {
     this.schemaJson = Objects.requireNonNull(schemaJson, "schemaJson cannot be null");
     this.rootSchemaJson = Objects.requireNonNull(rootSchemaJson, "rootSchemaJson cannot be null");
     this.id = id;
+    this.rootReferences = rootReferences == null ? new ArrayList<>() : rootReferences;
   }
 
   private void addDependencies(final Builder builder, final JSONObject deps) {
@@ -343,7 +351,7 @@ private <E> void ifPresent(final String key, final Class<E> expectedType,
   }
 
   /**
-   * Populates a {@code Schema} instance from the {@code schemaJson} schema definition.
+   * Populates a {@code Schema.Builder} instance from the {@code schemaJson} schema definition.
    */
   public Schema.Builder<?> load() {
     Schema.Builder<?> builder;
@@ -385,7 +393,7 @@ private EnumSchema.Builder buildEnumSchema() {
   }
 
   private Schema.Builder<?> loadChild(final JSONObject childJson) {
-    return new SchemaLoader(id, childJson, rootSchemaJson).load();
+    return new SchemaLoader(id, childJson, rootSchemaJson, rootReferences).load();
   }
 
   private Schema.Builder<?> loadForExplicitType(final String typeString) {
@@ -411,7 +419,9 @@ private Schema.Builder<?> loadForExplicitType(final String typeString) {
 
   private Schema.Builder<?> lookupReference(final String relPointerString) {
     if (relPointerString.equals("#")) {
-      throw new UnsupportedOperationException("recursive reference");
+      ReferenceSchema.Builder rval = new ReferenceSchema.Builder();
+      rootReferences.add(rval);
+      return rval;
     }
     JSONPointer pointer;
     String absPointerString = id + relPointerString;
@@ -421,7 +431,8 @@ private Schema.Builder<?> lookupReference(final String relPointerString) {
       pointer = JSONPointer.forURL(HttpClients.createDefault(), absPointerString);
     }
     QueryResult result = pointer.query();
-    return new SchemaLoader(id, result.getQueryResult(), result.getContainingDocument()).load();
+    return new SchemaLoader(id, result.getQueryResult(), result.getContainingDocument(),
+        rootReferences).load();
   }
 
   private boolean schemaHasAnyOf(final Collection<String> propNames) {

core/src/test/java/org/everit/jsonvalidator/ReferenceSchemaTest.java

@@ -0,0 +1,22 @@
+package org.everit.jsonvalidator;
+
+import org.everit.jsonvalidator.ReferenceSchema.Builder;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ReferenceSchemaTest {
+
+  @Test
+  public void constructorMustRunOnlyOnce() {
+    Builder builder = ReferenceSchema.builder();
+    Assert.assertSame(builder.build(), builder.build());
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void setterShouldWorkOnlyOnce() {
+    ReferenceSchema subject = ReferenceSchema.builder().build();
+    subject.setReferredSchema(BooleanSchema.INSTANCE);
+    subject.setReferredSchema(BooleanSchema.INSTANCE);
+  }
+
+}

core/src/test/java/org/everit/jsonvalidator/loader/SchemaLoaderTest.java

@@ -35,7 +35,6 @@
 import org.json.JSONTokener;
 import org.junit.Assert;
 import org.junit.BeforeClass;
-import org.junit.Ignore;
 import org.junit.Test;
 
 public class SchemaLoaderTest {
@@ -44,32 +43,32 @@ public class SchemaLoaderTest {
 
   @Test
   public void typeBasedMultiplexerTest() {
-    SchemaLoader loader = new SchemaLoader(null, new JSONObject(), new JSONObject());
+    SchemaLoader loader = new SchemaLoader(null, new JSONObject(), new JSONObject(), null);
     loader.typeMultiplexer(new JSONObject())
-        .ifObject().then(jsonObj -> {
-        })
-        .ifIs(JSONArray.class).then(jsonArr -> {
-        })
-        .orElse(obj -> {
-        });
+    .ifObject().then(jsonObj -> {
+    })
+    .ifIs(JSONArray.class).then(jsonArr -> {
+    })
+    .orElse(obj -> {
+    });
 
     loader.typeMultiplexer(new JSONObject())
-        .ifObject().then(jsonObj -> {
-        })
-        .ifIs(JSONArray.class).then(jsonArr -> {
-        })
-        .requireAny();
+    .ifObject().then(jsonObj -> {
+    })
+    .ifIs(JSONArray.class).then(jsonArr -> {
+    })
+    .requireAny();
   }
 
   @Test(expected = SchemaException.class)
   public void typeBasedMultiplexerFailure() {
-    SchemaLoader loader = new SchemaLoader(null, new JSONObject(), new JSONObject());
+    SchemaLoader loader = new SchemaLoader(null, new JSONObject(), new JSONObject(), null);
     loader.typeMultiplexer("foo")
-        .ifObject().then(o -> {
-        })
-        .ifIs(JSONArray.class).then(o -> {
-        })
-        .requireAny();
+    .ifObject().then(o -> {
+    })
+    .ifIs(JSONArray.class).then(o -> {
+    })
+    .requireAny();
   }
 
   @BeforeClass
@@ -336,7 +335,6 @@ public void emptySchemaWithDefault() {
   }
 
   @Test
-  @Ignore
   public void selfRecursiveSchema() {
     SchemaLoader.load(get("selfRecursiveSchema"));
   }