//! `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), // Session scrollback ScrollPanePageUp, ScrollPanePageDown, // Sidebar highlight movement SidebarNext, SidebarPrev, ToggleSidebarGroup, // Catalog actions on the highlighted sidebar row AttachHighlighted, ToggleAttachHighlighted, OpenSpawnModal, /// Fast-forward spawn (#67): spawn immediately with every default /// resolved; unresolvable defaults open a pre-filled form instead. FastForwardSpawn, KillHighlighted, /// Rename the highlighted session (#125): opens a prompt pre-filled with /// its current name. RenameHighlighted, // 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 { /// Plain-language label for the in-app help menu. Configuration keeps the /// stable enum spelling; operators should not have to decode it. pub fn help_label(&self) -> String { match self { Action::Noop => "Do nothing".into(), Action::EnterInsert => "Send keys to session".into(), Action::LeaveInsert => "Return to sidebar".into(), Action::FocusSidebar => "Focus sidebar".into(), Action::FocusPane(direction) => { format!( "Focus session pane ({})", format!("{direction:?}").to_lowercase() ) } Action::ScrollPanePageUp => "Scroll session up one page".into(), Action::ScrollPanePageDown => "Scroll session down one page".into(), Action::SidebarNext => "Select next sidebar item".into(), Action::SidebarPrev => "Select previous sidebar item".into(), Action::ToggleSidebarGroup => "Expand or collapse directory".into(), Action::AttachHighlighted => "Open selected item".into(), Action::ToggleAttachHighlighted => "Open selected item".into(), Action::OpenSpawnModal => "Create a session".into(), Action::FastForwardSpawn => "Create session with defaults".into(), Action::KillHighlighted => "Kill selected session".into(), Action::RenameHighlighted => "Rename selected session".into(), Action::ToggleSidebar => "Show or hide sidebar".into(), Action::ShowHelp => "Show help".into(), Action::Quit => "Quit Maestro".into(), } } /// Parse a canonical action string like `"EnterInsert"` or /// `"FocusPane(Left)"`. 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), "ScrollPanePageUp" => return Ok(Action::ScrollPanePageUp), "ScrollPanePageDown" => return Ok(Action::ScrollPanePageDown), "SidebarNext" => return Ok(Action::SidebarNext), "SidebarPrev" => return Ok(Action::SidebarPrev), "ToggleSidebarGroup" => return Ok(Action::ToggleSidebarGroup), "AttachHighlighted" => return Ok(Action::AttachHighlighted), "ToggleAttachHighlighted" => return Ok(Action::ToggleAttachHighlighted), "OpenSpawnModal" => return Ok(Action::OpenSpawnModal), "FastForwardSpawn" => return Ok(Action::FastForwardSpawn), "KillHighlighted" => return Ok(Action::KillHighlighted), "RenameHighlighted" => return Ok(Action::RenameHighlighted), "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)) } _ => 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:?})"), 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 help_labels_are_plain_language() { assert_eq!(Action::EnterInsert.help_label(), "Send keys to session"); assert_eq!(Action::AttachHighlighted.help_label(), "Open selected item"); assert!(!Action::OpenSpawnModal .help_label() .contains("OpenSpawnModal")); } #[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 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_unclosed_paren() { let err = Action::parse("FocusPane(Left").unwrap_err(); assert_eq!(err, ActionParseError::Malformed("FocusPane(Left".into())); } /// The fast-forward pair sits next to the spawn 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 rename_action_round_trips() { assert_eq!( Action::parse("RenameHighlighted").unwrap(), Action::RenameHighlighted ); assert_eq!(Action::RenameHighlighted.to_string(), "RenameHighlighted"); assert_eq!( Action::RenameHighlighted.help_label(), "Rename selected session" ); } #[test] fn display_round_trips() { for a in [ Action::EnterInsert, Action::RenameHighlighted, Action::Quit, Action::OpenSpawnModal, Action::ScrollPanePageDown, Action::FocusPane(Direction::Right), ] { let s = a.to_string(); assert_eq!(Action::parse(&s).unwrap(), a, "round-trip for {a:?}"); } } /// Draft panes are gone; their old action string must not resolve. #[test] fn the_removed_draft_pane_action_no_longer_parses() { assert_eq!( Action::parse("NewDraftPane").unwrap_err(), ActionParseError::Unknown("NewDraftPane".into()) ); } }