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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
# validator
[](https://travis-ci.org/Keats/validator)
Macros 1.1 custom derive to simplify struct validation inspired by [marshmallow](http://marshmallow.readthedocs.io/en/latest/) and
[Django validators](https://docs.djangoproject.com/en/1.10/ref/validators/).
It relies on the `proc_macro` feature which will be stable in Rust 1.15.
By default all args to a `validate` must be strings if you are using stable.
However, if you are using nightly, you can also activate the `attr_literals` feature to be able to use int, float and boolean as well.
A short example:
```rust
#[macro_use] extern crate validator_derive;
extern crate validator;
#[macro_use] extern crate serde_derive;
extern crate serde_json;
// A trait that the Validate derive will impl
use validator::Validate;
#[derive(Debug, Validate, Deserialize)]
struct SignupData {
#[validate(email)]
mail: String,
#[validate(url)]
site: String,
#[validate(length(min = "1"), custom = "validate_unique_username")]
#[serde(rename = "firstName")]
first_name: String,
#[validate(range(min = "18", max = "20"))]
age: u32,
}
fn validate_unique_username(username: &str) -> Option<String> {
if username == "xXxShad0wxXx" {
return Some("terrible_username".to_string());
}
None
}
// load the struct from some json...
// `validate` returns `Result<(), HashMap<String, Vec<String>>>`
signup_data.validate()?;
```
This crate only sends back error codes for each field, it's up to you to write a message
for each error code.
Note that `validator` works in conjunction with serde: in the example we can see that the `first_name`
field is renamed from/to `firstName`. Any error on that field will be in the `firstName` key of the hashmap,
not `first_name`.
## Usage
You will need to import the `Validate` trait, and optionally use the `attr_literals` feature.
The `validator` crate can also be used without the custom derive as it exposes all the
validation functions.
## Validators
The crate comes with some built-in validators and you can have several validators for a given field.
### email
Tests whether the String is a valid email according to the HTML5 regex, which means it will mark
some esoteric emails as invalid that won't be valid in a `email` input as well.
This validator doesn't take any arguments: `#[validate(email)]`.
### url
Tests whether the String is a valid URL.
This validator doesn't take any arguments: `#[validate(url)]`;
### length
Tests whether a String or a Vec match the length requirement given. `length` has 3 integer arguments:
- min
- max
- equal
Using `equal` excludes the `min` or `max` and will result in a compilation error if they are found.
At least one argument is required with a maximum of 2 (having `min` and `max` at the same time).
Examples:
```rust
#[validate(length(min = "1", max = "10"))]
#[validate(length(min = "1"))]
#[validate(length(max = "10"))]
#[validate(length(equal = "10"))]
```
### range
Tests whether a number is in the given range. `range` takes 2 number arguments: `min` and `max`.
Examples:
```rust
#[validate(range(min = "1", max = "10"))]
#[validate(range(min = "1", max = "10.8"))]
#[validate(range(min = "1.1", max = "10.8"))]
```
### must_match
Tests whether the 2 fields are equal. `must_match` takes 1 string argument. It will error if the field
mentioned is missing or has a different type than the field the attribute is on.
Examples:
```rust
#[validate(must_match = "password2"))]
```
### contains
Tests whether the string contains the substring given or if a key is present in a hashmap. `contains` takes
1 string argument.
Examples:
```rust
#[validate(contains = "gmail"))]
```
### regex
Tests whether the string matchs the regex given. `regex` takes
1 string argument: the path to a static Regex instance.
Examples:
```rust
#[validate(regex = "ALLOWED_USERNAMES_RE"))]
```
### custom
Calls one of your function to do a custom validation.
The field will be given as parameter and it should return a `Option<String>` representing the error code,
if there was an error.
Examples:
```rust
#[validate(custom = "validate_something")]
#[validate(custom = "::utils::validate_something"]
```
TODO: have it return a bool and pass a `code` to the `custom` validator instead?
## Struct level validation
Often, some error validation can only be applied when looking at the full struct, here's how it works here:
```rust
#[derive(Debug, Validate, Deserialize)]
#[validate(schema(function = "validate_category", skip_on_field_errors = "false")]
struct CategoryData {
category: String,
name: String,
}
```
The function mentioned should return a `Option<(String, String)>` where the tuple is (key error, error code)
and will be called after validation is done for all fields.
This means that the error can be reported on an existing field or on a new key.
The `skip_on_field_errors` defaults to `true` if not present and will ensure that the function is not called
if an error happened while validating the struct fields.
## Changelog
### 0.3.0 (2017/01/17)
- Add `contains` and `regex` validator
- BREAKING: change `Errors` type to be a newtype in order to extend it
### 0.2.0 (2017/01/17)
- Remove need for `attr_literals` feature
- Fix error when not having validation on each field
- Add struct level validation
- Add `must_match` validator
|
