snax 0.3.0

JSX-like syntax for proc macro authors
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

use proc_macro2::{
    TokenTree,
    Ident,
};

use crate::SnaxAttribute;

#[derive(Debug)]
pub enum HtmlToken {
    OpenTag(HtmlOpenToken),
    CloseTag(HtmlCloseToken),
    SelfClosingTag(HtmlSelfClosingToken),
    Textish(HtmlTextishToken),
    OpenFragment,
    CloseFragment,
}

#[derive(Debug)]
pub struct HtmlOpenToken {
    pub name: Ident,
    pub attributes: Vec<SnaxAttribute>,
}

#[derive(Debug, Clone)]
pub struct HtmlCloseToken {
    pub name: Ident,
}

#[derive(Debug)]
pub struct HtmlSelfClosingToken {
    pub name: Ident,
    pub attributes: Vec<SnaxAttribute>,
}

#[derive(Debug)]
pub struct HtmlTextishToken {
    pub content: TokenTree,
}

#[derive(Debug)]
pub enum TokenizeError {
    UnexpectedEnd,
    UnexpectedToken(TokenTree),
}

/// Grabs the next item of the iterator, handling the None case, and then makes
/// sure the given pattern matches.
macro_rules! expect_next {
    ($iterator: expr, $pattern: pat $(if $guard: expr)? => $result: expr) => {
        match $iterator.next().ok_or(TokenizeError::UnexpectedEnd)? {
            $pattern $(if $guard)? => $result,
            unexpected => return Err(TokenizeError::UnexpectedToken(unexpected)),
        }
    };
    ($iterator: expr, $pattern: pat $(if $guard: expr)?) => {
        expect_next!($iterator, $pattern $(if $guard)? => ())
    };
}

pub fn parse_html_token(mut input: impl Iterator<Item = TokenTree>) -> Result<HtmlToken, TokenizeError> {
    match input.next().ok_or(TokenizeError::UnexpectedEnd)? {
        TokenTree::Punct(ref punct) if punct.as_char() == '<' => {
            match input.next().ok_or(TokenizeError::UnexpectedEnd)? {
                TokenTree::Punct(ref punct) if punct.as_char() == '/' => {
                    match input.next().ok_or(TokenizeError::UnexpectedEnd)? {
                        TokenTree::Punct(ref punct) if punct.as_char() == '>' => {
                            Ok(HtmlToken::CloseFragment)
                        },
                        TokenTree::Ident(name) => {
                            expect_next!(input, TokenTree::Punct(ref punct) if punct.as_char() == '>');

                            Ok(HtmlToken::CloseTag(HtmlCloseToken {
                                name,
                            }))
                        },
                        unexpected => return Err(TokenizeError::UnexpectedToken(unexpected)),
                    }
                },
                TokenTree::Punct(ref punct) if punct.as_char() == '>' => {
                    Ok(HtmlToken::OpenFragment)
                },
                TokenTree::Ident(name) => {
                    let mut attributes = Vec::new();

                    loop {
                        match input.next().ok_or(TokenizeError::UnexpectedEnd)? {
                            TokenTree::Ident(attribute_name) => {
                                expect_next!(input, TokenTree::Punct(ref punct) if punct.as_char() == '=');

                                match input.next().ok_or(TokenizeError::UnexpectedEnd)? {
                                    value @ TokenTree::Literal(_) | value @ TokenTree::Group(_) => {
                                        attributes.push(SnaxAttribute::Simple {
                                            name: attribute_name,
                                            value,
                                        });
                                    },
                                    unexpected => return Err(TokenizeError::UnexpectedToken(unexpected)),
                                }
                            },
                            TokenTree::Punct(ref punct) if punct.as_char() == '>' => {
                                // Opening tag

                                return Ok(HtmlToken::OpenTag(HtmlOpenToken {
                                    name,
                                    attributes,
                                }));
                            },
                            TokenTree::Punct(ref punct) if punct.as_char() == '/' => {
                                // Self-closing tag

                                expect_next!(input, TokenTree::Punct(ref punct) if punct.as_char() == '>');

                                return Ok(HtmlToken::SelfClosingTag(HtmlSelfClosingToken {
                                    name,
                                    attributes,
                                }));
                            },
                            unexpected => return Err(TokenizeError::UnexpectedToken(unexpected)),
                        }
                    }
                },
                unexpected => return Err(TokenizeError::UnexpectedToken(unexpected)),
            }
        },
        content @ TokenTree::Literal(_) => Ok(HtmlToken::Textish(HtmlTextishToken { content })),
        content @ TokenTree::Group(_) => Ok(HtmlToken::Textish(HtmlTextishToken { content })),
        unexpected => return Err(TokenizeError::UnexpectedToken(unexpected)),
    }
}