At last, the tests demonstrate that the custom types are being validated

Author: jmfernandez

core/src/main/java/org/everit/json/schema/AbstractCustomTypeSchema.java

@@ -29,4 +29,8 @@ protected AbstractCustomTypeSchema(Schema.Builder<? extends AbstractCustomTypeSc
      */
     public abstract Visitor buildVisitor(Object subject,ValidatingVisitor owner);
 
+    @Override void accept(Visitor visitor) {
+        visitor.visitCustomTypeSchema(this);
+    }
+
 }

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

@@ -10,6 +10,7 @@
 
 import java.net.URI;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import org.everit.json.schema.FormatValidator;
@@ -30,7 +31,9 @@ static LoaderConfig defaultV4Config() {
 
     final Map<String, FormatValidator> formatValidators;
 
-    final Map<String, Method> customTypes;
+    final Map<String, Method> customTypesMap;
+
+    final Map<String, List<String>> customTypesKeywordsMap;
 
     final Map<URI, Object> schemasByURI;
 
@@ -44,17 +47,19 @@ static LoaderConfig defaultV4Config() {
 
     LoaderConfig(SchemaClient schemaClient, Map<String, FormatValidator> formatValidators,
             SpecificationVersion specVersion, boolean useDefaults) {
-        this(schemaClient, formatValidators, emptyMap(), specVersion, useDefaults, false, new JavaUtilRegexpFactory(), emptyMap());
+        this(schemaClient, formatValidators, emptyMap(), specVersion, useDefaults, false, new JavaUtilRegexpFactory(), emptyMap(), emptyMap());
     }
 
     LoaderConfig(SchemaClient schemaClient, Map<String, FormatValidator> formatValidators,
             Map<URI, Object> schemasByURI,
             SpecificationVersion specVersion, boolean useDefaults, boolean nullableSupport,
             RegexpFactory regexpFactory,
-            Map<String,Method> customTypes) {
+            Map<String,Method> customTypesMap,
+            Map<String,List<String>> customTypesKeywordsMap) {
         this.schemaClient = requireNonNull(schemaClient, "schemaClient cannot be null");
         this.formatValidators = requireNonNull(formatValidators, "formatValidators cannot be null");
-        this.customTypes = requireNonNull(customTypes, "customTypes cannot be null");
+        this.customTypesMap = requireNonNull(customTypesMap, "customTypesMap cannot be null");
+        this.customTypesKeywordsMap = requireNonNull(customTypesKeywordsMap, "customTypesKeywordsMap cannot be null");
         if (schemasByURI == null) {
             this.schemasByURI = new HashMap<>();
         } else {

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

@@ -100,7 +100,7 @@ abstract class AbstractSchemaExtractor implements SchemaExtractor {
 
     protected JsonObject schemaJson;
 
-    private KeyConsumer consumedKeys;
+    protected KeyConsumer consumedKeys;
 
     final SchemaLoader defaultLoader;
 
@@ -240,11 +240,13 @@ private ConditionalSchema.Builder buildConditionalSchema() {
 }
 
 class TypeBasedSchemaExtractor extends AbstractSchemaExtractor {
-    private Map<String,Method> customTypes;
+    private Map<String,Method> customTypesMap;
+    private Map<String,List<String>> customTypesKeywordsMap;
 
-    TypeBasedSchemaExtractor(SchemaLoader defaultLoader,Map<String,Method> customTypes) {
+    TypeBasedSchemaExtractor(SchemaLoader defaultLoader, Map<String,Method> customTypesMap, Map<String,List<String>> customTypesKeywordsMap) {
         super(defaultLoader);
-        this.customTypes = customTypes;
+        this.customTypesMap = customTypesMap;
+        this.customTypesKeywordsMap = customTypesKeywordsMap;
     }
 
     @Override List<Schema.Builder<?>> extract() {
@@ -283,12 +285,24 @@ private Schema.Builder<?> loadForExplicitType(String typeString) {
         case "object":
             return buildObjectSchema();
         default:
-            if(customTypes.containsKey(typeString)) {
+            if(customTypesMap.containsKey(typeString)) {
                 // Calling the public static builder method using the
                 // Java reflection mechanisms
-                Method builderMethod = customTypes.get(typeString);
+                Method builderMethod = customTypesMap.get(typeString);
+                if(builderMethod==null) {
+                    throw new SchemaException(schemaJson.ls.locationOfCurrentObj(), format("type: [%s] builder creation has failed, as type was not found", typeString));
+                }
+                
+                List<String> typeKeywords = customTypesKeywordsMap.get(typeString);
+                if(typeKeywords==null) {
+                    throw new SchemaException(schemaJson.ls.locationOfCurrentObj(), format("type: [%s] builder creation has failed, as type was not found", typeString));
+                }
                 try {
-                    return (Schema.Builder<? extends AbstractCustomTypeSchema>) builderMethod.invoke(null);
+                    // Register the listened keywords
+                    typeKeywords.forEach(consumedKeys::keyConsumed);
+                    
+                    // Now, obtain the schema loader
+                    return (Schema.Builder<? extends AbstractCustomTypeSchema>) builderMethod.invoke(null,schemaJson.ls, config(), defaultLoader);
                 } catch(InvocationTargetException ite) {
                     throw new SchemaException(schemaJson.ls.locationOfCurrentObj(), format("type: [%s] builder creation has failed", typeString));
                 } catch(IllegalAccessException iae) {

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

@@ -9,6 +9,7 @@
 import static org.everit.json.schema.loader.SpecificationVersion.DRAFT_6;
 import static org.everit.json.schema.loader.SpecificationVersion.DRAFT_7;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 
@@ -74,7 +75,8 @@ public static class SchemaLoaderBuilder {
 
         RegexpFactory regexpFactory = new JavaUtilRegexpFactory();
 
-        Map<String,Method> customTypes = new HashMap<>();
+        Map<String,Method> customTypesMap = new HashMap<>();
+        Map<String,List<String>> customTypesKeywordsMap = new HashMap<>();
 
         Map<URI, Object> schemasByURI = null;
 
@@ -89,7 +91,7 @@ public SchemaLoaderBuilder() {
          *         a Map.Entry with the typeName and the class to register
          * @return {@code this}
          */
-        public SchemaLoaderBuilder addCustomType(Map.Entry<String,Class<? extends AbstractCustomTypeSchema>> entry) {
+        public SchemaLoaderBuilder addCustomType(Map.Entry<String,Class<?>> entry) {
             return addCustomType(entry.getKey(),entry.getValue());
         }
 
@@ -102,28 +104,54 @@ public SchemaLoaderBuilder addCustomType(Map.Entry<String,Class<? extends Abstra
          *         the class which implements the validation of this custom JSON Schema type
          * @return {@code this}
          */
-        public SchemaLoaderBuilder addCustomType(String typeName,Class<? extends AbstractCustomTypeSchema> clazz) {
+        public SchemaLoaderBuilder addCustomType(String typeName,Class<?> clazz) {
             typeName = requireNonNull(typeName, "the name of the custom type cannot be null");
             if(typeName.length() == 0) {
                     throw new IllegalArgumentException("the name of the custom type must be non-empty");
             }
+            
+            // Checking the pre-conditions
+            Method method = null;
             try {
-                Method method = clazz.getMethod("builder");
+                method = clazz.getMethod("schemaBuilderLoader", LoadingState.class, LoaderConfig.class, SchemaLoader.class);
                 int mods = method.getModifiers();
                 if(!Modifier.isStatic(mods) || !Modifier.isPublic(mods)) {
-                    throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' must have a public static 'builder()' method");
+                    throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' must have a public static 'schemaBuilderLoader(LoadingState ls, LoaderConfig config, SchemaLoader defaultLoader)' method");
                 }
                 Class<?> retClazz = method.getReturnType();
                 retClazz.asSubclass(Schema.Builder.class);
+            } catch(NoSuchMethodException nsme) {
+                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' must have a 'schemaBuilderLoader(LoadingState ls, LoaderConfig config, SchemaLoader defaultLoader)' method");
+            } catch(ClassCastException cce) {
+                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "': 'schemaBuilderLoader(LoadingState ls, LoaderConfig config, SchemaLoader defaultLoader)' method must return an instance of Schema.Builder");
+            }
+            
+            List<String> customTypeKeywords = null;
+            try {
+                Method kwMethod = clazz.getMethod("schemaKeywords");
+                int mods = method.getModifiers();
+                if(!Modifier.isStatic(mods) || !Modifier.isPublic(mods)) {
+                    throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' must have a public static 'schemaKeywords()' method");
+                }
+                Class<?> retClazz = kwMethod.getReturnType();
+                retClazz.asSubclass(List.class);
 
-                // If all is ok
-                customTypes.put(typeName,method);
-                return this;
+                // Now, obtain the list
+                customTypeKeywords = (List<String>)kwMethod.invoke(null);
             } catch(NoSuchMethodException nsme) {
-                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' must have a 'builder()' method");
+                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' must have a 'schemaKeywords()' method");
             } catch(ClassCastException cce) {
-                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "': 'builder()' method must return an instance of Schema.Builder");
+                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "': 'schemaKeywords()' method must return an instance of List<String>");
+            } catch(InvocationTargetException ite) {
+                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' failed invoking 'schemaKeywords()' method");
+            } catch(IllegalAccessException iae) {
+                throw new IllegalArgumentException("class '" + clazz.getName() + "', manager of custom type '" + typeName + "' failed invoking 'schemaKeywords()' method");
             }
+            
+            // If we are here, all is ok
+            customTypesMap.put(typeName,method);
+            customTypesKeywordsMap.put(typeName,customTypeKeywords);
+            return this;
         }
 
         /**
@@ -323,7 +351,7 @@ public static Schema load(final JSONObject schemaJson) {
      *         the custom types to use on the validation process
      * @return the created schema
      */
-    public static Schema load(final JSONObject schemaJson, final Map<String,Class<? extends AbstractCustomTypeSchema>> customTypes) {
+    public static Schema load(final JSONObject schemaJson, final Map<String,Class<?>> customTypes) {
         return SchemaLoader.load(schemaJson, new DefaultSchemaClient(), customTypes);
     }
 
@@ -351,10 +379,10 @@ public static Schema load(final JSONObject schemaJson, final SchemaClient schema
      *         the custom types to use on the validation process
      * @return the created schema
      */
-    public static Schema load(final JSONObject schemaJson, final SchemaClient schemaClient, final Map<String,Class<? extends AbstractCustomTypeSchema>> customTypes) {
+    public static Schema load(final JSONObject schemaJson, final SchemaClient schemaClient, final Map<String,Class<?>> customTypes) {
         SchemaLoaderBuilder builder = builder();
         if(customTypes != null) {
-            for(Map.Entry<String,Class<? extends AbstractCustomTypeSchema>> customTypeP: customTypes.entrySet()) {
+            for(Map.Entry<String,Class<?>> customTypeP: customTypes.entrySet()) {
                 builder.addCustomType(customTypeP);
             }
         }
@@ -405,7 +433,8 @@ public SchemaLoader(SchemaLoaderBuilder builder) {
                 builder.useDefaults,
                 builder.nullableSupport,
                 builder.regexpFactory,
-                builder.customTypes);
+                builder.customTypesMap,
+                builder.customTypesKeywordsMap);
         this.ls = new LoadingState(config,
                 builder.pointerSchemas,
                 effectiveRootSchemaJson,
@@ -474,7 +503,7 @@ private AdjacentSchemaExtractionState runSchemaExtractors(JsonObject o) {
                 new CombinedSchemaLoader(this),
                 new NotSchemaExtractor(this),
                 new ConstSchemaExtractor(this),
-                new TypeBasedSchemaExtractor(this,config.customTypes),
+                new TypeBasedSchemaExtractor(this,config.customTypesMap,config.customTypesKeywordsMap),
                 new PropertySnifferSchemaExtractor(this)
         );
         for (SchemaExtractor extractor : extractors) {

tests/vanilla/src/main/java/org/everit/json/schema/CustomTestSchema.java

@@ -2,9 +2,9 @@
 
 import java.io.IOException;
 import java.io.InputStreamReader;
+import java.util.List;
 
 import org.apache.commons.io.IOUtils;
-import org.everit.json.schema.loader.SchemaLoader;
 import org.everit.json.schema.Schema;
 import org.json.JSONObject;
 import org.json.JSONTokener;
@@ -21,14 +21,15 @@
 import org.everit.json.schema.regexp.Regexp;
 
 /**
+ * @author jmfernandez
  * {@code String} schema validator.
  */
 public class CustomTestSchema extends AbstractCustomTypeSchema {
 
     /**
      * Builder class for {@link CustomTestSchema}.
      */
-    public static class SchemaLoaderBuilder extends Schema.Builder<CustomTestSchema> {
+    public static class Builder extends Schema.Builder<CustomTestSchema> {
 
         private String rightValue;
 
@@ -37,16 +38,16 @@ public CustomTestSchema build() {
             return new CustomTestSchema(this);
         }
 
-        public SchemaLoaderBuilder rightValue(final String rightValue) {
+        public Builder rightValue(final String rightValue) {
             this.rightValue = rightValue;
             return this;
         }
     }
 
-    public static SchemaLoaderBuilder builder() {
-        return new SchemaLoaderBuilder();
+    public static Builder builder() {
+        return new Builder();
     }
-
+    
     private final String rightValue;
 
     public CustomTestSchema() {
@@ -59,15 +60,11 @@ public CustomTestSchema() {
      * @param builder
      *         the builder object containing validation criteria
      */
-    public CustomTestSchema(final SchemaLoaderBuilder builder) {
+    public CustomTestSchema(final Builder builder) {
         super(builder);
         this.rightValue = builder.rightValue;
     }
 
-    @Override void accept(Visitor visitor) {
-        visitor.visitCustomTypeSchema(this);
-    }
-
     @Override
     public Visitor buildVisitor(Object subject,ValidatingVisitor owner) {
         return new CustomTypeSchemaValidatingVisitor(subject, owner);

tests/vanilla/src/main/java/org/everit/json/schema/CustomTypeSchemaValidatingVisitor.java

@@ -22,17 +22,17 @@ public CustomTypeSchemaValidatingVisitor(Object subject, ValidatingVisitor owner
         this.owner = requireNonNull(owner, "failureReporter cannot be null");
     }
 
-    void visitCustomTypeSchema(CustomTestSchema customTestSchema) {
-        this.customTestSchema = customTestSchema;
+    void visitCustomTypeSchema(AbstractCustomTypeSchema customTestSchema) {
+        this.customTestSchema = (CustomTestSchema)customTestSchema;
         if (owner.passesTypeCheck(String.class, true, false)) {
             rightValueSubject = (String) subject;
-            visitRightValue(customTestSchema.rightValue());
+            visitRightValue(this.customTestSchema.rightValue());
         }
     }
 
     void visitRightValue(String rightValue) {
         if(rightValue != null && !rightValueSubject.equals(rightValue)) {
-            ValidationException violation = new ValidationException(customTestSchema,"'"+rightValue+"' is not the right value ('"+rightValueSubject+"')");
+            ValidationException violation = new ValidationException(customTestSchema,"'"+rightValueSubject+"' is not the right value ('"+rightValue+"')");
             owner.failure(violation);
         }
     }

tests/vanilla/src/main/java/org/everit/json/schema/CustomTypeTest.java

@@ -4,8 +4,10 @@
 import java.io.InputStreamReader;
 
 import org.apache.commons.io.IOUtils;
+import org.everit.json.schema.loader.CustomTestSchemaLoader;
 import org.everit.json.schema.loader.SchemaLoader;
 import org.everit.json.schema.Schema;
+import org.everit.json.schema.ValidationException;
 import org.json.JSONObject;
 import org.json.JSONTokener;
 import org.junit.Test;
@@ -35,19 +37,34 @@ public void validateCustomType() throws IOException {
             IOUtils.toString(
                 new InputStreamReader(getClass().getResourceAsStream("/org/everit/json/schema/customType/works.json")))
         ));
+	
+	// An easy way to register the custom types
+	HashMap<String,Class<?>> customTypes = new HashMap<>();
+	customTypes.put("customType",CustomTestSchemaLoader.class);
+        Schema schema = SchemaLoader.load(jsonSchema,customTypes);
+        
+        schema.validate(worksJson);
+    }
+
+
+    @Test(expected = ValidationException.class)
+    public void dontValidateCustomType() throws IOException {
+
+        JSONObject jsonSchema = new JSONObject(new JSONTokener(
+            IOUtils.toString(
+                new InputStreamReader(getClass().getResourceAsStream("/org/everit/json/schema/customType/schema.json")))
+        ));
 
         JSONObject failsJson = new JSONObject(new JSONTokener(
             IOUtils.toString(
                 new InputStreamReader(getClass().getResourceAsStream("/org/everit/json/schema/customType/fails.json")))
         ));
 
 	// An easy way to register the custom types
-	HashMap<String,AbstractCustomTypeSchema> customTypes = new HashMap<>();
-	customTypes.put("customType",CustomTestSchema.class);
+	HashMap<String,Class<?>> customTypes = new HashMap<>();
+	customTypes.put("customType",CustomTestSchemaLoader.class);
         Schema schema = SchemaLoader.load(jsonSchema,customTypes);
 
-        schema.validate(worksJson);
         schema.validate(failsJson);
     }
-
 }