wary 0.3.1

A simple validation and transformation 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

//! Transformer for trimming whitespace from the ends of a string.

use crate::toolbox::rule::*;

#[doc(hidden)]
pub type Transformer<Mode> = TrimTransformer<Mode>;

pub struct Ascii;

/// Transformer for trimming whitespace from the ends of a string.
///
/// # Example
///
/// ```
/// use wary::{Wary, Transform};
///
/// #[derive(Wary)]
/// struct Person {
///   #[transform(trim)]
///   message: String,
/// }
///
/// let mut person = Person {
///   message: " hello ".into(),
/// };
///
/// person.transform(&());
/// assert_eq!(person.message, "hello");
/// ```
#[must_use]
pub struct TrimTransformer<Mode> {
	mode: PhantomData<Mode>,
}

impl TrimTransformer<Unset> {
	#[inline]
	pub const fn new() -> Self {
		Self { mode: PhantomData }
	}

	/// Only trims ASCII whitespace.
	#[inline]
	pub const fn ascii(self) -> TrimTransformer<Ascii> {
		TrimTransformer { mode: PhantomData }
	}
}

impl crate::Transformer<String> for TrimTransformer<Unset> {
	type Context = ();

	#[inline]
	fn transform(&self, _ctx: &Self::Context, item: &mut String) {
		let end = item.trim_end().len();

		item.truncate(end);

		let start = item.len() - item.trim_start().len();

		item.drain(..start);
	}
}

impl crate::Transformer<String> for TrimTransformer<Ascii> {
	type Context = ();

	#[inline]
	fn transform(&self, _ctx: &Self::Context, item: &mut String) {
		let end = item
			.trim_end_matches(|c: char| c.is_ascii_whitespace())
			.len();

		item.truncate(end);

		let start = item.len()
			- item
				.trim_start_matches(|c: char| c.is_ascii_whitespace())
				.len();

		item.drain(..start);
	}
}

#[cfg(test)]
mod test {
	use super::TrimTransformer;
	use crate::toolbox::test::*;

	#[test]
	fn test_trim_transformer() {
		let rule = TrimTransformer::new();
		let mut input = " hello ".to_string();

		rule.transform(&(), &mut input);
		assert_eq!(input, "hello");

		let rule = TrimTransformer::new().ascii();
		let mut input = " hello ".to_string();

		rule.transform(&(), &mut input);
		assert_eq!(input, "hello");
	}
}