valkyrie-docgen 0.0.1

...
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

use super::*;

#[derive(Debug, Clone)]
pub enum Typing {
    Primitive(String),
    Generic(String),
    Normal { name: String, path: String },
}

impl Renderable for Typing {
    fn render(&self) -> Html {
        match self {
            Typing::Primitive(term) => html! {<span class="primitive">{term}</span>},
            Typing::Generic(term) => html! {<span class="generic">{term}</span>},
            Typing::Normal { name, path } => match path.len() {
                0 => html! {<span class="type">{name}</span>},
                _ => html! {<a class="type" href=path.as_str()>{name}</a>},
            },
        }
    }
}

impl From<&str> for Typing {
    fn from(s: &str) -> Self {
        match s {
            "u8" | "u16" | "u32" | "u64" | "i8" | "i16" | "i32" | "i64" | "f32" | "f64" | "char" | "bool" => {
                Typing::Primitive(String::from(s))
            }
            _ => Typing::Generic(String::from(s)),
        }
    }
}

impl Display for Typing {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            Typing::Primitive(name) | Typing::Generic(name) | Typing::Normal { name, .. } => write!(f, "{}", name),
        }
    }
}

impl Listable for Typing {
    fn left() -> Option<Html> {
        Some(Html::from("<"))
    }

    fn right() -> Option<Html> {
        Some(Html::from(">"))
    }

    fn delimiter() -> Html {
        Html::from(", ")
    }
}

pub fn build_generics(generics: &[Typing]) -> Html {
    let left = vec![Html::from("<")];
    let right = vec![Html::from(">")];
    let comma = Html::from(", ");
    // let comma: Html = html!{","};
    let items: Html =
        left.into_iter().chain(generics.into_iter().map(|s| s.render()).intersperse(comma)).chain(right.into_iter()).collect();
    html! {<>{items}</>}
}