implementing AdjacentSchemaExtractionState and integrating into SchemaLoader, also some testing improvements

Author: erosb

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

@@ -0,0 +1,39 @@
+package org.everit.json.schema.loader;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.everit.json.schema.Schema;
+
+class AdjacentSchemaExtractionState {
+
+    private final JsonObject context;
+
+    private final Set<Schema.Builder<?>> extractedSchemas;
+
+    AdjacentSchemaExtractionState(JsonObject context) {
+        this(context, new HashSet<>());
+    }
+
+    private AdjacentSchemaExtractionState(JsonObject context, Set<Schema.Builder<?>> extractedSchemas) {
+        this.context = context;
+        this.extractedSchemas = extractedSchemas;
+    }
+
+    AdjacentSchemaExtractionState reduce(ExtractionResult result) {
+        Set<Schema.Builder<?>> newExtractedSchemas = new HashSet<>(extractedSchemas.size() + result.extractedSchemas.size());
+        newExtractedSchemas.addAll(extractedSchemas);
+        newExtractedSchemas.addAll(result.extractedSchemas);
+        JsonObject projectedContext = new ProjectedJsonObject(context, result.consumedKeys);
+        return new AdjacentSchemaExtractionState(projectedContext, newExtractedSchemas);
+    }
+
+    public JsonObject projectedSchemaJson() {
+        return context;
+    }
+
+    public Collection<Schema.Builder<?>> extractedSchemaBuilders() {
+        return extractedSchemas;
+    }
+}

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

@@ -2,12 +2,13 @@
 
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.Function;
 
 import org.everit.json.schema.CombinedSchema;
@@ -42,16 +43,18 @@ public CombinedSchemaLoader(SchemaLoader defaultLoader) {
     }
 
     @Override
-    public Collection<Schema.Builder<?>> extract(LoadingState ls) {
-        List<String> presentKeys = COMB_SCHEMA_PROVIDERS.keySet().stream()
-                .filter(ls.schemaJson()::containsKey)
+    public ExtractionResult extract(JsonObject schemaJson) {
+        Set<String> presentKeys = COMB_SCHEMA_PROVIDERS.keySet().stream()
+                .filter(schemaJson::containsKey)
+                .collect(toSet());
+        Collection<Schema.Builder<?>> extractedSchemas = presentKeys.stream().map(key -> loadCombinedSchemaForKeyword(schemaJson, key))
                 .collect(toList());
-        return presentKeys.stream().map(key -> loadCombinedSchemaForKeyword(ls, key)).collect(toList());
+        return new ExtractionResult(presentKeys, extractedSchemas);
     }
 
-    private CombinedSchema.Builder loadCombinedSchemaForKeyword(LoadingState ls, String key) {
+    private CombinedSchema.Builder loadCombinedSchemaForKeyword(JsonObject schemaJson, String key) {
         Collection<Schema> subschemas = new ArrayList<>();
-        ls.schemaJson().require(key).requireArray()
+        schemaJson.require(key).requireArray()
                 .forEach((i, subschema) -> subschemas.add(defaultLoader.loadChild(subschema).build()));
         return COMB_SCHEMA_PROVIDERS.get(key).apply(subschemas);
     }

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

@@ -12,14 +12,13 @@
 import java.util.function.Function;
 
 import org.everit.json.schema.SchemaException;
-import org.json.JSONObject;
 
 /**
  * @author erosb
  */
-final class JsonObject extends JsonValue {
+class JsonObject extends JsonValue {
 
-    private final Map<String, Object> storage;
+    final Map<String, Object> storage;
 
     JsonObject(Map<String, Object> storage) {
         super(storage);

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

@@ -1,7 +1,10 @@
 package org.everit.json.schema.loader;
 
 import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singleton;
+import static java.util.Objects.requireNonNull;
+import static org.everit.json.schema.loader.ExtractionResult.EMPTY;
 
 import java.util.Collection;
 import java.util.HashSet;
@@ -10,23 +13,42 @@
 import org.everit.json.schema.EnumSchema;
 import org.everit.json.schema.Schema;
 
+class ExtractionResult {
+
+    static final ExtractionResult EMPTY = new ExtractionResult(emptySet(), emptySet());
+
+    final Set<String> consumedKeys;
+
+    final Collection<Schema.Builder<?>> extractedSchemas;
+
+    ExtractionResult(Set<String> consumedKeys, Collection<Schema.Builder<?>> extractedSchemas) {
+        this.consumedKeys = requireNonNull(consumedKeys, "consumedKeys cannot be null");
+        this.extractedSchemas = requireNonNull(extractedSchemas, "extractedSchemas cannot be null");
+    }
+
+    ExtractionResult(String consumedKeys, Collection<Schema.Builder<?>> extactedSchemas) {
+        this(singleton(consumedKeys), extactedSchemas);
+    }
+
+}
+
 interface SchemaExtractor {
 
-    Collection<Schema.Builder<?>> extract(LoadingState ls);
+    ExtractionResult extract(JsonObject schemaJson);
 
 }
 
 class EnumSchemaExtractor implements SchemaExtractor {
 
-    @Override public Collection<Schema.Builder<?>> extract(LoadingState ls) {
-        if (!ls.schemaJson().containsKey("enum")) {
-            return emptyList();
+    @Override public ExtractionResult extract(JsonObject schemaJson) {
+        if (!schemaJson.containsKey("enum")) {
+            return EMPTY;
         }
         EnumSchema.Builder builder = EnumSchema.builder();
         Set<Object> possibleValues = new HashSet<>();
-        ls.schemaJson().require("enum").requireArray().forEach((i, item) -> possibleValues.add(item.unwrap()));
+        schemaJson.require("enum").requireArray().forEach((i, item) -> possibleValues.add(item.unwrap()));
         builder.possibleValues(possibleValues);
-        return asList(builder);
+        return new ExtractionResult("enum", asList(builder));
     }
 
 }

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

@@ -412,9 +412,17 @@ private Schema.Builder loadSchemaBoolean(Boolean rawBoolean) {
     }
 
     private Schema.Builder loadSchemaObject(JsonObject o) {
-        List<Schema.Builder> extractedSchemas = new ArrayList<>(1);
+        Collection<Schema.Builder<?>> extractedSchemas = new ArrayList<>(1);
         List<SchemaExtractor> extractors = asList(new EnumSchemaExtractor(), new CombinedSchemaLoader(this));
-        extractors.stream().map(extractor -> extractor.extract(ls)).forEach(extractedSchemas::addAll);
+        //        extractors.stream().map(extractor -> extractor.extract(o)).forEach(extractedSchemas::addAll);
+
+        AdjacentSchemaExtractionState state = new AdjacentSchemaExtractionState(o);
+        for (SchemaExtractor extractor : extractors) {
+            ExtractionResult result = extractor.extract(state.projectedSchemaJson());
+            state = state.reduce(result);
+        }
+        extractedSchemas = state.extractedSchemaBuilders();
+
         //////////////////////
         Schema.Builder builder;
         if (ls.schemaJson().containsKey("const") && (config.specVersion != DRAFT_4)) {
@@ -438,7 +446,7 @@ private Schema.Builder loadSchemaObject(JsonObject o) {
         if (extractedSchemas.isEmpty()) {
             effectiveReturnedSchema = EmptySchema.builder();
         } else if (extractedSchemas.size() == 1) {
-            effectiveReturnedSchema = extractedSchemas.get(0);
+            effectiveReturnedSchema = extractedSchemas.iterator().next();
         } else {
             Collection<Schema> built = extractedSchemas.stream()
                     .map(Schema.Builder::build)

core/src/test/java/org/everit/json/schema/loader/AdjacentSchemaExtractionStateTest.java

@@ -0,0 +1,28 @@
+package org.everit.json.schema.loader;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singleton;
+import static org.junit.Assert.assertEquals;
+
+import org.everit.json.schema.ConstSchema;
+import org.junit.Test;
+
+import com.google.common.collect.ImmutableMap;
+
+public class AdjacentSchemaExtractionStateTest {
+
+    @Test
+    public void testReduce() {
+        AdjacentSchemaExtractionState original = new AdjacentSchemaExtractionState(JsonValue.of(ImmutableMap.builder()
+                .put("const", "2")
+                .put("minimum", 1)
+                .build()
+        ).requireObject());
+        ConstSchema.ConstSchemaBuilder schemaBuilder = ConstSchema.builder().permittedValue("2");
+
+        AdjacentSchemaExtractionState actual = original.reduce(new ExtractionResult("const", asList(schemaBuilder)));
+
+        assertEquals(singleton(schemaBuilder), actual.extractedSchemaBuilders());
+        assertEquals(singleton("minimum"), actual.projectedSchemaJson().keySet());
+    }
+}

core/src/test/java/org/everit/json/schema/loader/CombinedSchemaLoaderTest.java

@@ -65,10 +65,11 @@ public void combinedSchemaWithMultipleBaseSchemas() {
     @Test
     public void multipleCombinedSchemasAtTheSameNestingLevel() {
         SchemaLoader defaultLoader = SchemaLoader.builder().schemaJson(get("multipleKeywords")).build();
-        JsonValue json = JsonValue.of(get("multipleKeywords"));
+        JsonObject json = JsonValue.of(get("multipleKeywords")).requireObject();
         new LoadingState(LoaderConfig.defaultV4Config(), emptyMap(), json, json, null, emptyList());
         CombinedSchemaLoader subject = new CombinedSchemaLoader(defaultLoader);
-        Set<Schema> actual = new HashSet<>(subject.extract(json.ls).stream().map(builder -> builder.build()).collect(toList()));
+        Set<Schema> actual = new HashSet<>(
+                subject.extract(json).extractedSchemas.stream().map(builder -> builder.build()).collect(toList()));
         HashSet<CombinedSchema> expected = new HashSet<>(asList(
                 CombinedSchema.allOf(singletonList(BooleanSchema.INSTANCE)).build(),
                 CombinedSchema.anyOf(singletonList(StringSchema.builder().build())).build()

tests/src/test/java/org/everit/json/schema/IssueTest.java

@@ -1,6 +1,7 @@
 package org.everit.json.schema;
 
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -12,6 +13,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -184,9 +186,16 @@ private void validate(final File file, final Schema schema, final boolean should
             Optional<File> expectedFile = fileByName("expectedException.json");
             if (expectedFile.isPresent()) {
                 if (!checkExpectedValues(expectedFile.get(), thrown)) {
+                    expectedFailureList.stream()
+                            .filter(exp -> !validationFailureList.contains(exp))
+                            .forEach(System.out::println);
+                    System.out.println("--");
+                    validationFailureList.stream()
+                            .filter(exp -> !expectedFailureList.contains(exp))
+                            .forEach(System.out::println);
                     Assert.fail("Validation failures do not match expected values: \n" +
-                            "Expected: " + expectedFailureList + ",\nActual:   " +
-                            validationFailureList);
+                            "Expected: " + expectedFailureList.stream().collect(joining("\n\t")) + ",\nActual:   " +
+                            validationFailureList.stream().collect(joining("\n\t")));
                 }
             }
         }
@@ -234,20 +243,19 @@ private Object loadJsonFile(final File file) {
      */
     private boolean checkExpectedValues(final File expectedExceptionsFile,
             final ValidationException ve) {
-
         // Read the expected values from user supplied file
         Object expected = loadJsonFile(expectedExceptionsFile);
         expectedFailureList = new ArrayList<String>();
         // NOTE: readExpectedValues() will update expectedFailureList
         readExpectedValues((JSONObject) expected);
 
         // Read the actual validation failures into a list
-        validationFailureList = new ArrayList<String>();
+        validationFailureList = new ArrayList<>();
         // NOTE: processValidationFailures() will update validationFailureList
         processValidationFailures(ve);
 
         // Compare expected to actual
-        return expectedFailureList.equals(validationFailureList);
+        return new HashSet<>(expectedFailureList).equals(new HashSet<>(validationFailureList));
     }
 
     // Recursively process the ValidationExceptions, which can contain lists

tests/src/test/resources/org/everit/json/schema/issues/issue174/expectedException.json

@@ -0,0 +1,36 @@
+{
+  "causingExceptions": [
+    {
+      "causingExceptions": [
+        {
+          "causingExceptions": [
+            {
+              "causingExceptions": [],
+              "message": "#/prop: 4 is not a valid enum value"
+            }
+          ],
+          "message": "#/prop: #: only 1 subschema matches out of 2"
+        },
+        {
+          "causingExceptions": [],
+          "message": "#/prop: 4 is not less or equal to 0"
+        },
+        {
+          "causingExceptions": [],
+          "message": "#/prop: subject must not be valid against schema {}"
+        }
+      ],
+      "message": "#/prop: #: 0 subschemas matched instead of one"
+    },
+    {
+      "causingExceptions": [
+        {
+          "causingExceptions": [],
+          "message": "#/prop: 4 is not a multiple of 3"
+        }
+      ],
+      "message": "#/prop: #: only 1 subschema matches out of 2"
+    }
+  ],
+  "message": "#/prop: #: only 0 subschema matches out of 2"
+}