Implemented builder for validation fields

Author: ditschedev

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

@@ -2,10 +2,7 @@
 
 import dev.ditsche.validator.error.ErrorBag;
 import dev.ditsche.validator.error.ValidationException;
-import dev.ditsche.validator.rule.Rule;
-import dev.ditsche.validator.rule.RuleInfo;
-import dev.ditsche.validator.rule.RuleParser;
-import dev.ditsche.validator.rule.ValidationField;
+import dev.ditsche.validator.rule.*;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -31,7 +28,7 @@ public class Validator<T> {
     /**
      * All registered fields.
      */
-    private List<ValidationField> fields;
+    private List<? extends Validatable> fields;
 
     /**
      * Parses a pattern and creates a Rule instance dynamically if it
@@ -98,32 +95,55 @@ public Validator<T> addField(String field, String rulesString) {
         return addField(field, parsed);
     }
 
+    /**
+     * Adds a field using the ValidationField class.
+     *
+     * @param validationField
+     * @return
+     */
+    public Validator<T> addField(ValidationField validationField) {
+        return addField(validationField.getField(), (Rule[]) validationField.getRules().toArray());
+    }
+
+    /**
+     * Adds a field using the ValidationObject class.
+     *
+     * @param validationField
+     * @return
+     */
+    public Validator<T> addField(ValidationObject validationObject) {
+        return null;
+    }
+
+    public T validate(T object) throws ValidationException, IllegalAccessException {
+        return validate(object, false);
+    }
+
     /**
      * Validates an object against a schema and returns an error bag.
-     * @deprecated since 1.0.4
+     *
      * @param object The object that need to be validated.
      * @throws ValidationException Thrown when at least one rule fails.
      * @throws IllegalAccessException Thrown when the field is not public.
      */
-    @Deprecated
-    public void validate(T object) throws ValidationException, IllegalAccessException {
+    public T validate(T object, boolean abortEarly) throws ValidationException, IllegalAccessException {
         errorBag.clear();
         List<Field> fieldSet = new ArrayList<>();
         for (Class<?> c = object.getClass(); c != null; c = c.getSuperclass())
         {
             Field[] fields = c.getDeclaredFields();
             fieldSet.addAll(Arrays.asList(fields));
         }
-        for(ValidationField vf : this.fields) {
-            Field field = fieldSet.stream().filter(f -> f.getName().equals(vf.getField())).findFirst().orElse(null);
+        for(Validatable validatable : this.fields) {
+            Field field = fieldSet.stream().filter(f -> f.getName().equals(validatable.getField())).findFirst().orElse(null);
             if(field == null) continue;
             Object value = getValue(field, object);
-            for(Rule rule : vf.getRules()) {
-                if(!rule.passes(value)) errorBag.add(vf.getField(), rule.message(vf.getField()));
-            }
+            errorBag.merge(validatable.validate(value, abortEarly));
         }
         if(!errorBag.isEmpty())
             throw new ValidationException(errorBag);
+
+        return object;
     }
 
     /**
@@ -141,13 +161,11 @@ public void tryValidate(T object) throws ValidationException, IllegalAccessExcep
             Field[] fields = c.getDeclaredFields();
             fieldSet.addAll(Arrays.asList(fields));
         }
-        for(ValidationField vf : this.fields) {
-            Field field = fieldSet.stream().filter(f -> f.getName().equals(vf.getField())).findFirst().orElse(null);
+        for(Validatable validatable : this.fields) {
+            Field field = fieldSet.stream().filter(f -> f.getName().equals(validatable.getField())).findFirst().orElse(null);
             if(field == null) continue;
             Object value = getValue(field, object);
-            for(Rule rule : vf.getRules()) {
-                if(!rule.passes(value)) errorBag.add(vf.getField(), rule.message(vf.getField()));
-            }
+            errorBag.merge(validatable.validate(value, abortEarly));
         }
         if(!errorBag.isEmpty())
             throw new ValidationException(errorBag);

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

@@ -5,6 +5,7 @@
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * The error bag holds the fields for which at least one rule has not passed.
@@ -29,9 +30,13 @@ public ErrorBag() {
      * @param message The error message.
      */
     public void add(String field, String message) {
-        List<String> errorList = errors.getOrDefault(field, new ValidationError(field)).getErrors();
-        errorList.add(message);
-        errors.put(field, new ValidationError(field, errorList));
+        add(new ValidationError(field, List.of(message)));
+    }
+
+    public void add(ValidationError validationError) {
+        List<String> errorList = errors.getOrDefault(validationError.getField(), new ValidationError(validationError.getField())).getErrors();
+        errorList.addAll(validationError.getErrors());
+        errors.put(validationError.getField(), new ValidationError(validationError.getField(), errorList));
     }
 
     /**
@@ -52,4 +57,10 @@ public boolean isEmpty() {
         return errors.isEmpty();
     }
 
+    public void merge(ErrorBag errorBag) {
+        for(ValidationError error: errorBag.getErrors().values()) {
+            add(error);
+        }
+    }
+
 }

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

@@ -9,7 +9,7 @@
  * Thrown when the validation of an object fails.
  * Gets the error bag of the Validator and provides access to the errors.
  */
-public class ValidationException extends Exception {
+public class ValidationException extends RuntimeException {
 
     /**
      * The error bag holding the errors.

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

@@ -0,0 +1,7 @@
+package dev.ditsche.validator.error;
+
+/**
+ * @author Tobias Dittmann
+ */
+public class ValueNotAccessibleException extends RuntimeException {
+}

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

@@ -1,5 +1,6 @@
 package dev.ditsche.validator.rule;
 
+import dev.ditsche.validator.rule.builder.StringRuleBuilder;
 import dev.ditsche.validator.ruleset.*;
 
 import java.util.HashMap;

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

@@ -0,0 +1,11 @@
+package dev.ditsche.validator.rule;
+
+import dev.ditsche.validator.error.ErrorBag;
+
+public interface Validatable {
+
+    String getField();
+
+    ErrorBag validate(Object object, boolean abortEarly);
+
+}

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

@@ -1,5 +1,7 @@
 package dev.ditsche.validator.rule;
 
+import dev.ditsche.validator.error.ErrorBag;
+import dev.ditsche.validator.error.ValidationException;
 import lombok.Getter;
 
 import java.util.List;
@@ -10,7 +12,7 @@
  * Describes a validatable field.
  * Holds information about the fields name and the assigned rules.
  */
-public class ValidationField {
+public class ValidationField implements Validatable {
 
     /**
      * The fields name.
@@ -60,4 +62,17 @@ public void addRule(Rule rule) {
         this.rules.add(rule);
     }
 
+    @Override
+    public ErrorBag validate(Object object, boolean abortEarly) {
+        ErrorBag errorBag = new ErrorBag();
+        for(Rule rule : rules) {
+            boolean passed = rule.passes(object);
+            if(!passed) {
+                errorBag.add(field, rule.message(field));
+                if(abortEarly)
+                    throw new ValidationException(errorBag);
+            }
+        }
+        return errorBag;
+    }
 }

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

@@ -0,0 +1,71 @@
+package dev.ditsche.validator.rule;
+
+import dev.ditsche.validator.error.ErrorBag;
+import dev.ditsche.validator.error.ValueNotAccessibleException;
+import lombok.Getter;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Tobias Dittmann
+ */
+public class ValidationObject implements Validatable {
+
+    @Getter
+    private String field;
+
+    @Getter
+    private List<Validatable> fields;
+
+    @Override
+    public ErrorBag validate(Object object, boolean abortEarly) {
+        ErrorBag errorBag = new ErrorBag();
+        List<Field> fieldSet = new ArrayList<>();
+        for (Class<?> c = object.getClass(); c != null; c = c.getSuperclass()) {
+            Field[] fields = c.getDeclaredFields();
+            fieldSet.addAll(Arrays.asList(fields));
+        }
+        for(Validatable validatable : fields) {
+            Field field = fieldSet.stream().filter(f -> f.getName().equals(validatable.getField())).findFirst().orElse(null);
+            if(field == null) continue;
+            try {
+                Object value = getValue(field, object);
+                errorBag.merge(validatable.validate(value, abortEarly));
+            } catch (IllegalAccessException e) {
+                throw new ValueNotAccessibleException();
+            }
+        }
+        return errorBag;
+    }
+
+    /**
+     * Uses reflection to invoke a getter of the validation target.
+     * Falls back to the fields default getter. Will fail if the variable
+     * is not publicly accessible.
+     *
+     * @param field The field name whose value should be received.
+     * @param object The validation target object.
+     * @return {@code null} if the field cannot be resolved, or the value.
+     */
+    private Object getValue(Field field, Object object) throws IllegalAccessException {
+        for (Method method : object.getClass().getMethods()) {
+            if ((method.getName().startsWith("get")) && (method.getName().length() == (field.getName().length() + 3)) ||
+                    (method.getName().startsWith("is")) && (method.getName().length() == (field.getName().length() + 2))) {
+                if (method.getName().toLowerCase().endsWith(field.getName().toLowerCase())) {
+                    try {
+                        return method.invoke(object);
+                    }
+                    catch (IllegalAccessException | InvocationTargetException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+        return field.get(object);
+    }
+}

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

@@ -0,0 +1,9 @@
+package dev.ditsche.validator.rule.builder;
+
+import dev.ditsche.validator.rule.ValidationField;
+
+public interface Builder {
+
+    ValidationField build();
+
+}

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

@@ -0,0 +1,40 @@
+package dev.ditsche.validator.rule.builder;
+
+import dev.ditsche.validator.rule.Rule;
+import dev.ditsche.validator.ruleset.StringRule;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author Tobias Dittmann
+ */
+public final class RuleBuilder {
+
+    private String field;
+
+    private List<Rule> rules;
+
+    private RuleBuilder(String field, Rule rule) {
+        this.field = field;
+        this.rules = new LinkedList<>();
+        this.rules.add(rule);
+    }
+
+    public static StringRuleBuilder string(String field) {
+        return new StringRuleBuilder(field);
+    }
+
+    public static NumberRuleBuilder number(String field) {
+        return new NumberRuleBuilder(field);
+    }
+
+    public static ObjectRuleBuilder object(String field) {
+        return new ObjectRuleBuilder(field);
+    }
+
+    public static ArrayRuleBuilder object(String field) {
+        return new ArrayRuleBuilder(field);
+    }
+
+}