topcoat-cli 0.12.0

A modular, batteries-included Rust web framework for server-rendered apps.
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

//! Formatting of Topcoat macro bodies.

use topcoat_core_grammar::common::pretty::Registry;

/// Every macro whose body Topcoat can format: function-like macros, then
/// attribute macros.
pub const MACROS: &[&str] = &[
    "asset",
    "view",
    "attributes",
    "class",
    "live",
    "emit",
    "font_face",
    "font",
    "fontsource_font_face",
    "fontsource_font",
    "include",
    "iconify_icon",
    "messages",
    "t",
    "not_found",
    "segment",
    "path_param",
    "module_param",
    "href",
    "expr",
    "memoize",
    "component",
    "page",
    "route",
    "layout",
    "layer",
    "query_params",
    "procedure",
    "shard",
    "record",
];

/// Registers the macro called `name` for formatting. Returns `false` if it is not one of
/// [`MACROS`].
pub fn register(registry: &mut Registry, name: &str) -> bool {
    use topcoat_asset_grammar::asset::Asset;
    use topcoat_core_grammar::memoize::MemoizeAttr;
    use topcoat_font_grammar::{font::Font, font_face::FontFace, fontsource};
    use topcoat_icon_grammar::iconify::{IconifyIcon, Include};
    use topcoat_l10n_grammar::fluent::{Messages, Translate};
    use topcoat_router_grammar::{
        href::Href, layer::LayerAttr, layout::LayoutAttr, module_param::ModuleParam,
        not_found::NotFound, page::PageAttr, path_param::PathParam, query_params::QueryParamsAttr,
        route::RouteAttr, segment::Segment,
    };
    use topcoat_runtime_grammar::{
        expr::ExprInput, procedure::ProcedureAttr, record::RecordAttr, shard::ShardAttr,
    };
    use topcoat_view_grammar::{
        attributes::Attributes,
        class::Class,
        component::ComponentAttr,
        live::{Emit, Live},
        view::View,
    };

    match name {
        "asset" => registry.register_function_like::<Asset>(name),
        "view" => registry.register_function_like::<View>(name),
        "attributes" => registry.register_function_like::<Attributes>(name),
        "class" => registry.register_function_like::<Class>(name),
        "live" => registry.register_function_like::<Live>(name),
        "emit" => registry.register_function_like::<Emit>(name),
        "font_face" => registry.register_function_like::<FontFace>(name),
        "font" => registry.register_function_like::<Font>(name),
        "fontsource_font_face" => {
            registry.register_function_like::<fontsource::font_face::FontsourceFontFace>(name)
        }
        "fontsource_font" => {
            registry.register_function_like::<fontsource::font::FontsourceFont>(name)
        }
        "include" => registry.register_function_like::<Include>(name),
        "iconify_icon" => registry.register_function_like::<IconifyIcon>(name),
        "messages" => registry.register_function_like::<Messages>(name),
        "t" => registry.register_function_like::<Translate>(name),
        "not_found" => registry.register_function_like::<NotFound>(name),
        "segment" => registry.register_function_like::<Segment>(name),
        "path_param" => registry.register_function_like::<PathParam>(name),
        "module_param" => registry.register_function_like::<ModuleParam>(name),
        "href" => registry.register_function_like::<Href>(name),
        "expr" => registry.register_function_like::<ExprInput>(name),
        "memoize" => registry.register_attribute::<MemoizeAttr>(name),
        "component" => registry.register_attribute::<ComponentAttr>(name),
        "page" => registry.register_attribute::<PageAttr>(name),
        "route" => registry.register_attribute::<RouteAttr>(name),
        "layout" => registry.register_attribute::<LayoutAttr>(name),
        "layer" => registry.register_attribute::<LayerAttr>(name),
        "query_params" => registry.register_attribute::<QueryParamsAttr>(name),
        "procedure" => registry.register_attribute::<ProcedureAttr>(name),
        "shard" => registry.register_attribute::<ShardAttr>(name),
        "record" => registry.register_attribute::<RecordAttr>(name),
        _ => return false,
    };
    true
}

/// Returns a registry that formats every macro in [`MACROS`].
pub fn registry() -> Registry {
    let mut registry = Registry::new();
    for name in MACROS {
        register(&mut registry, name);
    }
    registry
}

#[cfg(test)]
mod tests {
    use topcoat_core_grammar::common::pretty::pretty_print_str;

    use super::*;

    #[test]
    fn every_listed_macro_registers() {
        let mut registry = Registry::new();
        for name in MACROS {
            assert!(register(&mut registry, name), "{name}");
        }
        assert!(!register(&mut registry, "println"));
    }

    #[test]
    fn formats_a_macro_nested_in_another_macro() {
        let input = "view! { <p>(t!(greeting,name :user . name))</p> }";
        let expected = "view! { <p>(t!(greeting, name: user.name))</p> }";
        let formatted = pretty_print_str(&registry(), input).unwrap();
        assert_eq!(formatted, expected);
    }
}