Update -validator to 2.1.0, update code accordingly

fge · fge · commit b3d17a1e8057 · 2013-03-19T14:15:24.000+01:00
Remove ref expander for now.

Signed-off-by: Francis Galiegue &lt;fgaliegue@gmail.com&gt;
diff --git a/pom.xml b/pom.xml
@@ -70,7 +70,7 @@
         <dependency>
             <groupId>com.github.fge</groupId>
             <artifactId>json-schema-validator</artifactId>
-            <version>2.0.1</version>
+            <version>2.1.0</version>
         </dependency>
         <dependency>
             <groupId>com.github.reinert</groupId>
diff --git a/src/main/java/com/github/fge/avro/Avro2JsonSchemaProcessor.java b/src/main/java/com/github/fge/avro/Avro2JsonSchemaProcessor.java
@@ -4,19 +4,19 @@
 import com.github.fge.avro.translators.AvroTranslators;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.processing.Processor;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.CanonicalSchemaTree;
 import com.github.fge.jsonschema.tree.JsonTree;
+import com.github.fge.jsonschema.tree.SchemaTree;
 import com.github.fge.jsonschema.util.ValueHolder;
 import org.apache.avro.AvroRuntimeException;
 import org.apache.avro.Schema;
 
 public final class Avro2JsonSchemaProcessor
-    implements Processor<ValueHolder<JsonTree>, SchemaHolder>
+    implements Processor<ValueHolder<JsonTree>, ValueHolder<SchemaTree>>
 {
     @Override
-    public SchemaHolder process(final ProcessingReport report,
+    public ValueHolder<SchemaTree> process(final ProcessingReport report,
         final ValueHolder<JsonTree> input)
         throws ProcessingException
     {
@@ -35,6 +35,8 @@ public SchemaHolder process(final ProcessingReport report,
         AvroTranslators.getTranslator(avroType)
             .translate(avroSchema, tree, report);
 
-        return new SchemaHolder(new CanonicalSchemaTree(tree.getBaseNode()));
+        final SchemaTree schemaTree
+            = new CanonicalSchemaTree(tree.getBaseNode());
+        return ValueHolder.hold("schema", schemaTree);
     }
 }
diff --git a/src/main/java/com/github/fge/jjschema/JJSchemaFromSource.java b/src/main/java/com/github/fge/jjschema/JJSchemaFromSource.java
@@ -5,13 +5,14 @@
 import com.github.fge.compiler.CompilingException;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.processing.Processor;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
+import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 
 import java.io.File;
 
 public final class JJSchemaFromSource
-    implements Processor<SourceHolder, SchemaHolder>
+    implements Processor<SourceHolder, ValueHolder<SchemaTree>>
 {
     private static final JJSchemaFromSource INSTANCE = new JJSchemaFromSource();
 
@@ -28,7 +29,7 @@ private JJSchemaFromSource()
     }
 
     @Override
-    public SchemaHolder process(final ProcessingReport report,
+    public ValueHolder<SchemaTree> process(final ProcessingReport report,
         final SourceHolder input)
         throws ProcessingException
     {
diff --git a/src/main/java/com/github/fge/jjschema/JJSchemaProcessor.java b/src/main/java/com/github/fge/jjschema/JJSchemaProcessor.java
@@ -3,27 +3,29 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.processing.Processor;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingMessage;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.CanonicalSchemaTree;
+import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.reinert.jjschema.JsonSchemaGenerator;
 import com.github.reinert.jjschema.SchemaGeneratorBuilder;
 
 public final class JJSchemaProcessor
-    implements Processor<ClassHolder, SchemaHolder>
+    implements Processor<ClassHolder, ValueHolder<SchemaTree>>
 {
     private static final JsonSchemaGenerator GENERATOR
         = SchemaGeneratorBuilder.draftV4Schema().build();
 
     @Override
-    public SchemaHolder process(final ProcessingReport report,
+    public ValueHolder<SchemaTree> process(final ProcessingReport report,
         final ClassHolder input)
         throws ProcessingException
     {
         final ProcessingMessage message = input.newMessage();
         report.debug(message.message("processing"));
         final JsonNode node = GENERATOR.generateSchema(input.getValue());
-        return new SchemaHolder(new CanonicalSchemaTree(node));
+        final SchemaTree tree = new CanonicalSchemaTree(node);
+        return ValueHolder.hold("schema", tree);
     }
 }
diff --git a/src/main/java/com/github/fge/jjschema/JJSchemaValidator.java b/src/main/java/com/github/fge/jjschema/JJSchemaValidator.java
@@ -1,19 +1,20 @@
 package com.github.fge.jjschema;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.github.fge.jsonschema.cfg.LoadingConfiguration;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.library.DraftV4Library;
+import com.github.fge.jsonschema.load.RefResolver;
 import com.github.fge.jsonschema.load.SchemaLoader;
+import com.github.fge.jsonschema.load.configuration.LoadingConfiguration;
 import com.github.fge.jsonschema.processors.data.FullData;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
-import com.github.fge.jsonschema.processors.ref.RefResolver;
 import com.github.fge.jsonschema.processors.validation.ValidationChain;
 import com.github.fge.jsonschema.processors.validation.ValidationProcessor;
 import com.github.fge.jsonschema.report.ConsoleProcessingReport;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.JsonTree;
+import com.github.fge.jsonschema.tree.SchemaTree;
 import com.github.fge.jsonschema.tree.SimpleJsonTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 
 public final class JJSchemaValidator
 {
@@ -37,7 +38,7 @@ public void validate(final Class<?> c, final JsonNode instance)
     {
         final ProcessingReport report = new ConsoleProcessingReport();
         final ClassHolder classHolder = new ClassHolder(c);
-        final SchemaHolder schemaHolder
+        final ValueHolder<SchemaTree> schemaHolder
             = classToSchema.process(report, classHolder);
         final JsonTree tree = new SimpleJsonTree(instance);
         final FullData fullData = new FullData(schemaHolder.getValue(),
diff --git a/src/main/java/com/github/fge/jsonschema2avro/AvroWriterProcessor.java b/src/main/java/com/github/fge/jsonschema2avro/AvroWriterProcessor.java
@@ -3,8 +3,8 @@
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.processing.Processor;
 import com.github.fge.jsonschema.processing.ProcessorSelector;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
+import com.github.fge.jsonschema.tree.SchemaTree;
 import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.fge.jsonschema2avro.writers.ArrayWriter;
 import com.github.fge.jsonschema2avro.writers.EnumWriter;
@@ -18,7 +18,7 @@
 import static com.github.fge.jsonschema2avro.predicates.AvroPredicates.*;
 
 public final class AvroWriterProcessor
-    implements Processor<SchemaHolder, ValueHolder<Schema>>
+    implements Processor<ValueHolder<SchemaTree>, ValueHolder<Schema>>
 {
     private final Processor<AvroPayload, ValueHolder<Schema>> processor;
 
@@ -37,7 +37,7 @@ public AvroWriterProcessor()
 
     @Override
     public ValueHolder<Schema> process(final ProcessingReport report,
-        final SchemaHolder input)
+        final ValueHolder<SchemaTree> input)
         throws ProcessingException
     {
         final AvroPayload payload = new AvroPayload(input.getValue(), this);
diff --git a/src/main/java/com/github/fge/jsonschema2avro/writers/ArrayWriter.java b/src/main/java/com/github/fge/jsonschema2avro/writers/ArrayWriter.java
@@ -3,9 +3,9 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.jsonpointer.JsonPointer;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.fge.jsonschema2avro.AvroWriterProcessor;
 import org.apache.avro.Schema;
 
@@ -33,7 +33,8 @@ protected Schema generate(final AvroWriterProcessor writer,
             : JsonPointer.of("additionalItems");
 
         final SchemaTree subTree = tree.append(ptr);
-        final SchemaHolder input = new SchemaHolder(subTree);
+        final ValueHolder<SchemaTree> input
+            = ValueHolder.hold("schema", subTree);
         final Schema itemsSchema = writer.process(report, input).getValue();
         return Schema.createArray(itemsSchema);
     }
diff --git a/src/main/java/com/github/fge/jsonschema2avro/writers/MapWriter.java b/src/main/java/com/github/fge/jsonschema2avro/writers/MapWriter.java
@@ -2,9 +2,9 @@
 
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.jsonpointer.JsonPointer;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.fge.jsonschema2avro.AvroWriterProcessor;
 import org.apache.avro.Schema;
 
@@ -30,7 +30,8 @@ protected Schema generate(final AvroWriterProcessor writer,
         final ProcessingReport report, final SchemaTree tree)
         throws ProcessingException
     {
-        final SchemaHolder input = new SchemaHolder(tree.append(POINTER));
+        final ValueHolder<SchemaTree> input
+            = ValueHolder.hold("schema", tree.append(POINTER));
         final Schema valueSchema = writer.process(report, input).getValue();
         return Schema.createMap(valueSchema);
     }
diff --git a/src/main/java/com/github/fge/jsonschema2avro/writers/RecordWriter.java b/src/main/java/com/github/fge/jsonschema2avro/writers/RecordWriter.java
@@ -2,9 +2,9 @@
 
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.jsonpointer.JsonPointer;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.fge.jsonschema2avro.AvroWriterProcessor;
 import com.google.common.collect.Lists;
 import org.apache.avro.Schema;
@@ -33,12 +33,12 @@ protected Schema generate(final AvroWriterProcessor writer,
         final List<Schema.Field> fields = Lists.newArrayList();
 
         JsonPointer ptr;
-        SchemaHolder holder;
+        ValueHolder<SchemaTree> holder;
         Schema fieldSchema;
 
         for (final String name: list) {
             ptr = JsonPointer.of("properties", name);
-            holder = new SchemaHolder(tree.append(ptr));
+            holder = ValueHolder.hold("schema", tree.append(ptr));
             fieldSchema = writer.process(report, holder).getValue();
             fields.add(new Schema.Field(name, fieldSchema, null, null));
         }
diff --git a/src/main/java/com/github/fge/jsonschema2avro/writers/SimpleUnionWriter.java b/src/main/java/com/github/fge/jsonschema2avro/writers/SimpleUnionWriter.java
@@ -3,9 +3,9 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.jsonpointer.JsonPointer;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.fge.jsonschema2avro.AvroWriterProcessor;
 import com.google.common.collect.Lists;
 import org.apache.avro.Schema;
@@ -36,14 +36,14 @@ protected Schema generate(final AvroWriterProcessor writer,
         final int size = node.get(keyword).size();
 
         JsonPointer ptr;
-        SchemaHolder holder;
+        ValueHolder<SchemaTree> holder;
         Schema subSchema;
 
         final List<Schema> schemas = Lists.newArrayList();
 
         for (int index = 0; index < size; index++) {
             ptr = JsonPointer.of(keyword, index);
-            holder = new SchemaHolder(tree.append(ptr));
+            holder = ValueHolder.hold("schema", tree.append(ptr));
             subSchema = writer.process(report, holder).getValue();
             if (subSchema.getType() == Schema.Type.UNION)
                 throw new ProcessingException("union within union is illegal");
diff --git a/src/main/java/com/github/fge/jsonschema2avro/writers/TypeUnionWriter.java b/src/main/java/com/github/fge/jsonschema2avro/writers/TypeUnionWriter.java
@@ -4,10 +4,10 @@
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.github.fge.jsonschema.exceptions.ProcessingException;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
 import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.CanonicalSchemaTree;
 import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.github.fge.jsonschema2avro.AvroWriterProcessor;
 import com.google.common.collect.Lists;
 import org.apache.avro.Schema;
@@ -38,18 +38,18 @@ protected Schema generate(final AvroWriterProcessor writer,
         final JsonNode node = tree.getNode();
         final List<Schema> schemas = Lists.newArrayList();
 
-        for (final SchemaHolder holder: expand(node))
+        for (final ValueHolder<SchemaTree> holder: expand(node))
             schemas.add(writer.process(report, holder).getValue());
 
         return Schema.createUnion(schemas);
     }
 
-    private static List<SchemaHolder> expand(final JsonNode node)
+    private static List<ValueHolder<SchemaTree>> expand(final JsonNode node)
     {
         final ObjectNode common = node.deepCopy();
         final ArrayNode typeNode = (ArrayNode) common.remove("type");
 
-        final List<SchemaHolder> ret = Lists.newArrayList();
+        final List<ValueHolder<SchemaTree>> ret = Lists.newArrayList();
 
         ObjectNode schema;
         SchemaTree tree;
@@ -58,7 +58,7 @@ private static List<SchemaHolder> expand(final JsonNode node)
             schema = common.deepCopy();
             schema.put("type", element);
             tree = new CanonicalSchemaTree(schema);
-            ret.add(new SchemaHolder(tree));
+            ret.add(ValueHolder.hold("schema", tree));
         }
 
         return ret;
diff --git a/src/main/java/com/github/fge/jsonschema2pojo/DraftV3OnlySyntaxProcessor.java b/src/main/java/com/github/fge/jsonschema2pojo/DraftV3OnlySyntaxProcessor.java
@@ -5,16 +5,18 @@
 import com.github.fge.jsonschema.library.DraftV3Library;
 import com.github.fge.jsonschema.processing.Processor;
 import com.github.fge.jsonschema.processing.ProcessorMap;
-import com.github.fge.jsonschema.processors.data.SchemaHolder;
-import com.github.fge.jsonschema.processors.syntax.SyntaxProcessor;
 import com.github.fge.jsonschema.ref.JsonRef;
 import com.github.fge.jsonschema.report.ProcessingReport;
+import com.github.fge.jsonschema.syntax.SyntaxProcessor;
+import com.github.fge.jsonschema.tree.SchemaTree;
+import com.github.fge.jsonschema.util.ValueHolder;
 import com.google.common.base.Function;
 
 public final class DraftV3OnlySyntaxProcessor
-    implements Processor<SchemaHolder, SchemaHolder>
+    implements Processor<ValueHolder<SchemaTree>, ValueHolder<SchemaTree>>
 {
-    private final Processor<SchemaHolder, SchemaHolder> processor;
+    private final Processor<ValueHolder<SchemaTree>,  ValueHolder<SchemaTree>>
+        processor;
 
     public DraftV3OnlySyntaxProcessor()
     {
@@ -24,7 +26,8 @@ public DraftV3OnlySyntaxProcessor()
         final JsonRef draftv3
             = JsonRef.fromURI(SchemaVersion.DRAFTV3.getLocation());
 
-        final ProcessorMap<JsonRef, SchemaHolder, SchemaHolder> map
+        final ProcessorMap<JsonRef, ValueHolder<SchemaTree>,
+            ValueHolder<SchemaTree>> map
             = new SchemaMap()
                 .addEntry(draftv3, syntaxProcessor)
                 .addEntry(JsonRef.emptyRef(), syntaxProcessor)
@@ -34,36 +37,37 @@ public DraftV3OnlySyntaxProcessor()
     }
 
     @Override
-    public SchemaHolder process(final ProcessingReport report,
-        final SchemaHolder input)
+    public ValueHolder<SchemaTree> process(final ProcessingReport report,
+        final ValueHolder<SchemaTree> input)
         throws ProcessingException
     {
         return processor.process(report, input);
     }
 
-    private static final Processor<SchemaHolder, SchemaHolder> UNSUPPORTED
-        = new Processor<SchemaHolder, SchemaHolder>()
+    private static final Processor<ValueHolder<SchemaTree>,
+        ValueHolder<SchemaTree>> UNSUPPORTED
+        = new Processor<ValueHolder<SchemaTree>, ValueHolder<SchemaTree>>()
     {
         @Override
-        public SchemaHolder process(final ProcessingReport report,
-            final SchemaHolder input)
+        public ValueHolder<SchemaTree> process(final ProcessingReport report,
+            final ValueHolder<SchemaTree> input)
             throws ProcessingException
         {
             throw new UnsupportedVersionException();
         }
     };
 
     private static final class SchemaMap
-        extends ProcessorMap<JsonRef, SchemaHolder, SchemaHolder>
+        extends ProcessorMap<JsonRef, ValueHolder<SchemaTree>, ValueHolder<SchemaTree>>
     {
 
         @Override
-        protected Function<SchemaHolder, JsonRef> f()
+        protected Function<ValueHolder<SchemaTree>, JsonRef> f()
         {
-            return new Function<SchemaHolder, JsonRef>()
+            return new Function<ValueHolder<SchemaTree>, JsonRef>()
             {
                 @Override
-                public JsonRef apply(final SchemaHolder input)
+                public JsonRef apply(final ValueHolder<SchemaTree> input)
                 {
                     return input.getValue().getDollarSchema();
                 }
diff --git a/src/main/java/com/github/fge/jsonschema2pojo/JsonSchema2SourceCode.java b/src/main/java/com/github/fge/jsonschema2pojo/JsonSchema2SourceCode.java
diff --git a/src/main/java/com/github/fge/refexpand/MutableTree.java b/src/main/java/com/github/fge/refexpand/MutableTree.java
diff --git a/src/main/java/com/github/fge/refexpand/RefExpander.java b/src/main/java/com/github/fge/refexpand/RefExpander.java
diff --git a/src/main/java/com/github/fge/refexpand/SchemaExpander.java b/src/main/java/com/github/fge/refexpand/SchemaExpander.java
diff --git a/src/test/java/com/github/fge/avro/AvroTranslationsTest.java b/src/test/java/com/github/fge/avro/AvroTranslationsTest.java
diff --git a/src/test/java/com/github/fge/jsonschema2avro/AvroWriterProcessorTest.java b/src/test/java/com/github/fge/jsonschema2avro/AvroWriterProcessorTest.java
