statica 0.50.3

A blazingly fast static site generator that builds on just HTML
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

//! Named / default `<slot>` filling on the AST.

use serde_json::Value;

use crate::funnel;
use crate::parse::{Node, SlotKind};

pub fn fill_named_slots(nodes: &mut [Node], ctx: &Value) {
    let mut i = 0;
    while i < nodes.len() {
        let replace = match &nodes[i] {
            Node::Element(el) => match el.slot_kind() {
                Some(SlotKind::Named(name)) => Some(name),
                Some(SlotKind::Default | SlotKind::FragmentMount(_)) | None => None,
            },
            _ => None,
        };
        if let Some(name) = replace {
            // Scope is validated statically; missing/null at runtime → empty.
            let html = match funnel::path_value(ctx, &name) {
                None | Some(Value::Null) => String::new(),
                Some(v) => funnel::value_to_html(v),
            };
            nodes[i] = Node::Text(html);
        } else if let Node::Element(el) = &mut nodes[i] {
            fill_named_slots(&mut el.children, ctx);
        }
        i += 1;
    }
}

/// Project usage children into unnamed `<slot>` (no name, no id).
pub fn fill_default_slots(nodes: &mut Vec<Node>, children: &[Node]) {
    let mut i = 0;
    while i < nodes.len() {
        let is_default = matches!(
            &nodes[i],
            Node::Element(el) if matches!(el.slot_kind(), Some(SlotKind::Default))
        );
        if is_default {
            if children.is_empty() {
                // keep fallback children inside the slot by unwrapping
                if let Node::Element(el) = &mut nodes[i] {
                    let fallback = std::mem::take(&mut el.children);
                    nodes.splice(i..=i, fallback);
                }
            } else {
                nodes.splice(i..=i, children.iter().cloned());
            }
        } else if let Node::Element(el) = &mut nodes[i] {
            fill_default_slots(&mut el.children, children);
        }
        i += 1;
    }
}

pub fn clear_remaining_named_slots(nodes: &mut Vec<Node>) {
    let mut i = 0;
    while i < nodes.len() {
        let clear = matches!(
            &nodes[i],
            Node::Element(el) if matches!(el.slot_kind(), Some(SlotKind::Named(_)))
        );
        if clear {
            if let Node::Element(el) = &mut nodes[i] {
                let fallback = std::mem::take(&mut el.children);
                nodes.splice(i..=i, fallback);
            }
        } else if let Node::Element(el) = &mut nodes[i] {
            clear_remaining_named_slots(&mut el.children);
            i += 1;
        } else {
            i += 1;
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse::{Element, Node};
    use indexmap::IndexMap;
    use serde_json::json;

    fn named_slot(name: &str, fallback: &str) -> Node {
        let mut attrs = IndexMap::new();
        attrs.insert("name".into(), name.into());
        Node::Element(Element {
            name: "slot".into(),
            attrs,
            children: vec![Node::Text(fallback.into())],
            void: false,
        })
    }

    #[test]
    fn null_and_missing_slots_render_empty() {
        let mut nodes = vec![
            named_slot("label", "fallback"),
            named_slot("missing", "fallback"),
        ];
        fill_named_slots(&mut nodes, &json!({"label": null}));
        assert!(matches!(&nodes[0], Node::Text(t) if t.is_empty()));
        assert!(matches!(&nodes[1], Node::Text(t) if t.is_empty()));
    }

    #[test]
    fn dotted_slot_name_resolves_path() {
        let mut nodes = vec![named_slot("posts.headline", "fallback")];
        fill_named_slots(
            &mut nodes,
            &json!({"posts": {"headline": "Hello", "html": "<p>Hi</p>"}}),
        );
        assert!(matches!(&nodes[0], Node::Text(t) if t == "Hello"));
    }

    #[test]
    fn present_slot_renders_value() {
        let mut nodes = vec![named_slot("label", "fallback")];
        fill_named_slots(&mut nodes, &json!({"label": "Go"}));
        assert!(matches!(&nodes[0], Node::Text(t) if t == "Go"));
    }
}