vale 0.0.0

A simple entity validation library
Documentation 
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

use rkt::data::{Data, FromData, Outcome, Transform, Transformed};
use rkt::http::Status;
use rkt::request::Request;
use std::ops::Deref;
use std::ops::DerefMut;

/// A struct that can be used in `Rocket` routes. If you have some type that implements `Validate`,
/// you can designate in your controller that you want to have a validated instance of that type.
///
/// ### Example
/// ```rust
/// # #![feature(decl_macro)]
/// # 
/// # #[derive(vale::Validate)]
/// # struct User {}
/// # impl rocket::data::FromDataSimple for User { 
/// #     type Error = String;
/// #     fn from_data(req: &rocket::Request, data: rocket::Data) -> rocket::data::Outcome<Self, String> {
/// #         rocket::data::Outcome::Success(Self {})
/// #     }
/// # }
/// #
/// # extern crate rkt as rocket;
/// use vale::Valid;
///
/// #[rocket::post("/user", data = "<user>")]
/// fn update_user(user: Valid<User>) {
///     // user is now validated, this code is not reached if the validation failed
/// }
/// # fn main() {}
/// ```
///
/// It is also possible to nest this type with other wrappers:
///
/// ```rust
/// # #![feature(decl_macro, proc_macro_hygiene)]
/// # #[derive(vale::Validate, serde::Deserialize)]
/// # struct User {}
/// # use vale::{Valid};
/// # use rkt_contrib::json::Json;
/// # extern crate rkt as rocket;
/// #[rocket::post("/user", data = "<user>")]
/// fn update_user(user: Valid<Json<User>>) {
///     let user = user.into_inner().into_inner();
/// }
/// # fn main() {}
/// ```
/// ### Features
/// Requires the `rocket` feature to be enabled
pub struct Valid<T> {
    data: T,
}

impl<T: crate::Validate> Valid<T> {
    fn new(t: T) -> Self {
        Self {
            data: t,
        }
    }

    /// Consumes the `Valid` wrapper and returns the inner item.
    pub fn into_inner(self) -> T {
        self.data
    }
}

impl<T: crate::Validate> Deref for Valid<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

impl<T: crate::Validate> DerefMut for Valid<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.data
    }
}

pub enum ValidationError<T> {
    FromDataError(T),
    ValidationError(Vec<String>),
}

impl<'a, T> From<Vec<String>> for ValidationError<T> {
    fn from(s: Vec<String>) -> Self {
        Self::ValidationError(s)
    }
}

impl<T> ValidationError<T> {
    fn from_data_error(t: T) -> Self {
        Self::FromDataError(t)
    }

    fn get_t(self) -> T {
        match self {
            Self::FromDataError(t) => t,
            Self::ValidationError(_) => panic!("Called `get_t` on `ValidationError::FromDataError`"),
        }
    }
}

impl<'a, T: 'a> FromData<'a> for Valid<T>
where
    T: FromData<'a> + crate::Validate
{
    type Error = ValidationError<T::Error>;
    type Owned = T::Owned;
    type Borrowed = T::Borrowed;

    fn transform(r: &Request, d: Data) -> Transform<Outcome<Self::Owned, Self::Error>> {
        match T::transform(r, d) {
            Transform::Owned(out) => Transform::Owned(out.map_failure(|(s, f)| (s, Self::Error::from_data_error(f)))),
            Transform::Borrowed(out) => {
                Transform::Borrowed(out.map_failure(|(s, f)| (s, Self::Error::from_data_error(f))))
            }
        }
    }

    fn from_data(r: &Request, o: Transformed<'a, Self>) -> Outcome<Self, Self::Error> {
        let outcome = match o {
            Transform::Owned(o) => {
                Transform::Owned(o.map_failure(|(s, f)| (s, f.get_t())))
            }
            Transform::Borrowed(o) => {
                Transform::Borrowed(o.map_failure(|(s, f)| (s, f.get_t())))
            }
        };
        let mut inner = match T::from_data(r, outcome) {
            Outcome::Success(s) => s,
            Outcome::Failure((s, f)) => return Outcome::Failure((s, Self::Error::from_data_error(f))),
            Outcome::Forward(f) => return Outcome::Forward(f),
        };
        if let Err(msg) = inner.validate() {
            return Outcome::Failure((Status::BadRequest, msg.into()));
        }
        Outcome::Success(Valid::new(inner))
    }
}

impl<T, U> crate::Validate for U
where
    U: Deref<Target=T> + DerefMut,
    T: crate::Validate,
{
    fn validate(&mut self) -> Result<(), Vec<String>> {
        let t: &mut T = self.deref_mut();
        t.validate()
    }
}