fhtml-macros 0.6.1

Macro implementations for `fhtml`
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

use core::fmt;
use std::vec::IntoIter;

use syn::parse::Parse;

use crate::ast;

#[cfg_attr(test, derive(Debug, PartialEq))]
pub(crate) enum AstPart<Value: fmt::Display> {
    Doctype,
    OpeningTagStart,
    OpeningTagName(ast::DashIdent),
    OpeningTagEnd,
    ClosingTagStart,
    ClosingTagName(ast::DashIdent),
    ClosingTagEnd,
    AttrName(ast::DashIdent),
    AttrValueStart,
    AttrValue(Value),
    AttrValueEnd,
    Value(Value),
}

impl<Value: Parse + fmt::Display> IntoIterator for ast::Attr<Value> {
    type IntoIter = core::array::IntoIter<AstPart<Value>, 4>;
    type Item = AstPart<Value>;

    fn into_iter(self) -> Self::IntoIter {
        [
            AstPart::AttrName(self.name),
            AstPart::AttrValueStart,
            AstPart::AttrValue(self.value),
            AstPart::AttrValueEnd,
        ]
        .into_iter()
    }
}

impl<Value: Parse + fmt::Display> IntoIterator for ast::Tag<Value> {
    type IntoIter = IntoIter<AstPart<Value>>;
    type Item = AstPart<Value>;

    fn into_iter(self) -> Self::IntoIter {
        match self {
            Self::Opening { name, attrs, .. } => {
                let mut v = vec![
                    AstPart::OpeningTagStart,
                    AstPart::OpeningTagName(name),
                ];
                for attr in attrs {
                    v.extend(attr.into_iter())
                }
                v.push(AstPart::OpeningTagEnd);
                v
            }
            Self::Closing { name } => vec![
                AstPart::ClosingTagStart,
                AstPart::ClosingTagName(name),
                AstPart::ClosingTagEnd,
            ],
        }
        .into_iter()
    }
}

impl<Value: Parse + fmt::Display> IntoIterator for ast::Node<Value> {
    type IntoIter = IntoIter<AstPart<Value>>;
    type Item = AstPart<Value>;

    fn into_iter(self) -> Self::IntoIter {
        match self {
            ast::Node::Doctype(_) => vec![AstPart::Doctype].into_iter(),
            ast::Node::Tag(tag) => tag.into_iter(),
            ast::Node::Value(value) => vec![AstPart::Value(value)].into_iter(),
        }
    }
}

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

    macro_rules! dash_ident {
        ($($arg:tt)*) => {
            syn::parse2::<crate::ast::DashIdent>(
                quote::quote! { $($arg)* }
            ).unwrap()
        }
    }

    #[test]
    fn opening_tags() {
        assert_eq!(
            ast::Tag::<ast::LitValue>::Opening {
                name: dash_ident!(foo),
                attrs: vec![],
                self_closing: false
            }
            .into_iter()
            .collect::<Vec<_>>(),
            vec![
                AstPart::OpeningTagStart,
                AstPart::OpeningTagName(dash_ident!(foo)),
                AstPart::OpeningTagEnd,
            ]
        );
    }
}