megumax-template 0.1.0

Template library for Megumax project
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

use crate::template::Template;
use crate::variant::Variant;

#[derive(Debug, Clone)]
pub struct Solver<'a> {
	inner: Variant<'a, String>,
	keys: Vec<String>,
}

impl<'a> Solver<'a> {
	pub fn new(list: Vec<&'a [String]>, keys: Vec<String>) -> Self {
		let inner = Variant::new(list);
		Self { inner, keys }
	}
}

impl<'a> Iterator for Solver<'a> {
	type Item = Template;

	fn next(&mut self) -> Option<Self::Item> {
		let keys = self.keys.iter().cloned();
		let variant = self.inner.next()?.into_iter().map(|s| s.to_string());
		let result = keys.zip(variant).collect();
		Some(result)
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::template::Pool;

	fn prepare_pool() -> Pool {
		let mut pool = Pool::default_rule();
		pool.append("color", "red");
		pool.append("color", "blue");
		pool.append("shape", "circle");
		pool.append("shape", "square");

		pool
	}

	#[test]
	fn solve_color() {
		let pool = prepare_pool();

		let keys = &["color".into()];
		let list = pool.intersect(keys).unwrap();
		let solver = Solver::new(list, keys.to_vec());

		let result: Vec<Template> = solver.collect();
		let expect = vec![
			Template::default().insert("color".into(), "red".into()),
			Template::default().insert("color".into(), "blue".into()),
		];

		assert_eq!(result, expect);
	}

	#[test]
	fn solve_shape() {
		let pool = prepare_pool();
		let keys = &["shape".into()];
		let list = pool.intersect(keys).unwrap();
		let solver = Solver::new(list, keys.to_vec());

		let result: Vec<Template> = solver.collect();
		let expect = vec![
			Template::default().insert("shape".into(), "circle".into()),
			Template::default().insert("shape".into(), "square".into()),
		];

		assert_eq!(result, expect);
	}

	#[test]
	fn solve_both() {
		let pool = prepare_pool();
		let keys = &["color".into(), "shape".into()];
		let list = pool.intersect(keys).unwrap();
		let solver = Solver::new(list, keys.to_vec());

		let result: Vec<Template> = solver.collect();
		let expect = vec![
			Template::default()
				.insert("color".into(), "red".into())
				.insert("shape".into(), "circle".into()),
			Template::default()
				.insert("color".into(), "red".into())
				.insert("shape".into(), "square".into()),
			Template::default()
				.insert("color".into(), "blue".into())
				.insert("shape".into(), "circle".into()),
			Template::default()
				.insert("color".into(), "blue".into())
				.insert("shape".into(), "square".into()),
		];

		assert_eq!(result, expect);
	}

	#[test]
	fn empty_input() {
		let keys = vec![];
		let list = vec![];
		let solver = Solver::new(list, keys);

		let result: Vec<_> = solver.collect();
		let expect = vec![Template::default()];

		assert_eq!(result, expect);
	}
}