smix-selector-resolver 2.0.0

smix-selector-resolver — DFS pre-order + visibility filter + spatial filter (near/below/above/leftOf/rightOf/inside) + index pick (nth/first/last) + anchor-only base form short-circuit (stone, hot path).
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

//! `ResolverContext` + `resolve_selector_compiled` /
//! `resolve_selector_all_compiled` API surface unit tests.
//!
//! Validates the four entry-point cases callers of the pub API must
//! handle:
//! 1. plain hit — non-regex `Pattern`, single tree match
//! 2. regex hit — regex `Pattern`, single tree match (cache prepass
//!    builds a `CompiledPattern` once, looked up via `ctx.pattern`)
//! 3. miss — selector compiles but matches no node in the tree
//! 4. invalid regex — `ResolverContext::new` returns `None` at compile
//!    time (matches `resolve_selector` silent-`None` semantic; caller
//!    can branch on `?` short-circuit)

use smix_screen::{A11yNode, Rect};
use smix_selector::{Modifiers, Pattern, Selector};
use smix_selector_resolver::{
    ResolverContext, resolve_selector_all_compiled, resolve_selector_compiled,
};

fn mk_leaf(label: &str) -> A11yNode {
    A11yNode {
        raw_type: "other".into(),
        element_type_raw: 1,
        role: None,
        identifier: None,
        label: Some(label.into()),
        title: None,
        placeholder_value: None,
        value: None,
        text: None,
        bounds: Rect {
            x: 20.0,
            y: 50.0,
            w: 100.0,
            h: 25.0,
        },
        enabled: true,
        selected: false,
        has_focus: false,
        visible: true,
        children: vec![],
    }
}

fn mk_app(children: Vec<A11yNode>) -> A11yNode {
    A11yNode {
        raw_type: "application".into(),
        element_type_raw: 1,
        role: None,
        identifier: None,
        label: None,
        title: None,
        placeholder_value: None,
        value: None,
        text: None,
        bounds: Rect {
            x: 0.0,
            y: 0.0,
            w: 390.0,
            h: 844.0,
        },
        enabled: true,
        selected: false,
        has_focus: false,
        visible: true,
        children,
    }
}

#[test]
fn compiled_plain_hit() {
    let tree = mk_app(vec![mk_leaf("Target")]);
    let sel = Selector::Text {
        text: Pattern::text("Target"),
        modifiers: Modifiers::default(),
    };
    let ctx = ResolverContext::new(&sel).expect("plain pattern always compiles");
    let hit = resolve_selector_compiled(&tree, &sel, &ctx);
    assert!(hit.is_some(), "plain hit must resolve");
    assert_eq!(hit.unwrap().label.as_deref(), Some("Target"));
}

#[test]
fn compiled_regex_hit() {
    let tree = mk_app(vec![mk_leaf("Login")]);
    let sel = Selector::Text {
        text: Pattern::regex("^Log.*"),
        modifiers: Modifiers::default(),
    };
    let ctx = ResolverContext::new(&sel).expect("valid regex must compile");
    let hit = resolve_selector_compiled(&tree, &sel, &ctx);
    assert!(hit.is_some(), "regex hit must resolve");
    assert_eq!(hit.unwrap().label.as_deref(), Some("Login"));
}

#[test]
fn compiled_miss() {
    let tree = mk_app(vec![mk_leaf("Login")]);
    let sel = Selector::Text {
        text: Pattern::text("NotInTree"),
        modifiers: Modifiers::default(),
    };
    let ctx = ResolverContext::new(&sel).expect("plain pattern always compiles");
    let hit = resolve_selector_compiled(&tree, &sel, &ctx);
    assert!(hit.is_none(), "miss must return None");
    let all = resolve_selector_all_compiled(&tree, &sel, &ctx);
    assert!(all.is_empty(), "_all miss must return empty vec");
}

#[test]
fn compiled_invalid_regex_returns_none_from_new() {
    let sel = Selector::Text {
        text: Pattern::regex("[unbalanced"),
        modifiers: Modifiers::default(),
    };
    let ctx = ResolverContext::new(&sel);
    assert!(
        ctx.is_none(),
        "invalid regex must short-circuit at ResolverContext::new"
    );
}