use std::ffi::OsStr;
use std::fmt::Write as _;
use std::io::{self, IsTerminal, Write};
use std::path::PathBuf;
use crate::cleanup::CleanupCandidate;
use crate::report::{escape_path_text, format_bytes};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Mode {
Normal,
Insert,
}
impl Mode {
pub fn as_str(self) -> &'static str {
match self {
Self::Normal => "NOR",
Self::Insert => "INS",
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Key {
Up,
Down,
PageUp,
PageDown,
Home,
End,
Char(char),
Space,
Backspace,
Enter,
Esc,
CtrlC,
Ignored,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Outcome {
Continue,
Commit(Vec<PathBuf>),
Quit,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum SessionResult {
Selected(Vec<PathBuf>),
Cancelled,
NothingToClean,
}
pub trait Terminal {
fn enter_raw(&mut self) -> io::Result<()>;
fn restore(&mut self) -> io::Result<()>;
fn read_key(&mut self) -> io::Result<Key>;
fn size(&mut self) -> io::Result<(u16, u16)>;
fn rewind(&mut self, lines: usize) -> io::Result<()>;
fn set_cursor_visible(&mut self, visible: bool) -> io::Result<()>;
fn clear(&mut self) -> io::Result<()>;
fn draw(&mut self, lines: &[String]) -> io::Result<()>;
}
const HEADER_LINES: usize = 4;
const FOOTER_LINES: usize = 1;
const CHROME_LINES: usize = HEADER_LINES + FOOTER_LINES;
const PAGE_ROWS: usize = 15;
const MIN_LIST_ROWS: usize = 1;
const MIN_FRAME_WIDTH: usize = 6;
const MIN_SESSION_WIDTH: usize = 20;
const MIN_SESSION_HEIGHT: usize = 6;
const ARMED_HINT_COMPACT: &str = "(Esc again)";
const MIN_NAME_WIDTH: usize = 8;
const GUTTER_WIDTH: usize = 1;
const CHECKBOX_WIDTH: usize = 3;
const SIZE_WIDTH: usize = 11;
const COLUMN_GAP: usize = 2;
const ARMED_HINT: &str = " (Esc again to exit)";
const LEAD_WIDTH: usize = GUTTER_WIDTH + 1 + CHECKBOX_WIDTH + 1;
const ANSI_RESET: &str = "\u{1b}[0m";
const ANSI_DIM: &str = "\u{1b}[2m";
const ANSI_BOLD: &str = "\u{1b}[1m";
const ANSI_REVERSE: &str = "\u{1b}[7m";
const ANSI_GREEN: &str = "\u{1b}[32m";
const ANSI_CYAN: &str = "\u{1b}[36m";
const ANSI_YELLOW: &str = "\u{1b}[33m";
#[derive(Clone, Debug)]
pub struct Session {
candidates: Vec<CleanupCandidate>,
labels: Vec<String>,
checked: Vec<bool>,
visible: Vec<usize>,
cursor: usize,
scroll: usize,
mode: Mode,
filter: String,
exit_armed: bool,
width: usize,
height: usize,
color: bool,
}
impl Session {
pub fn new(candidates: Vec<CleanupCandidate>) -> Self {
let checked = vec![false; candidates.len()];
let visible = (0..candidates.len()).collect();
let labels = unique_labels(&candidates);
Self {
candidates,
labels,
checked,
visible,
cursor: 0,
scroll: 0,
mode: Mode::Normal,
filter: String::new(),
exit_armed: false,
width: 80,
height: 24,
color: true,
}
}
pub fn with_color(mut self, color: bool) -> Self {
self.color = color;
self
}
pub fn with_size(mut self, width: u16, height: u16) -> Self {
self.set_size(width, height);
self
}
pub fn set_size(&mut self, width: u16, height: u16) {
self.width = (width as usize).max(MIN_FRAME_WIDTH);
self.height = (height as usize).max(1);
let max = self.rows().saturating_sub(1);
if self.cursor > max {
self.cursor = max;
}
self.ensure_cursor_visible();
}
pub fn candidate_count(&self) -> usize {
self.candidates.len()
}
pub fn visible_count(&self) -> usize {
self.visible.len()
}
pub fn selected_count(&self) -> usize {
self.checked.iter().filter(|c| **c).count()
}
pub fn selected_bytes(&self) -> u64 {
self.candidates
.iter()
.zip(&self.checked)
.filter(|(_, c)| **c)
.map(|(candidate, _)| candidate.bytes)
.sum()
}
pub fn mode(&self) -> Mode {
self.mode
}
pub fn filter(&self) -> &str {
&self.filter
}
pub fn cursor_candidate(&self) -> Option<usize> {
if self.cursor == 0 {
None
} else {
self.visible.get(self.cursor - 1).copied()
}
}
fn all_checked(&self) -> bool {
!self.checked.is_empty() && self.checked.iter().all(|c| *c)
}
fn rows(&self) -> usize {
self.visible.len() + 1
}
fn list_rows(&self) -> usize {
let available = self.plan().list;
let wanted = self.visible.len().max(MIN_LIST_ROWS);
PAGE_ROWS.min(wanted).min(available)
}
fn plan(&self) -> Plan {
Plan::for_size(self.height)
}
pub fn on_key(&mut self, key: Key) -> Outcome {
if key == Key::CtrlC {
return Outcome::Quit;
}
match self.mode {
Mode::Normal => self.on_key_normal(key),
Mode::Insert => self.on_key_insert(key),
}
}
fn on_key_normal(&mut self, key: Key) -> Outcome {
match key {
Key::Up => self.move_cursor(-1),
Key::Down | Key::Char('j') => self.move_cursor(1),
Key::PageUp => self.move_page(-1),
Key::PageDown => self.move_page(1),
Key::Home => self.move_to_start(),
Key::End => self.move_to_end(),
Key::Char('k') => self.move_cursor(-1),
Key::Space => self.toggle_cursor_row(),
Key::Char('i') => {
self.mode = Mode::Insert;
self.exit_armed = false;
}
Key::Esc => {
if self.exit_armed {
return Outcome::Quit;
}
self.exit_armed = true;
}
Key::Enter => return self.commit(),
Key::Char('q') => return Outcome::Quit,
Key::Char(_) | Key::Backspace | Key::Ignored => {}
Key::CtrlC => return Outcome::Quit,
}
Outcome::Continue
}
fn on_key_insert(&mut self, key: Key) -> Outcome {
match key {
Key::Esc => self.mode = Mode::Normal,
Key::Enter => return self.commit(),
Key::Backspace => {
self.filter.pop();
self.refilter();
}
Key::Space => {
self.filter.push(' ');
self.refilter();
}
Key::Char(c) => {
self.filter.push(c);
self.refilter();
}
Key::Up | Key::Down | Key::PageUp | Key::PageDown | Key::Home | Key::End => {}
Key::Ignored => {}
Key::CtrlC => return Outcome::Quit,
}
Outcome::Continue
}
fn move_cursor(&mut self, delta: isize) {
let max = self.rows().saturating_sub(1) as isize;
let next = (self.cursor as isize + delta).clamp(0, max);
self.set_cursor(next as usize);
}
fn move_page(&mut self, direction: isize) {
let page = self.list_rows() as isize;
self.move_cursor(direction * page);
}
fn move_to_start(&mut self) {
let target = if self.visible.is_empty() { 0 } else { 1 };
self.set_cursor(target);
}
fn move_to_end(&mut self) {
self.set_cursor(self.visible.len());
}
fn set_cursor(&mut self, target: usize) {
let max = self.rows().saturating_sub(1);
self.cursor = target.min(max);
self.exit_armed = false;
self.ensure_cursor_visible();
}
fn toggle_cursor_row(&mut self) {
if self.cursor == 0 {
let target = !self.all_checked();
self.checked.fill(target);
} else if let Some(idx) = self.cursor_candidate() {
self.checked[idx] = !self.checked[idx];
}
self.exit_armed = false;
}
fn refilter(&mut self) {
let needle = self.filter.to_lowercase();
self.visible = if needle.is_empty() {
(0..self.candidates.len()).collect()
} else {
(0..self.candidates.len())
.filter(|&i| {
self.candidates[i]
.root
.to_string_lossy()
.to_lowercase()
.contains(&needle)
})
.collect()
};
self.cursor = 0;
self.scroll = 0;
}
fn ensure_cursor_visible(&mut self) {
let page = self.list_rows();
if self.cursor == 0 {
self.scroll = 0;
return;
}
if self.scroll > self.cursor - 1 {
self.scroll = self.cursor - 1;
}
if self.scroll + page < self.cursor {
self.scroll = self.cursor - page;
}
let max_scroll = self.visible.len().saturating_sub(page);
if self.scroll > max_scroll {
self.scroll = max_scroll;
}
}
fn commit(&mut self) -> Outcome {
let roots: Vec<PathBuf> = self
.candidates
.iter()
.zip(&self.checked)
.filter(|(_, c)| **c)
.map(|(candidate, _)| candidate.root.clone())
.collect();
if roots.is_empty() {
return Outcome::Continue;
}
Outcome::Commit(roots)
}
pub fn frame(&self) -> Vec<String> {
let width = self.width;
let plan = self.plan();
let page = self.list_rows();
let columns = self.columns();
let mut out = Vec::with_capacity(CHROME_LINES + page);
if plan.title {
out.push(self.title_line(width));
}
if plan.status {
out.push(self.status_line(width));
}
if plan.all {
out.push(self.all_row(width));
}
if plan.header {
out.push(self.column_header(&columns, width));
}
if page > 0 {
if self.visible.is_empty() {
out.push(pad(
&truncate_end(" (no workspace matches the filter)", width),
width,
));
for _ in 1..page {
out.push(String::new());
}
} else {
let end = (self.scroll + page).min(self.visible.len());
for idx in self.scroll..end {
out.push(self.candidate_row(idx, end, &columns, width));
}
for _ in end..(self.scroll + page) {
out.push(String::new());
}
}
}
if plan.hint {
out.push(self.hint_bar(width));
}
debug_assert!(out.len() <= self.height.saturating_sub(1).max(1));
out
}
fn title_line(&self, width: usize) -> String {
let selected = self.selected_count();
let total = self.candidates.len();
let head = "cargo-cleanme — select workspaces — ";
let body = format!(
"{selected} selected of {total}, {} reclaimable",
format_bytes(self.selected_bytes()).trim()
);
let truncated = truncate(&format!("{head}{body}"), width);
if !self.color {
return pad(&truncated, width);
}
let body_cells = display_width(&body);
let truncated_cells = display_width(&truncated);
let styled = if truncated_cells >= body_cells {
let chrome: String = truncated
.chars()
.take(truncated_cells - body_cells)
.collect();
format!("{ANSI_DIM}{chrome}{ANSI_RESET}{ANSI_BOLD}{body}{ANSI_RESET}")
} else {
format!("{ANSI_DIM}{truncated}{ANSI_RESET}")
};
pad_visible(&styled, width)
}
fn status_line(&self, width: usize) -> String {
let mode = self.mode.as_str();
let position = self.position_indicator();
let armed = if self.mode == Mode::Normal && self.exit_armed {
ARMED_HINT
} else {
""
};
let caret = if self.mode == Mode::Insert { "_" } else { "" };
let filter = if self.filter.is_empty() && self.mode == Mode::Normal {
"<none>".to_string()
} else {
self.filter.clone()
};
let head = format!("{mode} filter: ");
let fixed = display_width(&head) + display_width(&position) + display_width(caret);
let available = width.saturating_sub(fixed + 1);
let slot = if available >= display_width(ARMED_HINT) {
display_width(ARMED_HINT)
} else if width > display_width(ARMED_HINT_COMPACT) + display_width(&position) {
display_width(ARMED_HINT_COMPACT)
} else {
0
};
let armed_text = if armed.is_empty() {
String::new()
} else if slot >= display_width(ARMED_HINT) {
ARMED_HINT.to_string()
} else if slot >= display_width(ARMED_HINT_COMPACT) {
ARMED_HINT_COMPACT.to_string()
} else {
String::new()
};
let right = format!("{armed_text:<slot$}{position}", slot = slot);
let left_budget = width.saturating_sub(display_width(&right) + display_width(caret) + 1);
let head = truncate_end(&head, left_budget);
let room = left_budget.saturating_sub(display_width(&head));
let left = format!("{head}{}{caret}", truncate_end(&filter, room));
let gap = width.saturating_sub(display_width(&left) + display_width(&right));
format!("{left}{}{right}", " ".repeat(gap))
}
fn position_indicator(&self) -> String {
let total = self.visible.len();
if self.cursor == 0 {
format!("—/{total}")
} else {
format!("{}/{total}", self.cursor)
}
}
fn column_header(&self, columns: &Columns, width: usize) -> String {
let mut plain = String::new();
plain.push_str(&" ".repeat(LEAD_WIDTH));
plain.push_str(&pad(&truncate("WORKSPACE", columns.name), columns.name));
if columns.size {
plain.push_str(&" ".repeat(COLUMN_GAP));
plain.push_str(&pad_left("RECLAIMABLE", SIZE_WIDTH));
}
if columns.own > 0 {
plain.push_str(&" ".repeat(columns.own_gap));
plain.push_str(&pad(&truncate_end("OWNERSHIP", columns.own), columns.own));
}
if !self.color {
return pad(&plain, width);
}
format!("{ANSI_DIM}{}{ANSI_RESET}", pad_visible(&plain, width))
}
fn all_row(&self, width: usize) -> String {
let selected = self.selected_count();
let total = self.candidates.len();
let mark = if self.all_checked() {
"x"
} else if selected > 0 {
"-"
} else {
" "
};
let pointer = if self.cursor == 0 { '>' } else { ' ' };
let label = format!("[{mark}] all");
let arithmetic = format!("({selected}/{total} selected)");
let left = truncate_end(&format!("{pointer} {label}"), width);
let arithmetic = if display_width(&left) + display_width(&arithmetic) <= width {
arithmetic
} else {
String::new()
};
let gap = width.saturating_sub(display_width(&left) + display_width(&arithmetic));
let plain = format!("{left}{}{arithmetic}", " ".repeat(gap));
if self.cursor == 0 && self.color {
return format!("{ANSI_REVERSE}{plain}{ANSI_RESET}");
}
if !self.color {
return plain;
}
let mark_style = if self.all_checked() { ANSI_GREEN } else { "" };
let styled_label = truncate_end(&label, width.saturating_sub(2));
let mut styled = String::new();
styled.push(pointer);
styled.push(' ');
styled.push_str(&self.paint(mark_style, &styled_label));
styled.push_str(&" ".repeat(gap));
if !arithmetic.is_empty() {
styled.push_str(&self.paint(ANSI_DIM, &arithmetic));
}
styled
}
fn candidate_row(&self, idx: usize, end: usize, columns: &Columns, width: usize) -> String {
let candidate_idx = self.visible[idx];
let candidate = &self.candidates[candidate_idx];
let checked = self.checked[candidate_idx];
let mark = if checked { "x" } else { " " };
let checkbox = format!("[{mark}]");
let label = &self.labels[candidate_idx];
let size = format_bytes(candidate.bytes).trim().to_string();
let ownership = ownership_cell(candidate, columns);
let gutter = self.gutter_char(idx, end);
let mut plain = String::new();
plain.push(gutter);
plain.push(' ');
plain.push_str(&checkbox);
plain.push(' ');
plain.push_str(&pad(&truncate(label, columns.name), columns.name));
if columns.size {
plain.push_str(&" ".repeat(COLUMN_GAP));
plain.push_str(&pad_left(&truncate(&size, SIZE_WIDTH), SIZE_WIDTH));
}
if columns.own > 0 {
plain.push_str(&" ".repeat(columns.own_gap));
plain.push_str(&pad(&ownership, columns.own));
}
if self.cursor == idx + 1 {
let plain = pad(&plain, width);
if self.color {
return format!("{ANSI_REVERSE}{plain}{ANSI_RESET}");
}
return plain;
}
if !self.color {
return pad(&plain, width);
}
let mut styled = String::new();
styled.push(gutter);
styled.push(' ');
styled.push_str(&self.paint(if checked { ANSI_GREEN } else { "" }, &checkbox));
styled.push(' ');
styled.push_str(&pad(&truncate(label, columns.name), columns.name));
if columns.size {
styled.push_str(&" ".repeat(COLUMN_GAP));
styled.push_str(&self.paint(
ANSI_CYAN,
&pad_left(&truncate(&size, SIZE_WIDTH), SIZE_WIDTH),
));
}
if columns.own > 0 {
styled.push_str(&" ".repeat(columns.own_gap));
let style = if candidate.provably_private() {
ANSI_DIM
} else {
ANSI_YELLOW
};
styled.push_str(&self.paint(style, &pad(&ownership, columns.own)));
}
pad_visible(&styled, width)
}
fn gutter_char(&self, idx: usize, end: usize) -> char {
if self.cursor == idx + 1 {
return '>';
}
if idx == self.scroll && self.scroll > 0 {
return '^';
}
if idx + 1 == end && end < self.visible.len() {
return 'v';
}
' '
}
fn hint_bar(&self, width: usize) -> String {
let full = "[↑↓/PgUp/PgDn move • Space select • i filter • Enter clean • Esc quit]";
let compact = "[↑↓ PgUp/PgDn • Space • i • Enter • Esc]";
let hints = if display_width(full) <= width {
full
} else {
compact
};
let plain = pad(&truncate_end(hints, width), width);
if !self.color {
return plain;
}
format!("{ANSI_DIM}{plain}{ANSI_RESET}")
}
fn paint(&self, style: &str, text: &str) -> String {
if !self.color || style.is_empty() {
return text.to_string();
}
format!("{style}{text}{ANSI_RESET}")
}
fn columns(&self) -> Columns {
let present = self.ownership_is_present();
let size_fits = self.width >= LEAD_WIDTH + COLUMN_GAP + SIZE_WIDTH + MIN_NAME_WIDTH;
let mut size = size_fits;
let mut columns = self.columns_with(size, present);
if present && columns.own == 0 && size {
size = false;
columns = self.columns_with(size, present);
}
columns
}
fn columns_with(&self, size: bool, present: bool) -> Columns {
let size_gap = if size { COLUMN_GAP } else { 0 };
let available = self
.width
.saturating_sub(LEAD_WIDTH + size_gap + if size { SIZE_WIDTH } else { 0 });
if !present {
return Columns {
name: available,
own: 0,
own_full: false,
size,
own_gap: 0,
};
}
let full = self
.candidates
.iter()
.map(|c| display_width(&ownership_text(c, true)))
.max()
.unwrap_or(0);
if available.saturating_sub(COLUMN_GAP + full) >= MIN_NAME_WIDTH {
return Columns {
name: available - COLUMN_GAP - full,
own: full,
own_full: true,
size,
own_gap: COLUMN_GAP,
};
}
let class = self
.candidates
.iter()
.map(|c| display_width(c.ownership.label()))
.max()
.unwrap_or(0);
let own = class.min(available.saturating_sub(COLUMN_GAP + MIN_NAME_WIDTH));
let own = if own == 0 && !size && available >= 1 {
1
} else {
own
};
let own_gap = if own > 0 && available > own + COLUMN_GAP {
COLUMN_GAP
} else {
0
};
let name = if own > 0 {
available - own - own_gap
} else {
available
};
Columns {
name,
own,
own_full: false,
size,
own_gap,
}
}
fn ownership_is_present(&self) -> bool {
!self.candidates.is_empty() && !self.candidates.iter().all(|c| c.provably_private())
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct Plan {
title: bool,
status: bool,
all: bool,
header: bool,
hint: bool,
list: usize,
}
impl Plan {
fn for_size(height: usize) -> Self {
let budget = height.saturating_sub(1);
const ESSENTIAL: usize = 3;
let mut plan = Plan {
title: true,
status: true,
all: true,
header: true,
hint: true,
list: 0,
};
let mut list = budget.saturating_sub(ESSENTIAL + 2);
if list < MIN_LIST_ROWS {
plan.hint = false;
list = budget.saturating_sub(ESSENTIAL + 1);
}
if list < MIN_LIST_ROWS {
plan.header = false;
list = budget.saturating_sub(ESSENTIAL);
}
if list < MIN_LIST_ROWS {
plan.all = false;
list = 0;
}
if budget < 2 {
plan.status = false;
}
if budget < 1 {
plan.title = false;
}
plan.list = list;
plan
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct Columns {
name: usize,
own: usize,
own_full: bool,
size: bool,
own_gap: usize,
}
fn ownership_text(candidate: &CleanupCandidate, full: bool) -> String {
if full {
if candidate.provably_private() {
"private".to_string()
} else {
format!("{} — inventory only", candidate.ownership.label())
}
} else {
candidate.ownership.label().to_string()
}
}
fn ownership_cell(candidate: &CleanupCandidate, columns: &Columns) -> String {
if columns.own == 1 {
let mut out = String::new();
out.push(candidate.ownership.label().chars().next().unwrap_or('?'));
return out;
}
truncate_end(&ownership_text(candidate, columns.own_full), columns.own)
}
fn unique_labels(candidates: &[CleanupCandidate]) -> Vec<String> {
let tails: Vec<Vec<&OsStr>> = candidates
.iter()
.map(|c| c.root.components().map(|c| c.as_os_str()).collect())
.collect();
(0..candidates.len())
.map(|i| {
let mine = &tails[i];
for k in 1..=mine.len() {
let suffix = &mine[mine.len() - k..];
let clashes = tails.iter().enumerate().any(|(j, other)| {
j != i
&& other.len() >= suffix.len()
&& other[other.len() - suffix.len()..] == *suffix
});
if !clashes {
return escape_path_text(&join_components(suffix)).into_owned();
}
}
escape_path_text(&candidates[i].root.display().to_string()).into_owned()
})
.collect()
}
fn join_components(components: &[&OsStr]) -> String {
let mut out = PathBuf::new();
for component in components {
out.push(component);
}
out.display().to_string()
}
fn char_width(c: char) -> usize {
let cp = c as u32;
if cp < 0x20 || (0x7f..0xa0).contains(&cp) {
return 0;
}
if (0x0300..=0x036f).contains(&cp)
|| (0x200b..=0x200f).contains(&cp)
|| (0xfe00..=0xfe0f).contains(&cp)
|| (0xfe20..=0xfe2f).contains(&cp)
|| cp == 0xfeff
{
return 0;
}
let wide = matches!(cp,
0x1100..=0x115f | 0x2e80..=0x303e | 0x3041..=0x33ff | 0x3400..=0x4dbf | 0x4e00..=0x9fff | 0xa000..=0xa4cf | 0xa960..=0xa97f | 0xac00..=0xd7a3 | 0xf900..=0xfaff | 0xfe10..=0xfe19 | 0xfe30..=0xfe6f | 0xff00..=0xff60 | 0xffe0..=0xffe6 | 0x1f300..=0x1f64f | 0x1f680..=0x1f6ff | 0x1f900..=0x1f9ff | 0x20000..=0x3fffd );
if wide { 2 } else { 1 }
}
fn display_width(text: &str) -> usize {
text.chars().map(char_width).sum()
}
fn truncate(text: &str, width: usize) -> String {
if display_width(text) <= width {
return text.to_string();
}
if width == 0 {
return String::new();
}
let target = width - 1;
let chars: Vec<char> = text.chars().collect();
let mut start = chars.len();
let mut used = 0usize;
while start > 0 {
let w = char_width(chars[start - 1]);
if used + w > target {
break;
}
used += w;
start -= 1;
}
let mut out = String::from("…");
out.extend(&chars[start..]);
out
}
fn truncate_end(text: &str, width: usize) -> String {
if display_width(text) <= width {
return text.to_string();
}
if width == 0 {
return String::new();
}
let target = width - 1;
let mut out = String::new();
let mut used = 0usize;
for c in text.chars() {
let w = char_width(c);
if used + w > target {
break;
}
out.push(c);
used += w;
}
out.push('…');
out
}
fn pad(text: &str, width: usize) -> String {
let len = display_width(text);
if len >= width {
return text.to_string();
}
let mut out = text.to_string();
out.extend(std::iter::repeat_n(' ', width - len));
out
}
fn pad_left(text: &str, width: usize) -> String {
let len = display_width(text);
if len >= width {
return text.to_string();
}
let mut out = String::new();
out.extend(std::iter::repeat_n(' ', width - len));
out.push_str(text);
out
}
fn visible_width(text: &str) -> usize {
let mut width = 0usize;
let mut chars = text.chars();
while let Some(c) = chars.next() {
if c == '\u{1b}' {
for c in chars.by_ref() {
if c.is_ascii_alphabetic() {
break;
}
}
continue;
}
width += char_width(c);
}
width
}
fn pad_visible(text: &str, width: usize) -> String {
let visible = visible_width(text);
if visible >= width {
return text.to_string();
}
let mut out = text.to_string();
out.extend(std::iter::repeat_n(' ', width - visible));
out
}
struct TerminalGuard<'a> {
terminal: &'a mut dyn Terminal,
restored: bool,
}
impl TerminalGuard<'_> {
fn restore(&mut self) -> io::Result<()> {
if self.restored {
return Ok(());
}
self.restored = true;
let mode = self.terminal.restore();
let cursor = self.terminal.set_cursor_visible(true);
mode.and(cursor)
}
}
impl Drop for TerminalGuard<'_> {
fn drop(&mut self) {
let _ = self.restore();
}
}
pub fn terminal_geometry() -> std::io::Result<(u16, u16)> {
crossterm::terminal::size()
}
pub fn ensure_interactive_geometry(width: u16, height: u16) -> Result<(), String> {
if (width as usize) < MIN_SESSION_WIDTH || (height as usize) < MIN_SESSION_HEIGHT {
return Err(format!(
"a terminal of {width}x{height} is too small for the interactive list; \
it needs at least {MIN_SESSION_WIDTH}x{MIN_SESSION_HEIGHT}"
));
}
Ok(())
}
pub fn ensure_interactive_terminal(
stdin_is_tty: bool,
stdout_is_tty: bool,
) -> Result<(), &'static str> {
if !stdin_is_tty {
return Err("standard input is not a terminal");
}
if !stdout_is_tty {
return Err("standard output is not a terminal");
}
Ok(())
}
fn color_enabled() -> bool {
color_enabled_with(std::env::var_os("NO_COLOR"), std::env::var("TERM").ok())
}
fn color_enabled_with(no_color: Option<std::ffi::OsString>, term: Option<String>) -> bool {
if no_color.is_some() {
return false;
}
!matches!(term.as_deref(), Some("dumb"))
}
pub fn drive(
terminal: &mut dyn Terminal,
candidates: Vec<CleanupCandidate>,
) -> io::Result<SessionResult> {
let mut session = Session::new(candidates).with_color(color_enabled());
terminal.enter_raw()?;
let mut guard = TerminalGuard {
terminal,
restored: false,
};
let result = session_loop(&mut *guard.terminal, &mut session);
let restored = guard.restore();
match (result, restored) {
(Ok(outcome), Ok(())) => Ok(outcome),
(Err(e), _) => Err(e),
(Ok(_), Err(e)) => Err(e),
}
}
fn session_loop(terminal: &mut dyn Terminal, session: &mut Session) -> io::Result<SessionResult> {
terminal.set_cursor_visible(false)?;
let mut painted = 0usize;
let result = paint_frames(terminal, session, &mut painted);
let _ = terminal.rewind(painted);
let _ = terminal.clear();
result
}
fn paint_frames(
terminal: &mut dyn Terminal,
session: &mut Session,
painted: &mut usize,
) -> io::Result<SessionResult> {
loop {
let (width, height) = terminal.size()?;
session.set_size(width, height);
let frame = session.frame();
if *painted > 0 {
terminal.rewind(*painted)?;
}
terminal.draw(&frame)?;
*painted = frame.len();
match session.on_key(terminal.read_key()?) {
Outcome::Continue => {}
Outcome::Commit(roots) => return Ok(SessionResult::Selected(roots)),
Outcome::Quit => return Ok(SessionResult::Cancelled),
}
}
}
fn frame_bytes(lines: &[String]) -> String {
let mut out = String::new();
for line in lines {
out.push('\r');
out.push_str(line);
out.push('\n');
}
out
}
fn clear_bytes() -> String {
"\u{1b}[J".to_string()
}
fn rewind_bytes(lines: usize) -> String {
let mut out = String::new();
if lines > 0 {
out.push_str("\u{1b}[1G");
out.push_str(&format!("\u{1b}[{lines}A"));
}
out.push_str(&clear_bytes());
out
}
pub struct CrosstermTerminal;
impl Terminal for CrosstermTerminal {
fn enter_raw(&mut self) -> io::Result<()> {
crossterm::terminal::enable_raw_mode()
}
fn restore(&mut self) -> io::Result<()> {
crossterm::terminal::disable_raw_mode()
}
fn read_key(&mut self) -> io::Result<Key> {
normalize_event(crossterm::event::read())
}
fn size(&mut self) -> io::Result<(u16, u16)> {
crossterm::terminal::size()
}
fn rewind(&mut self, lines: usize) -> io::Result<()> {
let mut out = io::stdout();
out.write_all(rewind_bytes(lines).as_bytes())?;
out.flush()
}
fn set_cursor_visible(&mut self, visible: bool) -> io::Result<()> {
let mut out = io::stdout();
if visible {
crossterm::execute!(out, crossterm::cursor::Show)?;
} else {
crossterm::execute!(out, crossterm::cursor::Hide)?;
}
out.flush()
}
fn clear(&mut self) -> io::Result<()> {
let mut out = io::stdout();
out.write_all(clear_bytes().as_bytes())?;
out.flush()
}
fn draw(&mut self, lines: &[String]) -> io::Result<()> {
let mut out = io::stdout();
out.write_all(frame_bytes(lines).as_bytes())?;
out.flush()
}
}
fn normalize_event(event: Result<crossterm::event::Event, io::Error>) -> io::Result<Key> {
match event {
Ok(crossterm::event::Event::Key(key)) => Ok(normalize(key)),
Ok(_) => Ok(Key::Ignored),
Err(e) => Err(e),
}
}
fn normalize(event: crossterm::event::KeyEvent) -> Key {
use crossterm::event::{KeyCode, KeyModifiers};
if event.modifiers.contains(KeyModifiers::CONTROL) {
return match event.code {
KeyCode::Char('c') | KeyCode::Char('C') => Key::CtrlC,
_ => Key::Ignored,
};
}
match event.code {
KeyCode::Up => Key::Up,
KeyCode::Down => Key::Down,
KeyCode::PageUp => Key::PageUp,
KeyCode::PageDown => Key::PageDown,
KeyCode::Home => Key::Home,
KeyCode::End => Key::End,
KeyCode::Esc => Key::Esc,
KeyCode::Enter => Key::Enter,
KeyCode::Backspace => Key::Backspace,
KeyCode::Char(' ') => Key::Space,
KeyCode::Char(c) => Key::Char(c),
_ => Key::Ignored,
}
}
pub fn run_interactive(candidates: Vec<CleanupCandidate>) -> Result<SessionResult, String> {
if candidates.is_empty() {
return Ok(SessionResult::NothingToClean);
}
ensure_interactive_terminal(
std::io::stdin().is_terminal(),
std::io::stdout().is_terminal(),
)
.map_err(|reason| {
format!(
"interactive selection requires a terminal ({reason}); \
drop -i to clean without choosing interactively, or \
use `cargo cleanme scan --all` to inspect the same units read-only"
)
})?;
drive(&mut CrosstermTerminal, candidates)
.map_err(|e| format!("interactive selection failed: {e}"))
}
pub fn render_to_string(session: &Session) -> String {
let mut out = String::new();
for (i, line) in session.frame().iter().enumerate() {
if i > 0 {
let _ = writeln!(out);
}
let _ = write!(out, "{line}");
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::OutputOwnershipClass;
use std::collections::VecDeque;
use std::panic::AssertUnwindSafe;
fn private(path: &str) -> CleanupCandidate {
CleanupCandidate {
root: PathBuf::from(path),
bytes: 1024,
ownership: OutputOwnershipClass::PrivateBounded,
}
}
fn sample() -> Vec<CleanupCandidate> {
vec![
private("/home/u/projects/alpha"),
private("/home/u/projects/beta"),
CleanupCandidate {
root: PathBuf::from("/home/u/projects/gamma"),
bytes: 4096,
ownership: OutputOwnershipClass::Shared,
},
]
}
fn session() -> Session {
Session::new(sample()).with_size(80, 20)
}
fn press(s: &mut Session, keys: &[Key]) -> Outcome {
let mut last = Outcome::Continue;
for key in keys {
last = s.on_key(key.clone());
if last != Outcome::Continue {
break;
}
}
last
}
fn filter(s: &mut Session, needle: &str) {
press(s, &[Key::Char('i')]);
press(s, &needle.chars().map(Key::Char).collect::<Vec<_>>());
press(s, &[Key::Esc]);
}
#[test]
fn starts_in_normal_mode_with_nothing_selected() {
let s = session();
assert_eq!(s.mode(), Mode::Normal);
assert_eq!(s.selected_count(), 0);
assert_eq!(s.selected_bytes(), 0);
assert_eq!(s.cursor_candidate(), None, "row 0 is the all-toggle");
}
#[test]
fn arrows_and_vim_keys_move_the_cursor_identically() {
let mut arrows = session();
let mut vim = session();
press(&mut arrows, &[Key::Down, Key::Down]);
press(&mut vim, &[Key::Char('j'), Key::Char('j')]);
assert_eq!(arrows.cursor_candidate(), vim.cursor_candidate());
assert_eq!(arrows.cursor_candidate(), Some(1));
press(&mut arrows, &[Key::Up]);
press(&mut vim, &[Key::Char('k')]);
assert_eq!(arrows.cursor_candidate(), vim.cursor_candidate());
}
#[test]
fn the_cursor_stops_at_both_ends() {
let mut s = session();
press(&mut s, &[Key::Up, Key::Up, Key::Up]);
assert_eq!(s.cursor_candidate(), None, "cannot move above the all-row");
for _ in 0..10 {
press(&mut s, &[Key::Down]);
}
assert_eq!(
s.cursor_candidate(),
Some(2),
"cannot move past the last candidate"
);
}
#[test]
fn space_toggles_the_row_under_the_cursor_only() {
let mut s = session();
press(&mut s, &[Key::Down, Key::Space]);
assert_eq!(s.selected_count(), 1);
assert_eq!(s.selected_bytes(), 1024);
press(&mut s, &[Key::Space]);
assert_eq!(s.selected_count(), 0, "space on the same row unchecks it");
}
#[test]
fn the_all_row_checks_every_candidate_including_filtered_ones() {
let mut s = session();
filter(&mut s, "alph");
assert_eq!(
s.candidate_count(),
3,
"the filter does not shrink the list"
);
press(&mut s, &[Key::Space]);
assert_eq!(s.selected_count(), 3);
assert_eq!(s.selected_bytes(), 1024 + 1024 + 4096);
}
#[test]
fn the_all_row_unchecks_everything_when_everything_is_checked() {
let mut s = session();
press(&mut s, &[Key::Space, Key::Space]);
assert_eq!(s.selected_count(), 0);
press(&mut s, &[Key::Space]);
assert_eq!(s.selected_count(), 3);
press(&mut s, &[Key::Space]);
assert_eq!(s.selected_count(), 0);
}
#[test]
fn i_enters_insert_mode_and_esc_returns_keeping_the_filter() {
let mut s = session();
press(&mut s, &[Key::Char('i')]);
assert_eq!(s.mode(), Mode::Insert);
press(&mut s, &[Key::Char('b'), Key::Char('e')]);
assert_eq!(s.filter(), "be");
press(&mut s, &[Key::Esc]);
assert_eq!(s.mode(), Mode::Normal);
assert_eq!(s.filter(), "be", "the filter survives the mode change");
}
#[test]
fn insert_mode_types_keys_that_are_nor_commands() {
let mut s = session();
press(&mut s, &[Key::Char('i')]);
press(&mut s, &[Key::Char('q'), Key::Char('j'), Key::Char('k')]);
press(&mut s, &[Key::Space]);
assert_eq!(s.mode(), Mode::Insert);
assert_eq!(s.filter(), "qjk ");
assert_eq!(
s.selected_count(),
0,
"space typed a character; it did not toggle a row"
);
}
#[test]
fn a_filter_can_contain_a_space_because_paths_can() {
let mut s = Session::new(vec![
private("/home/u/my projects/alpha"),
private("/home/u/projects/beta"),
])
.with_size(80, 20);
filter(&mut s, "my proj");
assert_eq!(s.selected_count(), 0);
press(&mut s, &[Key::Down, Key::Space]);
let Outcome::Commit(roots) = s.on_key(Key::Enter) else {
panic!("the only match must be committable");
};
assert_eq!(roots, vec![PathBuf::from("/home/u/my projects/alpha")]);
}
#[test]
fn q_quits_from_normal_but_types_in_insert() {
let mut s = session();
assert_eq!(press(&mut s, &[Key::Char('q')]), Outcome::Quit);
let mut s = session();
press(&mut s, &[Key::Char('i')]);
assert_eq!(press(&mut s, &[Key::Char('q')]), Outcome::Continue);
assert_eq!(s.filter(), "q");
}
#[test]
fn ctrl_c_quits_from_either_mode() {
let mut s = session();
press(&mut s, &[Key::Char('i'), Key::Char('x')]);
assert_eq!(press(&mut s, &[Key::CtrlC]), Outcome::Quit);
let mut s = session();
assert_eq!(press(&mut s, &[Key::CtrlC]), Outcome::Quit);
}
#[test]
fn two_escapes_exit_and_one_does_not() {
let mut s = session();
assert_eq!(press(&mut s, &[Key::Esc]), Outcome::Continue);
assert_eq!(press(&mut s, &[Key::Esc]), Outcome::Quit);
}
#[test]
fn a_pending_exit_is_cancelled_by_navigating_away() {
let mut s = session();
press(&mut s, &[Key::Esc, Key::Down]);
assert_eq!(press(&mut s, &[Key::Esc]), Outcome::Continue);
assert_eq!(press(&mut s, &[Key::Esc]), Outcome::Quit);
}
#[test]
fn enter_commits_the_checked_roots_in_candidate_order() {
let mut s = session();
press(
&mut s,
&[Key::Down, Key::Space, Key::Down, Key::Down, Key::Space],
);
let Outcome::Commit(roots) = s.on_key(Key::Enter) else {
panic!("enter on a non-empty selection must commit");
};
assert_eq!(
roots,
vec![
PathBuf::from("/home/u/projects/alpha"),
PathBuf::from("/home/u/projects/gamma"),
]
);
}
#[test]
fn enter_with_nothing_selected_stays_in_the_session() {
let mut s = session();
assert_eq!(press(&mut s, &[Key::Enter]), Outcome::Continue);
assert_eq!(s.mode(), Mode::Normal);
assert_eq!(press(&mut s, &[Key::Enter, Key::Enter]), Outcome::Continue);
}
#[test]
fn enter_in_insert_mode_commits_too() {
let mut s = session();
press(&mut s, &[Key::Space]);
press(&mut s, &[Key::Char('i')]);
let Outcome::Commit(roots) = s.on_key(Key::Enter) else {
panic!("enter must commit from INS as well");
};
assert_eq!(roots.len(), 3);
}
#[test]
fn filtering_never_discards_an_existing_selection() {
let mut s = session();
press(&mut s, &[Key::Down, Key::Down, Key::Space]);
assert_eq!(s.selected_count(), 1);
filter(&mut s, "be");
assert_eq!(s.selected_count(), 1, "beta was checked before the filter");
filter(&mut s, "alph");
assert_eq!(s.selected_count(), 1, "still beta, not alpha");
assert_eq!(s.selected_bytes(), 1024);
}
#[test]
fn filtering_is_case_insensitive_and_matches_the_full_path() {
let mut s = session();
filter(&mut s, "PROJ");
assert_eq!(s.visible_count(), 3, "'PROJ' matches all three roots");
let mut fresh = session();
filter(&mut fresh, "/home/u/projects");
assert_eq!(
fresh.visible_count(),
3,
"the filter must still match the full path"
);
let frame = render_to_string(&fresh);
assert!(
frame.contains("alpha") && frame.contains("beta") && frame.contains("gamma"),
"the rows are named by their shortest unique suffix: {frame}"
);
}
#[test]
fn a_filter_matching_nothing_renders_an_explicit_empty_row() {
let mut s = session();
filter(&mut s, "zz");
let frame = s.frame();
assert!(
frame.iter().any(|l| l.contains("no workspace matches")),
"an empty result set must say so, not render blank: {frame:?}"
);
assert_eq!(press(&mut s.clone(), &[Key::Enter]), Outcome::Continue);
}
#[test]
fn the_empty_result_row_is_truncated_to_the_frame_width() {
for w in [20u16, 24, 30, 36, 37, 40] {
let mut s = Session::new(sample()).with_color(false).with_size(w, 8);
filter(&mut s, "zz");
let frame = s.frame();
for line in &frame {
assert!(
visible_width(line) <= w as usize,
"line overflows {w} columns: {line:?}"
);
}
let mut tiny = TinyTerminal::new(10, w as usize);
tiny.feed(&frame_bytes(&frame));
tiny.feed(&rewind_bytes(frame.len()));
for row in 0..8 {
assert_eq!(
tiny.row_text(row),
"",
"row {row} survived the erase at {w} columns: {frame:?}"
);
}
}
}
#[test]
fn the_ownership_column_survives_every_legal_terminal_width() {
let candidates = sample();
let private_candidate = private("/home/u/projects/alpha");
let shared_candidate = candidates
.iter()
.find(|c| !c.provably_private())
.expect("the sample set carries a shared candidate");
for w in MIN_FRAME_WIDTH as u16..=60 {
let s = Session::new(sample()).with_color(false).with_size(w, 12);
let columns = s.columns();
if (w as usize) > LEAD_WIDTH {
assert!(
columns.own > 0,
"the ownership column vanished at {w} columns: {columns:?}"
);
let private_cell = ownership_cell(&private_candidate, &columns);
let shared_cell = ownership_cell(shared_candidate, &columns);
assert_ne!(
private_cell, shared_cell,
"an inventory-only unit must not look cleanable at {w} columns"
);
assert!(
!shared_cell.trim().is_empty(),
"the inventory-only unit carries no marking at {w} columns"
);
}
}
}
#[test]
fn a_narrow_frame_still_fits_its_rows() {
for w in MIN_FRAME_WIDTH as u16..=60 {
let mut s = Session::new(sample()).with_color(true).with_size(w, 12);
press(&mut s, &[Key::Down]);
for line in s.frame() {
assert!(
visible_width(&line) <= w as usize,
"line overflows {w} columns: {line:?}"
);
}
}
}
#[test]
fn the_coloured_all_row_fits_the_frame() {
for w in MIN_FRAME_WIDTH as u16..=20 {
let mut s = Session::new(sample()).with_color(true).with_size(w, 12);
press(&mut s, &[Key::Down]);
for line in s.frame() {
assert!(
visible_width(&line) <= w as usize,
"line overflows {w} columns: {line:?}"
);
}
}
}
#[test]
fn backspace_edits_the_filter_and_widens_the_result_set() {
let mut s = session();
press(
&mut s,
&[
Key::Char('i'),
Key::Char('a'),
Key::Char('l'),
Key::Backspace,
],
);
assert_eq!(s.filter(), "a");
press(&mut s, &[Key::Backspace]);
assert_eq!(s.filter(), "");
press(&mut s, &[Key::Backspace]);
assert_eq!(s.filter(), "", "backspace on an empty field is a no-op");
}
#[test]
fn editing_the_filter_parks_the_cursor_on_the_all_row() {
let mut s = session();
press(&mut s, &[Key::Down, Key::Down]);
assert_eq!(s.cursor_candidate(), Some(1));
press(&mut s, &[Key::Char('i'), Key::Char('b'), Key::Esc]);
assert_eq!(
s.cursor_candidate(),
None,
"a cursor carried across a changing result set would point at a different unit"
);
}
#[test]
fn rows_annotate_ownership_so_an_inventory_only_unit_is_not_mistaken_for_a_candidate() {
let frame = render_to_string(&session());
assert!(frame.contains("private"), "alpha/beta are private: {frame}");
assert!(
frame.contains("shared — inventory only"),
"gamma must be visibly non-cleanable: {frame}"
);
}
#[test]
fn the_all_row_states_its_own_arithmetic() {
let mut s = session();
press(&mut s, &[Key::Down, Key::Space]);
let frame = render_to_string(&s);
assert!(frame.contains("1 selected of 3"), "{frame}");
assert!(
frame.contains("[-] all"),
"partial selection is shown: {frame}"
);
press(&mut s, &[Key::Up, Key::Space]);
let frame = render_to_string(&s);
assert!(frame.contains("3 selected of 3"), "{frame}");
assert!(
frame.contains("[x] all"),
"full selection is shown: {frame}"
);
}
#[test]
fn the_status_line_shows_the_filter_in_both_modes_and_the_armed_exit_in_nor() {
let mut s = session();
filter(&mut s, "be");
assert!(render_to_string(&s).contains("NOR filter: be"));
press(&mut s, &[Key::Esc]);
let frame = render_to_string(&s);
assert!(
frame.contains("Esc again to exit"),
"the armed exit must be visible before it fires: {frame}"
);
press(&mut s, &[Key::Char('i')]);
let frame = render_to_string(&s);
assert!(frame.contains("INS filter: be"), "{frame}");
assert!(
!frame.contains("Esc again to exit"),
"entering INS disarms the pending exit: {frame}"
);
}
#[test]
fn the_frame_fits_the_terminal_in_both_axes() {
for (w, h) in [
(6u16, 1u16),
(6, 5),
(12, 3),
(20, 6),
(24, 8),
(30, 4),
(39, 24),
(40, 9),
(80, 24),
(200, 60),
] {
let frame = Session::new(sample()).with_size(w, h).frame();
let occupied = frame.len() + 1;
assert!(
occupied <= (h as usize).max(1),
"the frame occupies {occupied} rows and must not exceed the terminal's {h} at {w}x{h}"
);
assert!(
frame.len() <= CHROME_LINES + PAGE_ROWS,
"the frame must stay bounded at {w}x{h}: {} lines",
frame.len()
);
for line in &frame {
assert!(
visible_width(line) <= w as usize,
"line overflows {} at {w}x{h}: {line:?}",
w as usize
);
}
}
}
#[test]
fn a_control_character_in_a_path_is_escaped_and_the_frame_keeps_its_geometry() {
let candidates = vec![
private("/home/u/projects/we\nird"),
private("/home/u/projects/es\x1b[31mc"),
private("/home/u/projects/plain"),
];
for (w, h) in [(20u16, 6u16), (40, 9), (80, 24)] {
let frame = Session::new(candidates.clone())
.with_color(false)
.with_size(w, h)
.frame();
for line in &frame {
assert!(
!line.chars().any(char::is_control),
"a raw control character reached the frame at {w}x{h}: {line:?}"
);
}
let bytes = frame_bytes(&frame);
assert_eq!(
bytes.matches('\n').count(),
frame.len(),
"the frame must paint one row per line at {w}x{h}"
);
assert!(
frame.iter().all(|line| visible_width(line) <= w as usize),
"a line overflows {w} at {w}x{h}"
);
}
let frame = Session::new(candidates)
.with_color(false)
.with_size(80, 24)
.frame();
let text = frame.join("\n");
assert!(
text.contains("\\u{a}") && text.contains("\\u{1b}"),
"the control characters must be shown escaped: {text:?}"
);
}
#[test]
fn the_erase_removes_every_row_the_frame_occupied() {
for (w, h) in [(6u16, 5u16), (20, 6), (24, 8), (39, 24), (40, 9), (80, 24)] {
let frame = Session::new(sample())
.with_color(false)
.with_size(w, h)
.frame();
let mut tiny = TinyTerminal::new(h as usize + 2, w as usize);
tiny.feed(&frame_bytes(&frame));
tiny.feed(&rewind_bytes(frame.len()));
for row in 0..h as usize {
assert_eq!(
tiny.row_text(row),
"",
"row {row} survived the erase at {w}x{h}: {frame:?}"
);
}
}
}
#[test]
fn a_terminal_too_small_for_the_list_is_refused() {
assert!(ensure_interactive_geometry(80, 24).is_ok());
assert!(ensure_interactive_geometry(20, 6).is_ok());
let narrow = ensure_interactive_geometry(19, 24).unwrap_err();
assert!(narrow.contains("too small"), "{narrow}");
let short = ensure_interactive_geometry(80, 5).unwrap_err();
assert!(short.contains("too small"), "{short}");
}
#[test]
fn a_narrow_terminal_degrades_the_columns_and_keeps_the_title() {
let wide = Session::new(sample())
.with_color(false)
.with_size(80, 20)
.frame();
assert!(
wide.iter().any(|l| l.contains("RECLAIMABLE")),
"the wide frame has the reclaimable column: {wide:?}"
);
let narrow = Session::new(sample())
.with_color(false)
.with_size(24, 12)
.frame();
assert!(
!narrow.iter().any(|l| l.contains("RECLAIMABLE")),
"the narrow frame drops the reclaimable column: {narrow:?}"
);
let text = narrow.join("\n");
assert!(text.contains("reclaimable"), "the title survives: {text}");
assert!(text.contains("NOR"), "the mode survives: {text}");
assert!(text.contains("alpha"), "the name survives: {text}");
}
#[test]
fn the_frame_does_not_grow_with_the_candidate_count() {
let few: Vec<CleanupCandidate> = (0..3)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let many: Vec<CleanupCandidate> = (0..3000)
.map(|i| private(&format!("/home/u/projects/p{i:04}")))
.collect();
let small = Session::new(few).with_size(100, 40).frame();
let large = Session::new(many).with_size(100, 40).frame();
assert_eq!(
small.len(),
CHROME_LINES + 3,
"a short list shows no blank filler rows"
);
assert_eq!(
large.len(),
CHROME_LINES + PAGE_ROWS,
"a long list stops at the page"
);
assert!(
large.len() < 40,
"the frame must not fill the terminal: {} lines",
large.len()
);
}
#[test]
fn the_page_is_capped_by_the_terminal_height() {
let many: Vec<CleanupCandidate> = (0..300)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
for h in [6u16, 8, 12, 20] {
let frame = Session::new(many.clone()).with_size(80, h).frame();
let occupied = frame.len() + 1;
assert!(
occupied <= h as usize,
"the frame occupies {occupied} rows and must fit a {h}-row terminal"
);
}
}
#[test]
fn a_long_display_name_is_truncated_from_the_left_not_the_right() {
let long = format!("/{}/deep/project", "x".repeat(200));
let other = format!("/{}/deep/project", "y".repeat(200));
let s = Session::new(vec![private(&long), private(&other)]).with_size(60, 10);
let frame = render_to_string(&s);
assert!(frame.contains('…'), "{frame}");
assert!(
frame.contains(&PathBuf::from("deep").join("project").display().to_string()),
"the distinguishing tail must survive: {frame}"
);
}
#[test]
fn scrolling_keeps_the_cursor_row_inside_the_viewport() {
let many: Vec<CleanupCandidate> = (0..40)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(many).with_size(60, 10);
for _ in 0..30 {
press(&mut s, &[Key::Down]);
}
let cursor = s.cursor_candidate().expect("cursor is on a candidate");
let frame = render_to_string(&s);
assert!(
frame.contains(&format!("p{cursor:02}")),
"the cursor's own row must be painted: {frame}"
);
for _ in 0..29 {
press(&mut s, &[Key::Up]);
}
assert_eq!(s.cursor_candidate(), Some(0));
}
#[test]
fn scrolling_up_from_the_bottom_reaches_the_first_candidate() {
let many: Vec<CleanupCandidate> = (0..40)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(many).with_size(60, 10);
for _ in 0..39 {
press(&mut s, &[Key::Down]);
}
assert_eq!(s.cursor_candidate(), Some(38));
for _ in 0..38 {
press(&mut s, &[Key::Up]);
}
assert_eq!(s.cursor_candidate(), Some(0), "back at the first candidate");
let frame = render_to_string(&s);
assert!(frame.contains("p00"), "{frame}");
assert!(
!frame.contains("p38"),
"the viewport followed the cursor home: {frame}"
);
}
#[test]
fn a_resize_keeps_the_selection_and_reclamps_the_cursor() {
let many: Vec<CleanupCandidate> = (0..40)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(many).with_size(60, 10);
for _ in 0..20 {
press(&mut s, &[Key::Down, Key::Space]);
}
assert_eq!(s.selected_count(), 20);
s.set_size(200, 60);
assert_eq!(s.selected_count(), 20, "a resize is not a reset");
assert_eq!(s.mode(), Mode::Normal);
assert_eq!(s.frame().len(), CHROME_LINES + PAGE_ROWS);
assert!(s.frame().len() <= 60, "the frame still fits the terminal");
}
#[test]
fn an_empty_candidate_list_still_renders_and_exits() {
let mut s = Session::new(Vec::new()).with_size(60, 10);
assert_eq!(s.frame().len(), CHROME_LINES + MIN_LIST_ROWS);
assert_eq!(press(&mut s, &[Key::Enter]), Outcome::Continue);
assert_eq!(press(&mut s, &[Key::Esc, Key::Esc]), Outcome::Quit);
filter(&mut s, "anything");
assert_eq!(s.frame().len(), CHROME_LINES + MIN_LIST_ROWS);
}
struct FakeTerminal {
keys: VecDeque<Key>,
frames: Vec<Vec<String>>,
raw: bool,
raw_before_panic: bool,
restored: usize,
cleared: usize,
cursor_visibility: Vec<bool>,
}
impl FakeTerminal {
fn new(keys: Vec<Key>) -> Self {
Self {
keys: keys.into(),
frames: Vec::new(),
raw: false,
raw_before_panic: false,
restored: 0,
cleared: 0,
cursor_visibility: Vec::new(),
}
}
fn cursor_at_exit(&self) -> Option<bool> {
self.cursor_visibility.last().copied()
}
}
impl Terminal for FakeTerminal {
fn enter_raw(&mut self) -> io::Result<()> {
self.raw = true;
self.raw_before_panic = true;
Ok(())
}
fn restore(&mut self) -> io::Result<()> {
self.restored += 1;
self.raw = false;
Ok(())
}
fn read_key(&mut self) -> io::Result<Key> {
Ok(self.keys.pop_front().unwrap_or(Key::Ignored))
}
fn size(&mut self) -> io::Result<(u16, u16)> {
Ok((80, 20))
}
fn rewind(&mut self, _lines: usize) -> io::Result<()> {
Ok(())
}
fn set_cursor_visible(&mut self, visible: bool) -> io::Result<()> {
self.cursor_visibility.push(visible);
Ok(())
}
fn clear(&mut self) -> io::Result<()> {
self.cleared += 1;
Ok(())
}
fn draw(&mut self, lines: &[String]) -> io::Result<()> {
self.frames.push(lines.to_vec());
Ok(())
}
}
#[test]
fn the_driver_restores_the_terminal_on_the_commit_path() {
let mut term = FakeTerminal::new(vec![
Key::Down,
Key::Space,
Key::Down,
Key::Space,
Key::Enter,
]);
let result = drive(&mut term, sample()).unwrap();
assert_eq!(
result,
SessionResult::Selected(vec![
PathBuf::from("/home/u/projects/alpha"),
PathBuf::from("/home/u/projects/beta"),
])
);
assert!(!term.raw, "the terminal must not be left in raw mode");
assert_eq!(term.restored, 1);
assert_eq!(term.cleared, 1, "the painted region is erased on exit");
}
#[test]
fn the_driver_restores_the_terminal_on_the_quit_path() {
let mut term = FakeTerminal::new(vec![Key::Char('q')]);
assert_eq!(
drive(&mut term, sample()).unwrap(),
SessionResult::Cancelled
);
assert!(!term.raw);
assert_eq!(term.restored, 1);
assert_eq!(term.cleared, 1);
}
#[test]
fn the_cursor_is_visible_again_when_the_session_ends() {
let paths: [&[Key]; 3] = [
&[Key::Char('q')],
&[Key::Down, Key::Space, Key::Enter],
&[Key::Char('i'), Key::Char('x'), Key::Esc, Key::Char('q')],
];
for keys in paths {
let mut term = FakeTerminal::new(keys.to_vec());
drive(&mut term, sample()).unwrap();
assert_eq!(
term.cursor_at_exit(),
Some(true),
"the cursor must be visible when the session ends: {keys:?}"
);
}
}
#[test]
fn the_hardware_cursor_stays_hidden_for_the_whole_session() {
let mut term = FakeTerminal::new(vec![
Key::Char('i'),
Key::Char('x'),
Key::Esc,
Key::Char('q'),
]);
drive(&mut term, sample()).unwrap();
assert!(
term.frames.len() >= 3,
"insert mode should have painted at least one frame: {}",
term.frames.len()
);
let (during, after) = term
.cursor_visibility
.split_at(term.cursor_visibility.len().saturating_sub(1));
assert!(
during.iter().all(|visible| !*visible),
"the cursor must be hidden while the session runs: {:?}",
term.cursor_visibility
);
assert_eq!(after, &[true], "and shown again when it ends");
}
#[test]
fn the_driver_repaints_in_place_without_an_alternate_screen() {
let mut term = FakeTerminal::new(vec![Key::Down, Key::Down, Key::Char('q')]);
drive(&mut term, sample()).unwrap();
assert!(term.frames.len() >= 3, "each key repaints");
for frame in &term.frames {
assert_eq!(
frame.len(),
CHROME_LINES + 3,
"every frame is the same bounded shape"
);
assert!(
frame.len() < 20,
"the frame must not fill the terminal: {} lines",
frame.len()
);
}
}
#[test]
fn a_read_failure_restores_the_terminal_and_propagates() {
struct FailingRead {
inner: FakeTerminal,
}
impl Terminal for FailingRead {
fn enter_raw(&mut self) -> io::Result<()> {
self.inner.enter_raw()
}
fn restore(&mut self) -> io::Result<()> {
self.inner.restore()
}
fn read_key(&mut self) -> io::Result<Key> {
Err(io::Error::other("device disappeared"))
}
fn size(&mut self) -> io::Result<(u16, u16)> {
self.inner.size()
}
fn rewind(&mut self, l: usize) -> io::Result<()> {
self.inner.rewind(l)
}
fn set_cursor_visible(&mut self, v: bool) -> io::Result<()> {
self.inner.set_cursor_visible(v)
}
fn clear(&mut self) -> io::Result<()> {
self.inner.clear()
}
fn draw(&mut self, l: &[String]) -> io::Result<()> {
self.inner.draw(l)
}
}
let mut term = FailingRead {
inner: FakeTerminal::new(Vec::new()),
};
assert!(drive(&mut term, sample()).is_err());
assert_eq!(term.inner.restored, 1);
assert!(!term.inner.raw);
assert_eq!(
term.inner.cleared, 1,
"the painted region is erased even when the session fails"
);
}
#[test]
fn the_guard_restores_when_dropped_during_unwind() {
struct Harness {
terminal: FakeTerminal,
}
let mut harness = Harness {
terminal: FakeTerminal::new(Vec::new()),
};
let outcome = std::panic::catch_unwind(AssertUnwindSafe(|| {
let guard = TerminalGuard {
terminal: &mut harness.terminal,
restored: false,
};
guard.terminal.enter_raw().unwrap();
panic!("boom");
}));
assert!(outcome.is_err());
assert!(
harness.terminal.raw_before_panic,
"the session was genuinely in raw mode when it panicked"
);
assert_eq!(
harness.terminal.restored, 1,
"a panicking session must still restore the terminal"
);
assert!(!harness.terminal.raw);
}
#[test]
fn the_guard_restores_exactly_once_even_when_restored_explicitly() {
let mut term = FakeTerminal::new(Vec::new());
{
let mut guard = TerminalGuard {
terminal: &mut term,
restored: false,
};
guard.restore().unwrap();
guard.restore().unwrap();
}
assert_eq!(term.restored, 1);
}
#[test]
fn a_failing_restore_is_not_retried_on_drop() {
struct FailingRestore {
calls: usize,
}
impl Terminal for FailingRestore {
fn enter_raw(&mut self) -> io::Result<()> {
Ok(())
}
fn restore(&mut self) -> io::Result<()> {
self.calls += 1;
Err(io::Error::other("terminal handle is gone"))
}
fn read_key(&mut self) -> io::Result<Key> {
Ok(Key::Ignored)
}
fn size(&mut self) -> io::Result<(u16, u16)> {
Ok((80, 20))
}
fn rewind(&mut self, _l: usize) -> io::Result<()> {
Ok(())
}
fn set_cursor_visible(&mut self, _v: bool) -> io::Result<()> {
Ok(())
}
fn clear(&mut self) -> io::Result<()> {
Ok(())
}
fn draw(&mut self, _l: &[String]) -> io::Result<()> {
Ok(())
}
}
let mut term = FailingRestore { calls: 0 };
{
let mut guard = TerminalGuard {
terminal: &mut term,
restored: false,
};
assert!(guard.restore().is_err());
}
assert_eq!(term.calls, 1, "an explicit failure must not be retried");
}
struct TinyTerminal {
rows: usize,
cols: usize,
screen: Vec<Vec<char>>,
row: usize,
col: usize,
pending_wrap: bool,
}
impl TinyTerminal {
fn new(rows: usize, cols: usize) -> Self {
Self {
rows,
cols,
screen: vec![vec![' '; cols]; rows],
row: 0,
col: 0,
pending_wrap: false,
}
}
fn feed(&mut self, bytes: &str) {
let mut chars = bytes.chars();
while let Some(c) = chars.next() {
match c {
'\r' => {
self.col = 0;
self.pending_wrap = false;
}
'\n' => {
self.line_feed();
self.pending_wrap = false;
}
'\u{1b}' => {
for c in chars.by_ref() {
if c == '[' {
break;
}
}
let mut params = String::new();
for c in chars.by_ref() {
if !c.is_ascii_alphabetic() {
params.push(c);
continue;
}
match c {
'A' => {
let n: usize = params.parse().unwrap_or(1);
self.row = self.row.saturating_sub(n);
}
'G' => {
let n: usize = params.parse().unwrap_or(1);
self.col = n.saturating_sub(1).min(self.cols - 1);
}
'J' => self.erase_from_cursor(),
_ => {}
}
break;
}
self.pending_wrap = false;
}
_ => {
if self.pending_wrap {
self.line_feed();
self.col = 0;
self.pending_wrap = false;
}
self.screen[self.row][self.col] = c;
if self.col == self.cols - 1 {
self.pending_wrap = true;
} else {
self.col += 1;
}
}
}
}
}
fn line_feed(&mut self) {
self.row += 1;
if self.row >= self.rows {
self.screen.remove(0);
self.screen.push(vec![' '; self.cols]);
self.row = self.rows - 1;
}
}
fn erase_from_cursor(&mut self) {
for c in self.col..self.cols {
self.screen[self.row][c] = ' ';
}
for r in self.row + 1..self.rows {
self.screen[r] = vec![' '; self.cols];
}
}
fn row_text(&self, row: usize) -> String {
self.screen[row]
.iter()
.collect::<String>()
.trim_end()
.to_string()
}
}
#[test]
fn the_frame_lands_on_the_rows_it_claims() {
let candidates: Vec<CleanupCandidate> = (0..4)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let s = Session::new(candidates)
.with_color(false)
.with_size(100, 20);
let frame = s.frame();
let mut tiny = TinyTerminal::new(frame.len() + 2, 100);
tiny.feed(&frame_bytes(&frame));
for (i, line) in frame.iter().enumerate() {
assert_eq!(
tiny.row_text(i),
line.trim_end(),
"line {i} did not land on row {i}: {frame:?}"
);
}
for i in frame.len()..tiny.rows {
assert_eq!(
tiny.row_text(i),
"",
"row {i} was painted outside the frame: {frame:?}"
);
}
}
#[test]
fn a_repaint_replaces_the_frame_instead_of_stacking_under_it() {
let candidates: Vec<CleanupCandidate> = (0..4)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(candidates)
.with_color(false)
.with_size(100, 20);
let first = s.frame();
let mut tiny = TinyTerminal::new(first.len() + 2, 100);
tiny.feed(&frame_bytes(&first));
press(&mut s, &[Key::Down, Key::Space]);
let second = s.frame();
tiny.feed(&rewind_bytes(second.len()));
tiny.feed(&frame_bytes(&second));
for (i, line) in second.iter().enumerate() {
assert_eq!(
tiny.row_text(i),
line.trim_end(),
"row {i} is stale: {second:?}"
);
}
for i in second.len()..tiny.rows {
assert_eq!(
tiny.row_text(i),
"",
"row {i} was painted outside the frame: {second:?}"
);
}
}
#[test]
fn every_line_of_a_frame_starts_with_a_carriage_return() {
let frame = session().frame();
let bytes = frame_bytes(&frame);
let mut parts: Vec<&str> = bytes.split('\n').collect();
parts.pop();
assert_eq!(
parts.len(),
frame.len(),
"one line of bytes per line of the frame"
);
for (i, part) in parts.iter().enumerate() {
assert!(
part.starts_with('\r'),
"line {i} does not start with a carriage return: {part:?}"
);
}
}
#[test]
fn the_armed_exit_hint_survives_a_long_filter() {
let mut s = session();
filter(&mut s, "a-very-long-filter-that-fills-the-field");
press(&mut s, &[Key::Esc]);
let frame = render_to_string(&s);
assert!(
frame.contains("Esc again to exit"),
"the armed hint must not be truncated away: {frame}"
);
assert!(
frame.contains("a-very-long-filter"),
"the filter must still be readable: {frame}"
);
}
#[test]
fn the_armed_exit_hint_is_visible_at_every_admitted_width() {
for w in MIN_SESSION_WIDTH as u16..=40 {
let mut s = Session::new(sample()).with_color(false).with_size(w, 12);
let before = s.frame()[1].clone();
press(&mut s, &[Key::Esc]);
let after = s.frame()[1].clone();
assert!(
after.contains("Esc again"),
"the armed hint must be readable at {w} columns: {after:?}"
);
assert_ne!(
before, after,
"arming the exit must change the status line at {w} columns"
);
for line in s.frame() {
assert!(
visible_width(&line) <= w as usize,
"line overflows {w} columns: {line:?}"
);
}
}
}
#[test]
fn arming_the_exit_does_not_resize_the_filter_field() {
let mut s = session();
filter(
&mut s,
"a-filter-long-enough-to-be-cut-at-one-width-and-not-the-other",
);
let before = s.frame()[1].clone();
press(&mut s, &[Key::Esc]);
let after = s.frame()[1].clone();
let blanked = after.replace(ARMED_HINT, &" ".repeat(display_width(ARMED_HINT)));
assert_eq!(
blanked, before,
"arming the exit must change nothing but the hint"
);
}
#[test]
fn a_wide_character_is_two_cells_wide() {
assert_eq!(display_width("abc"), 3);
assert_eq!(display_width("プãƒã‚¸ã‚§ã‚¯ãƒˆ"), 12);
assert_eq!(display_width(&truncate("プãƒã‚¸ã‚§ã‚¯ãƒˆ", 5)), 5);
assert_eq!(display_width(&truncate_end("プãƒã‚¸ã‚§ã‚¯ãƒˆ", 5)), 5);
}
#[test]
fn a_wide_character_path_does_not_overflow_the_frame() {
let candidates = vec![private("/one/プãƒã‚¸ã‚§ã‚¯ãƒˆ"), private("/two/プãƒã‚¸ã‚§ã‚¯ãƒˆ")];
let s = Session::new(candidates).with_size(60, 10);
let frame = s.frame();
for line in &frame {
assert!(
visible_width(line) <= 60,
"a wide character painted past the edge: {line:?}"
);
}
}
#[test]
fn a_redirected_stream_is_refused_before_raw_mode() {
assert!(ensure_interactive_terminal(true, true).is_ok());
assert_eq!(
ensure_interactive_terminal(false, true),
Err("standard input is not a terminal")
);
assert_eq!(
ensure_interactive_terminal(true, false),
Err("standard output is not a terminal")
);
assert!(ensure_interactive_terminal(false, false).is_err());
}
#[test]
fn crossterm_keys_map_to_the_session_vocabulary() {
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
let press = |code, mods| normalize(KeyEvent::new(code, mods));
assert_eq!(press(KeyCode::Up, KeyModifiers::NONE), Key::Up);
assert_eq!(press(KeyCode::Down, KeyModifiers::NONE), Key::Down);
assert_eq!(press(KeyCode::Esc, KeyModifiers::NONE), Key::Esc);
assert_eq!(press(KeyCode::Enter, KeyModifiers::NONE), Key::Enter);
assert_eq!(
press(KeyCode::Backspace, KeyModifiers::NONE),
Key::Backspace
);
assert_eq!(press(KeyCode::Char(' '), KeyModifiers::NONE), Key::Space);
assert_eq!(
press(KeyCode::Char('x'), KeyModifiers::NONE),
Key::Char('x')
);
assert_eq!(press(KeyCode::Char('c'), KeyModifiers::CONTROL), Key::CtrlC);
assert_eq!(
press(
KeyCode::Char('C'),
KeyModifiers::CONTROL | KeyModifiers::SHIFT
),
Key::CtrlC,
"Ctrl-Shift-C is still Ctrl-C"
);
assert_eq!(
press(KeyCode::Char('q'), KeyModifiers::SHIFT),
Key::Char('q'),
"the terminal has already applied SHIFT; the payload is plain"
);
assert_eq!(press(KeyCode::F(5), KeyModifiers::NONE), Key::Ignored);
assert_eq!(press(KeyCode::Tab, KeyModifiers::NONE), Key::Ignored);
}
#[test]
fn a_read_failure_is_not_an_unbound_key() {
let failed = normalize_event(Err(io::Error::other("device disappeared")));
assert!(
failed.is_err(),
"a read failure must propagate, not become an unbound key"
);
assert!(
normalize_event(Ok(crossterm::event::Event::FocusGained)).is_ok(),
"a focus event carries no binding and is not a failure"
);
assert_eq!(
normalize_event(Ok(crossterm::event::Event::Key(
crossterm::event::KeyEvent::new(
crossterm::event::KeyCode::Char('q'),
crossterm::event::KeyModifiers::NONE
)
)))
.unwrap(),
Key::Char('q')
);
}
#[test]
fn an_empty_candidate_set_is_a_plain_negative_result_not_a_usage_error() {
assert_eq!(
run_interactive(Vec::new()),
Ok(SessionResult::NothingToClean),
"an empty candidate set has one true sentence, and it is not an error"
);
}
#[test]
fn a_non_empty_candidate_set_still_needs_a_terminal() {
assert!(
run_interactive(vec![private("/home/u/projects/alpha")]).is_err(),
"a headless caller must not be able to drive a session"
);
}
#[test]
fn a_row_is_named_by_the_shortest_suffix_that_identifies_it() {
let candidates = vec![
private("/home/u/projects/alpha"),
private("/home/u/projects/beta"),
private("/home/u/projects/gamma"),
];
let labels = unique_labels(&candidates);
assert_eq!(labels, vec!["alpha", "beta", "gamma"]);
}
#[test]
fn a_colliding_basename_is_told_apart_by_more_of_the_path() {
let candidates = vec![private("/a/x"), private("/b/x")];
let labels = unique_labels(&candidates);
assert_eq!(
labels,
vec![
PathBuf::from("a").join("x").display().to_string(),
PathBuf::from("b").join("x").display().to_string(),
]
);
assert_ne!(labels[0], labels[1]);
}
#[test]
fn two_candidates_with_the_same_path_fall_back_to_the_whole_path() {
let candidates = vec![private("/a/x"), private("/a/x")];
let labels = unique_labels(&candidates);
assert_eq!(labels, vec!["/a/x", "/a/x"]);
}
#[test]
fn the_rendered_row_carries_the_short_name_not_the_whole_path() {
let s = session();
let frame = render_to_string(&s);
assert!(frame.contains("alpha"), "{frame}");
assert!(
!frame.contains("/home/u/projects/alpha"),
"the absolute path must not be spelled out on the row: {frame}"
);
}
#[test]
fn the_ownership_column_is_omitted_when_every_candidate_is_private() {
let candidates = vec![
private("/home/u/projects/alpha"),
private("/home/u/projects/beta"),
];
let s = Session::new(candidates).with_size(100, 20);
let frame = render_to_string(&s);
assert!(
!frame.contains("private"),
"a column that says the same word on every row carries no information: {frame}"
);
assert!(!frame.contains("OWNERSHIP"), "{frame}");
}
#[test]
fn the_ownership_column_appears_when_the_set_is_mixed() {
let frame = render_to_string(&session());
assert!(frame.contains("private"), "{frame}");
assert!(
frame.contains("shared — inventory only"),
"a non-private row must say it is not cleanable: {frame}"
);
assert!(frame.contains("OWNERSHIP"), "{frame}");
}
#[test]
fn the_reclaimable_column_is_right_aligned() {
let candidates = vec![
CleanupCandidate {
root: PathBuf::from("/home/u/projects/alpha"),
bytes: 1024,
ownership: OutputOwnershipClass::PrivateBounded,
},
CleanupCandidate {
root: PathBuf::from("/home/u/projects/beta"),
bytes: 1024 * 1024 * 1024,
ownership: OutputOwnershipClass::PrivateBounded,
},
];
let s = Session::new(candidates).with_size(100, 20);
let frame = s.frame();
let ends: Vec<usize> = frame
.iter()
.filter(|l| l.contains("KiB") || l.contains("GiB"))
.map(|l| visible_width(l.trim_end()))
.collect();
assert_eq!(ends.len(), 2, "both rows carry a size: {frame:?}");
assert_eq!(ends[0], ends[1], "the sizes must line up: {frame:?}");
}
#[test]
fn the_cursor_row_is_reverse_video() {
let mut s = session();
press(&mut s, &[Key::Down]);
let frame = s.frame();
let cursor_row = frame
.iter()
.find(|l| l.contains("alpha"))
.expect("the cursor's row is painted");
assert!(
cursor_row.contains(ANSI_REVERSE),
"the cursor's row must be findable at a glance: {cursor_row:?}"
);
}
#[test]
fn the_gutter_marks_the_edges_of_the_window() {
let many: Vec<CleanupCandidate> = (0..40)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(many).with_size(80, 20);
press(&mut s, &[Key::End]);
let frame = s.frame();
assert!(
frame.iter().any(|l| l.contains("^ [ ]")),
"the window's top edge must be marked: {frame:?}"
);
assert!(
frame.iter().any(|l| l.contains("> [ ]")),
"the cursor must be marked: {frame:?}"
);
}
#[test]
fn colour_can_be_turned_off() {
let coloured = render_to_string(&session());
assert!(
coloured.contains('\u{1b}'),
"the default surface carries ANSI styling"
);
let plain = render_to_string(&session().with_color(false));
assert!(
!plain.contains('\u{1b}'),
"a surface with colour off must carry no escape sequences: {plain:?}"
);
assert!(
plain.contains("alpha"),
"turning colour off must not remove any content: {plain}"
);
}
#[test]
fn the_colour_decision_honours_no_color_and_a_dumb_terminal() {
assert!(!color_enabled_with(
Some(std::ffi::OsString::from("1")),
None
));
assert!(!color_enabled_with(None, Some("dumb".to_string())));
assert!(color_enabled_with(None, Some("xterm-256color".to_string())));
assert!(color_enabled_with(None, None));
}
#[test]
fn paging_keys_move_the_cursor_by_a_page() {
let many: Vec<CleanupCandidate> = (0..40)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(many).with_size(80, 20);
press(&mut s, &[Key::PageDown]);
assert_eq!(s.cursor_candidate(), Some(13));
press(&mut s, &[Key::PageDown]);
assert_eq!(s.cursor_candidate(), Some(27));
press(&mut s, &[Key::PageUp]);
assert_eq!(s.cursor_candidate(), Some(13));
}
#[test]
fn home_and_end_jump_to_the_ends_of_the_list() {
let many: Vec<CleanupCandidate> = (0..40)
.map(|i| private(&format!("/home/u/projects/p{i:02}")))
.collect();
let mut s = Session::new(many).with_size(80, 20);
press(&mut s, &[Key::End]);
assert_eq!(s.cursor_candidate(), Some(39));
press(&mut s, &[Key::Home]);
assert_eq!(s.cursor_candidate(), Some(0), "back to the first candidate");
}
#[test]
fn the_paging_keys_are_ignored_in_insert_mode() {
let mut s = session();
press(&mut s, &[Key::Char('i')]);
press(&mut s, &[Key::PageDown, Key::End]);
assert_eq!(
s.cursor_candidate(),
None,
"the cursor stayed on the all-toggle"
);
assert_eq!(s.mode(), Mode::Insert);
}
}