paperos 0.2.0

A programmable editor built on the Runact actor runtime
Documentation
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use std::collections::HashMap;

/// Key as a hashable key for the keymap.
pub type Key = (KeyCode, KeyModifiers);

/// Per-mode keybinding table.
/// Maps keys to command names for a specific editor mode.
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(),
        }
    }

    /// Bind a key (with modifiers) to a command.
    pub fn bind(&mut self, code: KeyCode, modifiers: KeyModifiers, command: &str) {
        self.bindings.insert((code, modifiers), command.to_string());
    }

    /// Unbind a key.
    #[allow(dead_code)]
    pub fn unbind(&mut self, code: KeyCode, modifiers: KeyModifiers) {
        self.bindings.remove(&(code, modifiers));
    }

    /// Resolve a key to its bound command, if any.
    pub fn resolve(&self, key: &KeyEvent) -> Option<&str> {
        self.bindings
            .get(&(key.code, key.modifiers))
            .map(|s| s.as_str())
    }

    /// Check if a key is bound.
    pub fn is_bound(&self, key: &KeyEvent) -> bool {
        self.bindings.contains_key(&(key.code, key.modifiers))
    }

    /// Get the mode name.
    pub fn mode(&self) -> &str {
        &self.mode
    }

    /// Iterate over all bindings.
    pub fn bindings(&self) -> &HashMap<Key, String> {
        &self.bindings
    }

    /// Load default keybindings for this mode.
    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");
                // Mode switches — resolved as ordinary bindings rather than
                // hardcoded in input code
                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");
            }
            _ => {}
        }
    }

    /// Unload all bindings.
    pub fn clear(&mut self) {
        self.bindings.clear();
    }

    /// Convert this keymap into a new-style `Layer` with the canonical `Key`
    /// representation used by `KeymapRegistry`.
    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() {
        // Alt+x is NOT in the basic keymap — it's intercepted by render.rs
        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());
    }
}