Accord

Accord is a library for validating data according to rules like length, contains, range and either.

Accord is two fold, the first part being a set of validator-functions that for example tests that a String has a minimum of 5 characters or that an i32 is either 10 or 20, and the second part being the rules! macro which allows you to run a set of validators on a single piece of data, or a whole collection of data and get back a set of errors which explains exactly what is wrong. The errors can easily be serialized using [Serde] and then be used in for example a REST API to report to the user which of the data the user posted contains illegal values.

See the [Rocket example] for how to use Accord with [Rocket] to validate JSON input and return explanations for any occuring error as JSON which then can be parsed by the requesting application and shown to the user to guide them in how to fix their input values according to the applications rules.

Error messages uses numbered placeholders meaning that an error message could be "Must not be less than %1." with an accompanien list [5], which makes it easy to translate "Must not be less than %1." without having to deal with the variable value 5.

Usage tl;dr:

```rust

[macro_use]

extern crate accord;

use accord::{Error, MultipleError, MultipleInvalid}; use accord::validators::{length, contains, range};

fn main() { let email = "test@test.test".tostring(); let password = "kfjsdkfjsdkfjfksjdfkdsfjs".tostring(); let age = 25;

// This way of using the the `rules!` macro returns a
// `Result<(), Error>`
let _ = rules!(email, [length(5..64), contains("@"), contains(".")]);
let _ = rules!(password, [length(8..64)]);
let _ = rules!(age, [range(12..127)]);

// This way of using the `rules!` macro returns a 
// `Result<(), MultipleError>`. Notice the string slices that has
// been appended to the lines from last example. These string slices
// are called tags and are used to distingues between the sets of errors
// that are returned. 
let _ = rules!{
    "email" => email => [length(5..64), contains("@"), contains(".")],
    "password" => password => [length(8..64)],
    "age" => age => [range(12..127)]
};

} ```

Documentation

[Examples]: Usage examples are available in the examples/ directory
[API Documentation]: Documentation generated from the source code, comments and examples

Building locally

Building: cargo build

Testing: cargo test

Contributing

Contributions are absolutely, positively welcome and encouraged! Contributions come in many forms. You could:

Submit a feature request or bug report as an issue.
Ask for improved documentation as an issue.
Contribute code via pull requests.

To keep a high standard of quality, contributed code must be:

Commented: Public items must be commented.
Documented: Exposed items must have rustdoc comments with examples, if applicable.
Styled: Your code should be rustfmt'd when possible.
Simple: Your code should accomplish its task as simply and idiomatically as possible.
Tested: You must add (and pass) convincing tests for any functionality you add.
Focused: Your code should do what it's supposed to do and nothing more.

All pull requests are code reviewed and tested by the CI. Note that unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Accord by you shall be MIT License without any additional terms or conditions.

Thanks to Rocket for showing how to form a great contributing-section.