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

//! Combinator tests

use crate::dom::cascade::resolver::StyleResolver;
use crate::dom::node::{DomNode, WidgetMeta};
use crate::dom::DomId;
use crate::style::{Rule, StyleSheet};

#[test]
fn test_match_descendant_combinator() {
    let stylesheet = StyleSheet {
        rules: vec![Rule {
            selector: "Container Button".to_string(),
            declarations: vec![],
        }],
        variables: std::collections::HashMap::new(),
        keyframes: std::collections::HashMap::new(),
    };
    let mut resolver = StyleResolver::new(&stylesheet);

    // Create parent node
    let parent_id = DomId::new(1);
    let parent = DomNode::new(parent_id, WidgetMeta::new("Container"));

    // Create child node with parent reference
    let child_id = DomId::new(2);
    let mut child = DomNode::new(child_id, WidgetMeta::new("Button"));
    child.parent = Some(parent_id);

    // Closure to get parent node
    let get_node = |id: DomId| -> Option<&DomNode> {
        if id == parent_id {
            Some(&parent)
        } else {
            None
        }
    };

    let matches = resolver.match_node(&child, get_node);
    assert_eq!(matches.len(), 1);
}

#[test]
fn test_match_child_combinator() {
    let stylesheet = StyleSheet {
        rules: vec![Rule {
            selector: "Container > Button".to_string(),
            declarations: vec![],
        }],
        variables: std::collections::HashMap::new(),
        keyframes: std::collections::HashMap::new(),
    };
    let mut resolver = StyleResolver::new(&stylesheet);

    let parent_id = DomId::new(1);
    let parent = DomNode::new(parent_id, WidgetMeta::new("Container"));

    let child_id = DomId::new(2);
    let mut child = DomNode::new(child_id, WidgetMeta::new("Button"));
    child.parent = Some(parent_id);

    let get_node = |id: DomId| -> Option<&DomNode> {
        if id == parent_id {
            Some(&parent)
        } else {
            None
        }
    };

    let matches = resolver.match_node(&child, get_node);
    assert_eq!(matches.len(), 1);
}

#[test]
fn test_match_adjacent_sibling_combinator() {
    let stylesheet = StyleSheet {
        rules: vec![Rule {
            selector: "Label + Input".to_string(),
            declarations: vec![],
        }],
        variables: std::collections::HashMap::new(),
        keyframes: std::collections::HashMap::new(),
    };
    let mut resolver = StyleResolver::new(&stylesheet);

    let parent_id = DomId::new(1);
    let sibling_id = DomId::new(2);
    let target_id = DomId::new(3);

    let mut parent = DomNode::new(parent_id, WidgetMeta::new("Form"));
    parent.children = vec![sibling_id, target_id];

    let mut sibling = DomNode::new(sibling_id, WidgetMeta::new("Label"));
    sibling.parent = Some(parent_id);

    let mut target = DomNode::new(target_id, WidgetMeta::new("Input"));
    target.parent = Some(parent_id);

    let get_node = |id: DomId| -> Option<&DomNode> {
        match id.inner() {
            1 => Some(&parent),
            2 => Some(&sibling),
            _ => None,
        }
    };

    let matches = resolver.match_node(&target, get_node);
    assert_eq!(matches.len(), 1);
}

#[test]
fn test_match_no_parent() {
    let stylesheet = StyleSheet {
        rules: vec![Rule {
            selector: "Container Button".to_string(),
            declarations: vec![],
        }],
        variables: std::collections::HashMap::new(),
        keyframes: std::collections::HashMap::new(),
    };
    let mut resolver = StyleResolver::new(&stylesheet);

    // Node without parent
    let dom_id = DomId::new(1);
    let node = DomNode::new(dom_id, WidgetMeta::new("Button"));
    let get_node = |_: DomId| -> Option<&DomNode> { None };

    let matches = resolver.match_node(&node, get_node);
    assert_eq!(matches.len(), 0);
}