validate 0.6.0

A library to easily validate user input
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

use std::ops::Add;

#[derive(Debug, PartialEq)]
pub struct Error {
	message: String
}

impl Error {
	pub fn get_message(&self) -> String {
		self.message.clone()
	}
}

impl<S: Into<String>> From<S> for Error {
	fn from(msg: S) -> Self {
		Error { message: msg.into() }
	}
}


pub type ValidationResult = Result<(), Error>;

pub struct Rule<T: ? Sized> {
	rule: Box<Fn(&T) -> ValidationResult>
}

impl<T: 'static> Rule<T> {
	pub fn map<'b, F, U>(self, get: F) -> Rule<U>
		where F: Fn(&U) -> T + 'static,
		      U: ? Sized + 'static {
		Rule::from(move |input: &U| {
			let mapped_input = get(input);
			self.validate(&mapped_input)
		})
	}
}

impl<T: ? Sized + 'static> Rule<T> {
	pub fn validate(&self, input: &T) -> ValidationResult {
		(*self.rule)(input)
	}

	pub fn nest<'b, R, F, U>(get: F, rule: R) -> Self
		where
				R: Into<Rule<U>>,
				F: Fn(&T) -> &U + 'static,
				U: ? Sized + 'static {
		let converted_rule = rule.into();
		Rule::from(move |input: &T| {
			let mapped_input = get(input);
			converted_rule.validate(&mapped_input)
		})
	}


	pub fn name(self, name: &str) -> Self {
		let name = name.to_owned();
		Rule::from(move |input: &T| {
			self.validate(&input).map_err(|err: Error| {
				(name.clone() + " " + &err.get_message()).into()
			})
		})
	}
}

impl<T, F> From<F> for Rule<T>
	where F: Fn(&T) -> ValidationResult + 'static,
	      T: ? Sized {
	fn from(func: F) -> Self {
		Rule {
			rule: Box::new(func)
		}
	}
}

impl<T: ? Sized + 'static, R: Into<Rule<T>>> Add<R> for Rule<T> {
	type Output = Rule<T>;

	fn add(self, rule: R) -> Self::Output {
		let rule = rule.into();
		Rule::from(move |input: &T| {
			self.validate(input)?;
			rule.validate(input)
		})
	}
}