Updated Tests

Author: ditschedev

.travis.yml

@@ -0,0 +1 @@
+language: java

pom.xml

@@ -82,6 +82,16 @@
 
     <build>
         <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.22.0</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>2.22.0</version>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-source-plugin</artifactId>

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

@@ -1,8 +1,10 @@
 package dev.ditsche.validator;
 
 import dev.ditsche.validator.error.ErrorBag;
+import dev.ditsche.validator.error.FieldNotAccessibleException;
 import dev.ditsche.validator.error.ValidationException;
 import dev.ditsche.validator.rule.*;
+import dev.ditsche.validator.rule.builder.Builder;
 import org.apache.commons.lang3.reflect.FieldUtils;
 
 import java.lang.reflect.Field;
@@ -12,10 +14,8 @@
 
 /**
  * Validates an object against a defined schema.
- *
- * @param <T> The type of the validated object.
  */
-public class Validator<T> {
+public class Validator {
 
     /**
      * The error bag for the
@@ -37,29 +37,49 @@ public class Validator<T> {
     /**
      * Create a new validator instance based on a given type.
      */
-    public Validator() {
+    private Validator() {
         this.errorBag = new ErrorBag();
         this.ruleParser = new RuleParser();
         this.fields = new ArrayList<>();
     }
 
-    public Validator<T> add(Validatable validatable) {
+    public static Validator fromRules(Builder ...builders) {
+        Validator validator = new Validator();
+        for(Builder builder : builders) {
+            validator.add(builder);
+        }
+        return validator;
+    }
+
+    public static Validator fromRules(Validatable ...rules) {
+        Validator validator = new Validator();
+        for(Validatable validatable : rules) {
+            validator.add(validatable);
+        }
+        return validator;
+    }
+
+
+
+    public Validator add(Builder builder) {
+        return add(builder.build());
+    }
+
+    public Validator add(Validatable validatable) {
         this.fields.add(validatable);
         return this;
     }
 
-    public T validate(T object) throws ValidationException, IllegalAccessException {
+    public <T> T validate(T object) {
         return validate(object, false);
     }
 
     /**
      * Validates an object against a schema and returns an error bag.
      *
      * @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.
      */
-    public T validate(T object, boolean abortEarly) throws ValidationException, IllegalAccessException {
+    public <T> T validate(T object, boolean abortEarly) {
         errorBag.clear();
         List<Field> fieldSet = new ArrayList<>();
         for (Class<?> c = object.getClass(); c != null; c = c.getSuperclass())
@@ -68,38 +88,24 @@ public T validate(T object, boolean abortEarly) throws ValidationException, Ille
             fieldSet.addAll(Arrays.asList(fields));
         }
         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 = FieldUtils.readField(field, object, true);
-            ValidationResult result = validatable.validate(value, abortEarly);
-            if(result.isChanged())
-                FieldUtils.writeField(field, object, value, true);
-            errorBag.merge(result.getErrorBag());
+            try {
+                Field field = fieldSet.stream().filter(f -> f.getName().equals(validatable.getField())).findFirst().orElse(null);
+                if(field == null) continue;
+                Object value = FieldUtils.readField(field, object, true);
+                ValidationResult result = validatable.validate(value, abortEarly);
+                if(result.isChanged())
+                    FieldUtils.writeField(field, object, result.getValue(), true);
+                errorBag.merge(result.getErrorBag());
+            } catch (IllegalAccessException ex) {
+                throw new FieldNotAccessibleException();
+            }
         }
         if(!errorBag.isEmpty())
             throw new ValidationException(errorBag);
 
         return object;
     }
 
-    /**
-     * 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 {
-        return FieldUtils.readField(field, object, true);
-    }
-
-    private Object setValue(Field field, Object value, Object object) throws IllegalAccessException {
-        FieldUtils.writeField(field, object, value, true);
-        return object;
-    }
-
     /**
      * Registers a custom rule with an abbreviation.
      *

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

@@ -51,6 +51,15 @@ public ValidationField(String field, Rule ...rules) {
         this.rules = Stream.of(rules).collect(Collectors.toList());
     }
 
+    public ValidationField(String field, List<Rule> rules) {
+        if(field == null || field.trim().isEmpty())
+            throw new IllegalArgumentException("Validation field requires a valid field name");
+        if(rules == null)
+            throw new IllegalArgumentException("Validation rules cannot be null");
+        this.field = field;
+        this.rules = rules;
+    }
+
     /**
      * Adds a rule to the field.
      * Replaces the rule if existing.

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

@@ -2,6 +2,7 @@
 
 import dev.ditsche.validator.rule.Rule;
 import dev.ditsche.validator.rule.Validatable;
+import dev.ditsche.validator.rule.ValidationField;
 import dev.ditsche.validator.rule.ruleset.*;
 
 import java.util.LinkedList;
@@ -10,7 +11,7 @@
 /**
  * @author Tobias Dittmann
  */
-class NumberRuleBuilder implements Builder {
+public class NumberRuleBuilder implements Builder {
 
     private final String field;
 
@@ -54,7 +55,7 @@ public NumberRuleBuilder custom(Rule rule) {
 
     @Override
     public Validatable build() {
-        return null;
+        return new ValidationField(field, rules);
     }
 
 }

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

@@ -10,7 +10,7 @@
 /**
  * @author Tobias Dittmann
  */
-class StringRuleBuilder implements Builder {
+public class StringRuleBuilder implements Builder {
 
     private final String field;
 
@@ -82,13 +82,18 @@ public StringRuleBuilder defaultValue(String value) {
         return this;
     }
 
+    public StringRuleBuilder trim() {
+        rules.add(new TrimRule());
+        return this;
+    }
+
     public StringRuleBuilder custom(Rule rule) {
         rules.add(rule);
         return this;
     }
 
     public ValidationField build() {
-        return new ValidationField(field, (Rule[]) rules.toArray());
+        return new ValidationField(field, rules);
     }
 
 }

src/main/java/dev/ditsche/validator/rule/ruleset/EmailRule.java

@@ -14,7 +14,7 @@
  */
 public class EmailRule implements Rule {
 
-    private final String PATTERN = "^[A-Za-z0-9._%'-]+@[A-Za-z0-9.-]+\\\\.[a-zA-Z]{2,4}$";
+    private final String PATTERN = "^[A-Za-z0-9._%'+-]+@[A-Za-z0-9.-]+.[a-zA-Z]{2,4}$";
 
     @Override
     public RuleResult passes(Object value) {

src/main/java/dev/ditsche/validator/rule/ruleset/TrimRule.java

@@ -0,0 +1,25 @@
+package dev.ditsche.validator.rule.ruleset;
+
+import dev.ditsche.validator.rule.Rule;
+import dev.ditsche.validator.rule.RuleResult;
+
+/**
+ * @author Tobias Dittmann
+ */
+public class TrimRule implements Rule {
+
+    @Override
+    public RuleResult passes(Object value) {
+
+        if(!(value instanceof String))
+            return RuleResult.reject();
+
+        return RuleResult.resolve(((String) value).trim());
+    }
+
+    @Override
+    public String message(String field) {
+        return String.format("The field \"%s\" needs to be a string to be able to trim it", field);
+    }
+
+}

src/test/java/dev/ditsche/validator/dto/TestEntity.java

@@ -1,16 +1,21 @@
 package dev.ditsche.validator.dto;
 
+import lombok.Data;
+
 /**
  * @author Tobias Dittmann
  */
+@Data
 public class TestEntity {
     private String title;
+    private String email;
+    private String firstName;
+    private int count;
 
-    public TestEntity(String title) {
+    public TestEntity(String title, String email, String firstName, int count) {
         this.title = title;
-    }
-
-    public String getTitle() {
-        return this.title;
+        this.email = email;
+        this.firstName = firstName;
+        this.count = count;
     }
 }

src/test/java/dev/ditsche/validator/rule/RuleParserTest.java

@@ -14,16 +14,16 @@ public class RuleParserTest {
     public void shouldParseRequiredRuleByString() {
         Rule rule = ruleParser.parse("required").orElse(null);
         assertThat(rule.getClass()).isEqualTo(RequiredRule.class);
-        assertThat(rule.passes("abc")).isTrue();
+        assertThat(rule.passes("abc").isPassed()).isTrue();
     }
 
     @Test
     public void shouldParseMaxRuleByString() {
         Rule rule = ruleParser.parse("max:50").orElse(null);
         assertThat(rule.getClass()).isEqualTo(MaxRule.class);
 
-        assertThat(rule.passes(51)).isFalse();
-        assertThat(rule.passes(49)).isTrue();
+        assertThat(rule.passes(51).isPassed()).isFalse();
+        assertThat(rule.passes(49).isPassed()).isTrue();
     }
 
 }