run_key_action_for_mode(): Tap keys using `KeyboardKeyWithModifiers`

Use `autopilot::key::tap()` to simulate each key and modifier in an
action.

Originally tried to do this using a method that takes a closure to
access the `KeyCodeConvertible` types inside `KeyboardKey`. Ended up
with a much cleaner API solution that only requires a single method
call.

2 files changed, 47 insertions, 2 deletions

diff --git a/src/cocoa_bridge.rs b/src/cocoa_bridge.rs
index 68a8515..c2e493b 100644
--- a/src/cocoa_bridge.rs
+++ b/src/cocoa_bridge.rs
@@ -300,6 +300,12 @@ mode <play><up> {
                                             .with_action(s)
                                             .in_mode(trigger)
                                     )
+                                } else if let Action::Map(action) = &map.action {
+                                    for key in action {
+                                        key.tap()
+                                    }
+
+                                    None
                                 } else {
                                     None
                                 }
@@ -327,6 +333,12 @@ mode <play><up> {
                                     KeyActionResult::new(ActionKind::Map)
                                         .with_action(s)
                                 )
+                            } else if let Action::Map(action) = &map.action {
+                                for key in action {
+                                    key.tap()
+                                }
+
+                                None
                             } else {
                                 None
                             }
diff --git a/src/parser.rs b/src/parser.rs
index 9e11175..daea8fc 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -65,13 +65,35 @@ impl KeyCode {
 }
 
 #[derive(Debug, PartialEq)]
-enum KeyboardKey {
+pub enum KeyboardKey {
     Character(Character),
     KeyCode(KeyCode),
 }
 
+impl KeyboardKey {
+    // fn map<K, F>(&self, f: F) -> &Self
+    // where
+    //     K: KeyCodeConvertible,
+    //     F: Fn(K),
+    // {
+    //     match self {
+    //         KeyboardKey::Character(c) => f(c.0),
+    //         KeyboardKey::KeyCode(k) => f(k.0),
+    //     }
+    //
+    //     self
+    // }
+
+    // pub fn extract<K: KeyCodeConvertible + Copy>(&self) -> Box<K> {
+    //     return match self {
+    //         KeyboardKey::Character(c) => Box::new(c.0),
+    //         KeyboardKey::KeyCode(k) => Box::new(k.0),
+    //     }
+    // }
+}
+
 #[derive(Debug, PartialEq)]
-struct KeyboardKeyWithModifiers {
+pub struct KeyboardKeyWithModifiers {
     key: KeyboardKey,
     flags: Vec<Flag>,
 }
@@ -83,6 +105,17 @@ impl KeyboardKeyWithModifiers {
             flags: modifiers,
         }
     }
+
+    pub fn tap(&self) {
+        match self.key {
+            KeyboardKey::Character(ref c) => {
+                autopilot::key::tap(c.0, &self.flags, 0)
+            },
+            KeyboardKey::KeyCode(ref k) => {
+                autopilot::key::tap(k.0, &self.flags, 0)
+            },
+        }
+    }
 }
 
 #[derive(Debug, PartialEq)]