kanata-parser 0.1110.0

A parser for configuration language of kanata, a keyboard remapper.
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

use super::*;

#[test]
fn disallow_same_key_in_defsrc_unmapped_except() {
    let source = "
(defcfg process-unmapped-keys (all-except bspc))
(defsrc bspc)
(deflayermap (name) 0 0)
";
    parse_cfg(source)
        .map(|_| ())
        //.map_err(|e| eprintln!("{:?}", miette::Error::from(e)))
        .expect_err("fails");
}

#[test]
fn unmapped_except_keys_cannot_have_dupes() {
    let source = "
(defcfg process-unmapped-keys (all-except bspc bspc))
(defsrc)
(deflayermap (name) 0 0)
";
    parse_cfg(source)
        .map(|_| ())
        //.map_err(|e| eprintln!("{:?}", miette::Error::from(e)))
        .expect_err("fails");
}

#[test]
fn unmapped_except_keys_must_be_known() {
    let source = "
(defcfg process-unmapped-keys (all-except notakey))
(defsrc)
(deflayermap (name) 0 0)
";
    parse_cfg(source)
        .map(|_| ())
        //.map_err(|e| eprintln!("{:?}", miette::Error::from(e)))
        .expect_err("fails");
}

#[test]
fn unmapped_except_keys_respects_deflocalkeys() {
    let source = "
(deflocalkeys-win         lkey90 555)
(deflocalkeys-winiov2     lkey90 555)
(deflocalkeys-wintercept  lkey90 555)
(deflocalkeys-linux       lkey90 555)
(deflocalkeys-macos       lkey90 555)
(defcfg process-unmapped-keys (all-except lkey90))
(defsrc)
(deflayermap (name) 0 0)
";
    let cfg = parse_cfg(source)
        .map_err(|e| eprintln!("{:?}", miette::Error::from(e)))
        .expect("passes");
    assert!(!cfg.mapped_keys.contains(&OsCode::from(555u16)));
    assert!(cfg.mapped_keys.contains(&OsCode::KEY_ENTER));
    for osc in 0..KEYS_IN_ROW as u16 {
        if let Some(osc) = OsCode::from_u16(osc) {
            match KeyCode::from(osc) {
                KeyCode::No | KeyCode::K555 => {
                    assert!(!cfg.mapped_keys.contains(&osc));
                }
                _ if osc.is_mouse_code() => {
                    assert!(!cfg.mapped_keys.contains(&osc));
                }
                _ => {
                    assert!(cfg.mapped_keys.contains(&osc));
                }
            }
        }
    }
}

#[test]
fn unmapped_except_keys_is_removed_from_mapping() {
    let source = "
(defcfg process-unmapped-keys (all-except 1 2 3))
(defsrc mlft mmid)
(deflayermap (name) 0 0)
";
    let cfg = parse_cfg(source)
        .map_err(|e| eprintln!("{:?}", miette::Error::from(e)))
        .expect("passes");
    assert!(cfg.mapped_keys.contains(&OsCode::KEY_A));
    assert!(cfg.mapped_keys.contains(&OsCode::KEY_0));
    assert!(!cfg.mapped_keys.contains(&OsCode::KEY_1));
    assert!(!cfg.mapped_keys.contains(&OsCode::KEY_2));
    assert!(!cfg.mapped_keys.contains(&OsCode::KEY_3));
    assert!(cfg.mapped_keys.contains(&OsCode::KEY_4));
    for osc in 0..KEYS_IN_ROW as u16 {
        if let Some(osc) = OsCode::from_u16(osc) {
            match KeyCode::from(osc) {
                KeyCode::No | KeyCode::Kb1 | KeyCode::Kb2 | KeyCode::Kb3 => {
                    assert!(!cfg.mapped_keys.contains(&osc));
                }
                // mlft, mmid
                KeyCode::K272 | KeyCode::K274 => {
                    assert!(cfg.mapped_keys.contains(&osc));
                }
                _ if osc.is_mouse_code() => {
                    assert!(!cfg.mapped_keys.contains(&osc));
                }
                _ => {
                    assert!(cfg.mapped_keys.contains(&osc));
                }
            }
        }
    }
}

#[test]
fn non_applicable_os_deflocalkeys_always_succeeds_parsing() {
    let source = "
(deflocalkeys-linux å 26 ' 43)
(defsrc)
(deflayer base)
";
    parse_cfg(source)
        .map_err(|e| eprintln!("{:?}", miette::Error::from(e)))
        .expect("passes");
}