Allow keys to be mapped to sequences of commands

helix-term/src/keymap.rs

@@ -52,6 +52,10 @@ macro_rules! keymap {
         keymap!({ $label $($($key)|+ => $value,)+ })
     };
 
+    (@trie [$($cmd:ident),* $(,)?]) => {
+        $crate::keymap::KeyTrie::Sequence(vec![$($crate::commands::Command::$cmd),*])
+    };
+
     (
         { $label:literal $($($key:literal)|+ => $value:tt,)+ }
     ) => {
@@ -128,6 +132,8 @@ impl From<KeyTrieNode> for Info {
             let desc = match trie {
                 KeyTrie::Leaf(cmd) => cmd.doc(),
                 KeyTrie::Node(n) => n.name(),
+                // TODO
+                KeyTrie::Sequence(_) => "",
             };
             match body.iter().position(|(d, _)| d == &desc) {
                 // FIXME: multiple keys are ordered randomly (use BTreeSet)
@@ -179,21 +185,22 @@ impl DerefMut for KeyTrieNode {
 #[serde(untagged)]
 pub enum KeyTrie {
     Leaf(Command),
+    Sequence(Vec<Command>),
     Node(KeyTrieNode),
 }
 
 impl KeyTrie {
     pub fn node(&self) -> Option<&KeyTrieNode> {
         match *self {
             KeyTrie::Node(ref node) => Some(node),
-            KeyTrie::Leaf(_) => None,
+            KeyTrie::Leaf(_) | KeyTrie::Sequence(_) => None,
         }
     }
 
     pub fn node_mut(&mut self) -> Option<&mut KeyTrieNode> {
         match *self {
             KeyTrie::Node(ref mut node) => Some(node),
-            KeyTrie::Leaf(_) => None,
+            KeyTrie::Leaf(_) | KeyTrie::Sequence(_) => None,
         }
     }
 
@@ -210,18 +217,20 @@ impl KeyTrie {
             trie = match trie {
                 KeyTrie::Node(map) => map.get(key),
                 // leaf encountered while keys left to process
-                KeyTrie::Leaf(_) => None,
+                KeyTrie::Leaf(_) | KeyTrie::Sequence(_) => None,
             }?
         }
         Some(trie)
     }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum KeymapResult {
+pub enum KeymapResult<'a> {
     /// Needs more keys to execute a command. Contains valid keys for next keystroke.
     Pending(KeyTrieNode),
     Matched(Command),
+    /// Matched a sequence of commands to execute.
+    MatchedSequence(&'a [Command]),
     /// Key was not found in the root keymap
     NotFound,
     /// Key is invalid in combination with previous keys. Contains keys leading upto
@@ -271,6 +280,10 @@ impl Keymap {
                 self.state.clear();
                 KeymapResult::Matched(command)
             }
+            Some(&KeyTrie::Sequence(ref commands)) => {
+                self.state.clear();
+                KeymapResult::MatchedSequence(commands)
+            }
             None => KeymapResult::Cancelled(self.state.drain(..).collect()),
         }
     }

helix-term/src/ui/editor.rs

@@ -675,6 +675,11 @@ impl EditorView {
         self.autoinfo = None;
         match self.keymaps.get_mut(&mode).unwrap().get(event) {
             KeymapResult::Matched(command) => command.execute(cxt),
+            KeymapResult::MatchedSequence(commands) => {
+                for command in commands {
+                    command.execute(cxt);
+                }
+            }
             KeymapResult::Pending(node) => self.autoinfo = Some(node.into()),
             k @ KeymapResult::NotFound | k @ KeymapResult::Cancelled(_) => return Some(k),
         }