use crate::application::menu::common::handle_common_key;
use crate::domain::{Error, MenuAction, MenuItem, Result, Selection, Theme, item::AnnotatedItem};
use crate::ports::KeyEvent;
pub const DEFAULT_PROJECTS: &[(&str, &str, &str, &str)] = &[
("current", "brainless", "~/dev/brainless", "current"),
(
"cloudstate",
"freestyle-cloudstate",
"~/Documents/GitHub/freestyle-cloudstate",
"5h ago",
),
("conduit", "Conduit", "~/Documents/Conduit", "5h ago"),
];
const CUSTOM_KEY: char = 'z';
pub fn default_projects() -> Result<Vec<AnnotatedItem>> {
DEFAULT_PROJECTS
.iter()
.enumerate()
.map(|(i, (_id, name, path, meta))| {
let key = u32::try_from(i + 1)
.ok()
.and_then(|n| char::from_digit(n, 10));
let annotation = if *meta == "current" {
None
} else {
Some(*meta)
};
AnnotatedItem::try_from((*name, *path, annotation)).map(|item| match key {
Some(c) => item.with_key(c),
None => item,
})
})
.collect()
}
#[derive(Debug, Clone)]
pub struct ProjectPicker {
title: String,
description: String,
projects: Vec<AnnotatedItem>,
custom_label: String,
selection: Selection,
theme: Theme,
show_scrollbar: bool,
}
impl ProjectPicker {
#[must_use]
pub fn builder() -> ProjectPickerBuilder {
ProjectPickerBuilder::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 description(&self) -> &str {
self.description.as_str()
}
#[must_use]
pub const fn projects(&self) -> &[AnnotatedItem] {
self.projects.as_slice()
}
#[must_use]
pub const fn custom_label(&self) -> &str {
self.custom_label.as_str()
}
#[must_use]
pub const fn selection(&self) -> usize {
self.selection.index()
}
#[must_use]
pub const fn is_custom_selected(&self) -> bool {
self.selection.index() == self.projects.len()
}
#[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: KeyEvent) -> MenuAction {
let items = self.items_view();
match handle_common_key(&mut self.selection, &items, event) {
MenuAction::Selected(_) if self.is_custom_selected() => MenuAction::Activated,
other => other,
}
}
pub fn dispatch(&mut self, event: impl Into<crate::ports::MenuEvent>) -> MenuAction {
crate::ports::dispatch(self, event)
}
fn items_view(&self) -> Vec<MenuItem> {
let mut v: Vec<MenuItem> = self
.projects
.iter()
.map(|p| MenuItem {
name: p.name.clone(),
description: p.description.clone(),
key: p.key,
})
.collect();
v.push(MenuItem {
name: self.custom_label.clone(),
description: String::new(),
key: Some(CUSTOM_KEY),
});
v
}
}
impl crate::ports::MenuDispatch for ProjectPicker {
fn key_input(&mut self, event: 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.projects.len() + 1 {
self.selection.set(row);
}
self.update(crate::ports::KeyEvent::new(
crate::ports::KeyCode::Enter,
crate::ports::KeyModifiers::NONE,
))
}
_ => MenuAction::None,
}
}
}
#[derive(Debug, Clone)]
pub struct ProjectPickerBuilder {
title: String,
description: String,
projects: Vec<AnnotatedItem>,
custom_label: String,
theme: Theme,
show_scrollbar: bool,
}
impl Default for ProjectPickerBuilder {
fn default() -> Self {
Self {
title: "Run in a project directory?".to_owned(),
description: "This gives full context of your codebase for better results.".to_owned(),
projects: Vec::new(),
custom_label: "Type your answer here".to_owned(),
theme: Theme::default(),
show_scrollbar: false,
}
}
}
impl ProjectPickerBuilder {
#[must_use]
pub fn title(mut self, title: impl Into<String>) -> Self {
self.title = title.into();
self
}
#[must_use]
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = description.into();
self
}
#[must_use]
pub fn projects<I>(mut self, projects: I) -> Self
where
I: IntoIterator<Item = AnnotatedItem>,
{
self.projects = projects.into_iter().collect();
self
}
#[must_use]
pub fn project(mut self, project: AnnotatedItem) -> Self {
self.projects.push(project);
self
}
#[must_use]
pub fn custom_label(mut self, label: impl Into<String>) -> Self {
self.custom_label = label.into();
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 with_defaults(mut self) -> Result<Self> {
self.projects = default_projects()?;
Ok(self)
}
pub fn build(self) -> Result<ProjectPicker> {
if self.projects.is_empty() {
return Err(Error::EmptyMenu);
}
if self.custom_label.is_empty() {
return Err(Error::EmptyCustomLabel);
}
let count = self.projects.len() + 1; Ok(ProjectPicker {
title: self.title,
description: self.description,
projects: self.projects,
custom_label: self.custom_label,
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_have_three_projects() -> Result<()> {
let p = ProjectPicker::with_defaults()?;
assert_eq!(p.projects().len(), 3);
Ok(())
}
#[test]
fn selecting_project_returns_selected() -> Result<()> {
let mut p = ProjectPicker::with_defaults()?;
let _ = p.update(ev(KeyCode::Char('1')));
let action = p.update(ev(KeyCode::Enter));
assert!(matches!(action, MenuAction::Selected(_)));
Ok(())
}
#[test]
fn selecting_custom_returns_activated() -> Result<()> {
let mut p = ProjectPicker::with_defaults()?;
let _ = p.update(ev(KeyCode::Char('z')));
assert!(p.is_custom_selected());
let action = p.update(ev(KeyCode::Enter));
assert_eq!(action, MenuAction::Activated);
Ok(())
}
#[test]
fn rejects_empty_custom_label() -> Result<()> {
let result = ProjectPicker::builder()
.with_defaults()?
.custom_label("")
.build();
assert!(matches!(result, Err(Error::EmptyCustomLabel)));
Ok(())
}
}