miasma 0.2.7

Trap malicious AI web scrapers in an endless pit of poisoned training data.
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

use crate::templating::TemplatePart;

/// Iterates over parts of a template.
///
/// ```
/// use miasma::templating::TemplateIter;
///
/// let from_a_string: TemplateIter = "<p>Hello world!</p>".into();
/// let from_an_array: TemplateIter = ["<p>Hello world!</p>", "<div>Goodbye</div>"].into();
/// let manually = TemplateIter::new(vec!["<span>Hello </span>".into(), "<span>world!</span>".into()]);
/// let nested = TemplateIter::new(vec![TemplateIter::new(vec!["<p>Hello world!</p>".into()]).into()]);
/// ```
#[derive(Default)]
pub struct TemplateIter {
    current: usize,
    parts: Vec<TemplatePart>,
}

impl TemplateIter {
    pub fn new(parts: Vec<TemplatePart>) -> Self {
        Self { current: 0, parts }
    }
}

impl Iterator for TemplateIter {
    type Item = &'static str;

    fn next(&mut self) -> Option<Self::Item> {
        let next = match self.parts.get_mut(self.current) {
            None => return None,
            Some(p) => match p {
                TemplatePart::Str(s) => {
                    self.current += 1;
                    *s
                }
                TemplatePart::Iter(i) => match i.next() {
                    Some(s) => s,
                    None => {
                        self.current += 1;
                        return self.next();
                    }
                },
            },
        };
        Some(next)
    }
}

impl<T, const N: usize> From<[T; N]> for TemplateIter
where
    T: Into<TemplatePart>,
{
    fn from(value: [T; N]) -> Self {
        Self::new(value.into_iter().map(Into::into).collect())
    }
}

impl<T> From<Vec<T>> for TemplateIter
where
    T: Into<TemplatePart>,
{
    fn from(value: Vec<T>) -> Self {
        Self::new(value.into_iter().map(Into::into).collect())
    }
}

impl From<&'static str> for TemplateIter {
    fn from(value: &'static str) -> Self {
        Self::new(vec![value.into()])
    }
}

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

    #[test]
    fn next_handles_flat_parts() {
        let iter: TemplateIter = ["1", "2", "3"].into();
        let expected = vec!["1", "2", "3"];

        let actual: Vec<&str> = iter.collect();
        assert_eq!(actual, expected);
    }

    #[test]
    fn next_handles_nested_parts() {
        let iter = TemplateIter::new(vec![
            "1".into(),
            TemplatePart::Iter(["2", "3"].into()),
            "4".into(),
            TemplatePart::Iter(["5", "6"].into()),
            "7".into(),
        ]);
        let expected = vec!["1", "2", "3", "4", "5", "6", "7"];

        let actual: Vec<&str> = iter.collect();
        assert_eq!(actual, expected);
    }

    #[test]
    fn next_is_safe_to_call_after_done() {
        let mut iter: TemplateIter = ["1", "2", "3"].into();
        // drain it
        for _ in iter.by_ref() {}

        assert_eq!(iter.next(), None);
        assert_eq!(iter.next(), None);
    }
}