use crate::application::menu::common::handle_common_key;
use crate::domain::{Error, MenuAction, MenuItem, Result, Selection, Theme};
#[derive(Debug, Clone)]
pub struct SelectMenu {
items: Vec<MenuItem>,
filtered: Vec<usize>,
query: String,
selection: Selection,
theme: Theme,
title: Option<String>,
show_scrollbar: bool,
}
impl SelectMenu {
#[must_use]
pub fn builder() -> SelectMenuBuilder {
SelectMenuBuilder::default()
}
#[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 title(&self) -> Option<&str> {
match &self.title {
Some(s) => Some(s.as_str()),
None => None,
}
}
#[must_use]
pub const fn show_scrollbar(&self) -> bool {
self.show_scrollbar
}
#[must_use]
pub const fn query(&self) -> &str {
self.query.as_str()
}
#[must_use]
pub const fn filtered_indices(&self) -> &[usize] {
self.filtered.as_slice()
}
pub fn update(&mut self, event: crate::ports::KeyEvent) -> MenuAction {
match event.code {
crate::ports::KeyCode::Char(c)
if !event
.modifiers
.contains(crate::ports::KeyModifiers::CONTROL) =>
{
if let Some(idx) = self.items.iter().position(|i| i.key == Some(c)) {
self.query.clear();
self.recompute_filtered();
self.selection.set(idx);
} else {
self.query.push(c);
self.recompute_filtered();
}
MenuAction::None
}
crate::ports::KeyCode::Backspace => {
self.query.pop();
self.recompute_filtered();
MenuAction::None
}
_ => {
let visible: Vec<MenuItem> = self
.filtered
.iter()
.filter_map(|&i| self.items.get(i).cloned())
.collect();
match handle_common_key(&mut self.selection, &visible, event) {
MenuAction::Selected(item) => MenuAction::Selected(item),
other => other,
}
}
}
}
fn recompute_filtered(&mut self) {
self.filtered = crate::application::filter::filter_indices(&self.items, &self.query);
self.selection = Selection::new(self.filtered.len());
}
pub fn dispatch(&mut self, event: impl Into<crate::ports::MenuEvent>) -> MenuAction {
crate::ports::dispatch(self, event)
}
}
impl crate::ports::MenuDispatch for SelectMenu {
fn key_input(&mut self, event: crate::ports::KeyEvent) -> MenuAction {
self.update(event)
}
fn on_mouse(&mut self, event: crate::ports::MouseEvent) -> MenuAction {
use crate::ports::MouseEventKind;
match event.kind {
MouseEventKind::Down(crate::ports::MouseButton::Left) => {
let row = event.row as usize;
if row < self.items.len() {
self.selection.set(row);
}
MenuAction::None
}
_ => MenuAction::None,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct SelectMenuBuilder {
items: Vec<MenuItem>,
query: String,
theme: Theme,
title: Option<String>,
show_scrollbar: bool,
}
impl SelectMenuBuilder {
#[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 fn query(mut self, value: impl Into<String>) -> Self {
self.query = value.into();
self
}
#[must_use]
pub const fn theme(mut self, theme: Theme) -> Self {
self.theme = theme;
self
}
#[must_use]
pub fn title(mut self, title: impl Into<String>) -> Self {
self.title = Some(title.into());
self
}
#[must_use]
pub const fn show_scrollbar(mut self, on: bool) -> Self {
self.show_scrollbar = on;
self
}
pub fn build(self) -> Result<SelectMenu> {
if self.items.is_empty() {
return Err(Error::EmptyMenu);
}
let count = self.items.len();
let mut menu = SelectMenu {
items: self.items,
filtered: (0..count).collect(),
query: self.query,
selection: Selection::new(count),
theme: self.theme,
title: self.title,
show_scrollbar: self.show_scrollbar,
};
if !menu.query.is_empty() {
menu.recompute_filtered();
}
Ok(menu)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ports::{KeyCode, KeyEvent, KeyModifiers};
fn ev(code: KeyCode) -> KeyEvent {
KeyEvent::new(code, KeyModifiers::NONE)
}
#[test]
fn builder_rejects_empty() {
let result = SelectMenu::builder().build();
assert!(matches!(result, Err(Error::EmptyMenu)));
}
#[test]
fn down_advances_cursor() -> Result<()> {
let mut menu = SelectMenu::builder()
.items([
MenuItem::try_from(("a", "first"))?,
MenuItem::try_from(("b", "second"))?,
MenuItem::try_from(("c", "third"))?,
])
.build()?;
assert_eq!(menu.selection(), 0);
let _ = menu.update(ev(KeyCode::Down));
assert_eq!(menu.selection(), 1);
Ok(())
}
#[test]
fn down_wraps_at_bottom() -> Result<()> {
let mut menu = SelectMenu::builder()
.items([
MenuItem::try_from(("a", "first"))?,
MenuItem::try_from(("b", "second"))?,
])
.build()?;
let _ = menu.update(ev(KeyCode::Down));
let _ = menu.update(ev(KeyCode::Down));
assert_eq!(menu.selection(), 0);
Ok(())
}
#[test]
fn enter_returns_selected_item() -> Result<()> {
let mut menu = SelectMenu::builder()
.items([
MenuItem::try_from(("a", "first"))?,
MenuItem::try_from(("b", "second"))?,
])
.build()?;
let _ = menu.update(ev(KeyCode::Down));
let action = menu.update(ev(KeyCode::Enter));
assert!(matches!(action, MenuAction::Selected(ref i) if i.name == "b"));
Ok(())
}
#[test]
fn esc_returns_cancelled() -> Result<()> {
let mut menu = SelectMenu::builder()
.items([MenuItem::try_from(("a", "first"))?])
.build()?;
let action = menu.update(ev(KeyCode::Esc));
assert_eq!(action, MenuAction::Cancelled);
Ok(())
}
#[test]
fn hotkey_jumps_to_matching_item() -> Result<()> {
let mut menu = SelectMenu::builder()
.items([
MenuItem::try_from(("yes", "approve"))?.with_key('y'),
MenuItem::try_from(("no", "reject"))?.with_key('n'),
])
.build()?;
let _ = menu.update(ev(KeyCode::Char('n')));
assert_eq!(menu.selection(), 1);
Ok(())
}
}