kobold_macros 0.3.0

Macros for Kobold
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

use proc_macro::Ident;
use proc_macro2::TokenStream as QuoteTokens;
use std::fmt::{self, Debug, Display};

pub struct Field {
    pub kind: FieldKind,
    pub typ: QuoteTokens,
    pub name: QuoteTokens,
    pub expr: QuoteTokens,
}

impl Debug for Field {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Foo")
            .field("kind", &self.kind)
            .field("typ", &DisplayDebug(&self.typ))
            .field("name", &DisplayDebug(&self.name))
            .field("expr", &DisplayDebug(&self.expr))
            .finish()
    }
}

struct DisplayDebug<T>(T);

impl<T: Display> Debug for DisplayDebug<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.0, f)
    }
}

#[derive(Debug)]
pub enum FieldKind {
    Html,
    Attr,
    Callback(String),
}

#[derive(Debug)]
pub enum Node {
    Element(Element),
    Text(String),
    Expression, // variable arg, node ref arg
    Fragment(Vec<Node>),
}

impl Node {
    pub fn is_expression(&self) -> bool {
        matches!(self, Node::Expression)
    }

    pub fn is_fragment(&self) -> bool {
        matches!(self, Node::Fragment(_))
    }
}

#[derive(Debug)]
pub struct Element {
    pub tag: String,
    pub generics: Option<QuoteTokens>,
    pub attributes: Vec<Attribute>,
    pub children: Vec<Node>,
    pub children_raw: Option<QuoteTokens>,
    pub defaults: bool,
}

impl Element {
    pub fn is_component(&self) -> bool {
        !self.tag.chars().next().unwrap().is_ascii_lowercase()
    }
}

#[derive(Debug)]
pub struct Attribute {
    pub name: String,
    pub ident: Ident,
    pub value: AttributeValue,
}

#[derive(Debug)]
pub enum AttributeValue {
    Text(String),
    Expression(QuoteTokens),
}