Squashed commit of bugfixes and added features

Author: ditschedev

src/main/java/dev/ditsche/validator/Validator.java

@@ -92,6 +92,8 @@ public <T> T validate(T object) {
      * Validates an object against a schema and returns an error bag.
      *
      * @param object The object that need to be validated.
+     * @param abortEarly Indicates, if the validator should return after finding
+     *                   the first unsuccessful rule.
      * @param <T> The type of the validated object.
      * @return The validated object.
      */

src/main/java/dev/ditsche/validator/error/ErrorBag.java

@@ -27,12 +27,12 @@ public ErrorBag() {
      * @param field The field that did not pass.
      * @param message The error message.
      */
-    public void add(String field, String message) {
-        add(new ValidationError(field, List.of(message)));
+    public void add(String field, String type, String message) {
+        add(new ValidationError(field, List.of(new ValidationErrorInfo(message, type))));
     }
 
     public void add(ValidationError validationError) {
-        List<String> errorList = errors.getOrDefault(validationError.getField(), new ValidationError(validationError.getField())).getErrors();
+        List<ValidationErrorInfo> errorList = errors.getOrDefault(validationError.getField(), new ValidationError(validationError.getField())).getErrors();
         errorList.addAll(validationError.getErrors());
         errors.put(validationError.getField(), new ValidationError(validationError.getField(), errorList));
     }

src/main/java/dev/ditsche/validator/error/ValidationError.java

@@ -17,7 +17,7 @@ public class ValidationError {
 
     private String field;
 
-    private List<String> errors;
+    private List<ValidationErrorInfo> errors;
 
     public ValidationError(String field) {
         this(field, new LinkedList<>());

src/main/java/dev/ditsche/validator/error/ValidationErrorInfo.java

@@ -0,0 +1,19 @@
+package dev.ditsche.validator.error;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author Tobias Dittmann
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ValidationErrorInfo {
+
+    private String message;
+
+    private String errorType;
+
+}

src/main/java/dev/ditsche/validator/rule/Rule.java

@@ -6,20 +6,31 @@
  */
 public interface Rule {
 
+    String RULE_TYPE_PREFIX = "validation.error.";
+
     /**
      * Checks if the field passes the rule.
      *
      * @param value The value that will be tested.
      * @return {@code true} if the test passes, {@code false} if not.
      */
-    RuleResult passes(Object value);
+    RuleResult test(Object value);
 
     /**
      * The error message, when the test does not pass.
      *
      * @param field The name of the field.
-     * @return A {@code} string representation of the error.
+     * @return A {@code String} representation of the error.
      */
     String message(String field);
 
+    /**
+     * Gets the type of the error message so that applications consuming
+     * the validation results can make use of internationalization using the
+     * error type key.
+     *
+     * @return A {@code String} key representing the error type.
+     */
+    String getType();
+
 }

src/main/java/dev/ditsche/validator/rule/builder/ArrayElementRuleBuilder.java

@@ -0,0 +1,75 @@
+package dev.ditsche.validator.rule.builder;
+
+import dev.ditsche.validator.rule.Rule;
+import dev.ditsche.validator.rule.ruleset.*;
+import dev.ditsche.validator.validation.Validatable;
+import dev.ditsche.validator.validation.ValidationArray;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author Tobias Dittmann
+ */
+public class ArrayElementRuleBuilder implements Builder {
+
+    private String field;
+
+    private List<Rule> rules;
+
+    private List<Rule> children;
+
+    private boolean optional;
+
+    protected ArrayElementRuleBuilder(String field, List<Rule> rules, boolean optional) {
+        this.field = field;
+        this.rules = rules;
+        this.optional = optional;
+        children = new LinkedList<>();
+    }
+
+    public ArrayElementRuleBuilder required() {
+        children.add(new RequiredRule());
+        return this;
+    }
+
+    public ArrayElementRuleBuilder string() {
+        children.add(new StringRule());
+        return this;
+    }
+
+    public ArrayElementRuleBuilder number() {
+        children.add(new NumberRule());
+        return this;
+    }
+
+    public ArrayElementRuleBuilder bool(boolean value) {
+        children.add(new BooleanRule(value));
+        return this;
+    }
+
+    public ArrayElementRuleBuilder min(int min) {
+        children.add(new MinRule(min));
+        return this;
+    }
+
+    public ArrayElementRuleBuilder max(int max) {
+        children.add(new MaxRule(max));
+        return this;
+    }
+
+    public ArrayElementRuleBuilder length(int length) {
+        children.add(new LengthRule(length));
+        return this;
+    }
+
+    public ArrayElementRuleBuilder size(int min, int max) {
+        children.add(new SizeRule(min, max));
+        return this;
+    }
+
+    @Override
+    public Validatable build() {
+        return new ValidationArray(field, rules, children, null, optional);
+    }
+}

src/main/java/dev/ditsche/validator/rule/builder/ArrayRuleBuilder.java

@@ -1,16 +1,82 @@
 package dev.ditsche.validator.rule.builder;
 
+import dev.ditsche.validator.rule.Rule;
+import dev.ditsche.validator.rule.ruleset.*;
 import dev.ditsche.validator.validation.Validatable;
+import dev.ditsche.validator.validation.ValidationArray;
+import dev.ditsche.validator.validation.ValidationObject;
+import lombok.Getter;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
 
 /**
  * @author Tobias Dittmann
  */
 public class ArrayRuleBuilder implements Builder {
 
+    private String field;
+
+    private List<Rule> rules;
+
+    private List<Rule> childRules;
+
+    private List<Validatable> childValidateables;
+
+    private boolean optional;
+
+    public ArrayRuleBuilder(String field) {
+        this.field = field;
+        rules = new LinkedList<>();
+        rules.add(new ArrayRule());
+    }
+
+    public ArrayRuleBuilder required() {
+        rules.add(new RequiredRule());
+        return this;
+    }
+
+    public ArrayRuleBuilder length(int length) {
+        rules.add(new LengthRule(length));
+        return this;
+    }
+
+    public ArrayRuleBuilder min(int min) {
+        rules.add(new MinRule(min));
+        return this;
+    }
+
+    public ArrayRuleBuilder max(int max) {
+        rules.add(new MaxRule(max));
+        return this;
+    }
+
+    public ArrayRuleBuilder size(int min, int max) {
+        rules.add(new SizeRule(min, max));
+        return this;
+    }
 
+    public ArrayElementRuleBuilder elements() {
+        return new ArrayElementRuleBuilder(field, this.rules, this.optional);
+    }
+
+    public ArrayRuleBuilder objects(Builder ...builders) {
+        childRules = null;
+        childValidateables = new LinkedList<>();
+        for(Builder builder : builders) {
+            this.childValidateables.add(builder.build());
+        }
+        return this;
+    }
+
+    public ArrayRuleBuilder optional() {
+        this.optional = true;
+        return this;
+    }
 
     @Override
     public Validatable build() {
-        return null;
+        return new ValidationArray(field, rules, childRules, childValidateables, optional);
     }
 }

src/main/java/dev/ditsche/validator/rule/builder/RuleBuilder.java

@@ -17,8 +17,12 @@ public static ObjectRuleBuilder object(String field) {
         return new ObjectRuleBuilder(field);
     }
 
-    /*public static ArrayRuleBuilder array(String field) {
+    public static BooleanRuleBuilder bool(String field) {
+        return new BooleanRuleBuilder(field);
+    }
+
+    public static ArrayRuleBuilder array(String field) {
         return new ArrayRuleBuilder(field);
-    }*/
+    }
 
 }

src/main/java/dev/ditsche/validator/rule/builder/Rules.java

@@ -15,7 +15,7 @@ public class AlphaNumericRule implements Rule {
     private final String PATTERN = "[a-zA-Z0-9]+";
 
     @Override
-    public RuleResult passes(Object value) {
+    public RuleResult test(Object value) {
         if(value == null)
             return RuleResult.reject();
         if(!(value instanceof String))
@@ -27,4 +27,9 @@ public RuleResult passes(Object value) {
     public String message(String field) {
         return String.format("The field \"%s\" must be alpha numeric", field);
     }
+
+    @Override
+    public String getType() {
+        return RULE_TYPE_PREFIX + "format.alphanum";
+    }
 }