revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! DOM building logic for DomRenderer

use crate::dom::renderer::types::DomRenderer;
use crate::dom::DomId;
use crate::dom::WidgetMeta;
use crate::widget::View;

#[allow(dead_code)]
impl DomRenderer {
    /// Build DOM from scratch (first frame or full rebuild)
    pub(crate) fn build_fresh<V: View>(&mut self, root: &V) {
        self.tree = crate::dom::DomTree::new();
        self.styles.clear();

        // Create root node and recursively build children
        let meta = root.meta();
        let root_id = self.tree.create_root(meta);

        // Recursively build child nodes
        build_children_internal(self, root_id, root.children());
    }

    /// Force a full DOM rebuild on next build() call
    pub fn invalidate(&mut self) {
        self.tree = crate::dom::DomTree::new();
        self.styles.clear();
    }

    /// Build DOM with children
    pub fn build_tree(&mut self, root_meta: WidgetMeta, children: Vec<WidgetMeta>) {
        self.tree = crate::dom::DomTree::new();
        self.styles.clear();

        let root_id = self.tree.create_root(root_meta);
        for child_meta in children {
            self.tree.add_child(root_id, child_meta);
        }
    }

    /// Recursively build child nodes
    pub(crate) fn build_children_recursive(
        &mut self,
        parent_id: DomId,
        children: &[Box<dyn View>],
    ) {
        build_children_internal(self, parent_id, children);
    }
}

/// Standalone function to recursively build child nodes
pub(crate) fn build_children_internal(
    renderer: &mut DomRenderer,
    parent_id: DomId,
    children: &[Box<dyn View>],
) {
    for child in children {
        let child_meta = child.meta();
        let child_id = renderer.tree.add_child(parent_id, child_meta);

        // Recursively process this child's children
        build_children_internal(renderer, child_id, child.children());
    }
}

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

    fn create_test_renderer() -> DomRenderer {
        DomRenderer::with_stylesheet(crate::style::StyleSheet::new())
    }

    #[test]
    fn test_invalidate() {
        let mut renderer = create_test_renderer();
        // Add some data to verify it's cleared
        renderer
            .styles
            .insert(crate::dom::DomId::new(1), crate::style::Style::default());

        renderer.invalidate();

        assert!(renderer.tree.is_empty());
        assert!(renderer.styles.is_empty());
    }

    #[test]
    fn test_build_tree() {
        let mut renderer = create_test_renderer();
        let root_meta = WidgetMeta::new("root");
        let child1_meta = WidgetMeta::new("child1");
        let child2_meta = WidgetMeta::new("child2");

        renderer.build_tree(root_meta, vec![child1_meta, child2_meta]);

        assert!(!renderer.tree.is_empty());
        // Tree should have root + 2 children = 3 nodes
        assert_eq!(renderer.tree.len(), 3);
    }

    #[test]
    fn test_build_tree_clears_previous_state() {
        let mut renderer = create_test_renderer();
        let root_meta = WidgetMeta::new("root");

        // First build
        renderer.build_tree(root_meta.clone(), vec![]);
        assert_eq!(renderer.tree.len(), 1);

        // Add some style data
        use crate::dom::DomId;
        renderer
            .styles
            .insert(DomId::new(1), crate::style::Style::default());

        // Second build should clear previous state
        let child_meta = WidgetMeta::new("child");
        renderer.build_tree(root_meta, vec![child_meta]);

        assert_eq!(renderer.tree.len(), 2);
        assert!(renderer.styles.is_empty());
    }

    #[test]
    fn test_build_tree_empty_children() {
        let mut renderer = create_test_renderer();
        let root_meta = WidgetMeta::new("root");

        renderer.build_tree(root_meta, vec![]);

        assert_eq!(renderer.tree.len(), 1);
    }

    #[test]
    fn test_build_tree_single_child() {
        let mut renderer = create_test_renderer();
        let root_meta = WidgetMeta::new("root");
        let child_meta = WidgetMeta::new("child");

        renderer.build_tree(root_meta, vec![child_meta]);

        assert_eq!(renderer.tree.len(), 2);
    }

    #[test]
    fn test_invalidate_clears_styles() {
        let mut renderer = create_test_renderer();
        use crate::dom::DomId;

        renderer
            .styles
            .insert(DomId::new(1), crate::style::Style::default());
        renderer
            .styles
            .insert(DomId::new(2), crate::style::Style::default());
        assert_eq!(renderer.styles.len(), 2);

        renderer.invalidate();

        assert!(renderer.styles.is_empty());
    }
}