mintyml 0.1.19

A minialist alternative syntax to HTML
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

use alloc::{boxed::Box, vec::Vec};
use gramma::parse::{Location, LocationRange};

use crate::ast::post_selector_chain;

use super::tokens::*;

gramma::define_string_pattern!(
    fn text_word() {
        repeat(
            1..,
            (!char("\\[]{}<> \n\r\t") & !whitespace()) + !precedes(char('>'))
                | alphanumeric()
                | escape(),
        )
        .simple()
            + !precedes(post_selector_chain())
    }

    fn interpolation() {
        !follows(char("\\{"))
            + exactly("{{")
            + !precedes(char('{'))
            + char(..).repeat(..).lazy()
            + !follows(char("\\}"))
            + exactly("}}")
            + !precedes(char('}'))
            | exactly("{%") + char(..).repeat(..).lazy() + exactly("%}")
            | exactly("<%") + char(..).repeat(..).lazy() + exactly("%>")
            | exactly("<?") + char(..).repeat(..).lazy() + exactly("?>")
    }
);

gramma::define_token!(
    #[pattern(matcher = {
        text_word() + repeat(.., space() + text_word()).simple()
    })]
    /// Matches any part of a paragraph line that is not an element.
    pub struct TextSegment;

    #[pattern(matcher = {
        exactly("```") | exactly(r#"""""#) | exactly("'''")
    })]
    /// Fail if TextSegment matches this so it doesn't match multiline elements.
    pub struct InvalidTextSegment;

    #[pattern(exact = r"<[")]
    pub struct VerbatimOpen;

    #[pattern(exact = "raw")]
    pub struct KeywordRaw;

    #[pattern(matcher = {
        char('[') + char(..).repeat(..).lazy() + exactly("]]>")
    })]
    pub struct VerbatimTail0;

    #[pattern(matcher = {
        exactly("#[") + char(..).repeat(..).lazy() + exactly("]#]>")
    })]
    pub struct VerbatimTail1;

    #[pattern(matcher = {
        exactly("##[") + char(..).repeat(..).lazy() + exactly("]##]>")
    })]
    pub struct VerbatimTail2;

    #[pattern(matcher = {
        exactly("'''") + (!char("\n`")).repeat(..).simple() + line_end()
    })]
    pub struct MultilineUnescapedOpen;
    #[pattern(matcher = {
        char(..).repeat(1..).lazy() + (
            src_end()
            | precedes(exactly("'''"))
            + follows(line_start() + char("\t ").repeat(..).simple())
        )
    })]
    pub struct MultilineUnescapedBody;
    #[pattern(matcher = exactly("'''") + !precedes(char('\'')))]
    pub struct MultilineUnescapedClose;

    #[pattern(matcher = {
        exactly("\"\"\"") + (!char("\n`")).repeat(..).simple() + line_end()
    })]
    pub struct MultilineEscapedOpen;
    #[pattern(matcher = {
        char(..).repeat(1..).lazy() + (
            src_end()
            | precedes(exactly("\"\"\""))
            + follows(line_start() + char("\t ").repeat(..).simple())
        )
    })]
    pub struct MultilineEscapedBody;
    #[pattern(matcher = exactly("\"\"\"") + !precedes(char('"')))]
    pub struct MultilineEscapedClose;

    #[pattern(matcher = {
        exactly("```") + (!char("\n`")).repeat(..).simple() + line_end()
    })]
    pub struct MultilineCodeOpen;
    #[pattern(matcher = {
        char(..).repeat(1..).lazy() + (
            src_end()
            | precedes(exactly("```"))
            + follows(line_start() + char("\t ").repeat(..).simple())
        )
    })]
    pub struct MultilineCodeBody;
    #[pattern(matcher = exactly("```") + !precedes(char('`')))]
    pub struct MultilineCodeClose;

    #[pattern(matcher = interpolation())]
    pub struct Interpolation;

    #[pattern(matcher = {
        !char("<!")
        | char('<') + !precedes(char('!'))
        | char('!') + !precedes(char('>'))
    })]
    pub struct CommentText;

    #[pattern(exact = "<!")]
    pub struct OpenComment;
    #[pattern(exact = "!>")]
    pub struct CloseComment;
);

gramma::define_rule!(
    pub enum InlineText {
        Segment { value: TextSegment },
        Verbatim { value: Verbatim },
        Comment { comment: Comment },
        Interpolation { interpolation: Interpolation },
    }

    pub struct Verbatim {
        pub open: VerbatimOpen,
        pub raw: Option<KeywordRaw>,
        pub tail: VerbatimTail,
    }

    pub enum VerbatimTail {
        Verbatim0 { value: VerbatimTail0 },
        Verbatim1 { value: VerbatimTail1 },
        Verbatim2 { value: VerbatimTail2 },
    }

    pub enum Multiline {
        Escaped {
            open: MultilineEscapedOpen,
            start: Location,
            body: MultilineEscapedBody,
            end: Location,
            close: MultilineEscapedClose,
        },
        Unescaped {
            open: MultilineUnescapedOpen,
            start: Location,
            body: MultilineUnescapedBody,
            end: Location,
            close: MultilineUnescapedClose,
        },
        Code {
            open: MultilineCodeOpen,
            start: Location,
            body: MultilineCodeBody,
            end: Location,
            close: MultilineCodeClose,
        },
    }

    pub struct Comment {
        pub start: Location,
        pub open: OpenComment,
        #[transform(parse_as<Vec<CommentPart>>)]
        pub inner: LocationRange,
        pub close: Option<CloseComment>,
        pub end: Location,
    }

    pub enum CommentPart {
        Text { text: CommentText },
        Comment { comment: Box<Comment> },
    }
);