splitting validator implementations into multiple files, and implementing formatValidator handling in StringSchema

Author: erosb

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

@@ -15,9 +15,15 @@
  */
 package org.everit.json.schema;
 
+import java.util.Objects;
 import java.util.Optional;
 
-import org.everit.json.schema.internal.DefaultFormatValidator;
+import org.everit.json.schema.internal.DateTimeFormatValidator;
+import org.everit.json.schema.internal.EmailFormatValidator;
+import org.everit.json.schema.internal.HostnameFormatValidator;
+import org.everit.json.schema.internal.IPV4Validator;
+import org.everit.json.schema.internal.IPV6Validator;
+import org.everit.json.schema.internal.URIFormatValidator;
 
 /**
  * Implementations perform the validation against the "format" keyword (see JSON Schema spec section
@@ -29,10 +35,41 @@ public interface FormatValidator {
   /**
    * No-operation implementation (never throws {always returns {@link Optional#empty()}).
    */
-  FormatValidator NONE = (subject, format) -> Optional.empty();
+  FormatValidator NONE = subject -> Optional.empty();
 
-  FormatValidator DEFAULT = new DefaultFormatValidator();
+  /**
+   * Static factory method for {@code FormatValidator} implementations supporting the
+   * {@code formatName}s mandated by the json schema spec.
+   *
+   * <ul>
+   * <li>date-time</li>
+   * <li>email</li>
+   * <li>hostname</li>
+   * <li>uri</li>
+   * <li>ipv4</li>
+   * <li>ipv6</li>
+   * </ul>
+   */
+  static FormatValidator forFormat(final String formatName) {
+    Objects.requireNonNull(formatName, "formatName cannot be null");
+    switch (formatName) {
+      case "date-time":
+        return new DateTimeFormatValidator();
+      case "email":
+        return new EmailFormatValidator();
+      case "hostname":
+        return new HostnameFormatValidator();
+      case "uri":
+        return new URIFormatValidator();
+      case "ipv4":
+        return new IPV4Validator();
+      case "ipv6":
+        return new IPV6Validator();
+      default:
+        throw new IllegalArgumentException("unsupported format: " + formatName);
+    }
+  }
 
-  Optional<String> validate(String subject, Format format);
+  Optional<String> validate(String subject);
 
 }

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

@@ -15,6 +15,11 @@
  */
 package org.everit.json.schema;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
 import java.util.regex.Pattern;
 
 /**
@@ -35,11 +40,24 @@ public static class Builder extends Schema.Builder<StringSchema> {
 
     private boolean requiresString = true;
 
+    private FormatValidator formatValidator = FormatValidator.NONE;
+
     @Override
     public StringSchema build() {
       return new StringSchema(this);
     }
 
+    /**
+     * Setter for the format validator. It should be used in conjunction with
+     * {@link FormatValidator#forFormat(String)} if a {@code "format"} value is found in a schema
+     * json.
+     */
+    public Builder formatValidator(final FormatValidator formatValidator) {
+      this.formatValidator = Objects.requireNonNull(formatValidator,
+          "formatValidator cannot be null");
+      return this;
+    }
+
     public Builder maxLength(final Integer maxLength) {
       this.maxLength = maxLength;
       return this;
@@ -74,6 +92,8 @@ public static Builder builder() {
 
   private final boolean requiresString;
 
+  private final FormatValidator formatValidator;
+
   public StringSchema() {
     this(builder());
   }
@@ -94,6 +114,7 @@ public StringSchema(final Builder builder) {
     } else {
       this.pattern = null;
     }
+    this.formatValidator = builder.formatValidator;
   }
 
   public Integer getMaxLength() {
@@ -108,23 +129,27 @@ public Pattern getPattern() {
     return pattern;
   }
 
-  private void testLength(final String subject) {
+  private List<ValidationException> testLength(final String subject) {
     int actualLength = subject.length();
+    List<ValidationException> rval = new ArrayList<>();
     if (minLength != null && actualLength < minLength.intValue()) {
-      throw new ValidationException(this, "expected minLength: " + minLength + ", actual: "
-          + actualLength);
+      rval.add(new ValidationException(this, "expected minLength: " + minLength + ", actual: "
+          + actualLength));
     }
     if (maxLength != null && actualLength > maxLength.intValue()) {
-      throw new ValidationException(this, "expected maxLength: " + maxLength + ", actual: "
-          + actualLength);
+      rval.add(new ValidationException(this, "expected maxLength: " + maxLength + ", actual: "
+          + actualLength));
     }
+    return rval;
   }
 
-  private void testPattern(final String subject) {
+  private List<ValidationException> testPattern(final String subject) {
     if (pattern != null && !pattern.matcher(subject).find()) {
-      throw new ValidationException(this, String.format("string [%s] does not match pattern %s",
-          subject, pattern.pattern()));
+      return Arrays.asList(new ValidationException(this, String.format(
+          "string [%s] does not match pattern %s",
+          subject, pattern.pattern())));
     }
+    return Collections.emptyList();
   }
 
   @Override
@@ -135,9 +160,13 @@ public void validate(final Object subject) {
       }
     } else {
       String stringSubject = (String) subject;
-      testLength(stringSubject);
-      testPattern(stringSubject);
+      List<ValidationException> rval = new ArrayList<>();
+      rval.addAll(testLength(stringSubject));
+      rval.addAll(testPattern(stringSubject));
+      formatValidator.validate(stringSubject)
+          .map(failure -> new ValidationException(this, failure))
+          .ifPresent(rval::add);
+      ValidationException.throwFor(this, rval);
     }
   }
-
 }

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2011 Everit Kft. (http://www.everit.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.everit.json.schema.internal;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Optional;
+
+import org.everit.json.schema.FormatValidator;
+
+/**
+ * Implementation of the "date-time" format value.
+ */
+public class DateTimeFormatValidator implements FormatValidator {
+
+  private static final String DATETIME_FORMAT_STRING = "yyyy-MM-dd'T'HH:mm:ssXXX";
+
+  private static final String DATETIME_FORMAT_STRING_SECFRAC = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
+
+  @Override
+  public Optional<String> validate(final String subject) {
+    try {
+      new SimpleDateFormat(DATETIME_FORMAT_STRING).parse(subject);
+      return Optional.empty();
+    } catch (ParseException e) {
+      try {
+        new SimpleDateFormat(DATETIME_FORMAT_STRING_SECFRAC).parse(subject);
+        return Optional.empty();
+      } catch (ParseException e1) {
+        return Optional.of(String.format("[%s] is not a valid date-time", subject));
+      }
+    }
+  }
+
+}