keymap_derive 1.0.0-rc.7

A derive macro to generate compile-time validated key mappings for enums, enabling declarative and ergonomic key binding support.
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

extern crate keymap_dev as keymap;

#[derive(Debug, PartialEq, Eq, keymap_derive::KeyMap, Clone)]
enum Action {
    #[key("enter")]
    Create,
    #[key("@digit")]
    Digit(char),
}

#[derive(Debug, PartialEq, Eq, keymap_derive::KeyMap, Clone)]
enum DigitAction {
    #[key("@digit")]
    DigitU8(u8),
    #[key("@any")]
    DigitAny(char),
}

#[derive(Debug, PartialEq, Eq, keymap_derive::KeyMap, Clone)]
enum DigitAction2 {
    #[key("@digit")]
    DigitU16(u16),
    #[key("a")]
    Letter(char),
}

// Type alias — the old string-based approach would fail here.
type MyDigit = u32;

#[derive(Debug, PartialEq, Eq, keymap_derive::KeyMap, Clone)]
enum AliasAction {
    #[key("@digit")]
    Count(MyDigit),
    #[key("@any")]
    Any(char),
}

#[cfg(test)]
mod tests {
    use keymap_dev::{Error, KeyMap, KeyMapConfig, ToKeyMap};

    use super::*;

    struct Wrapper(keymap_parser::Node);
    impl ToKeyMap for Wrapper {
        fn to_keymap(&self) -> Result<KeyMap, Error> {
            Ok(self.0.clone())
        }
    }

    #[test]
    fn test_digit_char() {
        let config = Action::keymap_config();
        let keys = keymap_parser::parse_seq("1")
            .unwrap()
            .into_iter()
            .map(Wrapper)
            .collect::<Vec<_>>();
        let bound = config.get_bound_seq(&keys).unwrap();
        assert_eq!(bound, Action::Digit('1'));
    }

    #[test]
    fn test_digit_u8() {
        let config = DigitAction::keymap_config();
        let keys = keymap_parser::parse_seq("5")
            .unwrap()
            .into_iter()
            .map(Wrapper)
            .collect::<Vec<_>>();
        let bound = config.get_bound_seq(&keys).unwrap();
        assert_eq!(bound, DigitAction::DigitU8(5));
    }

    #[test]
    fn test_digit_u16() {
        let config = DigitAction2::keymap_config();
        let keys = keymap_parser::parse_seq("7")
            .unwrap()
            .into_iter()
            .map(Wrapper)
            .collect::<Vec<_>>();
        let bound = config.get_bound_seq(&keys).unwrap();
        assert_eq!(bound, DigitAction2::DigitU16(7));
    }

    #[test]
    fn test_digit_type_alias() {
        let config = AliasAction::keymap_config();
        let keys = keymap_parser::parse_seq("3")
            .unwrap()
            .into_iter()
            .map(Wrapper)
            .collect::<Vec<_>>();
        let bound = config.get_bound_seq(&keys).unwrap();
        assert_eq!(bound, AliasAction::Count(3));
    }
}