platelet 0.1.2

HTML-first templating language
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

use winnow::combinator::alt;
use winnow::combinator::{delimited, separated_pair};
use winnow::error::StrContext;
use winnow::prelude::*;

use crate::expression_parser::Expression;
use crate::expression_parser::{expression, identifier, ws};

#[derive(Debug, PartialEq)]
pub(crate) enum ForLoop {
    // item in items
    Simple(String, Expression),
    // (item, index) in items
    // (value, key) in object
    IndexedObjectOrKeyValue((String, String), Expression),
    // (value, name, index) in object
    IndexedKeyValue((String, String, String), Expression),
}

pub(crate) fn for_loop(input: &mut &str) -> Result<ForLoop, String> {
    delimited(ws, for_, ws)
        .parse(input)
        .map_err(|e| format!("{}", e.to_string()))
}

fn for_(input: &mut &str) -> PResult<ForLoop> {
    alt((
        separated_pair(identifier, (ws, "in", ws), expression)
            .map(|(id, exp)| ForLoop::Simple(id, exp)),
        separated_pair(
            delimited(
                ('(', ws),
                separated_pair(identifier, (ws, ',', ws), identifier),
                (ws, ')'),
            ),
            (ws, "in", ws),
            expression,
        )
        .map(|(p, exp)| ForLoop::IndexedObjectOrKeyValue(p, exp)),
        separated_pair(
            delimited(
                ('(', ws),
                separated_pair(
                    identifier,
                    (ws, ',', ws),
                    separated_pair(identifier, (ws, ',', ws), identifier),
                ),
                (ws, ')'),
            ),
            (ws, "in", ws),
            expression,
        )
        .map(|((a, (b, c)), exp)| ForLoop::IndexedKeyValue((a, b, c), exp)),
    ))
    .context(StrContext::Label("for loop"))
    .parse_next(input)
}

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

    #[test]
    fn simple() {
        assert_eq!(
            for_.parse_peek("item in items"),
            Ok((
                "",
                ForLoop::Simple(
                    "item".to_owned(),
                    Expression::Identifier("items".to_owned())
                )
            ))
        );
    }

    #[test]
    fn complex() {
        assert_eq!(
            for_.parse_peek("(item, i) in items"),
            Ok((
                "",
                ForLoop::IndexedObjectOrKeyValue(
                    ("item".to_owned(), "i".to_owned()),
                    Expression::Identifier("items".to_owned())
                )
            ))
        );
    }

    #[test]
    fn indexed_key_value() {
        assert_eq!(
            for_.parse_peek("(key, value, index) in items"),
            Ok((
                "",
                ForLoop::IndexedKeyValue(
                    ("key".to_owned(), "value".to_owned(), "index".to_owned()),
                    Expression::Identifier("items".to_owned())
                )
            ))
        );
    }
}