merging master

Author: erosb

README.md

@@ -9,6 +9,8 @@
 * [Draft 4 or Draft 6?](#draft-4-or-draft-6)
 * [Investigating failures](#investigating-failures)
   * [JSON report of the failures](#json-report-of-the-failures)
+* [Eary failure mode](#early-failure-mode)
+* [Default values](#default-values)
 * [Format validators](#format-validators)
   * [Example](#example)
 * [Resolution scopes](#resolution-scopes)
@@ -40,7 +42,7 @@ Add the JitPack repository and the dependency to your `pom.xml` as follows:
 <dependency>
     <groupId>com.github.everit-org.json-schema</groupId>
     <artifactId>org.everit.json.schema</artifactId>
-    <version>1.6.1</version>
+    <version>1.7.0</version>
 </dependency>
 ...
 <repositories>
@@ -191,6 +193,7 @@ This will print the following output:
 #/rectangle/a: -5.0 is not higher or equal to 0
 #/rectangle/b: expected type: Number, found: String
 ```
+
 ### JSON report of the failures
 
 Since version `1.4.0` it is possible to print the `ValidationException` instances as
@@ -208,6 +211,61 @@ following keys:
 Please take into account that the complete failure report is a *hierarchical tree structure*: sub-causes of a cause can
 be obtained using `#getCausingExceptions()` .  
 
+## Early failure mode
+
+By default the validation error reporting in collecting mode (see the "Investigating failures" chapter). That is convenient for having a
+detailed error report, but under some circumstances it is more appropriate to stop the validation when a failure is found without
+checking the rest of the JSON document. To toggle this fast-failing validation mode
+ * you have to explicitly build a `Validator` instance for your schema instead of calling `Schema#validate(input)`
+ * you have to call the `failEarly()` method of `ValidatorBuilder`
+ 
+Example:
+
+```java
+import org.everit.json.schema.Validator;
+...
+Validator validator = Validator.builder()
+	.failEarly()
+	.build();
+validator.performValidation(schema, input);
+```
+
+_Note: the `Validator` class is immutable and thread-safe, so you don't have to create a new one for each validation, it is enough
+to configure it only once._
+
+
+## Default values
+
+The JSON Schema specification defines the "default" keyword for denoting default values, though it doesn't explicitly state how it should
+affect the validation process. By default this library doesn't set the default values, but if you need this feature, you can turn it on
+by the `SchemaLoaderBuilder#useDefaults(boolean)` method, before loading the schema:
+
+```json
+{
+  "properties": {
+    "prop": {
+      "type": "number",
+      "default": 1
+    }
+  }
+}
+```
+
+
+```java
+JSONObject input = new JSONObject("{}");
+System.out.println(input.get("prop")); // prints null
+Schema schema = SchemaLoader.builder()
+	.useDefaults(true)
+	.schemaJson(rawSchema)
+	.build()
+	.load().build();
+schema.validate(input);
+System.out.println(input.get("prop")); // prints 1
+```
+
+If there are some properties missing from `input` which have `"default"` values in the schema, then they will be set by the validator
+during validation.
 
 ## Format validators
 

core/pom.xml

@@ -21,7 +21,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.everit.json</groupId>
     <artifactId>org.everit.json.schema</artifactId>
-    <version>1.7.0-SNAPSHOT</version>
+    <version>1.7.0</version>
     <packaging>bundle</packaging>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -136,7 +136,7 @@
         <dependency>
             <groupId>org.json</groupId>
             <artifactId>json</artifactId>
-            <version>20171018</version>
+            <version>20180130</version>
         </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>

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

@@ -30,11 +30,7 @@ public ArraySchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
     }
 
     @Override void visitArraySchema(ArraySchema arraySchema) {
-        if (!(subject instanceof JSONArray)) {
-            if (arraySchema.requiresArray()) {
-                owner.failure(JSONArray.class, subject);
-            }
-        } else {
+        if (owner.passesTypeCheck(JSONArray.class, arraySchema.requiresArray(), arraySchema.isNullable())) {
             this.arraySubject = (JSONArray) subject;
             this.subjectLength = arraySubject.length();
             this.arraySchema = arraySchema;

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

@@ -2,6 +2,8 @@
 
 import static org.everit.json.schema.EnumSchema.toJavaValue;
 
+import org.everit.json.schema.internal.JSONPrinter;
+
 public class ConstSchema extends Schema {
 
     public static class ConstSchemaBuilder extends Schema.Builder<ConstSchema> {
@@ -29,6 +31,11 @@ protected ConstSchema(ConstSchemaBuilder builder) {
         this.permittedValue = toJavaValue(builder.permittedValue);
     }
 
+    @Override void describePropertiesTo(JSONPrinter writer) {
+        writer.key("const");
+        writer.value(this.permittedValue);
+    }
+
     @Override void accept(Visitor visitor) {
         visitor.visitConstSchema(this);
     }

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

@@ -8,27 +8,23 @@ class NumberSchemaValidatingVisitor extends Visitor {
 
     private final Object subject;
 
-    private final ValidationFailureReporter failureReporter;
+    private final ValidatingVisitor owner;
 
     private boolean exclusiveMinimum;
 
     private boolean exclusiveMaximum;
 
     private double numberSubject;
 
-    NumberSchemaValidatingVisitor(Object subject, ValidationFailureReporter failureReporter) {
+    NumberSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
         this.subject = subject;
-        this.failureReporter = failureReporter;
+        this.owner= owner;
     }
 
     @Override void visitNumberSchema(NumberSchema numberSchema) {
-        if (!(subject instanceof Number)) {
-            if (numberSchema.isRequiresNumber()) {
-                failureReporter.failure(Number.class, subject);
-            }
-        } else {
+        if (owner.passesTypeCheck(Number.class, numberSchema.isRequiresNumber(), numberSchema.isNullable())) {
             if (!(subject instanceof Integer || subject instanceof Long) && numberSchema.requiresInteger()) {
-                failureReporter.failure(Integer.class, subject);
+                owner.failure(Integer.class, subject);
             } else {
                 this.numberSubject = ((Number) subject).doubleValue();
                 super.visitNumberSchema(numberSchema);
@@ -45,16 +41,16 @@ class NumberSchemaValidatingVisitor extends Visitor {
             return;
         }
         if (exclusiveMinimum && numberSubject <= minimum.doubleValue()) {
-            failureReporter.failure(subject + " is not greater than " + minimum, "exclusiveMinimum");
+            owner.failure(subject + " is not greater than " + minimum, "exclusiveMinimum");
         } else if (numberSubject < minimum.doubleValue()) {
-            failureReporter.failure(subject + " is not greater or equal to " + minimum, "minimum");
+            owner.failure(subject + " is not greater or equal to " + minimum, "minimum");
         }
     }
 
     @Override void visitExclusiveMinimumLimit(Number exclusiveMinimumLimit) {
         if (exclusiveMinimumLimit != null) {
             if (numberSubject <= exclusiveMinimumLimit.doubleValue()) {
-                failureReporter.failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
+                owner.failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
             }
         }
     }
@@ -64,9 +60,9 @@ class NumberSchemaValidatingVisitor extends Visitor {
             return;
         }
         if (exclusiveMaximum && maximum.doubleValue() <= numberSubject) {
-            failureReporter.failure(subject + " is not less than " + maximum, "exclusiveMaximum");
+            owner.failure(subject + " is not less than " + maximum, "exclusiveMaximum");
         } else if (maximum.doubleValue() < numberSubject) {
-            failureReporter.failure(subject + " is not less or equal to " + maximum, "maximum");
+            owner.failure(subject + " is not less or equal to " + maximum, "maximum");
         }
     }
 
@@ -77,7 +73,7 @@ class NumberSchemaValidatingVisitor extends Visitor {
     @Override void visitExclusiveMaximumLimit(Number exclusiveMaximumLimit) {
         if (exclusiveMaximumLimit != null) {
             if (numberSubject >= exclusiveMaximumLimit.doubleValue()) {
-                failureReporter.failure(format("is not less than " + exclusiveMaximumLimit), "exclusiveMaximum");
+                owner.failure(format("is not less than " + exclusiveMaximumLimit), "exclusiveMaximum");
             }
         }
     }
@@ -87,7 +83,7 @@ class NumberSchemaValidatingVisitor extends Visitor {
             BigDecimal remainder = BigDecimal.valueOf(numberSubject).remainder(
                     BigDecimal.valueOf(multipleOf.doubleValue()));
             if (remainder.compareTo(BigDecimal.ZERO) != 0) {
-                failureReporter.failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
+                owner.failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
             }
         }
     }

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

@@ -28,11 +28,7 @@ public ObjectSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
     }
 
     @Override void visitObjectSchema(ObjectSchema objectSchema) {
-        if (!(subject instanceof JSONObject)) {
-            if (objectSchema.requiresObject()) {
-                owner.failure(JSONObject.class, subject);
-            }
-        } else {
+        if (owner.passesTypeCheck(JSONObject.class, objectSchema.requiresObject(), objectSchema.isNullable())) {
             objSubject = (JSONObject) subject;
             objectSize = objSubject.length();
             this.schema = objectSchema;

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

@@ -31,6 +31,8 @@ public abstract static class Builder<S extends Schema> {
 
         private Object defaultValue;
 
+        private Boolean nullable = null;
+
         public Builder<S> title(String title) {
             this.title = title;
             return this;
@@ -56,10 +58,15 @@ public Builder<S> defaultValue(Object defaultValue) {
             return this;
         }
 
+        public Builder<S> nullable(Boolean nullable) {
+            this.nullable = nullable;
+            return this;
+        }
+
         public abstract S build();
 
-    }
 
+    }
     private final String title;
 
     private final String description;
@@ -70,6 +77,8 @@ public Builder<S> defaultValue(Object defaultValue) {
 
     private final Object defaultValue;
 
+    private final Boolean nullable;
+
     /**
      * Constructor.
      *
@@ -82,6 +91,7 @@ protected Schema(Builder<?> builder) {
         this.id = builder.id;
         this.schemaLocation = builder.schemaLocation;
         this.defaultValue = builder.defaultValue;
+        this.nullable = builder.nullable;
     }
 
     /**
@@ -154,15 +164,16 @@ public boolean equals(Object o) {
                     Objects.equals(title, schema.title) &&
                     Objects.equals(defaultValue, schema.defaultValue) &&
                     Objects.equals(description, schema.description) &&
-                    Objects.equals(id, schema.id);
+                    Objects.equals(id, schema.id) &&
+                    Objects.equals(nullable, schema.nullable);
         } else {
             return false;
         }
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(title, description, id, defaultValue);
+        return Objects.hash(title, description, id, defaultValue, nullable);
     }
 
     public String getTitle() {
@@ -189,6 +200,9 @@ public boolean hasDefaultValue() {
         return this.defaultValue != null;
     }
 
+    public Boolean isNullable() {
+        return nullable;
+    }
     /**
      * Describes the instance as a JSONObject to {@code writer}.
      * <p>
@@ -206,6 +220,7 @@ public void describeTo(JSONPrinter writer) {
         writer.ifPresent("description", description);
         writer.ifPresent("id", id);
         writer.ifPresent("default", defaultValue);
+        writer.ifPresent("nullable", nullable);
         describePropertiesTo(writer);
         writer.endObject();
     }

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

@@ -14,19 +14,15 @@ public class StringSchemaValidatingVisitor extends Visitor {
 
     private int stringLength;
 
-    private final ValidationFailureReporter failureReporter;
+    private final ValidatingVisitor owner;
 
-    public StringSchemaValidatingVisitor(Object subject, ValidationFailureReporter failureReporter) {
+    public StringSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
         this.subject = subject;
-        this.failureReporter = requireNonNull(failureReporter, "failureReporter cannot be null");
+        this.owner = requireNonNull(owner, "failureReporter cannot be null");
     }
 
     @Override void visitStringSchema(StringSchema stringSchema) {
-        if (!(subject instanceof String)) {
-            if (stringSchema.requireString()) {
-                failureReporter.failure(String.class, subject);
-            }
-        } else {
+        if (owner.passesTypeCheck(String.class, stringSchema.requireString(), stringSchema.isNullable())) {
             stringSubject = (String) subject;
             stringLength = stringSubject.codePointCount(0, stringSubject.length());
             super.visitStringSchema(stringSchema);
@@ -35,14 +31,14 @@ public StringSchemaValidatingVisitor(Object subject, ValidationFailureReporter f
 
     @Override void visitMinLength(Integer minLength) {
         if (minLength != null && stringLength < minLength.intValue()) {
-            failureReporter.failure("expected minLength: " + minLength + ", actual: "
+            owner.failure("expected minLength: " + minLength + ", actual: "
                     + stringLength, "minLength");
         }
     }
 
     @Override void visitMaxLength(Integer maxLength) {
         if (maxLength != null && stringLength > maxLength.intValue()) {
-            failureReporter.failure("expected maxLength: " + maxLength + ", actual: "
+            owner.failure("expected maxLength: " + maxLength + ", actual: "
                     + stringLength, "maxLength");
         }
     }
@@ -51,14 +47,15 @@ public StringSchemaValidatingVisitor(Object subject, ValidationFailureReporter f
         if (pattern != null && !pattern.matcher(stringSubject).find()) {
             String message = format("string [%s] does not match pattern %s",
                     subject, pattern.pattern());
-            failureReporter.failure(message, "pattern");
+            owner.failure(message, "pattern");
         }
     }
 
     @Override void visitFormat(FormatValidator formatValidator) {
         Optional<String> failure = formatValidator.validate(stringSubject);
         if (failure.isPresent()) {
-            failureReporter.failure(failure.get(), "format");
+            owner.failure(failure.get(), "format");
         }
     }
+
 }