use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use std::collections::HashMap;
pub type Key = (KeyCode, KeyModifiers);
pub struct Keymap {
bindings: HashMap<Key, String>,
mode: String,
}
#[allow(dead_code)]
impl Keymap {
pub fn new(mode: &str) -> Self {
Self {
bindings: HashMap::new(),
mode: mode.to_string(),
}
}
pub fn bind(&mut self, code: KeyCode, modifiers: KeyModifiers, command: &str) {
self.bindings.insert((code, modifiers), command.to_string());
}
#[allow(dead_code)]
pub fn unbind(&mut self, code: KeyCode, modifiers: KeyModifiers) {
self.bindings.remove(&(code, modifiers));
}
pub fn resolve(&self, key: &KeyEvent) -> Option<&str> {
self.bindings
.get(&(key.code, key.modifiers))
.map(|s| s.as_str())
}
pub fn is_bound(&self, key: &KeyEvent) -> bool {
self.bindings.contains_key(&(key.code, key.modifiers))
}
pub fn mode(&self) -> &str {
&self.mode
}
pub fn bindings(&self) -> &HashMap<Key, String> {
&self.bindings
}
pub fn load_defaults(&mut self) {
use KeyCode::*;
use KeyModifiers as M;
match self.mode.as_str() {
"basic" => {
self.bind(Left, M::NONE, "left");
self.bind(Right, M::NONE, "right");
self.bind(Up, M::NONE, "up");
self.bind(Down, M::NONE, "down");
self.bind(Home, M::NONE, "0");
self.bind(End, M::NONE, "$");
self.bind(PageUp, M::NONE, "page-up");
self.bind(PageDown, M::NONE, "page-down");
self.bind(Enter, M::NONE, "newline");
self.bind(Backspace, M::NONE, "delete");
self.bind(Tab, M::NONE, "insert-tab");
self.bind(KeyCode::Char('d'), M::CONTROL, "scroll-down");
self.bind(KeyCode::Char('u'), M::CONTROL, "scroll-up");
self.bind(KeyCode::Char('f'), M::CONTROL, "page-down");
self.bind(KeyCode::Char('b'), M::CONTROL, "page-up");
}
"normal" => {
self.bind(KeyCode::Char('h'), M::NONE, "left");
self.bind(KeyCode::Char('j'), M::NONE, "down");
self.bind(KeyCode::Char('k'), M::NONE, "up");
self.bind(KeyCode::Char('l'), M::NONE, "right");
self.bind(KeyCode::Char('w'), M::NONE, "nextword");
self.bind(KeyCode::Char('b'), M::NONE, "prevword");
self.bind(KeyCode::Char('e'), M::NONE, "endword");
self.bind(KeyCode::Char('G'), M::SHIFT, "lastline");
self.bind(KeyCode::Char('u'), M::NONE, "undo");
self.bind(KeyCode::Char('r'), M::CONTROL, "redo");
self.bind(KeyCode::Char('0'), M::NONE, "home");
self.bind(KeyCode::Char('$'), M::SHIFT, "end");
self.bind(KeyCode::Char('x'), M::NONE, "delete");
self.bind(KeyCode::Char('d'), M::NONE, "deleteline");
self.bind(KeyCode::Char('p'), M::NONE, "paste");
self.bind(KeyCode::Char('n'), M::NONE, "search-next");
self.bind(KeyCode::Char('N'), M::SHIFT, "search-prev");
self.bind(KeyCode::Char('i'), M::NONE, "insert-mode");
self.bind(KeyCode::Char('v'), M::NONE, "visual-mode");
self.bind(KeyCode::Char('V'), M::SHIFT, "visual-line-mode");
self.bind(KeyCode::Char('a'), M::NONE, "append-mode");
}
"insert" => {
self.bind(Backspace, M::NONE, "delete");
self.bind(Enter, M::NONE, "newline");
self.bind(Tab, M::NONE, "insert-tab");
self.bind(KeyCode::Esc, M::NONE, "normal-mode");
}
"visual" => {
self.bind(KeyCode::Char('h'), M::NONE, "left");
self.bind(KeyCode::Char('j'), M::NONE, "down");
self.bind(KeyCode::Char('k'), M::NONE, "up");
self.bind(KeyCode::Char('l'), M::NONE, "right");
self.bind(KeyCode::Char('w'), M::NONE, "nextword");
self.bind(KeyCode::Char('b'), M::NONE, "prevword");
self.bind(KeyCode::Char('d'), M::NONE, "delete-selection");
self.bind(KeyCode::Char('y'), M::NONE, "yank-selection");
self.bind(KeyCode::Esc, M::NONE, "normal-mode");
}
_ => {}
}
}
pub fn clear(&mut self) {
self.bindings.clear();
}
pub fn to_layer(&self, name: &str, priority: i32, mode: &str) -> Layer {
let ctx = if mode == "*" {
None
} else {
Some(Context::new(mode))
};
let mut layer = Layer::new(name, priority, ctx);
for ((code, modifiers), cmd) in &self.bindings {
if let Some(k) = crossterm_to_key_pair(*code, *modifiers) {
layer.bind(k, cmd);
}
}
layer
}
}
use crate::extensions::keymap_convert::crossterm_to_key_pair;
use crate::extensions::keymap_registry::{Context, Layer};
impl Default for Keymap {
fn default() -> Self {
Self::new("basic")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_keymap_bind_and_resolve() {
let mut km = Keymap::new("test");
km.bind(KeyCode::Char('x'), KeyModifiers::NONE, "save");
let key = KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE);
assert_eq!(km.resolve(&key), Some("save"));
assert!(km.is_bound(&key));
}
#[test]
fn test_keymap_unbind() {
let mut km = Keymap::new("test");
km.bind(KeyCode::Char('x'), KeyModifiers::NONE, "save");
let key = KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE);
assert!(km.is_bound(&key));
km.unbind(KeyCode::Char('x'), KeyModifiers::NONE);
assert!(!km.is_bound(&key));
assert_eq!(km.resolve(&key), None);
}
#[test]
fn test_keymap_modifiers() {
let mut km = Keymap::new("test");
km.bind(KeyCode::Char('s'), KeyModifiers::CONTROL, "save");
let key_ctrl_s = KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL);
assert_eq!(km.resolve(&key_ctrl_s), Some("save"));
let key_plain_s = KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE);
assert_eq!(km.resolve(&key_plain_s), None);
}
#[test]
fn test_keymap_mode() {
let km = Keymap::new("normal");
assert_eq!(km.mode(), "normal");
}
#[test]
fn test_keymap_default_basic() {
let mut km = Keymap::new("basic");
km.load_defaults();
let left = KeyEvent::new(KeyCode::Left, KeyModifiers::NONE);
assert_eq!(km.resolve(&left), Some("left"));
let right = KeyEvent::new(KeyCode::Right, KeyModifiers::NONE);
assert_eq!(km.resolve(&right), Some("right"));
let enter = KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE);
assert_eq!(km.resolve(&enter), Some("newline"));
let ctrl_d = KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL);
assert_eq!(km.resolve(&ctrl_d), Some("scroll-down"));
}
#[test]
fn test_keymap_default_normal() {
let mut km = Keymap::new("normal");
km.load_defaults();
let h = KeyEvent::new(KeyCode::Char('h'), KeyModifiers::NONE);
assert_eq!(km.resolve(&h), Some("left"));
let j = KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE);
assert_eq!(km.resolve(&j), Some("down"));
}
#[test]
fn test_keymap_default_insert() {
let mut km = Keymap::new("insert");
km.load_defaults();
let backspace = KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE);
assert_eq!(km.resolve(&backspace), Some("delete"));
}
#[test]
fn test_keymap_default_visual() {
let mut km = Keymap::new("visual");
km.load_defaults();
let d = KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE);
assert_eq!(km.resolve(&d), Some("delete-selection"));
}
#[test]
fn test_keymap_basic_no_command_mode() {
let mut km = Keymap::new("basic");
km.load_defaults();
let alt_x = KeyEvent::new(KeyCode::Char('x'), KeyModifiers::ALT);
assert_eq!(km.resolve(&alt_x), None);
}
#[test]
fn test_keymap_unbound_key() {
let km = Keymap::new("test");
let key = KeyEvent::new(KeyCode::Char('z'), KeyModifiers::NONE);
assert_eq!(km.resolve(&key), None);
}
#[test]
fn test_keymap_clear() {
let mut km = Keymap::new("test");
km.bind(KeyCode::Char('a'), KeyModifiers::NONE, "cmd-a");
km.clear();
assert!(km.bindings().is_empty());
}
#[test]
fn test_keymap_override() {
let mut km = Keymap::new("test");
km.bind(KeyCode::Char('x'), KeyModifiers::NONE, "cut");
km.bind(KeyCode::Char('x'), KeyModifiers::NONE, "copy");
let key = KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE);
assert_eq!(km.resolve(&key), Some("copy"));
}
#[test]
fn test_keymap_list_all() {
let mut km = Keymap::new("basic");
km.load_defaults();
assert!(!km.bindings().is_empty());
}
}