use crate::application::menu::common::handle_common_key;
use crate::domain::{MenuAction, MenuItem, Result, Selection, Theme};
pub const DEFAULT_OPTIONS: &[(&str, &str)] = &[
("Yes", "1"),
("Yes, and don't ask again this session", "2"),
("No, and tell Claude what to do (esc)", "3"),
];
pub fn default_options() -> Result<Vec<MenuItem>> {
DEFAULT_OPTIONS
.iter()
.map(|(label, key)| {
let key_char = key.chars().next();
MenuItem::try_from((String::from(*label), String::new())).map(|i| match key_char {
Some(c) => i.with_key(c),
None => i,
})
})
.collect()
}
#[derive(Debug, Clone)]
pub struct PermissionPrompt {
title: String,
command: String,
question: String,
items: Vec<MenuItem>,
selection: Selection,
theme: Theme,
show_scrollbar: bool,
}
impl PermissionPrompt {
#[must_use]
pub fn builder() -> PermissionPromptBuilder {
PermissionPromptBuilder::default()
}
pub fn with_defaults() -> Result<Self> {
Self::builder().with_defaults()?.build()
}
#[must_use]
pub const fn title(&self) -> &str {
self.title.as_str()
}
#[must_use]
pub const fn command(&self) -> &str {
self.command.as_str()
}
#[must_use]
pub const fn question(&self) -> &str {
self.question.as_str()
}
#[must_use]
pub const fn items(&self) -> &[MenuItem] {
self.items.as_slice()
}
#[must_use]
pub const fn selection(&self) -> usize {
self.selection.index()
}
#[must_use]
pub const fn theme(&self) -> Theme {
self.theme
}
#[must_use]
pub const fn show_scrollbar(&self) -> bool {
self.show_scrollbar
}
pub fn update(&mut self, event: crate::ports::KeyEvent) -> MenuAction {
handle_common_key(&mut self.selection, &self.items, event)
}
pub fn dispatch(&mut self, event: impl Into<crate::ports::MenuEvent>) -> crate::MenuAction {
crate::ports::dispatch(self, event)
}
}
impl crate::ports::MenuDispatch for PermissionPrompt {
fn key_input(&mut self, event: crate::ports::KeyEvent) -> crate::MenuAction {
self.update(event)
}
fn on_mouse(&mut self, event: crate::ports::MouseEvent) -> crate::MenuAction {
use crate::ports::MouseEventKind;
match event.kind {
MouseEventKind::Down(crate::ports::MouseButton::Left) => {
let row = event.row as usize;
match self.items.get(row) {
Some(item) => {
self.selection.set(row);
crate::MenuAction::Selected(item.clone())
}
None => crate::MenuAction::None,
}
}
_ => crate::MenuAction::None,
}
}
}
#[derive(Debug, Clone)]
pub struct PermissionPromptBuilder {
title: String,
command: String,
question: String,
items: Vec<MenuItem>,
theme: Theme,
show_scrollbar: bool,
}
impl Default for PermissionPromptBuilder {
fn default() -> Self {
Self {
title: "Bash command".to_owned(),
command: "<unknown>".to_owned(),
question: "Do you want to proceed?".to_owned(),
items: Vec::new(),
theme: Theme::default(),
show_scrollbar: false,
}
}
}
impl PermissionPromptBuilder {
#[must_use]
pub fn title(mut self, title: impl Into<String>) -> Self {
self.title = title.into();
self
}
#[must_use]
pub fn command(mut self, command: impl Into<String>) -> Self {
self.command = command.into();
self
}
#[must_use]
pub fn question(mut self, question: impl Into<String>) -> Self {
self.question = question.into();
self
}
pub fn with_defaults(mut self) -> Result<Self> {
self.items = default_options()?;
Ok(self)
}
#[must_use]
pub fn items<I>(mut self, items: I) -> Self
where
I: IntoIterator<Item = MenuItem>,
{
self.items = items.into_iter().collect();
self
}
#[must_use]
pub fn item(mut self, item: MenuItem) -> Self {
self.items.push(item);
self
}
#[must_use]
pub const fn theme(mut self, theme: Theme) -> Self {
self.theme = theme;
self
}
#[must_use]
pub const fn show_scrollbar(mut self, on: bool) -> Self {
self.show_scrollbar = on;
self
}
pub fn build(self) -> Result<PermissionPrompt> {
use crate::domain::error::Error;
if self.items.is_empty() {
return Err(Error::EmptyMenu);
}
let count = self.items.len();
Ok(PermissionPrompt {
title: self.title,
command: self.command,
question: self.question,
items: self.items,
selection: Selection::new(count),
theme: self.theme,
show_scrollbar: self.show_scrollbar,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ports::{KeyCode, KeyEvent, KeyModifiers};
fn ev(code: KeyCode) -> KeyEvent {
KeyEvent::new(code, KeyModifiers::NONE)
}
#[test]
fn defaults_to_three_options() -> Result<()> {
let p = PermissionPrompt::with_defaults()?;
assert_eq!(p.items().len(), 3);
Ok(())
}
#[test]
fn hotkey_jumps_to_choice() -> Result<()> {
let mut p = PermissionPrompt::with_defaults()?;
let _ = p.update(ev(KeyCode::Char('2')));
assert_eq!(p.selection(), 1);
let action = p.update(ev(KeyCode::Enter));
assert!(matches!(action, MenuAction::Selected(ref i) if i.key == Some('2')));
Ok(())
}
#[test]
fn esc_cancels() -> Result<()> {
let mut p = PermissionPrompt::with_defaults()?;
assert_eq!(p.update(ev(KeyCode::Esc)), MenuAction::Cancelled);
Ok(())
}
}