KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #typescript #ai-agent #developer-tools #claude-code #codex #deepseek-harness #ai-agents #react #mcp #rust

accord

★ 78 Open GitHub ↗

Data validation library for Rust

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Accord

[![Build Status](https://travis-ci.org/ChrisBuchholz/accord.svg?branch=master)](https://travis-ci.org/ChrisBuchholz/accord)
[![Current Crates.io Version](https://img.shields.io/crates/v/accord.svg)](https://crates.io/crates/accord)
[![API Documentation](https://docs.rs/accord/badge.svg)](https://docs.rs/accord)
[![codecov](https://codecov.io/gh/ChrisBuchholz/accord/branch/master/graph/badge.svg)](https://codecov.io/gh/ChrisBuchholz/accord)

[contribute]: #Contributing
[conservative_impl_trait]: https://github.com/rust-lang/rfcs/blob/master/text/1522-conservative-impl-trait.md

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*.

[Serde]: https://serde.rs
[Rocket]: https://rocket.rs
[Rocket example]: https://github.com/ChrisBuchholz/accord/tree/master/examples/unstable/rocket

## Usage tl;dr:

```rust
#[macro_use]
extern crate accord;
extern crate serde;
extern crate serde_json;

use accord::{Accord, Result as AccordResult, Error, MultipleError, MultipleInvalid};
use accord::validators::{length, contains, range};

struct Account {
    pub name: String,
    pub email: String,
    pub age: i8,
}

impl Accord for Account {
    fn validate(&self) -> AccordResult {
        rules!{
            "name" => self.name => [length(1, 64)],
            "email" => self.email => [length(5, 64), contains("@"), contains(".")],
            "age" => self.age => [range(12, 127)]
        }
    }
}

fn main() {
    let account = Account {
        name: "".to_string(),
        email: "test".to_string(),
        age: 11,
    };

// You can use the `rules!` macro on any value.
    // This way of using the the `rules!` macro returns a
    // `Result<(), Error>`.
    let _ = rules!(account.name, [length(1, 64)]);
    let _ = rules!(account.email, [length(5, 64), contains("@"), contains(".")]);
    let _ = rules!(account.age, [range(12, 127)]);

// You can also use the collection form of the `rules!` macro
    // again using any value you'd like.
    // 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!{
        "name" => account.name => [length(1, 64)],
        "email" => account.email => [length(5, 64), contains("@"), contains(".")],
        "age" => account.age => [range(12, 127)]
    };

// And finally, since our `Account` has implemented the
    // `Accord` trait, we can simply do the following, which once
    // again returns `Result<(), MultipleError>`, which we then
    // serialize to JSON using Serde and print:
    if let Err(multiple_error) = account.validate() {
        println!("Errors as json: {}",
                 serde_json::to_string(&multiple_error).unwrap());
    } else {
        println!("No errors occured");
    }
}
```

## Documentation

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

[examples]: https://github.com/ChrisBuchholz/accord/tree/master/examples
[API Documentation]: https://docs.rs/accord

## Building locally

### Stable

Building: `cargo build`

Testing: `cargo test`

### Nightly + unstable features

Make sure you have an up-to-date version of rust nightly installed.

Building: `cargo build`

Testing: `cargo test`

You can add `--features FEATURES TO ENABLE` to both `cargo build` and `cargo test` to build or test unstable features. The unstable features currently supported are:

* `inclusive_range` [RFC#1192] which enables one to use the `length` and `range` validators with [inclusive ranges] instead of `a, b`-variables, as in the example above. An example crate using inclusive ranges can be found [here][inclusive_range_example].

[RFC#1192]: https://github.com/rust-lang/rfcs/blob/master/text/1192-inclusive-ranges.md
[inclusive ranges]: https://doc.rust-lang.org/std/ops/enum.RangeInclusive.html
[inclusive_range_example]: https://github.com/ChrisBuchholz/accord/tree/master/examples/unstable/json

### Make

You can also use [make] for doing more stuff in a simpler way. The Makefile
requires that you are using Rust via [rustup].

[make]: https://www.gnu.org/software/make/
[rustup]: https://www.rustup.rs

* `make` will build and test Accord and all examples on both stable and nightly, on nightly both with and without unstable features
* `make build` will build everything on both stable and nightly
* `make build-stable` will build everything on stable
* `make build-unstable` will build everything on nightly with and without unstable features
* `make build-examples` will build examples on both stable and nightly
* `make build-stable-examples`
* `make build-unstable-examples`
* `make build-stable-example-<NAME-OF-STABLE-EXAMPLE>`
* `make build-unstable-example-<NAME-OF-UNSTABLE-EXAMPLE>`
* `make test` will test everything on both stable and nightly, on nightly with and without unstable features
* `make test-stable` will test everything on stable
* `make test-unstable` will test everything on nightly with and without unstable features
* `make test-examples` will test examples on both stable and nightly
* `make test-stable-examples`
* `make test-unstable-examples`
* `make test-stable-example-<NAME-OF-STABLE-EXAMPLE>`
* `make test-unstable-example-<NAME-OF-UNSTABLE-EXAMPLE>`

## Contributing

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

1. Submit a feature request or bug report as an [issue][issues].
2. Ask for improved documentation as an [issue][issues].
3. Contribute code via [pull requests][pulls].

[issues]: https://github.com/ChrisBuchholz/accord/issues
[pulls]: https://github.com/ChrisBuchholz/accord/pulls

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][rocket-contrib] for showing how to form a great contributing-section.*

[rocket-contrib]: https://github.com/SergioBenitez/Rocket/blob/master/README.md#contributing

## License

Accord is Copyright (c) 2017 Christoffer Buchholz. It is free software, and
may be redistributed under the terms specified in the [LICENSE] file.

[LICENSE]: /LICENSE

accord

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README