migrated StringSchema to visitor model; also some pieces of ObjectSchema migration

Author: erosb

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

@@ -4,11 +4,9 @@
 import static java.util.Objects.requireNonNull;
 import static org.everit.json.schema.FormatValidator.NONE;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.regex.Pattern;
 
 import org.everit.json.schema.internal.JSONPrinter;
@@ -146,29 +144,29 @@ private void testPattern(final String subject, List<ValidationException> validat
     }
 
     @Override void accept(Visitor visitor) {
-        throw new UnsupportedOperationException("not yet implemented");
-    }
-
-    @Override
-    public void validate(final Object subject) {
-        if (!(subject instanceof String)) {
-            if (requiresString) {
-                throw failure(String.class, subject);
-            }
-        } else {
-            List<ValidationException> validationExceptions = new ArrayList<>();
-            String stringSubject = (String) subject;
-            testLength(stringSubject, validationExceptions);
-            testPattern(stringSubject, validationExceptions);
-            Optional<String> failure = formatValidator.validate(stringSubject);
-            if (failure.isPresent()) {
-                validationExceptions.add(failure(failure.get(), "format"));
-            }
-            if (null != validationExceptions) {
-                ValidationException.throwFor(this, validationExceptions);
-            }
-        }
-    }
+        visitor.visitStringSchema(this);
+    }
+
+    //    @Override
+    //    public void validate(final Object subject) {
+    //        if (!(subject instanceof String)) {
+    //            if (requiresString) {
+    //                throw failure(String.class, subject);
+    //            }
+    //        } else {
+    //            List<ValidationException> validationExceptions = new ArrayList<>();
+    //            String stringSubject = (String) subject;
+    //            testLength(stringSubject, validationExceptions);
+    //            testPattern(stringSubject, validationExceptions);
+    //            Optional<String> failure = formatValidator.validate(stringSubject);
+    //            if (failure.isPresent()) {
+    //                validationExceptions.add(failure(failure.get(), "format"));
+    //            }
+    //            if (null != validationExceptions) {
+    //                ValidationException.throwFor(this, validationExceptions);
+    //            }
+    //        }
+    //    }
 
     @Override
     public boolean equals(Object o) {
@@ -222,4 +220,8 @@ void describePropertiesTo(JSONPrinter writer) {
             writer.key("format").value(formatValidator.formatName());
         }
     }
+
+    public boolean requireString() {
+        return requiresString;
+    }
 }

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

@@ -0,0 +1,64 @@
+package org.everit.json.schema;
+
+import static java.lang.String.format;
+import static java.util.Objects.requireNonNull;
+
+import java.util.Optional;
+import java.util.regex.Pattern;
+
+public class StringSchemaValidatingVisitor extends Visitor {
+
+    private final Object subject;
+
+    private String stringSubject;
+
+    private int stringLength;
+
+    private final FailureReporter failureReporter;
+
+    public StringSchemaValidatingVisitor(Object subject, FailureReporter failureReporter) {
+        this.subject = subject;
+        this.failureReporter = requireNonNull(failureReporter, "failureReporter cannot be null");
+    }
+
+    @Override void visitStringSchema(StringSchema stringSchema) {
+        if (!(subject instanceof String)) {
+            if (stringSchema.requireString()) {
+                failureReporter.failure(String.class, subject);
+            }
+        } else {
+            stringSubject = (String) subject;
+            stringLength = stringSubject.codePointCount(0, stringSubject.length());
+            super.visitStringSchema(stringSchema);
+        }
+    }
+
+    @Override void visitMinLength(Integer minLength) {
+        if (minLength != null && stringLength < minLength.intValue()) {
+            failureReporter.failure("expected minLength: " + minLength + ", actual: "
+                    + stringLength, "minLength");
+        }
+    }
+
+    @Override void visitMaxLength(Integer maxLength) {
+        if (maxLength != null && stringLength > maxLength.intValue()) {
+            failureReporter.failure("expected maxLength: " + maxLength + ", actual: "
+                    + stringLength, "maxLength");
+        }
+    }
+
+    @Override void visitPattern(Pattern pattern) {
+        if (pattern != null && !pattern.matcher(stringSubject).find()) {
+            String message = format("string [%s] does not match pattern %s",
+                    subject, pattern.pattern());
+            failureReporter.failure(message, "pattern");
+        }
+    }
+
+    @Override void visitFormat(FormatValidator formatValidator) {
+        Optional<String> failure = formatValidator.validate(stringSubject);
+        if (failure.isPresent()) {
+            failureReporter.failure(failure.get(), "format");
+        }
+    }
+}

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

@@ -84,7 +84,11 @@ private static boolean isNull(Object obj) {
     }
 
     @Override void visitObjectSchema(ObjectSchema objectSchema) {
-        super.visitObjectSchema(objectSchema);
+        objectSchema.accept(new ObjectSchemaValidatingVisitor(subject, this));
+    }
+
+    @Override void visitStringSchema(StringSchema stringSchema) {
+        stringSchema.accept(new StringSchemaValidatingVisitor(subject, failureReporter));
     }
 
     ValidationException getFailureOfSchema(Schema schema, Object input) {

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

@@ -1,6 +1,7 @@
 package org.everit.json.schema;
 
 import java.util.List;
+import java.util.regex.Pattern;
 
 abstract class Visitor {
 
@@ -86,15 +87,12 @@ void visitNullSchema(NullSchema nullSchema) {
     }
 
     void visitEmptySchema() {
-
     }
 
     void visitConstSchema(ConstSchema constSchema) {
-
     }
 
     void visitEnumSchema(EnumSchema enumSchema) {
-
     }
 
     void visitFalseSchema(FalseSchema falseSchema) {
@@ -105,4 +103,36 @@ void visitNotSchema(NotSchema notSchema) {
 
     void visitReferenceSchema(ReferenceSchema referenceSchema) {
     }
+
+    void visitObjectSchema(ObjectSchema objectSchema) {
+        for (String requiredPropName : objectSchema.getRequiredProperties()) {
+            visitRequiredPropertyName(requiredPropName);
+        }
+        visitPropertyNameSchema(objectSchema.getPropertyNameSchema());
+    }
+
+    void visitPropertyNameSchema(Schema propertyNameSchema) {
+    }
+
+    void visitRequiredPropertyName(String requiredPropName) {
+    }
+
+    void visitStringSchema(StringSchema stringSchema) {
+        visitMinLength(stringSchema.getMinLength());
+        visitMaxLength(stringSchema.getMaxLength());
+        visitPattern(stringSchema.getPattern());
+        visitFormat(stringSchema.getFormatValidator());
+    }
+
+    void visitFormat(FormatValidator formatValidator) {
+    }
+
+    void visitPattern(Pattern pattern) {
+    }
+
+    void visitMaxLength(Integer maxLength) {
+    }
+
+    void visitMinLength(Integer minLength) {
+    }
 }