use std::collections::HashMap;
use std::fmt;
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct Key {
pub code: KeyCodeInner,
pub ctrl: bool,
pub alt: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum KeyCodeInner {
Char(char),
Left,
Right,
Up,
Down,
Home,
End,
PageUp,
PageDown,
Enter,
Backspace,
Tab,
Escape,
}
impl Key {
pub fn parse(spec: &str) -> Option<Self> {
let spec = spec.trim();
let mut ctrl = false;
let mut alt = false;
let mut rest = spec;
loop {
if rest.starts_with("C-") {
ctrl = true;
rest = &rest[2..];
} else if rest.starts_with("M-") {
alt = true;
rest = &rest[2..];
} else if rest.starts_with("C-M-") {
ctrl = true;
alt = true;
rest = &rest[4..];
} else {
break;
}
}
if let Some(without_brackets) = rest.strip_prefix('<').and_then(|s| s.strip_suffix('>')) {
let special = match without_brackets.to_ascii_lowercase().as_str() {
"return" | "enter" | "cr" => KeyCodeInner::Enter,
"tab" => KeyCodeInner::Tab,
"esc" | "escape" => KeyCodeInner::Escape,
"backspace" | "bs" | "del" => KeyCodeInner::Backspace,
"left" => KeyCodeInner::Left,
"right" => KeyCodeInner::Right,
"up" => KeyCodeInner::Up,
"down" => KeyCodeInner::Down,
"home" => KeyCodeInner::Home,
"end" => KeyCodeInner::End,
"pageup" | "prior" => KeyCodeInner::PageUp,
"pagedown" | "next" => KeyCodeInner::PageDown,
_ => return None,
};
return Some(Self {
code: special,
ctrl,
alt,
});
}
let chars: Vec<char> = rest.chars().collect();
if chars.len() == 1 {
let c = chars[0];
Some(Self {
code: KeyCodeInner::Char(c),
ctrl,
alt,
})
} else {
None
}
}
pub fn to_emacs(self) -> String {
let mut s = String::new();
if self.ctrl {
s.push_str("C-");
}
if self.alt {
s.push_str("M-");
}
match self.code {
KeyCodeInner::Char(c) => {
s.push(c);
}
KeyCodeInner::Enter => s.push_str("<Return>"),
KeyCodeInner::Tab => s.push_str("<Tab>"),
KeyCodeInner::Escape => s.push_str("<Esc>"),
KeyCodeInner::Backspace => s.push_str("<Backspace>"),
KeyCodeInner::Left => s.push_str("<Left>"),
KeyCodeInner::Right => s.push_str("<Right>"),
KeyCodeInner::Up => s.push_str("<Up>"),
KeyCodeInner::Down => s.push_str("<Down>"),
KeyCodeInner::Home => s.push_str("<Home>"),
KeyCodeInner::End => s.push_str("<End>"),
KeyCodeInner::PageUp => s.push_str("<PageUp>"),
KeyCodeInner::PageDown => s.push_str("<PageDown>"),
}
s
}
}
impl fmt::Display for Key {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.to_emacs())
}
}
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub struct Context {
pub mode: String,
}
impl Context {
pub fn new(mode: &str) -> Self {
Self {
mode: mode.to_string(),
}
}
}
struct Binding {
command: String,
}
#[allow(dead_code)]
pub struct Layer {
pub name: String,
pub priority: i32,
pub context: Option<Context>, bindings: HashMap<Key, Binding>,
}
#[allow(dead_code)]
impl Layer {
pub fn new(name: &str, priority: i32, context: Option<Context>) -> Self {
Self {
name: name.to_string(),
priority,
context,
bindings: HashMap::new(),
}
}
pub fn bind(&mut self, key: Key, command: &str) {
self.bindings.insert(
key,
Binding {
command: command.to_string(),
},
);
}
fn resolve(&self, key: Key, ctx: &Context) -> Option<&str> {
if !self.matches_context(ctx) {
return None;
}
self.bindings.get(&key).map(|b| b.command.as_str())
}
fn matches_context(&self, ctx: &Context) -> bool {
match &self.context {
None => true,
Some(layer_ctx) => layer_ctx.mode == "*" || layer_ctx.mode == ctx.mode,
}
}
pub fn entries(&self) -> Vec<(Key, &str)> {
self.bindings
.iter()
.map(|(k, b)| (*k, b.command.as_str()))
.collect()
}
}
#[allow(dead_code)]
#[derive(Clone, Debug)]
pub struct Resolution {
pub command: String,
pub source: String,
pub source_priority: i32,
}
#[allow(dead_code)]
pub struct KeymapRegistry {
layers: Vec<Layer>,
}
impl Default for KeymapRegistry {
fn default() -> Self {
Self::new()
}
}
#[allow(dead_code)]
impl KeymapRegistry {
pub fn new() -> Self {
Self { layers: Vec::new() }
}
pub fn register(&mut self, layer: Layer) {
self.layers.retain(|l| l.name != layer.name);
self.layers.push(layer);
self.layers.sort_by_key(|l| std::cmp::Reverse(l.priority));
}
pub fn rebind(&mut self, layer_name: &str, key_spec: &str, command: &str) -> bool {
let key = match Key::parse(key_spec) {
Some(k) => k,
None => return false,
};
if let Some(layer) = self.layers.iter_mut().find(|l| l.name == layer_name) {
if command.is_empty() {
layer.bindings.remove(&key);
} else {
layer.bind(key, command);
}
true
} else {
false
}
}
pub fn resolve(&self, key: Key, ctx: &Context) -> Option<Resolution> {
for layer in &self.layers {
if let Some(cmd) = layer.resolve(key, ctx) {
return Some(Resolution {
command: cmd.to_string(),
source: layer.name.clone(),
source_priority: layer.priority,
});
}
}
None
}
pub fn describe_key(&self, key: Key, ctx: &Context) -> Option<&Layer> {
self.layers
.iter()
.find(|&layer| layer.matches_context(ctx) && layer.bindings.contains_key(&key))
.map(|v| v as _)
}
pub fn layers(&self) -> &[Layer] {
&self.layers
}
pub fn bindings_for(&self, ctx: &Context) -> Vec<(Key, String, String)> {
let mut seen: HashMap<Key, (String, String)> = HashMap::new();
for layer in &self.layers {
if layer.matches_context(ctx) {
for (k, cmd) in layer.entries() {
seen.entry(k)
.or_insert_with(|| (cmd.to_string(), layer.name.clone()));
}
}
}
let mut result: Vec<_> = seen.into_iter().collect();
result.sort_by_key(|a| a.0.to_emacs());
result.into_iter().map(|(k, (c, s))| (k, c, s)).collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_simple_char() {
let k = Key::parse("a").unwrap();
assert_eq!(k.code, KeyCodeInner::Char('a'));
assert!(!k.ctrl);
assert!(!k.alt);
}
#[test]
fn test_parse_ctrl() {
let k = Key::parse("C-d").unwrap();
assert_eq!(k.code, KeyCodeInner::Char('d'));
assert!(k.ctrl);
assert!(!k.alt);
}
#[test]
fn test_parse_alt() {
let k = Key::parse("M-x").unwrap();
assert_eq!(k.code, KeyCodeInner::Char('x'));
assert!(!k.ctrl);
assert!(k.alt);
}
#[test]
fn test_parse_ctrl_alt() {
let k = Key::parse("C-M-x").unwrap();
assert_eq!(k.code, KeyCodeInner::Char('x'));
assert!(k.ctrl);
assert!(k.alt);
}
#[test]
fn test_parse_special_keys() {
assert_eq!(Key::parse("<Return>").unwrap().code, KeyCodeInner::Enter);
assert_eq!(Key::parse("<Tab>").unwrap().code, KeyCodeInner::Tab);
assert_eq!(Key::parse("<Esc>").unwrap().code, KeyCodeInner::Escape);
assert_eq!(
Key::parse("<Backspace>").unwrap().code,
KeyCodeInner::Backspace
);
assert_eq!(Key::parse("<Left>").unwrap().code, KeyCodeInner::Left);
}
#[test]
fn test_parse_invalid() {
assert!(Key::parse("xyz").is_none());
assert!(Key::parse("C-xyz").is_none()); assert!(Key::parse("<Bogus>").is_none());
}
#[test]
fn test_to_emacs_roundtrip() {
let k = Key::parse("C-x").unwrap();
assert_eq!(k.to_emacs(), "C-x");
let k2 = Key::parse("<Return>").unwrap();
assert_eq!(k2.to_emacs(), "<Return>");
let k3 = Key::parse("M-x").unwrap();
assert_eq!(k3.to_emacs(), "M-x");
}
#[test]
fn test_resolve_first_hit_wins() {
let mut reg = KeymapRegistry::new();
let mut defaults = Layer::new("basic-defaults", 10, None);
defaults.bind(Key::parse("h").unwrap(), "left");
reg.register(defaults);
let mut vi = Layer::new("vi-normal", 100, Some(Context::new("normal")));
vi.bind(Key::parse("h").unwrap(), "vi-left");
reg.register(vi);
let ctx = Context::new("normal");
let r = reg.resolve(Key::parse("h").unwrap(), &ctx).unwrap();
assert_eq!(r.command, "vi-left");
assert_eq!(r.source, "vi-normal");
let ctx = Context::new("basic");
let r = reg.resolve(Key::parse("h").unwrap(), &ctx).unwrap();
assert_eq!(r.command, "left");
assert_eq!(r.source, "basic-defaults");
}
#[test]
fn test_resolve_no_binding() {
let reg = KeymapRegistry::new();
let ctx = Context::new("normal");
assert!(reg.resolve(Key::parse("z").unwrap(), &ctx).is_none());
}
#[test]
fn test_global_context_wildcard() {
let mut reg = KeymapRegistry::new();
let mut global = Layer::new("global", 10, Some(Context::new("*")));
global.bind(Key::parse("C-x").unwrap(), "command-mode");
reg.register(global);
let r = reg
.resolve(Key::parse("C-x").unwrap(), &Context::new("insert"))
.unwrap();
assert_eq!(r.command, "command-mode");
}
#[test]
fn test_rebind_existing_layer() {
let mut reg = KeymapRegistry::new();
let mut layer = Layer::new("my-layer", 50, None);
layer.bind(Key::parse("a").unwrap(), "cmd-a");
reg.register(layer);
assert!(reg.rebind("my-layer", "a", "cmd_a2"));
let r = reg
.resolve(Key::parse("a").unwrap(), &Context::new("any"))
.unwrap();
assert_eq!(r.command, "cmd_a2");
assert!(reg.rebind("my-layer", "a", ""));
assert!(reg
.resolve(Key::parse("a").unwrap(), &Context::new("any"))
.is_none());
}
#[test]
fn test_rebind_nonexistent_layer() {
let mut reg = KeymapRegistry::new();
assert!(!reg.rebind("no-such-layer", "a", "cmd"));
}
#[test]
fn test_layer_replaces_same_name() {
let mut reg = KeymapRegistry::new();
let mut l1 = Layer::new("dup", 50, None);
l1.bind(Key::parse("a").unwrap(), "first");
reg.register(l1);
let mut l2 = Layer::new("dup", 200, None);
l2.bind(Key::parse("b").unwrap(), "second");
reg.register(l2);
assert_eq!(reg.layers().iter().filter(|l| l.name == "dup").count(), 1);
assert!(reg
.resolve(Key::parse("a").unwrap(), &Context::new("x"))
.is_none());
assert!(reg
.resolve(Key::parse("b").unwrap(), &Context::new("x"))
.is_some());
}
#[test]
fn test_bindings_for_excludes_shadowed() {
let mut reg = KeymapRegistry::new();
let mut lower = Layer::new("lower", 10, None);
lower.bind(Key::parse("a").unwrap(), "cmd_a_lower");
lower.bind(Key::parse("b").unwrap(), "cmd_b");
reg.register(lower);
let mut upper = Layer::new("upper", 100, None);
upper.bind(Key::parse("a").unwrap(), "cmd_a_upper");
reg.register(upper);
let ctx = Context::new("*");
let bindings = reg.bindings_for(&ctx);
let a_entry = bindings
.iter()
.find(|(k, _, _)| k.to_emacs() == "a")
.unwrap();
assert_eq!(a_entry.1, "cmd_a_upper");
assert_eq!(a_entry.2, "upper");
let b_entry = bindings
.iter()
.find(|(k, _, _)| k.to_emacs() == "b")
.unwrap();
assert_eq!(b_entry.1, "cmd_b");
assert_eq!(b_entry.2, "lower");
}
#[test]
fn test_describe_key_returns_winning_layer() {
let mut reg = KeymapRegistry::new();
let mut l = Layer::new("my-layer", 10, Some(Context::new("normal")));
l.bind(Key::parse("j").unwrap(), "down");
reg.register(l);
let layer = reg
.describe_key(Key::parse("j").unwrap(), &Context::new("normal"))
.unwrap();
assert_eq!(layer.name, "my-layer");
}
#[test]
fn test_describe_key_returns_none_for_unbound() {
let reg = KeymapRegistry::new();
assert!(reg
.describe_key(Key::parse("z").unwrap(), &Context::new("normal"))
.is_none());
}
}