Support for custom rules

Author: ditschedev

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

@@ -124,15 +124,4 @@ public <T> T validate(T object, boolean abortEarly) {
         return object;
     }
 
-    /**
-     * Registers a custom rule with an abbreviation.
-     *
-     * @param ruleKey The abbreviation for the custom rule.
-     * @param ruleClass The custom rule class.
-     * @param paramTypes If the rule needs params pass the types in the correct order.
-     */
-    public void register(String ruleKey, Class<? extends Rule> ruleClass, Class<?> ...paramTypes) {
-        this.ruleParser.register(ruleKey, new RuleInfo(ruleClass, paramTypes));
-    }
-
 }

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

@@ -13,12 +13,15 @@ public class ValidationException extends RuntimeException {
      */
     private final ErrorBag errorBag;
 
+
     /**
      * Initiates a new exception.
      *
      * @param errorBag The error bag.
      */
     public ValidationException(ErrorBag errorBag) {
+        if(errorBag == null)
+            throw new IllegalArgumentException("error bag cannot be null");
         this.errorBag = errorBag;
     }
 

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

@@ -11,12 +11,10 @@
 /**
  * @author Tobias Dittmann
  */
-public class ArrayElementRuleBuilder implements Builder {
+public class ArrayElementRuleBuilder extends RuleBuilder {
 
     private String field;
 
-    private List<Rule> rules;
-
     private List<Rule> children;
 
     private boolean optional;
@@ -29,47 +27,53 @@ protected ArrayElementRuleBuilder(String field, List<Rule> rules, boolean option
     }
 
     public ArrayElementRuleBuilder required() {
-        children.add(new RequiredRule());
+        this.children.add(new RequiredRule());
         return this;
     }
 
     public ArrayElementRuleBuilder string() {
-        children.add(new StringRule());
+        this.children.add(new StringRule());
         return this;
     }
 
     public ArrayElementRuleBuilder number() {
-        children.add(new NumberRule());
+        this.children.add(new NumberRule());
         return this;
     }
 
     public ArrayElementRuleBuilder bool(boolean value) {
-        children.add(new BooleanRule(value));
+        this.children.add(new BooleanRule(value));
         return this;
     }
 
     public ArrayElementRuleBuilder min(int min) {
-        children.add(new MinRule(min));
+        this.children.add(new MinRule(min));
         return this;
     }
 
     public ArrayElementRuleBuilder max(int max) {
-        children.add(new MaxRule(max));
+        this.children.add(new MaxRule(max));
         return this;
     }
 
     public ArrayElementRuleBuilder length(int length) {
-        children.add(new LengthRule(length));
+        this.children.add(new LengthRule(length));
         return this;
     }
 
     public ArrayElementRuleBuilder size(int min, int max) {
-        children.add(new SizeRule(min, max));
+        this.children.add(new SizeRule(min, max));
+        return this;
+    }
+
+    @Override
+    public RuleBuilder custom(Rule rule) {
+        this.children.add(rule);
         return this;
     }
 
     @Override
     public Validatable build() {
-        return new ValidationArray(field, rules, children, null, optional);
+        return new ValidationArray(this.field, this.rules, this.children, null, this.optional);
     }
 }

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

@@ -4,51 +4,46 @@
 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 {
+public class ArrayRuleBuilder extends RuleBuilder {
 
     private String field;
 
-    private List<Rule> rules;
-
     private List<Rule> childRules;
 
-    private List<Validatable> childValidateables;
+    private List<Validatable> childValidatable;
 
     private boolean optional;
 
     public ArrayRuleBuilder(String field) {
         this.field = field;
-        rules = new LinkedList<>();
-        rules.add(new ArrayRule());
+        this.rules = new LinkedList<>();
+        this.rules.add(new ArrayRule());
     }
 
     public ArrayRuleBuilder required() {
-        rules.add(new RequiredRule());
+        this.rules.add(new RequiredRule());
         return this;
     }
 
     public ArrayRuleBuilder length(int length) {
-        rules.add(new LengthRule(length));
+        this.rules.add(new LengthRule(length));
         return this;
     }
 
     public ArrayRuleBuilder min(int min) {
-        rules.add(new MinRule(min));
+        this.rules.add(new MinRule(min));
         return this;
     }
 
     public ArrayRuleBuilder max(int max) {
-        rules.add(new MaxRule(max));
+        this.rules.add(new MaxRule(max));
         return this;
     }
 
@@ -58,14 +53,14 @@ public ArrayRuleBuilder size(int min, int max) {
     }
 
     public ArrayElementRuleBuilder elements() {
-        return new ArrayElementRuleBuilder(field, this.rules, this.optional);
+        return new ArrayElementRuleBuilder(this.field, this.rules, this.optional);
     }
 
     public ArrayRuleBuilder objects(Builder ...builders) {
-        childRules = null;
-        childValidateables = new LinkedList<>();
+        this.childRules = null;
+        this.childValidatable = new LinkedList<>();
         for(Builder builder : builders) {
-            this.childValidateables.add(builder.build());
+            this.childValidatable.add(builder.build());
         }
         return this;
     }
@@ -75,8 +70,14 @@ public ArrayRuleBuilder optional() {
         return this;
     }
 
+    @Override
+    public RuleBuilder custom(Rule rule) {
+        this.rules.add(rule);
+        return this;
+    }
+
     @Override
     public Validatable build() {
-        return new ValidationArray(field, rules, childRules, childValidateables, optional);
+        return new ValidationArray(this.field, this.rules, this.childRules, this.childValidatable, this.optional);
     }
 }

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

@@ -11,7 +11,7 @@
 /**
  * @author Tobias Dittmann
  */
-public class BooleanRuleBuilder implements Builder {
+public class BooleanRuleBuilder extends RuleBuilder {
 
     private String field;
 
@@ -23,17 +23,23 @@ public BooleanRuleBuilder(String field) {
     }
 
     public BooleanRuleBuilder isTrue() {
-        rules.add(new BooleanRule(true));
+        this.rules.add(new BooleanRule(true));
         return this;
     }
 
     public BooleanRuleBuilder isFalse() {
-        rules.add(new BooleanRule(false));
+        this.rules.add(new BooleanRule(false));
+        return this;
+    }
+
+    @Override
+    public RuleBuilder custom(Rule rule) {
+        this.rules.add(rule);
         return this;
     }
 
     @Override
     public Validatable build() {
-        return new ValidationField(field, rules);
+        return new ValidationField(this.field, this.rules);
     }
 }

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

@@ -1,5 +1,6 @@
 package dev.ditsche.validator.rule.builder;
 
+import dev.ditsche.validator.rule.Rule;
 import dev.ditsche.validator.validation.Validatable;
 
 public interface Builder {

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

@@ -11,51 +11,50 @@
 /**
  * @author Tobias Dittmann
  */
-public class NumberRuleBuilder implements Builder {
+public class NumberRuleBuilder extends RuleBuilder {
 
     private final String field;
 
-    private List<Rule> rules;
-
     NumberRuleBuilder(String field) {
         this.field = field;
         this.rules = new LinkedList<>();
         this.rules.add(new NumberRule());
     }
 
     public NumberRuleBuilder min(long min) {
-        rules.add(new MinRule(min));
+        this.rules.add(new MinRule(min));
         return this;
     }
 
     public NumberRuleBuilder max(long max) {
-        rules.add(new MaxRule(max));
+        this.rules.add(new MaxRule(max));
         return this;
     }
 
     public NumberRuleBuilder size(long min, long max) {
-        rules.add(new SizeRule(min, max));
+        this.rules.add(new SizeRule(min, max));
         return this;
     }
 
     public NumberRuleBuilder length(int length) {
-        rules.add(new LengthRule(length));
+        this.rules.add(new LengthRule(length));
         return this;
     }
 
     public NumberRuleBuilder defaultValue(Number number) {
-        rules.add(new DefaultRule(number));
+        this.rules.add(new DefaultRule(number));
         return this;
     }
 
-    public NumberRuleBuilder custom(Rule rule) {
-        rules.add(rule);
+    @Override
+    public RuleBuilder custom(Rule rule) {
+        this.rules.add(rule);
         return this;
     }
 
     @Override
     public Validatable build() {
-        return new ValidationField(field, rules);
+        return new ValidationField(this.field, this.rules);
     }
 
 }

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

@@ -1,5 +1,7 @@
 package dev.ditsche.validator.rule.builder;
 
+import dev.ditsche.validator.rule.Rule;
+import dev.ditsche.validator.rule.ruleset.RequiredRule;
 import dev.ditsche.validator.validation.Validatable;
 import dev.ditsche.validator.validation.ValidationObject;
 
@@ -23,12 +25,12 @@ public class ObjectRuleBuilder implements Builder {
     }
 
     public ObjectRuleBuilder child(Builder builder) {
-        children.add(builder.build());
+        this.children.add(builder.build());
         return this;
     }
 
     public ObjectRuleBuilder child(Validatable validatable) {
-        children.add(validatable);
+        this.children.add(validatable);
         return this;
     }
 
@@ -46,6 +48,6 @@ public ObjectRuleBuilder optional() {
 
     @Override
     public Validatable build() {
-        return new ValidationObject(field, children, optional);
+        return new ValidationObject(this.field, this.children, this.optional);
     }
 }

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

@@ -0,0 +1,17 @@
+package dev.ditsche.validator.rule.builder;
+
+import dev.ditsche.validator.rule.Rule;
+
+import java.util.List;
+
+/**
+ * @author Tobias Dittmann
+ */
+public abstract class RuleBuilder implements Builder {
+
+    protected List<Rule> rules;
+
+    public abstract RuleBuilder custom(Rule rule);
+
+}
+