Griffon Validation Plugin

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

  
package griffon.plugins.validation;

import griffon.plugins.validation.constraints.ConstraintDef;
import org.codehaus.griffon.runtime.validation.AbstractValidateable;

import java.util.List;
import java.util.Map;

import static griffon.plugins.validation.constraints.Constraints.blank;
import static griffon.plugins.validation.constraints.Constraints.list;
import static griffon.plugins.validation.constraints.Constraints.map;
import static griffon.plugins.validation.constraints.Constraints.size;

public class Credentials extends AbstractValidateable {
    private String username;
    private String password;

    public static final Map<String, List<ConstraintDef>> CONSTRAINTS = map()
        .e("username", list(blank(false), size(3, 10)))
        .e("password", list(blank(false), size(8, 10)));

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

  
package griffon.plugins.validation;

import griffon.plugins.validation.constraints.ConstraintDef;
import griffon.plugins.validation.constraints.PropertyConstraintDef;
import org.codehaus.griffon.runtime.validation.AbstractValidateable;

import javax.annotation.Nonnull;
import java.util.Collection;
import java.util.List;

import static griffon.plugins.validation.constraints.Constraints.blank;
import static griffon.plugins.validation.constraints.Constraints.list;
import static griffon.plugins.validation.constraints.Constraints.set;
import static griffon.plugins.validation.constraints.Constraints.size;

public class Credentials2 extends AbstractValidateable {
    private String username;
    private String password;

    private static PropertyConstraintDef username(@Nonnull List<ConstraintDef> constraints) {
        return new PropertyConstraintDef("username", constraints);
    }

    private static PropertyConstraintDef password(@Nonnull List<ConstraintDef> constraints) {
        return new PropertyConstraintDef("password", constraints);
    }

    public static final Collection<PropertyConstraintDef> CONSTRAINTS = set()
        .e(username(list(blank(false), size(3, 10))))
        .e(password(list(blank(false), size(8, 10))));

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13

  
package griffon.plugins.validation

import org.codehaus.griffon.runtime.validation.AbstractValidateable

class GroovyCredentials extends AbstractValidateable {
    String username
    String password

    static final CONSTRAINTS = {
        username(blank: false, size: 3..10)
        password(blank: false, size: 8..10)
    }
}

User user = application.injector.getInstance(User)
// TODO: update user properties
if (user.validate()) {
     // do something with user
} else {
    errorsTranslator(user.errors).each { println it }
}

package com.acme

class User extends AbstractValidateable {
    static final CONSTRAINTS= {
         login size: 5..15, blank: false
         password size: 5..15, blank: false
         email email: true, blank: false
         age min: 18
    }

    String login
    String password
    String email
    int age
}

[Class Name].[Property Name].[Constraint Code]

user.login.blank=Your login name must be specified!

package griffon.plugins.validation

@griffon.transform.Validateable
class GroovyCredentials {
    String username
    String password

    static final CONSTRAINTS = {
        username(blank: false, size: 3..10)
        password(blank: false, size: 8..10)
    }
}

.e("login", list(blank(false)))

login(blank: false)

.e("cardNumber", list(creditCard(true)))

cardNumber(creditCard: true)

.e("startDate", list(date("yyyy-MM-dd")))

startDate(date: 'yyyy-MM-dd')

.e("homeEmail", list(email(true)))

homeEmail(email: true)

.e("name", list(inList(Arrays.asList("Joe", "Fred", "Bob"))))

name inList: ["Joe", "Fred", "Bob"]

.e("login", list(matches("[a-zA-Z]+")))

login matches: "[a-zA-Z]+"

.e("age",   list(max(new Date())))
.e("price", list(max(999F)))

age   max: new Date()
price max: 999F

.e("children", list(maxSize(25)))

children maxSize: 25

.e("age",   list(min(new Date())))
.e("price", list(min(0F)))

age   min: new Date()
price min: 0F

.e("children", list(minSize(25)))

children minSize: 25

.e("username", list(notEqual("Bob")))

username notEqual: "Bob"

.e("age", list(nullable(false)))

age(nullable: false)

.e("age", list(range(18, 65)))

age range: 18..65

.e("salary", list(scale(2)))

salary scale: 2

.e("children", list(size(5,15)))

children size: 5..15

.e("homePage", list(url(true)))

homePage url: true

.e("even", list(validator( (Number v) -> {val % 2 ? "" : "validator.invalid"} )))
.e("password2", list(validator( (Number v, Bean b) -> areEqual(b.password, val) ? "" : "passwords.do.not.match" )))

even(validator: { val -> val % 2 ? '' : 'validator.invalid' })
password2(validator: { v, obj -> obj.password == val ? '' : 'passwords.do.not.match' })

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.griffon.plugins</groupId>
            <artifactId>griffon-validation-plugin</artifactId>
            <version>2.0.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependency>
    <groupId>org.codehaus.griffon.plugins</groupId>
    <artifactId>griffon-validation-core</artifactId>
</dependency>

<dependency>
    <groupId>org.codehaus.griffon.plugins</groupId>
    <artifactId>griffon-validation-groovy</artifactId>
</dependency>

<dependency>
    <groupId>org.codehaus.griffon.plugins</groupId>
    <artifactId>griffon-validation-groovy-compile</artifactId>
</dependency>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <classpathDependencyExcludes>
            <classpathDependencyExclude>
                org.codehaus.griffon:griffon-validation-groovy-compile
            </classpathDependencyExclude>
        </classpathDependencyExcludes>
    </configuration>
</plugin>

bind(ConstraintsEvaluator.class)
    .to(DefaultConstraintsEvaluator.class)
    .asSingleton();

bind(ConstraintsValidator.class)
    .to(DefaultConstraintsValidator.class)
    .asSingleton();

bind(ConstrainedPropertyAssembler.class)
    .to(DefaultConstrainedPropertyAssembler.class);

bind(ErrorMessagesResolver.class)
    .to(DefaultErrorMessagesResolver.class)
    .asSingleton();

bind(ConstrainedPropertyAssembler.class)
    .to(GroovyAwareConstrainedPropertyAssembler.class);