Change SchemaWalker

Issue #41 continued.

While not as generic as it could be (it will probably get more generic than that
later), the need here is to process the current schema before going any further.

Make SchemaWalker abstract. Require implementations to implement one method,
processCurrent(ProcessingReport, SchemaTree), so that whatever is needed to be
"done to the schema" is done _before_ walking further.

Signed-off-by: Francis Galiegue <[email protected]>

Author: fge

src/main/java/com/github/fge/jsonschema/processors/walk/KeywordWalker.java renamed to src/main/java/com/github/fge/jsonschema/processors/walk/PointerCollector.java

@@ -17,16 +17,12 @@
 
 package com.github.fge.jsonschema.processors.walk;
 
-import com.github.fge.jsonschema.exceptions.ProcessingException;
 import com.github.fge.jsonschema.jsonpointer.JsonPointer;
-import com.github.fge.jsonschema.report.ProcessingReport;
 import com.github.fge.jsonschema.tree.SchemaTree;
 
 import java.util.Collection;
 
-public interface KeywordWalker
+public interface PointerCollector
 {
-    void walk(final Collection<JsonPointer> pointers,
-        final ProcessingReport report, final SchemaTree tree)
-        throws ProcessingException;
+    void collect(final Collection<JsonPointer> pointers, final SchemaTree tree);
 }

src/main/java/com/github/fge/jsonschema/processors/walk/SchemaWalker.java

@@ -23,70 +23,58 @@
 import com.github.fge.jsonschema.library.Dictionary;
 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.SchemaTree;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-import com.google.common.collect.Ordering;
 import com.google.common.collect.Sets;
 
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
-
-import static com.github.fge.jsonschema.messages.SyntaxMessages.*;
 
 /*
  * NOTE NOTE NOTE: the schema MUST be valid at this point
  */
-public final class SchemaWalker
+public abstract class SchemaWalker
     implements Processor<SchemaHolder, SchemaHolder>
 {
-    private final Map<String, KeywordWalker> walkers;
+    private final Map<String, PointerCollector> collectors;
 
-    public SchemaWalker(final Dictionary<KeywordWalker> dict)
+    protected SchemaWalker(final Dictionary<PointerCollector> dict)
     {
-        walkers = dict.entries();
+        collectors = dict.entries();
     }
 
     @Override
-    public SchemaHolder process(final ProcessingReport report,
+    public final SchemaHolder process(final ProcessingReport report,
         final SchemaHolder input)
         throws ProcessingException
     {
         walk(report, input.getValue());
         return input;
     }
 
+    public abstract void processCurrent(final ProcessingReport report,
+        final SchemaTree tree)
+        throws ProcessingException;
+
     private void walk(final ProcessingReport report, final SchemaTree tree)
         throws ProcessingException
     {
+        processCurrent(report, tree);
         final JsonNode node = tree.getNode();
 
-        /*
-         * Grab all walkers and object member names. Retain walkers only for
-         * registered keywords, and remove from the member names set what is in
-         * the walkers' key set: if non empty, some walkers are missing (on
-         * purpose or not), report them.
-         */
-        final Map<String, KeywordWalker> map = Maps.newTreeMap();
-        map.putAll(walkers);
-
-        final Set<String> fieldNames = Sets.newHashSet(node.fieldNames());
-        map.keySet().retainAll(fieldNames);
-        fieldNames.removeAll(map.keySet());
+        final Map<String, PointerCollector> map = Maps.newTreeMap();
+        map.putAll(collectors);
 
-        if (!fieldNames.isEmpty())
-            report.warn(newMsg(tree).message(UNKNOWN_KEYWORDS)
-                .put("ignored", Ordering.natural().sortedCopy(fieldNames)));
+        map.keySet().retainAll(Sets.newHashSet(node.fieldNames()));
 
         /*
-         * Now, walk each keyword, and collect pointers for further processing.
+         * Collect pointers for further processing.
          */
         final List<JsonPointer> pointers = Lists.newArrayList();
-        for (final KeywordWalker walker: map.values())
-            walker.walk(pointers, report, tree);
+        for (final PointerCollector collector: map.values())
+            collector.collect(pointers, tree);
 
         /*
          * Operate on these pointers.
@@ -95,11 +83,6 @@ private void walk(final ProcessingReport report, final SchemaTree tree)
             walk(report, tree.append(pointer));
     }
 
-    private static ProcessingMessage newMsg(final SchemaTree tree)
-    {
-        return new ProcessingMessage().put("schema", tree);
-    }
-
     @Override
     public String toString()
     {