pest3_derive 0.0.3

Early WIP prototype version of pest 3.0
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

use pest3_core::typed::TypedNode;
use pest3_derive::Parser;

#[derive(Parser)]
#[grammar_inline = r#"
s1  = { "a" }
s2  = { "a" - "b" }
s3  = { "a" - "b" - "c" }
s4  = { "a" - "b" - "c" - "d" }
s5  = { "a" - "b" - "c" - "d" - "e" }
s6  = { "a" - "b" - "c" - "d" - "e" - "f" }
s7  = { "a" - "b" - "c" - "d" - "e" - "f" - "g" }
s8  = { "a" - "b" - "c" - "d" - "e" - "f" - "g" - "h" }
s9  = { "a" - "b" - "c" - "d" - "e" - "f" - "g" - "h" - "i" }
s10 = { "a" - "b" - "c" - "d" - "e" - "f" - "g" - "h" - "i" - "j" }
s11 = { "a" - "b" - "c" - "d" - "e" - "f" - "g" - "h" - "i" - "j" - "k" }
s12 = { "a" - "b" - "c" - "d" - "e" - "f" - "g" - "h" - "i" - "j" - "k" - "l" }
"#]
struct Parser;

macro_rules! test {
    ($name:ident, $input:literal, $($fields:tt)*) => {
        mod $name {
            use super::rules;
            use pest3_core::typed::TypedNode;

            #[test]
            fn matched() -> anyhow::Result<()> {
                let res = rules::$name::try_parse($input)?;
                assert_eq!(res, res.clone());
                Ok(())
            }
            #[test]
            fn unmatched() {
                rules::$name::try_parse(concat!("_", $input)).unwrap_err();
            }
            #[test]
            fn incomplete() {
                rules::$name::try_parse(concat!($input, "_")).unwrap_err();
            }
        }
    };
}

test!(s2, "ab", e0 e1);
test!(s3, "abc", e0 e1 e2);
test!(s4, "abcd", e0 e1 e2 e3);
test!(s5, "abcde", e0 e1 e2 e3 e4);
test!(s6, "abcdef", e0 e1 e2 e3 e4 e5);
test!(s7, "abcdefg", e0 e1 e2 e3 e4 e5 e6);
test!(s8, "abcdefgh", e0 e1 e2 e3 e4 e5 e6 e7);
test!(s9, "abcdefghi", e0 e1 e2 e3 e4 e5 e6 e7 e8);
test!(s10, "abcdefghij", e0 e1 e2 e3 e4 e5 e6 e7 e8 e9);
test!(s11, "abcdefghijk", e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10);
test!(s12, "abcdefghijkl", e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11);

#[test]
fn single() -> anyhow::Result<()> {
    rules::s1::try_parse("a")?;
    Ok(())
}

#[test]
fn as_ref() -> anyhow::Result<()> {
    let _s4 = rules::s4::try_parse("abcd")?;
    Ok(())
}