Merge pull request #248 from erosb/VisitorListener

Improved ValidationListener

Author: erosb

core/pom.xml

@@ -191,7 +191,7 @@
         <dependency>
             <groupId>nl.jqno.equalsverifier</groupId>
             <artifactId>equalsverifier</artifactId>
-            <version>2.3.1</version>
+            <version>3.0.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>

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

@@ -2,6 +2,8 @@
 
 import java.util.Optional;
 
+import org.everit.json.schema.internal.JSONPrinter;
+
 /**
  * Validator for {@code if}, {@code then}, {@code else} schemas.
  */
@@ -68,4 +70,18 @@ void accept(Visitor visitor) {
         visitor.visitConditionalSchema(this);
     }
 
+    @Override void describePropertiesTo(JSONPrinter writer) {
+        if (ifSchema != null) {
+            writer.key("if");
+            ifSchema.describeTo(writer);
+        }
+        if (thenSchema != null) {
+            writer.key("then");
+            thenSchema.describeTo(writer);
+        }
+        if (elseSchema != null) {
+            writer.key("else");
+            elseSchema.describeTo(writer);
+        }
+    }
 }

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

@@ -1,9 +1,14 @@
 package org.everit.json.schema;
 
-
-import java.util.Arrays;
-
+import static java.util.Arrays.asList;
 import static java.util.Objects.requireNonNull;
+import static org.everit.json.schema.event.ConditionalSchemaValidationEvent.Keyword.ELSE;
+import static org.everit.json.schema.event.ConditionalSchemaValidationEvent.Keyword.IF;
+import static org.everit.json.schema.event.ConditionalSchemaValidationEvent.Keyword.THEN;
+
+import org.everit.json.schema.event.ConditionalSchemaMatchEvent;
+import org.everit.json.schema.event.ConditionalSchemaMismatchEvent;
+import org.everit.json.schema.event.ConditionalSchemaValidationEvent;
 
 class ConditionalSchemaValidatingVisitor extends Visitor {
 
@@ -15,7 +20,7 @@ class ConditionalSchemaValidatingVisitor extends Visitor {
 
     private ValidationException ifSchemaException;
 
-    public ConditionalSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
+    ConditionalSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
         this.subject = subject;
         this.owner = requireNonNull(owner, "owner cannot be null");
     }
@@ -34,6 +39,11 @@ void visitConditionalSchema(ConditionalSchema conditionalSchema) {
     void visitIfSchema(Schema ifSchema) {
         if (conditionalSchema.getIfSchema().isPresent()) {
             ifSchemaException = owner.getFailureOfSchema(ifSchema, subject);
+            if (ifSchemaException == null) {
+                owner.validationListener.ifSchemaMatch(createMatchEvent(IF));
+            } else {
+                owner.validationListener.ifSchemaMismatch(createMismatchEvent(IF, ifSchemaException));
+            }
         }
     }
 
@@ -42,12 +52,17 @@ void visitThenSchema(Schema thenSchema) {
         if (ifSchemaException == null) {
             ValidationException thenSchemaException = owner.getFailureOfSchema(thenSchema, subject);
             if (thenSchemaException != null) {
-                owner.failure(new ValidationException(conditionalSchema,
+                ValidationException failure = new ValidationException(conditionalSchema,
                         new StringBuilder(new StringBuilder("#")),
                         "input is invalid against the \"then\" schema",
-                        Arrays.asList(thenSchemaException),
+                        asList(thenSchemaException),
                         "then",
-                        conditionalSchema.getSchemaLocation()));
+                        conditionalSchema.getSchemaLocation());
+
+                owner.validationListener.thenSchemaMismatch(createMismatchEvent(THEN, thenSchemaException));
+                owner.failure(failure);
+            } else {
+                owner.validationListener.thenSchemaMatch(createMatchEvent(THEN));
             }
         }
     }
@@ -57,14 +72,27 @@ void visitElseSchema(Schema elseSchema) {
         if (ifSchemaException != null) {
             ValidationException elseSchemaException = owner.getFailureOfSchema(elseSchema, subject);
             if (elseSchemaException != null) {
-                owner.failure(new ValidationException(conditionalSchema,
+                ValidationException failure = new ValidationException(conditionalSchema,
                         new StringBuilder(new StringBuilder("#")),
                         "input is invalid against both the \"if\" and \"else\" schema",
-                        Arrays.asList(ifSchemaException, elseSchemaException),
+                        asList(ifSchemaException, elseSchemaException),
                         "else",
-                        conditionalSchema.getSchemaLocation()));
+                        conditionalSchema.getSchemaLocation());
+                owner.validationListener.elseSchemaMismatch(createMismatchEvent(ELSE, elseSchemaException));
+                owner.failure(failure);
+            } else {
+                owner.validationListener.elseSchemaMatch(createMatchEvent(ELSE));
             }
         }
     }
 
+    private ConditionalSchemaMatchEvent createMatchEvent(ConditionalSchemaValidationEvent.Keyword keyword) {
+        return new ConditionalSchemaMatchEvent(conditionalSchema, subject, keyword);
+    }
+
+    private ConditionalSchemaMismatchEvent createMismatchEvent(ConditionalSchemaValidationEvent.Keyword keyword,
+            ValidationException failure) {
+        return new ConditionalSchemaMismatchEvent(conditionalSchema, subject, keyword, failure);
+    }
+
 }

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

@@ -18,6 +18,8 @@ public static Builder builder() {
         return new Builder();
     }
 
+    public static final FalseSchema INSTANCE = FalseSchema.builder().build();
+
     /**
      * Constructor.
      *

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

@@ -31,4 +31,8 @@ public void describeTo(JSONPrinter writer) {
     public String toString() {
         return "true";
     }
+
+    @Override public boolean equals(Object o) {
+        return o instanceof TrueSchema && super.equals(o);
+    }
 }

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

@@ -10,6 +10,10 @@
 import java.util.Collection;
 import java.util.List;
 
+import org.everit.json.schema.event.CombinedSchemaMatchEvent;
+import org.everit.json.schema.event.CombinedSchemaMismatchEvent;
+import org.everit.json.schema.event.SchemaReferencedEvent;
+import org.everit.json.schema.event.ValidationListener;
 import org.json.JSONArray;
 import org.json.JSONObject;
 
@@ -33,6 +37,8 @@ private static boolean isNull(Object obj) {
 
     protected Object subject;
 
+    final ValidationListener validationListener;
+
     private ValidationFailureReporter failureReporter;
 
     private final ReadWriteValidator readWriteValidator;
@@ -46,13 +52,15 @@ void visit(Schema schema) {
         super.visit(schema);
     }
 
-    ValidatingVisitor(Object subject, ValidationFailureReporter failureReporter, ReadWriteValidator readWriteValidator) {
+    ValidatingVisitor(Object subject, ValidationFailureReporter failureReporter, ReadWriteValidator readWriteValidator,
+            ValidationListener validationListener) {
         if (subject != null && !VALIDATED_TYPES.stream().anyMatch(type -> type.isAssignableFrom(subject.getClass()))) {
             throw new IllegalArgumentException(format(TYPE_FAILURE_MSG, subject.getClass().getSimpleName()));
         }
         this.subject = subject;
         this.failureReporter = failureReporter;
         this.readWriteValidator = readWriteValidator;
+        this.validationListener = validationListener;
     }
 
     @Override
@@ -125,6 +133,9 @@ void visitReferenceSchema(ReferenceSchema referenceSchema) {
         if (failure != null) {
             failureReporter.failure(failure);
         }
+        if (validationListener != null) {
+            validationListener.schemaReferenced(new SchemaReferencedEvent(referenceSchema, subject, referredSchema));
+        }
     }
 
     @Override
@@ -147,6 +158,7 @@ void visitCombinedSchema(CombinedSchema combinedSchema) {
             if (null != exception) {
                 failures.add(exception);
             }
+            reportSchemaMatchEvent(combinedSchema, subschema, exception);
         }
         int matchingCount = subschemas.size() - failures.size();
         try {
@@ -166,6 +178,14 @@ void visitConditionalSchema(ConditionalSchema conditionalSchema) {
         conditionalSchema.accept(new ConditionalSchemaValidatingVisitor(subject, this));
     }
 
+    private void reportSchemaMatchEvent(CombinedSchema schema, Schema subschema, ValidationException failure) {
+        if (failure == null) {
+            validationListener.combinedSchemaMatch(new CombinedSchemaMatchEvent(schema, subschema, subject));
+        } else {
+            validationListener.combinedSchemaMismatch(new CombinedSchemaMismatchEvent(schema, subschema, subject, failure));
+        }
+    }
+
     ValidationException getFailureOfSchema(Schema schema, Object input) {
         Object origSubject = this.subject;
         this.subject = input;

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

@@ -469,7 +469,7 @@ public String getSchemaLocation() {
             return false;
         if (!causingExceptions.equals(that.causingExceptions))
             return false;
-        return Objects.equals(keyword, that.keyword);
+        return Objects.equals(keyword, that.keyword) && Objects.equals(getMessage(), that.getMessage());
     }
 
     @Override public int hashCode() {

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

@@ -2,6 +2,8 @@
 
 import java.util.function.BiFunction;
 
+import org.everit.json.schema.event.ValidationListener;
+
 public interface Validator {
 
     class ValidatorBuilder {
@@ -10,6 +12,8 @@ class ValidatorBuilder {
 
         private ReadWriteContext readWriteContext;
 
+        private ValidationListener validationListener = ValidationListener.NOOP;
+
         public ValidatorBuilder failEarly() {
             this.failEarly = true;
             return this;
@@ -20,8 +24,13 @@ public ValidatorBuilder readWriteContext(ReadWriteContext readWriteContext) {
             return this;
         }
 
+        public ValidatorBuilder withListener(ValidationListener validationListener) {
+            this.validationListener = validationListener;
+            return this;
+        }
+
         public Validator build() {
-            return new DefaultValidator(failEarly, readWriteContext);
+            return new DefaultValidator(failEarly, readWriteContext, validationListener);
         }
 
     }
@@ -41,15 +50,22 @@ class DefaultValidator implements Validator {
 
     private final ReadWriteContext readWriteContext;
 
+    private final ValidationListener validationListener;
+
     DefaultValidator(boolean failEarly, ReadWriteContext readWriteContext) {
+        this(failEarly, readWriteContext, null);
+    }
+
+    DefaultValidator(boolean failEarly, ReadWriteContext readWriteContext, ValidationListener validationListener) {
         this.failEarly = failEarly;
         this.readWriteContext = readWriteContext;
+        this.validationListener = validationListener;
     }
 
     @Override public void performValidation(Schema schema, Object input) {
         ValidationFailureReporter failureReporter = createFailureReporter(schema);
         ReadWriteValidator readWriteValidator = ReadWriteValidator.createForContext(readWriteContext, failureReporter);
-        ValidatingVisitor visitor = new ValidatingVisitor(input, failureReporter, readWriteValidator);
+        ValidatingVisitor visitor = new ValidatingVisitor(input, failureReporter, readWriteValidator, validationListener);
         visitor.visit(schema);
         visitor.failIfErrorFound();
     }

core/src/main/java/org/everit/json/schema/event/CombinedSchemaMatchEvent.java

@@ -0,0 +1,26 @@
+package org.everit.json.schema.event;
+
+import org.everit.json.schema.CombinedSchema;
+import org.everit.json.schema.Schema;
+import org.json.JSONObject;
+
+public class CombinedSchemaMatchEvent extends CombinedSchemaValidationEvent {
+
+    public CombinedSchemaMatchEvent(CombinedSchema schema, Schema subSchema,
+            Object instance) {
+        super(schema, subSchema, instance);
+    }
+
+    @Override void describeTo(JSONObject obj) {
+        obj.put("type", "match");
+        obj.put("keyword", schema.getCriterion().toString());
+    }
+
+    @Override public boolean equals(Object o) {
+        return o instanceof CombinedSchemaMatchEvent && super.equals(o);
+    }
+
+    @Override boolean canEqual(Object o) {
+        return o instanceof CombinedSchemaMatchEvent;
+    }
+}

core/src/main/java/org/everit/json/schema/event/CombinedSchemaMismatchEvent.java

@@ -0,0 +1,49 @@
+package org.everit.json.schema.event;
+
+import java.util.Objects;
+
+import org.everit.json.schema.CombinedSchema;
+import org.everit.json.schema.Schema;
+import org.everit.json.schema.ValidationException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+public class CombinedSchemaMismatchEvent extends CombinedSchemaValidationEvent implements MismatchEvent {
+
+    private final ValidationException failure;
+
+    public CombinedSchemaMismatchEvent(CombinedSchema schema, Schema subSchema, Object instance, ValidationException failure) {
+        super(schema, subSchema, instance);
+        this.failure = failure;
+    }
+
+    @Override public ValidationException getFailure() {
+        return failure;
+    }
+
+    @Override void describeTo(JSONObject obj) {
+        obj.put("type", "mismatch");
+        obj.put("keyword", schema.getCriterion().toString());
+        obj.put("subSchema", new JSONTokener(subSchema.toString()).nextValue());
+        obj.put("failure", failure.toJSON());
+    }
+
+    @Override public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof CombinedSchemaMismatchEvent))
+            return false;
+        if (!super.equals(o))
+            return false;
+        CombinedSchemaMismatchEvent that = (CombinedSchemaMismatchEvent) o;
+        return failure.equals(that.failure);
+    }
+
+    @Override public int hashCode() {
+        return Objects.hash(super.hashCode(), failure);
+    }
+
+    @Override boolean canEqual(Object o) {
+        return o instanceof CombinedSchemaMismatchEvent;
+    }
+}