working f and t bindings

crates/gpui/src/keymap_matcher/binding.rs

@@ -0,0 +1,104 @@
+use anyhow::Result;
+use smallvec::SmallVec;
+
+use crate::Action;
+
+use super::{KeymapContext, KeymapContextPredicate, Keystroke};
+
+pub struct Binding {
+    action: Box<dyn Action>,
+    keystrokes: Option<SmallVec<[Keystroke; 2]>>,
+    context_predicate: Option<KeymapContextPredicate>,
+}
+
+impl Binding {
+    pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self {
+        Self::load(keystrokes, Box::new(action), context).unwrap()
+    }
+
+    pub fn load(keystrokes: &str, action: Box<dyn Action>, context: Option<&str>) -> Result<Self> {
+        let context = if let Some(context) = context {
+            Some(KeymapContextPredicate::parse(context)?)
+        } else {
+            None
+        };
+
+        let keystrokes = if keystrokes == "*" {
+            None // Catch all context
+        } else {
+            Some(
+                keystrokes
+                    .split_whitespace()
+                    .map(Keystroke::parse)
+                    .collect::<Result<_>>()?,
+            )
+        };
+
+        Ok(Self {
+            keystrokes,
+            action,
+            context_predicate: context,
+        })
+    }
+
+    fn match_context(&self, context: &KeymapContext) -> bool {
+        self.context_predicate
+            .as_ref()
+            .map(|predicate| predicate.eval(context))
+            .unwrap_or(true)
+    }
+
+    pub fn match_keys_and_context(
+        &self,
+        pending_keystrokes: &Vec<Keystroke>,
+        context: &KeymapContext,
+    ) -> BindingMatchResult {
+        if self
+            .keystrokes
+            .as_ref()
+            .map(|keystrokes| keystrokes.starts_with(&pending_keystrokes))
+            .unwrap_or(true)
+            && self.match_context(context)
+        {
+            // If the binding is completed, push it onto the matches list
+            if self
+                .keystrokes
+                .as_ref()
+                .map(|keystrokes| keystrokes.len() == pending_keystrokes.len())
+                .unwrap_or(true)
+            {
+                BindingMatchResult::Complete(self.action.boxed_clone())
+            } else {
+                BindingMatchResult::Partial
+            }
+        } else {
+            BindingMatchResult::Fail
+        }
+    }
+
+    pub fn keystrokes_for_action(
+        &self,
+        action: &dyn Action,
+        context: &KeymapContext,
+    ) -> Option<SmallVec<[Keystroke; 2]>> {
+        if self.action.eq(action) && self.match_context(context) {
+            self.keystrokes.clone()
+        } else {
+            None
+        }
+    }
+
+    pub fn keystrokes(&self) -> Option<&[Keystroke]> {
+        self.keystrokes.as_deref()
+    }
+
+    pub fn action(&self) -> &dyn Action {
+        self.action.as_ref()
+    }
+}
+
+pub enum BindingMatchResult {
+    Complete(Box<dyn Action>),
+    Partial,
+    Fail,
+}