//! `Action` — the closed list of verbs the TUI knows about, plus the canonical //! string form used by the keymap config. //! //! Every binding in `[tui.keymap.normal]` / `[tui.keymap.insert]` resolves to //! one of these variants. The string form is what the user types in the TOML; //! the enum is what the dispatcher matches on. use std::fmt; /// Geometric direction for focus motion and resize. Used inside [`Action`]. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum Direction { Left, Right, Up, Down, } /// Closed set of verbs the TUI dispatch loop understands. New verbs require a /// matching arm in `Action::parse`, the `Display` impl, and the dispatcher. #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Action { /// No-op. Bind to a key to suppress a default binding. Noop, // Mode EnterInsert, LeaveInsert, // Focus FocusSidebar, FocusPane(Direction), // Sidebar highlight movement SidebarNext, SidebarPrev, // Catalog actions on the highlighted sidebar row AttachHighlighted, ToggleAttachHighlighted, NewDraftPane, /// Fast-forward spawn (#67): spawn immediately with every default /// resolved; unresolvable defaults open a pre-filled draft instead. FastForwardSpawn, KillHighlighted, /// Open the retained-worktrees view (#85). ShowWorktrees, // Tabs NewTab, CloseTab, NextTab, PrevTab, GotoTab(u8), // Chrome ToggleSidebar, ShowHelp, Quit, } #[derive(Debug, thiserror::Error, PartialEq, Eq)] pub enum ActionParseError { #[error("unknown action {0:?}")] Unknown(String), #[error("bad arg for {action}: {detail}")] BadArg { action: String, detail: String }, #[error("malformed action string {0:?}")] Malformed(String), } impl Action { /// Parse a canonical action string like `"EnterInsert"`, `"FocusPane(Left)"`, /// or `"GotoTab(3)"`. pub fn parse(s: &str) -> Result { let s = s.trim(); match s { "Noop" => return Ok(Action::Noop), "EnterInsert" => return Ok(Action::EnterInsert), "LeaveInsert" => return Ok(Action::LeaveInsert), "FocusSidebar" => return Ok(Action::FocusSidebar), "SidebarNext" => return Ok(Action::SidebarNext), "SidebarPrev" => return Ok(Action::SidebarPrev), "AttachHighlighted" => return Ok(Action::AttachHighlighted), "ToggleAttachHighlighted" => return Ok(Action::ToggleAttachHighlighted), "NewDraftPane" => return Ok(Action::NewDraftPane), "FastForwardSpawn" => return Ok(Action::FastForwardSpawn), "KillHighlighted" => return Ok(Action::KillHighlighted), "ShowWorktrees" => return Ok(Action::ShowWorktrees), "NewTab" => return Ok(Action::NewTab), "CloseTab" => return Ok(Action::CloseTab), "NextTab" => return Ok(Action::NextTab), "PrevTab" => return Ok(Action::PrevTab), "ToggleSidebar" => return Ok(Action::ToggleSidebar), "ShowHelp" => return Ok(Action::ShowHelp), "Quit" => return Ok(Action::Quit), _ => {} } // Arg actions: Name(arg) let (name, rest) = s .split_once('(') .ok_or_else(|| ActionParseError::Unknown(s.to_string()))?; let arg = rest .strip_suffix(')') .ok_or_else(|| ActionParseError::Malformed(s.to_string()))?; match name { "FocusPane" => { let dir = parse_direction(arg).map_err(|d| ActionParseError::BadArg { action: name.to_string(), detail: d, })?; Ok(Action::FocusPane(dir)) } "GotoTab" => { let n: u8 = arg.parse().map_err(|_| ActionParseError::BadArg { action: name.to_string(), detail: format!("expected u8 0..=255, got {arg:?}"), })?; Ok(Action::GotoTab(n)) } _ => Err(ActionParseError::Unknown(name.to_string())), } } } fn parse_direction(s: &str) -> Result { match s { "Left" => Ok(Direction::Left), "Right" => Ok(Direction::Right), "Up" => Ok(Direction::Up), "Down" => Ok(Direction::Down), other => Err(format!("expected Left/Right/Up/Down, got {other:?}")), } } impl fmt::Display for Action { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Action::FocusPane(d) => write!(f, "FocusPane({d:?})"), Action::GotoTab(n) => write!(f, "GotoTab({n})"), other => write!(f, "{other:?}"), } } } #[cfg(test)] mod tests { use super::*; #[test] fn parses_no_arg_actions() { assert_eq!(Action::parse("EnterInsert").unwrap(), Action::EnterInsert); assert_eq!(Action::parse("Quit").unwrap(), Action::Quit); assert_eq!(Action::parse(" Noop ").unwrap(), Action::Noop); } #[test] fn parses_focus_pane_directions() { assert_eq!( Action::parse("FocusPane(Left)").unwrap(), Action::FocusPane(Direction::Left), ); assert_eq!( Action::parse("FocusPane(Down)").unwrap(), Action::FocusPane(Direction::Down), ); } #[test] fn parses_goto_tab() { assert_eq!(Action::parse("GotoTab(3)").unwrap(), Action::GotoTab(3)); assert_eq!(Action::parse("GotoTab(0)").unwrap(), Action::GotoTab(0)); } #[test] fn rejects_unknown_action() { let err = Action::parse("Frobnicate").unwrap_err(); assert_eq!(err, ActionParseError::Unknown("Frobnicate".into())); } #[test] fn rejects_bad_direction_arg() { let err = Action::parse("FocusPane(Sideways)").unwrap_err(); assert!( matches!(err, ActionParseError::BadArg { ref action, .. } if action == "FocusPane") ); } #[test] fn rejects_non_numeric_tab_arg() { let err = Action::parse("GotoTab(abc)").unwrap_err(); assert!(matches!(err, ActionParseError::BadArg { ref action, .. } if action == "GotoTab")); } #[test] fn rejects_overflow_tab_arg() { let err = Action::parse("GotoTab(9999)").unwrap_err(); assert!(matches!(err, ActionParseError::BadArg { .. })); } #[test] fn rejects_unclosed_paren() { let err = Action::parse("GotoTab(3").unwrap_err(); assert_eq!(err, ActionParseError::Malformed("GotoTab(3".into())); } /// The fast-forward pair sits next to the draft-pane key (#67). #[test] fn fast_forward_spawn_round_trips() { assert_eq!( Action::parse("FastForwardSpawn").unwrap(), Action::FastForwardSpawn ); assert_eq!(Action::FastForwardSpawn.to_string(), "FastForwardSpawn"); } #[test] fn display_round_trips() { for a in [ Action::EnterInsert, Action::Quit, Action::NewDraftPane, Action::FocusPane(Direction::Right), Action::GotoTab(7), ] { let s = a.to_string(); assert_eq!(Action::parse(&s).unwrap(), a, "round-trip for {a:?}"); } } /// The spawn modal is gone (issue #63); its old action string must not /// resolve to anything. #[test] fn the_removed_spawn_modal_action_no_longer_parses() { assert_eq!( Action::parse("OpenSpawnModal").unwrap_err(), ActionParseError::Unknown("OpenSpawnModal".into()) ); } }