polypty 0.1.0

Agent-aware terminal multiplexer with sidebar tabs and nested panes
Documentation
use std::fmt;

use anyhow::{bail, Result};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) struct KeyChord {
    code: KeyCode,
    modifiers: KeyModifiers,
}

impl KeyChord {
    pub(super) fn parse(value: &str) -> Result<Self> {
        let parts: Vec<_> = value.split('+').map(str::trim).collect();
        if parts.is_empty() || parts.iter().any(|part| part.is_empty()) {
            bail!("invalid key chord `{value}`; use the name `plus` for +");
        }
        let (key, modifiers) = parts.split_last().expect("parts are not empty");
        let mut flags = KeyModifiers::NONE;
        for modifier in modifiers {
            flags.insert(parse_modifier(modifier)?);
        }
        Ok(Self {
            code: parse_code(key)?,
            modifiers: flags,
        })
    }

    pub(super) fn matches(&self, event: KeyEvent) -> bool {
        self.code == normalize_code(event.code) && self.modifiers == event.modifiers
    }
}

impl fmt::Display for KeyChord {
    fn fmt(&self, output: &mut fmt::Formatter<'_>) -> fmt::Result {
        for (flag, label) in [
            (KeyModifiers::CONTROL, "Ctrl"),
            (KeyModifiers::ALT, "Alt"),
            (KeyModifiers::SHIFT, "Shift"),
            (KeyModifiers::SUPER, "Super"),
            (KeyModifiers::HYPER, "Hyper"),
            (KeyModifiers::META, "Meta"),
        ] {
            if self.modifiers.contains(flag) {
                write!(output, "{label}+")?;
            }
        }
        write!(output, "{}", code_label(self.code))
    }
}

fn parse_modifier(value: &str) -> Result<KeyModifiers> {
    match value.to_ascii_lowercase().as_str() {
        "ctrl" | "control" => Ok(KeyModifiers::CONTROL),
        "alt" | "option" => Ok(KeyModifiers::ALT),
        "shift" => Ok(KeyModifiers::SHIFT),
        "super" | "command" | "win" => Ok(KeyModifiers::SUPER),
        "hyper" => Ok(KeyModifiers::HYPER),
        "meta" => Ok(KeyModifiers::META),
        _ => bail!("unknown key modifier `{value}`"),
    }
}

fn parse_code(value: &str) -> Result<KeyCode> {
    let lower = value.to_ascii_lowercase();
    let named = match lower.as_str() {
        "backspace" => Some(KeyCode::Backspace),
        "enter" | "return" => Some(KeyCode::Enter),
        "left" => Some(KeyCode::Left),
        "right" => Some(KeyCode::Right),
        "up" => Some(KeyCode::Up),
        "down" => Some(KeyCode::Down),
        "home" => Some(KeyCode::Home),
        "end" => Some(KeyCode::End),
        "pageup" | "page-up" => Some(KeyCode::PageUp),
        "pagedown" | "page-down" => Some(KeyCode::PageDown),
        "tab" => Some(KeyCode::Tab),
        "backtab" | "back-tab" => Some(KeyCode::BackTab),
        "delete" => Some(KeyCode::Delete),
        "insert" => Some(KeyCode::Insert),
        "esc" | "escape" => Some(KeyCode::Esc),
        "space" => Some(KeyCode::Char(' ')),
        "plus" => Some(KeyCode::Char('+')),
        "minus" => Some(KeyCode::Char('-')),
        "equals" | "equal" => Some(KeyCode::Char('=')),
        _ => None,
    };
    if let Some(code) = named {
        return Ok(code);
    }
    if let Some(number) = lower.strip_prefix('f').and_then(|tail| tail.parse().ok()) {
        if (1..=24).contains(&number) {
            return Ok(KeyCode::F(number));
        }
    }
    let mut chars = value.chars();
    if let (Some(character), None) = (chars.next(), chars.next()) {
        return Ok(KeyCode::Char(lower_char(character)));
    }
    bail!("unknown key `{value}`")
}

fn normalize_code(code: KeyCode) -> KeyCode {
    match code {
        KeyCode::Char(character) => KeyCode::Char(lower_char(character)),
        other => other,
    }
}

fn lower_char(character: char) -> char {
    character.to_lowercase().next().unwrap_or(character)
}

fn code_label(code: KeyCode) -> String {
    match code {
        KeyCode::Char(' ') => "Space".into(),
        KeyCode::Char(character) => character.to_string(),
        KeyCode::F(number) => format!("F{number}"),
        other => format!("{other:?}"),
    }
}