keyseq 0.8.0

Specify key chords using `Ctrl-A` short-hand
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

#[cfg(feature = "bevy")]
mod for_bevy {
    use ::bevy::input::keyboard::{Key, KeyCode};
    use keyseq::{bevy::*, Modifiers};

    #[test]
    fn check_modifiers() {
        assert_eq!(pkey! { Shift-A }, (Modifiers::SHIFT, KeyCode::KeyA));
        assert_eq!(pkey! { Shift-B }, (Modifiers::SHIFT, KeyCode::KeyB));
    }

    #[test]
    fn check_match() {
        match pkey! { Ctrl-Shift-A } {
            (Modifiers(5), KeyCode::KeyA) => {}
            pkey! { Ctrl-A } => panic!(),
            // pkey!(Ctrl-Shift-A) => {},
            _ => panic!(),
        }
    }

    #[test]
    fn check_display() {
        assert_eq!(pkey! { A }.0.to_string(), "");
        assert_eq!(pkey! { Shift-A }.0.to_string(), "Shift");
        assert_eq!(pkey! { Ctrl-Shift-A }.0.to_string(), "Ctrl-Shift");
        assert_eq!(pkey! { Ctrl-Alt-Shift-A }.0.to_string(), "Ctrl-Alt-Shift");
        assert_eq!(pkey! { Ctrl-Alt-Super-A }.0.to_string(), "Ctrl-Alt-Super");
    }

    #[test]
    fn pkey0() {
        assert_eq!(
            pkeyseq! { Ctrl-Semicolon },
            [(Modifiers::CONTROL, KeyCode::Semicolon)]
        );
    }

    #[test]
    fn lkeyseq0() {
        assert_eq!(
            lkeyseq! { Ctrl-; },
            [(Modifiers::CONTROL, Key::Character(";".into()))]
        );
        assert_eq!(
            lkeyseq! { Ctrl-: },
            [(Modifiers::CONTROL, Key::Character(":".into()))]
        );
        // TODO: Is this ok? Isn't there an implicit shift? Does it matter?
        assert_eq!(
            lkeyseq! { Ctrl-A },
            [(Modifiers::CONTROL, Key::Character("A".into()))]
        );
        assert_eq!(
            lkeyseq! { Ctrl-a },
            [(Modifiers::CONTROL, Key::Character("a".into()))]
        );
    }

    #[test]
    fn lkey0() {
        assert_eq!(
            lkey! { Ctrl-; },
            (Modifiers::CONTROL, Key::Character(";".into()))
        );
        assert_eq!(
            lkey! { Ctrl-: },
            (Modifiers::CONTROL, Key::Character(":".into()))
        );
        // TODO: Is this ok? Isn't there an implicit shift? Does it matter?
        assert_eq!(
            lkey! { Ctrl-A },
            (Modifiers::CONTROL, Key::Character("A".into()))
        );
        assert_eq!(
            lkey! { Ctrl-a },
            (Modifiers::CONTROL, Key::Character("a".into()))
        );
    }

    // TODO: These doc tests don't work.
    // /// ```
    // /// assert!(false);
    // /// assert_eq!(lkeyseq! { Ctrl-Semicolon }, [(Modifiers::CONTROL, Key::Character(";".into()))]);
    // /// ````
    // struct TestLkey1;
}