pest3 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
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
114
115
116
117

//! Copied from [pest-typed/tests/predefined_node.rs] and modified.
//!
//! [pest-typed/tests/predefined_node.rs]: https://github.com/TheVeryDarkness/pest-typed/blob/0.12.1/main/tests/predefined_node.rs

extern crate alloc;

#[cfg(test)]
mod tests {
    use pest3_core::{
        choice::Choice2,
        full_rule_struct,
        typed::{
            template::*,
            wrapper::{Rule as RuleWrapper, String as StringWrapper},
            RuleType, Tracker, TypedNode, TypedParser,
        },
        unicode, Position, Span, Stack,
    };

    #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    pub enum Rule {
        Foo,
        EOI,
    }

    impl RuleType for Rule {
        const EOI: Self = Self::EOI;
    }

    type OptionalTrivia<'i> = Rep<Choice2<Char<' '>, Char<'\t'>>, Empty>;

    unicode!(MATH);

    struct Parser;
    impl TypedParser<Rule> for Parser {}

    #[derive(Clone, Debug, Hash, PartialEq, Eq)]
    pub struct Foo;
    impl StringWrapper for Foo {
        const CONTENT: &'static str = "foo";
    }

    #[derive(Debug, PartialEq, Eq)]
    pub struct StrFoo {
        content: Str<Foo>,
    }
    impl RuleWrapper for StrFoo {
        type Rule = Rule;
        const RULE: Rule = Rule::Foo;
    }
    impl<'i> TypedNode<'i, Rule> for StrFoo {
        fn try_parse_with_partial(
            input: Position<'i>,
            stack: &mut Stack<Span<'i>>,
            tracker: &mut Tracker<'i, Rule>,
        ) -> Option<(Position<'i>, Self)> {
            let (pos, content) = Str::<Foo>::try_parse_with_partial(input, stack, tracker)?;
            Some((pos, Self { content }))
        }
        fn check_with_partial(
            input: Position<'i>,
            stack: &mut Stack<Span<'i>>,
            tracker: &mut Tracker<'i, Rule>,
        ) -> Option<Position<'i>> {
            let pos = Str::<Foo>::check_with_partial(input, stack, tracker)?;
            Some(pos)
        }
    }

    #[test]
    fn string() {
        let s = StrFoo::try_parse("foo").unwrap();
        assert_eq!(format!("{s:?}"), r#"StrFoo { content: Str("foo") }"#)
    }

    #[test]
    fn ignore() {
        type Trivia<'i> = OptionalTrivia<'i>;
        let trivia = <Trivia as TypedNode<'static, Rule>>::try_parse(" \t  \t\t").unwrap();
        assert_eq!(
            format!("{trivia:?}"),
            "RepMinMax([Choice0(Char(' ')), Choice1(Char('\\t')), Choice0(Char(' ')), Choice0(Char(' ')), Choice1(Char('\\t')), Choice1(Char('\\t'))])"
        );
    }

    #[test]
    fn repetition() {
        type R<'i> = Rep<StrFoo, OptionalTrivia<'i>>;

        let rep1 = Parser::try_parse::<R>("foofoofoo").unwrap();
        let rep2 = Parser::try_parse::<R>("foo foo foo").unwrap();
        let rep3 = Parser::try_parse::<R>("foo foo\tfoo").unwrap();
        let _ = R::try_parse("").unwrap();
        assert_eq!(rep1, rep2);
        assert_eq!(rep1, rep3);
    }

    #[test]
    fn repetition_at_least_once() {
        type R<'i> = RepOnce<Insens<'i, Foo>, OptionalTrivia<'i>>;

        let rep1 = Parser::try_parse::<R>("fooFoofoo").unwrap();
        let rep2 = Parser::try_parse::<R>("foo Foo foo").unwrap();
        let rep3 = Parser::try_parse::<R>("Foo foo\tfoo").unwrap();
        let rep4 = Parser::try_parse::<R>("Foofoofoo").unwrap();
        assert_eq!(rep1, rep2);
        assert_ne!(rep1, rep3);
        assert_eq!(rep3, rep4);
    }

    #[allow(unused)]
    struct A<'i> {
        content: Empty,
        span: Span<'i>,
    }
    full_rule_struct!(A, (), Rule, Rule::Foo, Empty, Box<Empty>,);
}