use std::collections::VecDeque;
use std::io::{self, Write};
use std::time::Duration;
pub const CONFIRM_TIMEOUT: Duration = Duration::from_secs(30);
const SELECT_IDLE_TIMEOUT: Duration = Duration::from_secs(600);
const INVALID_INPUT_MSG: &str = "Please enter y or n";
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Fix {
pub description: String,
}
impl Fix {
pub fn new(description: impl Into<String>) -> Self {
Self {
description: description.into(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Key {
Char(char),
Enter,
Up,
Down,
Space,
Esc,
Unknown,
}
pub trait KeyReader {
fn read_key(&mut self, timeout: Duration) -> Option<Key>;
}
pub trait PromptWriter {
fn write(&mut self, text: &str);
fn flush(&mut self) -> io::Result<()>;
}
pub struct TerminalKeyReader;
impl KeyReader for TerminalKeyReader {
fn read_key(&mut self, timeout: Duration) -> Option<Key> {
loop {
if !crossterm::event::poll(timeout).unwrap_or(false) {
return None;
}
match crossterm::event::read() {
Ok(crossterm::event::Event::Key(event)) => return Some(key_from_crossterm(event)),
_ => continue,
}
}
}
}
fn key_from_crossterm(event: crossterm::event::KeyEvent) -> Key {
if event
.modifiers
.contains(crossterm::event::KeyModifiers::CONTROL)
&& event.code == crossterm::event::KeyCode::Char('c')
{
return Key::Char('\u{3}');
}
match event.code {
crossterm::event::KeyCode::Char(' ') => Key::Space,
crossterm::event::KeyCode::Char(c) => Key::Char(c),
crossterm::event::KeyCode::Enter => Key::Enter,
crossterm::event::KeyCode::Up => Key::Up,
crossterm::event::KeyCode::Down => Key::Down,
crossterm::event::KeyCode::Esc => Key::Esc,
_ => Key::Unknown,
}
}
pub struct StdoutWriter;
impl PromptWriter for StdoutWriter {
fn write(&mut self, text: &str) {
let _ = io::stdout().write_all(text.as_bytes());
}
fn flush(&mut self) -> io::Result<()> {
io::stdout().flush()
}
}
struct RawModeGuard;
impl RawModeGuard {
fn enable() -> io::Result<Self> {
crossterm::terminal::enable_raw_mode()?;
Ok(Self)
}
}
impl Drop for RawModeGuard {
fn drop(&mut self) {
let _ = crossterm::terminal::disable_raw_mode();
}
}
pub fn prompt_user_confirmation(message: &str, default: bool) -> bool {
let _guard = RawModeGuard::enable().ok();
let mut reader = TerminalKeyReader;
let mut writer = StdoutWriter;
prompt_user_confirmation_with(message, default, CONFIRM_TIMEOUT, &mut reader, &mut writer)
}
pub fn prompt_user_confirmation_with(
message: &str,
default: bool,
timeout: Duration,
reader: &mut dyn KeyReader,
writer: &mut dyn PromptWriter,
) -> bool {
loop {
writer.write(&prompt_line(message, default));
let _ = writer.flush();
let Some(key) = reader.read_key(timeout) else {
writer.write(&format!(
"\n(timeout after {timeout:?} — using default {})",
if default { "yes" } else { "no" }
));
let _ = writer.flush();
return default;
};
writer.write("*");
let _ = writer.flush();
match parse_confirmation_key(key, default) {
Some(decision) => {
writer.write("\n");
let _ = writer.flush();
return decision;
}
None => {
writer.write(format!("\n{INVALID_INPUT_MSG}\n").as_str());
let _ = writer.flush();
}
}
}
}
fn prompt_line(message: &str, default: bool) -> String {
let hint = if default { "(Y/n)" } else { "(y/N)" };
let bracket = if default { "[y]" } else { "[n]" };
format!("❓ {message} {hint} {bracket}\n>> ")
}
fn parse_confirmation_key(key: Key, default: bool) -> Option<bool> {
match key {
Key::Char(c) if c.eq_ignore_ascii_case(&'y') => Some(true),
Key::Char(c) if c.eq_ignore_ascii_case(&'n') => Some(false),
Key::Enter | Key::Char('\r') | Key::Char('\n') => Some(default),
Key::Char('\u{3}') => Some(default), _ => None,
}
}
pub fn fixes_from_mentors(suggestions: &[String]) -> Vec<Fix> {
suggestions.iter().map(|s| Fix::new(s.clone())).collect()
}
pub fn prompt_fix_selection(fixes: &[Fix]) -> Vec<Fix> {
let _guard = RawModeGuard::enable().ok();
let mut reader = TerminalKeyReader;
let mut writer = StdoutWriter;
prompt_fix_selection_with(fixes, &mut reader, &mut writer)
}
pub fn prompt_fix_selection_with(
fixes: &[Fix],
reader: &mut dyn KeyReader,
writer: &mut dyn PromptWriter,
) -> Vec<Fix> {
if fixes.is_empty() {
return Vec::new();
}
let count = fixes.len();
let mut index = 0usize;
let mut toggled = vec![false; count];
render_all(writer, fixes, index, &toggled, false);
let _ = writer.flush();
loop {
match reader.read_key(SELECT_IDLE_TIMEOUT) {
Some(Key::Up) => {
index = (index + count - 1) % count;
redraw(writer, fixes, index, &toggled);
}
Some(Key::Down) => {
index = (index + 1) % count;
redraw(writer, fixes, index, &toggled);
}
Some(Key::Space) => {
toggled[index] = !toggled[index];
redraw(writer, fixes, index, &toggled);
}
Some(Key::Enter) | Some(Key::Char('\r')) | Some(Key::Char('\n')) => {
writer.write("\x1b[2K\r");
let _ = writer.flush();
return collect_selected(fixes, &toggled);
}
Some(Key::Esc) => {
writer.write("\n");
let _ = writer.flush();
return Vec::new();
}
None => {
writer.write("\n");
let _ = writer.flush();
return collect_selected(fixes, &toggled);
}
Some(Key::Unknown) => {
continue;
}
Some(_) => {
continue;
}
}
}
}
fn collect_selected(fixes: &[Fix], toggled: &[bool]) -> Vec<Fix> {
fixes
.iter()
.zip(toggled)
.filter(|(_, on)| **on)
.map(|(fix, _)| fix.clone())
.collect()
}
fn render_all(
writer: &mut dyn PromptWriter,
fixes: &[Fix],
index: usize,
toggled: &[bool],
clear: bool,
) {
let erase = if clear { "\r\x1b[2K" } else { "" };
let mut out = String::new();
out.push_str(&format!(
"{erase}Which issues should we fix? (arrow keys to move, space to select)\n"
));
for (i, fix) in fixes.iter().enumerate() {
let marker = if toggled[i] { "☑" } else { "☐" };
if i == index {
out.push_str(&format!(
"{erase}\x1b[7m> {marker} {}\x1b[0m\n",
fix.description
));
} else {
out.push_str(&format!("{erase} {marker} {}\n", fix.description));
}
}
writer.write(&out);
}
fn redraw(writer: &mut dyn PromptWriter, fixes: &[Fix], index: usize, toggled: &[bool]) {
let lines = 1 + fixes.len();
writer.write(&format!("\x1b[{lines}A"));
render_all(writer, fixes, index, toggled, true);
let _ = writer.flush();
}
#[derive(Debug, Clone)]
pub struct MockKeyReader {
keys: VecDeque<Key>,
timeouts: u32,
}
impl MockKeyReader {
pub fn new(keys: Vec<Key>) -> Self {
Self {
keys: keys.into(),
timeouts: 0,
}
}
pub fn with_timeouts(mut self, timeouts: u32) -> Self {
self.timeouts = timeouts;
self
}
}
impl KeyReader for MockKeyReader {
fn read_key(&mut self, _timeout: Duration) -> Option<Key> {
if self.timeouts > 0 {
self.timeouts -= 1;
return None;
}
self.keys.pop_front()
}
}
#[derive(Debug, Clone, Default)]
pub struct CapturingWriter {
pub output: String,
}
impl PromptWriter for CapturingWriter {
fn write(&mut self, text: &str) {
self.output.push_str(text);
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn keys(values: &[char]) -> Vec<Key> {
values.iter().map(|c| Key::Char(*c)).collect()
}
fn run_confirmation(keys: Vec<Key>, default: bool, timeouts: u32) -> (bool, String) {
let mut reader = MockKeyReader::new(keys).with_timeouts(timeouts);
let mut writer = CapturingWriter::default();
let result = prompt_user_confirmation_with(
"Copy .env.example to .env?",
default,
Duration::from_secs(30),
&mut reader,
&mut writer,
);
(result, writer.output)
}
#[test]
fn lower_y_answers_yes() {
let (ok, out) = run_confirmation(keys(&['y']), true, 0);
assert!(ok);
assert!(out.contains("❓ Copy .env.example to .env? (Y/n) [y]"));
assert!(out.contains(">> "));
assert!(out.contains('*'), "visual feedback star expected");
}
#[test]
fn upper_y_answers_yes() {
let (ok, _) = run_confirmation(keys(&['Y']), false, 0);
assert!(ok);
}
#[test]
fn lower_n_answers_no() {
let (ok, _) = run_confirmation(keys(&['n']), true, 0);
assert!(!ok);
}
#[test]
fn upper_n_answers_no() {
let (ok, _) = run_confirmation(keys(&['N']), true, 0);
assert!(!ok);
}
#[test]
fn yes_word_first_char_decides() {
let (ok, _) = run_confirmation(keys(&['y', 'e', 's']), false, 0);
assert!(ok);
}
#[test]
fn no_word_first_char_decides() {
let (ok, _) = run_confirmation(keys(&['n', 'o']), true, 0);
assert!(!ok);
}
#[test]
fn enter_uses_default_true() {
let (ok, _) = run_confirmation(vec![Key::Enter], true, 0);
assert!(ok);
}
#[test]
fn enter_uses_default_false() {
let (ok, _) = run_confirmation(vec![Key::Enter], false, 0);
assert!(!ok);
}
#[test]
fn default_true_renders_caps_hint() {
let (_, out) = run_confirmation(keys(&['y']), true, 0);
assert!(out.contains("(Y/n) [y]"));
}
#[test]
fn default_false_renders_other_hint() {
let (_, out) = run_confirmation(keys(&['n']), false, 0);
assert!(out.contains("(y/N) [n]"));
}
#[test]
fn invalid_input_reprompts_then_accepts() {
let (ok, out) = run_confirmation(vec![Key::Char('x'), Key::Char('n')], true, 0);
assert!(!ok, "second key 'n' should answer no");
assert_eq!(out.matches(INVALID_INPUT_MSG).count(), 1);
assert_eq!(out.matches(">> ").count(), 2);
}
#[test]
fn invalid_input_until_enter_uses_default() {
let (ok, out) = run_confirmation(vec![Key::Char('?'), Key::Enter], true, 0);
assert!(ok);
assert_eq!(out.matches(INVALID_INPUT_MSG).count(), 1);
}
#[test]
fn timeout_uses_default() {
let (ok, out) = run_confirmation(vec![], true, 1);
assert!(ok, "timeout should fall back to default(true)");
assert!(out.contains("timeout"));
assert!(out.contains("default yes"));
}
#[test]
fn timeout_uses_default_false() {
let (ok, out) = run_confirmation(vec![], false, 1);
assert!(!ok);
assert!(out.contains("default no"));
}
#[test]
fn repeated_timeouts_do_not_hang() {
let (ok, out) = run_confirmation(vec![], true, 5);
assert!(ok);
assert_eq!(out.matches("timeout").count(), 1);
}
#[test]
fn unicode_message_preserved() {
let mut reader = MockKeyReader::new(vec![Key::Char('y')]);
let mut writer = CapturingWriter::default();
prompt_user_confirmation_with(
"Déployer 🚀 ?",
true,
Duration::from_secs(30),
&mut reader,
&mut writer,
);
assert!(writer.output.contains("Déployer 🚀 ?"));
}
fn sample_fixes() -> Vec<Fix> {
vec![
Fix::new("Copy .env.example to .env"),
Fix::new("Terminate ghost process on port 3000"),
Fix::new("Update dependencies"),
]
}
fn run_selection(keys: Vec<Key>) -> (Vec<Fix>, String) {
let mut reader = MockKeyReader::new(keys);
let mut writer = CapturingWriter::default();
let chosen = prompt_fix_selection_with(&sample_fixes(), &mut reader, &mut writer);
(chosen, writer.output)
}
#[test]
fn selection_toggle_with_arrows_and_space() {
let (chosen, out) = run_selection(vec![
Key::Down, Key::Space, Key::Down, Key::Space, Key::Up, Key::Space, Key::Enter,
]);
assert_eq!(chosen.len(), 1);
assert_eq!(chosen[0].description, "Update dependencies");
assert!(out.contains("Which issues should we fix?"));
assert!(out.contains("☑") && out.contains("☐"));
assert!(out.contains("☑ Update dependencies"));
}
#[test]
fn selection_enter_without_toggles_returns_empty() {
let (chosen, _) = run_selection(vec![Key::Enter]);
assert!(chosen.is_empty());
}
#[test]
fn selection_escape_cancels() {
let (chosen, _) = run_selection(vec![Key::Down, Key::Space, Key::Esc]);
assert!(chosen.is_empty());
}
#[test]
fn selection_wraps_around_top_and_bottom() {
let (chosen, _) = run_selection(vec![
Key::Up, Key::Space, Key::Enter,
]);
assert_eq!(chosen.len(), 1);
assert_eq!(chosen[0].description, "Update dependencies");
}
#[test]
fn selection_unknown_keys_are_ignored() {
let (chosen, _) = run_selection(vec![
Key::Unknown,
Key::Unknown,
Key::Space,
Key::Unknown,
Key::Enter,
]);
assert_eq!(chosen.len(), 1);
assert_eq!(chosen[0].description, "Copy .env.example to .env");
}
#[test]
fn selection_empty_fixes_returns_empty_immediately() {
let mut reader = MockKeyReader::new(vec![Key::Enter]);
let mut writer = CapturingWriter::default();
let chosen = prompt_fix_selection_with(&[], &mut reader, &mut writer);
assert!(chosen.is_empty());
assert!(writer.output.is_empty());
}
#[test]
fn selection_idle_timeout_keeps_current_choice() {
let mut reader = MockKeyReader::new(vec![Key::Down, Key::Space]);
let mut writer = CapturingWriter::default();
let chosen = prompt_fix_selection_with(&sample_fixes(), &mut reader, &mut writer);
assert_eq!(chosen.len(), 1);
assert_eq!(
chosen[0].description,
"Terminate ghost process on port 3000"
);
}
#[test]
fn fixes_from_mentors_maps_descriptions() {
let suggestions = vec![
"Install npm".to_string(),
"Set EDITOR".to_string(),
"Kill ghost process".to_string(),
];
let fixes = fixes_from_mentors(&suggestions);
assert_eq!(fixes.len(), 3);
assert_eq!(fixes[2].description, "Kill ghost process");
}
}