735 lines
21 KiB
Rust
735 lines
21 KiB
Rust
use crate::Action;
|
|
use anyhow::{anyhow, Result};
|
|
use smallvec::SmallVec;
|
|
use std::{
|
|
any::{Any, TypeId},
|
|
collections::{HashMap, HashSet},
|
|
fmt::{Debug, Write},
|
|
};
|
|
use tree_sitter::{Language, Node, Parser};
|
|
|
|
extern "C" {
|
|
fn tree_sitter_context_predicate() -> Language;
|
|
}
|
|
|
|
pub struct Matcher {
|
|
pending: HashMap<usize, Pending>,
|
|
keymap: Keymap,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct Pending {
|
|
keystrokes: Vec<Keystroke>,
|
|
context: Option<Context>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct Keymap {
|
|
bindings: Vec<Binding>,
|
|
binding_indices_by_action_type: HashMap<TypeId, SmallVec<[usize; 3]>>,
|
|
}
|
|
|
|
pub struct Binding {
|
|
keystrokes: SmallVec<[Keystroke; 2]>,
|
|
action: Box<dyn Action>,
|
|
context_predicate: Option<ContextPredicate>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub struct Keystroke {
|
|
pub ctrl: bool,
|
|
pub alt: bool,
|
|
pub shift: bool,
|
|
pub cmd: bool,
|
|
pub function: bool,
|
|
pub key: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
|
pub struct Context {
|
|
pub set: HashSet<String>,
|
|
pub map: HashMap<String, String>,
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
enum ContextPredicate {
|
|
Identifier(String),
|
|
Equal(String, String),
|
|
NotEqual(String, String),
|
|
Not(Box<ContextPredicate>),
|
|
And(Box<ContextPredicate>, Box<ContextPredicate>),
|
|
Or(Box<ContextPredicate>, Box<ContextPredicate>),
|
|
}
|
|
|
|
trait ActionArg {
|
|
fn boxed_clone(&self) -> Box<dyn Any>;
|
|
}
|
|
|
|
impl<T> ActionArg for T
|
|
where
|
|
T: 'static + Any + Clone,
|
|
{
|
|
fn boxed_clone(&self) -> Box<dyn Any> {
|
|
Box::new(self.clone())
|
|
}
|
|
}
|
|
|
|
pub enum MatchResult {
|
|
None,
|
|
Pending,
|
|
Match(Vec<(usize, Box<dyn Action>)>),
|
|
}
|
|
|
|
impl Debug for MatchResult {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
MatchResult::None => f.debug_struct("MatchResult2::None").finish(),
|
|
MatchResult::Pending => f.debug_struct("MatchResult2::Pending").finish(),
|
|
MatchResult::Match { view_id, action } => f
|
|
.debug_struct("MatchResult::Match")
|
|
.field("view_id", view_id)
|
|
.field("action", &action.name())
|
|
.finish(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for MatchResult {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
(MatchResult::None, MatchResult::None) => true,
|
|
(MatchResult::Pending, MatchResult::Pending) => true,
|
|
(
|
|
MatchResult::Match { view_id, action },
|
|
MatchResult::Match {
|
|
view_id: other_view_id,
|
|
action: other_action,
|
|
},
|
|
) => view_id == other_view_id && action.eq(other_action.as_ref()),
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Eq for MatchResult {}
|
|
|
|
impl Matcher {
|
|
pub fn new(keymap: Keymap) -> Self {
|
|
Self {
|
|
pending: HashMap::new(),
|
|
keymap,
|
|
}
|
|
}
|
|
|
|
pub fn set_keymap(&mut self, keymap: Keymap) {
|
|
self.pending.clear();
|
|
self.keymap = keymap;
|
|
}
|
|
|
|
pub fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
|
|
self.pending.clear();
|
|
self.keymap.add_bindings(bindings);
|
|
}
|
|
|
|
pub fn clear_bindings(&mut self) {
|
|
self.pending.clear();
|
|
self.keymap.clear();
|
|
}
|
|
|
|
pub fn bindings_for_action_type(&self, action_type: TypeId) -> impl Iterator<Item = &Binding> {
|
|
self.keymap.bindings_for_action_type(action_type)
|
|
}
|
|
|
|
pub fn clear_pending(&mut self) {
|
|
self.pending.clear();
|
|
}
|
|
|
|
pub fn has_pending_keystrokes(&self) -> bool {
|
|
!self.pending.is_empty()
|
|
}
|
|
|
|
pub fn push_keystroke(
|
|
&mut self,
|
|
keystroke: Keystroke,
|
|
dispatch_path: Vec<(usize, Context)>,
|
|
) -> MatchResult {
|
|
let mut any_pending = false;
|
|
let mut matched_bindings = Vec::new();
|
|
|
|
let first_keystroke = self.pending.is_empty();
|
|
dbg!(&dispatch_path);
|
|
for (view_id, context) in dispatch_path {
|
|
if !first_keystroke && !self.pending.contains_key(&view_id) {
|
|
continue;
|
|
}
|
|
|
|
let pending = self.pending.entry(view_id).or_default();
|
|
|
|
if let Some(pending_context) = pending.context.as_ref() {
|
|
if pending_context != &context {
|
|
pending.keystrokes.clear();
|
|
}
|
|
}
|
|
|
|
pending.keystrokes.push(keystroke.clone());
|
|
|
|
let mut retain_pending = false;
|
|
for binding in self.keymap.bindings.iter().rev() {
|
|
if binding.keystrokes.starts_with(&pending.keystrokes)
|
|
&& binding
|
|
.context_predicate
|
|
.as_ref()
|
|
.map(|c| c.eval(&context))
|
|
.unwrap_or(true)
|
|
{
|
|
if binding.keystrokes.len() == pending.keystrokes.len() {
|
|
self.pending.remove(&view_id);
|
|
matched_bindings.push((view_id, binding.action.boxed_clone()));
|
|
} else {
|
|
retain_pending = true;
|
|
pending.context = Some(context.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
if retain_pending {
|
|
any_pending = true;
|
|
} else {
|
|
self.pending.remove(&view_id);
|
|
}
|
|
}
|
|
|
|
if !matched_bindings.is_empty() {
|
|
MatchResult::Match(matched_bindings)
|
|
} else if any_pending {
|
|
MatchResult::Pending
|
|
} else {
|
|
MatchResult::None
|
|
}
|
|
}
|
|
|
|
pub fn keystrokes_for_action(
|
|
&self,
|
|
action: &dyn Action,
|
|
cx: &Context,
|
|
) -> Option<SmallVec<[Keystroke; 2]>> {
|
|
for binding in self.keymap.bindings.iter().rev() {
|
|
if binding.action.eq(action)
|
|
&& binding
|
|
.context_predicate
|
|
.as_ref()
|
|
.map_or(true, |predicate| predicate.eval(cx))
|
|
{
|
|
return Some(binding.keystrokes.clone());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
impl Default for Matcher {
|
|
fn default() -> Self {
|
|
Self::new(Keymap::default())
|
|
}
|
|
}
|
|
|
|
impl Keymap {
|
|
pub fn new(bindings: Vec<Binding>) -> Self {
|
|
let mut binding_indices_by_action_type = HashMap::new();
|
|
for (ix, binding) in bindings.iter().enumerate() {
|
|
binding_indices_by_action_type
|
|
.entry(binding.action.as_any().type_id())
|
|
.or_insert_with(SmallVec::new)
|
|
.push(ix);
|
|
}
|
|
Self {
|
|
binding_indices_by_action_type,
|
|
bindings,
|
|
}
|
|
}
|
|
|
|
fn bindings_for_action_type(&self, action_type: TypeId) -> impl Iterator<Item = &'_ Binding> {
|
|
self.binding_indices_by_action_type
|
|
.get(&action_type)
|
|
.map(SmallVec::as_slice)
|
|
.unwrap_or(&[])
|
|
.iter()
|
|
.map(|ix| &self.bindings[*ix])
|
|
}
|
|
|
|
fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
|
|
for binding in bindings {
|
|
self.binding_indices_by_action_type
|
|
.entry(binding.action.as_any().type_id())
|
|
.or_default()
|
|
.push(self.bindings.len());
|
|
self.bindings.push(binding);
|
|
}
|
|
}
|
|
|
|
fn clear(&mut self) {
|
|
self.bindings.clear();
|
|
self.binding_indices_by_action_type.clear();
|
|
}
|
|
}
|
|
|
|
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(ContextPredicate::parse(context)?)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let keystrokes = keystrokes
|
|
.split_whitespace()
|
|
.map(Keystroke::parse)
|
|
.collect::<Result<_>>()?;
|
|
|
|
Ok(Self {
|
|
keystrokes,
|
|
action,
|
|
context_predicate: context,
|
|
})
|
|
}
|
|
|
|
pub fn keystrokes(&self) -> &[Keystroke] {
|
|
&self.keystrokes
|
|
}
|
|
|
|
pub fn action(&self) -> &dyn Action {
|
|
self.action.as_ref()
|
|
}
|
|
}
|
|
|
|
impl Keystroke {
|
|
pub fn parse(source: &str) -> anyhow::Result<Self> {
|
|
let mut ctrl = false;
|
|
let mut alt = false;
|
|
let mut shift = false;
|
|
let mut cmd = false;
|
|
let mut function = false;
|
|
let mut key = None;
|
|
|
|
let mut components = source.split('-').peekable();
|
|
while let Some(component) = components.next() {
|
|
match component {
|
|
"ctrl" => ctrl = true,
|
|
"alt" => alt = true,
|
|
"shift" => shift = true,
|
|
"cmd" => cmd = true,
|
|
"fn" => function = true,
|
|
_ => {
|
|
if let Some(component) = components.peek() {
|
|
if component.is_empty() && source.ends_with('-') {
|
|
key = Some(String::from("-"));
|
|
break;
|
|
} else {
|
|
return Err(anyhow!("Invalid keystroke `{}`", source));
|
|
}
|
|
} else {
|
|
key = Some(String::from(component));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let key = key.ok_or_else(|| anyhow!("Invalid keystroke `{}`", source))?;
|
|
|
|
Ok(Keystroke {
|
|
ctrl,
|
|
alt,
|
|
shift,
|
|
cmd,
|
|
function,
|
|
key,
|
|
})
|
|
}
|
|
|
|
pub fn modified(&self) -> bool {
|
|
self.ctrl || self.alt || self.shift || self.cmd
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for Keystroke {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
if self.ctrl {
|
|
f.write_char('^')?;
|
|
}
|
|
if self.alt {
|
|
f.write_char('⎇')?;
|
|
}
|
|
if self.cmd {
|
|
f.write_char('⌘')?;
|
|
}
|
|
if self.shift {
|
|
f.write_char('⇧')?;
|
|
}
|
|
let key = match self.key.as_str() {
|
|
"backspace" => '⌫',
|
|
"up" => '↑',
|
|
"down" => '↓',
|
|
"left" => '←',
|
|
"right" => '→',
|
|
"tab" => '⇥',
|
|
"escape" => '⎋',
|
|
key => {
|
|
if key.len() == 1 {
|
|
key.chars().next().unwrap().to_ascii_uppercase()
|
|
} else {
|
|
return f.write_str(key);
|
|
}
|
|
}
|
|
};
|
|
f.write_char(key)
|
|
}
|
|
}
|
|
|
|
impl Context {
|
|
pub fn extend(&mut self, other: &Context) {
|
|
for v in &other.set {
|
|
self.set.insert(v.clone());
|
|
}
|
|
for (k, v) in &other.map {
|
|
self.map.insert(k.clone(), v.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ContextPredicate {
|
|
fn parse(source: &str) -> anyhow::Result<Self> {
|
|
let mut parser = Parser::new();
|
|
let language = unsafe { tree_sitter_context_predicate() };
|
|
parser.set_language(language).unwrap();
|
|
let source = source.as_bytes();
|
|
let tree = parser.parse(source, None).unwrap();
|
|
Self::from_node(tree.root_node(), source)
|
|
}
|
|
|
|
fn from_node(node: Node, source: &[u8]) -> anyhow::Result<Self> {
|
|
let parse_error = "error parsing context predicate";
|
|
let kind = node.kind();
|
|
|
|
match kind {
|
|
"source" => Self::from_node(node.child(0).ok_or_else(|| anyhow!(parse_error))?, source),
|
|
"identifier" => Ok(Self::Identifier(node.utf8_text(source)?.into())),
|
|
"not" => {
|
|
let child = Self::from_node(
|
|
node.child_by_field_name("expression")
|
|
.ok_or_else(|| anyhow!(parse_error))?,
|
|
source,
|
|
)?;
|
|
Ok(Self::Not(Box::new(child)))
|
|
}
|
|
"and" | "or" => {
|
|
let left = Box::new(Self::from_node(
|
|
node.child_by_field_name("left")
|
|
.ok_or_else(|| anyhow!(parse_error))?,
|
|
source,
|
|
)?);
|
|
let right = Box::new(Self::from_node(
|
|
node.child_by_field_name("right")
|
|
.ok_or_else(|| anyhow!(parse_error))?,
|
|
source,
|
|
)?);
|
|
if kind == "and" {
|
|
Ok(Self::And(left, right))
|
|
} else {
|
|
Ok(Self::Or(left, right))
|
|
}
|
|
}
|
|
"equal" | "not_equal" => {
|
|
let left = node
|
|
.child_by_field_name("left")
|
|
.ok_or_else(|| anyhow!(parse_error))?
|
|
.utf8_text(source)?
|
|
.into();
|
|
let right = node
|
|
.child_by_field_name("right")
|
|
.ok_or_else(|| anyhow!(parse_error))?
|
|
.utf8_text(source)?
|
|
.into();
|
|
if kind == "equal" {
|
|
Ok(Self::Equal(left, right))
|
|
} else {
|
|
Ok(Self::NotEqual(left, right))
|
|
}
|
|
}
|
|
"parenthesized" => Self::from_node(
|
|
node.child_by_field_name("expression")
|
|
.ok_or_else(|| anyhow!(parse_error))?,
|
|
source,
|
|
),
|
|
_ => Err(anyhow!(parse_error)),
|
|
}
|
|
}
|
|
|
|
fn eval(&self, cx: &Context) -> bool {
|
|
match self {
|
|
Self::Identifier(name) => cx.set.contains(name.as_str()),
|
|
Self::Equal(left, right) => cx
|
|
.map
|
|
.get(left)
|
|
.map(|value| value == right)
|
|
.unwrap_or(false),
|
|
Self::NotEqual(left, right) => {
|
|
cx.map.get(left).map(|value| value != right).unwrap_or(true)
|
|
}
|
|
Self::Not(pred) => !pred.eval(cx),
|
|
Self::And(left, right) => left.eval(cx) && right.eval(cx),
|
|
Self::Or(left, right) => left.eval(cx) || right.eval(cx),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use anyhow::Result;
|
|
use serde::Deserialize;
|
|
|
|
use crate::{actions, impl_actions};
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_push_keystroke() -> Result<()> {
|
|
actions!(test, [B, AB, C]);
|
|
|
|
let mut ctx1 = Context::default();
|
|
ctx1.set.insert("1".into());
|
|
|
|
let mut ctx2 = Context::default();
|
|
ctx2.set.insert("2".into());
|
|
|
|
let dispatch_path = vec![(2, ctx2), (1, ctx1)];
|
|
|
|
let keymap = Keymap::new(vec![
|
|
Binding::new("a b", AB, Some("1")),
|
|
Binding::new("b", B, Some("2")),
|
|
Binding::new("c", C, Some("2")),
|
|
]);
|
|
|
|
let mut matcher = Matcher::new(keymap);
|
|
|
|
assert_eq!(
|
|
MatchResult::Pending,
|
|
matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone())
|
|
);
|
|
assert_eq!(
|
|
MatchResult::Match {
|
|
view_id: 1,
|
|
action: Box::new(AB)
|
|
},
|
|
matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone())
|
|
);
|
|
assert!(matcher.pending.is_empty());
|
|
assert_eq!(
|
|
MatchResult::Match {
|
|
view_id: 2,
|
|
action: Box::new(B)
|
|
},
|
|
matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone())
|
|
);
|
|
assert!(matcher.pending.is_empty());
|
|
assert_eq!(
|
|
MatchResult::Pending,
|
|
matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone())
|
|
);
|
|
assert_eq!(
|
|
MatchResult::None,
|
|
matcher.push_keystroke(Keystroke::parse("c")?, dispatch_path.clone())
|
|
);
|
|
assert!(matcher.pending.is_empty());
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_keystroke_parsing() -> Result<()> {
|
|
assert_eq!(
|
|
Keystroke::parse("ctrl-p")?,
|
|
Keystroke {
|
|
key: "p".into(),
|
|
ctrl: true,
|
|
alt: false,
|
|
shift: false,
|
|
cmd: false,
|
|
function: false,
|
|
}
|
|
);
|
|
|
|
assert_eq!(
|
|
Keystroke::parse("alt-shift-down")?,
|
|
Keystroke {
|
|
key: "down".into(),
|
|
ctrl: false,
|
|
alt: true,
|
|
shift: true,
|
|
cmd: false,
|
|
function: false,
|
|
}
|
|
);
|
|
|
|
assert_eq!(
|
|
Keystroke::parse("shift-cmd--")?,
|
|
Keystroke {
|
|
key: "-".into(),
|
|
ctrl: false,
|
|
alt: false,
|
|
shift: true,
|
|
cmd: true,
|
|
function: false,
|
|
}
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_context_predicate_parsing() -> Result<()> {
|
|
use ContextPredicate::*;
|
|
|
|
assert_eq!(
|
|
ContextPredicate::parse("a && (b == c || d != e)")?,
|
|
And(
|
|
Box::new(Identifier("a".into())),
|
|
Box::new(Or(
|
|
Box::new(Equal("b".into(), "c".into())),
|
|
Box::new(NotEqual("d".into(), "e".into())),
|
|
))
|
|
)
|
|
);
|
|
|
|
assert_eq!(
|
|
ContextPredicate::parse("!a")?,
|
|
Not(Box::new(Identifier("a".into())),)
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_context_predicate_eval() -> Result<()> {
|
|
let predicate = ContextPredicate::parse("a && b || c == d")?;
|
|
|
|
let mut context = Context::default();
|
|
context.set.insert("a".into());
|
|
assert!(!predicate.eval(&context));
|
|
|
|
context.set.insert("b".into());
|
|
assert!(predicate.eval(&context));
|
|
|
|
context.set.remove("b");
|
|
context.map.insert("c".into(), "x".into());
|
|
assert!(!predicate.eval(&context));
|
|
|
|
context.map.insert("c".into(), "d".into());
|
|
assert!(predicate.eval(&context));
|
|
|
|
let predicate = ContextPredicate::parse("!a")?;
|
|
assert!(predicate.eval(&Context::default()));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_matcher() -> Result<()> {
|
|
#[derive(Clone, Deserialize, PartialEq, Eq, Debug)]
|
|
pub struct A(pub String);
|
|
impl_actions!(test, [A]);
|
|
actions!(test, [B, Ab]);
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
struct ActionArg {
|
|
a: &'static str,
|
|
}
|
|
|
|
let keymap = Keymap::new(vec![
|
|
Binding::new("a", A("x".to_string()), Some("a")),
|
|
Binding::new("b", B, Some("a")),
|
|
Binding::new("a b", Ab, Some("a || b")),
|
|
]);
|
|
|
|
let mut ctx_a = Context::default();
|
|
ctx_a.set.insert("a".into());
|
|
|
|
let mut ctx_b = Context::default();
|
|
ctx_b.set.insert("b".into());
|
|
|
|
let mut matcher = Matcher::new(keymap);
|
|
|
|
// Basic match
|
|
assert_eq!(
|
|
downcast(&matcher.test_keystroke("a", vec![(1, ctx_a.clone())])),
|
|
Some(&A("x".to_string()))
|
|
);
|
|
|
|
// Multi-keystroke match
|
|
assert!(matcher
|
|
.test_keystroke("a", vec![(1, ctx_b.clone())])
|
|
.is_none());
|
|
assert_eq!(
|
|
downcast(&matcher.test_keystroke("b", vec![(1, ctx_b.clone())])),
|
|
Some(&Ab)
|
|
);
|
|
|
|
// Failed matches don't interfere with matching subsequent keys
|
|
assert!(matcher
|
|
.test_keystroke("x", vec![(1, ctx_a.clone())])
|
|
.is_none());
|
|
assert_eq!(
|
|
downcast(&matcher.test_keystroke("a", vec![(1, ctx_a.clone())])),
|
|
Some(&A("x".to_string()))
|
|
);
|
|
|
|
// Pending keystrokes are cleared when the context changes
|
|
assert!(&matcher
|
|
.test_keystroke("a", vec![(1, ctx_b.clone())])
|
|
.is_none());
|
|
assert_eq!(
|
|
downcast(&matcher.test_keystroke("b", vec![(1, ctx_a.clone())])),
|
|
Some(&B)
|
|
);
|
|
|
|
let mut ctx_c = Context::default();
|
|
ctx_c.set.insert("c".into());
|
|
|
|
// Pending keystrokes are maintained per-view
|
|
assert!(matcher
|
|
.test_keystroke("a", vec![(1, ctx_b.clone()), (2, ctx_c.clone())])
|
|
.is_none());
|
|
assert_eq!(
|
|
downcast(&matcher.test_keystroke("b", vec![(1, ctx_b.clone())])),
|
|
Some(&Ab)
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn downcast<A: Action>(action: &Option<Box<dyn Action>>) -> Option<&A> {
|
|
action
|
|
.as_ref()
|
|
.and_then(|action| action.as_any().downcast_ref())
|
|
}
|
|
|
|
impl Matcher {
|
|
fn test_keystroke(
|
|
&mut self,
|
|
keystroke: &str,
|
|
dispatch_path: Vec<(usize, Context)>,
|
|
) -> Option<Box<dyn Action>> {
|
|
if let MatchResult::Match { action, .. } =
|
|
self.push_keystroke(Keystroke::parse(keystroke).unwrap(), dispatch_path)
|
|
{
|
|
Some(action.boxed_clone())
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|