(3b16540) Open a search with / in the tui, and bump to 0.13.6

Finding a ticket meant scrolling four columns and reading, which is what the
id and the title are for.

The real work was the input mode: every key in the dispatch was a single-shot
action, and a query needs one that swallows the keys bound to them. That is
Board::search_key, offered every key ahead of the action arms and reporting
what it took. With no prompt open it takes nothing, so every other state's
dispatch is unchanged. On Board for the reason dismiss is: the arm is not
reachable from a test.

ctrl-c is the one key the prompt declines, since a terminal application
always honours it. Every other control combination is swallowed and does
nothing: it must not type its letter, and it must not fall through either,
because the action arms match on the code alone and ctrl-d would reach the
arm bound to d.

first_match runs over every card in the visible columns, in reading order,
not the rows on screen: a query that answered differently on a tall terminal
and a short one is not a search, and the jump scrolls the match into view. A
hidden done column stays out, or the highlight would land on a ticket that is
not on the board. Id and title only, both lowercased.

The jump goes through select_at, extracted as the tail select_card already
used, so follow_selection scrolls the match's own column and refresh_detail
keeps an open overlay on it. Nothing calculates either a second way.

A hit closes the prompt; a miss keeps it open, marked in brightred beside the
query it is about, with the selection untouched, so the query can be
corrected in place rather than retyped from /. The mark clears on the next
edit. An empty query matches nothing rather than everything.

The prompt takes the whole footer row, since the key list it replaces
describes nothing that works while every key goes into the buffer. The real
terminal cursor sits after the query: ratatui shows it only for a frame that
asked, so it is also what says "you are typing" on an empty query. Both
closed footers now name / search.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-22 13:29:30 +02:00
co-authored by Claude Opus 5
parent 4502de7ee3
commit 1f68666470
5 changed files with 593 additions and 7 deletions
+14
View File
@@ -163,6 +163,20 @@ and this file is for what someone changing worklane's own code needs.
- The choice is not remembered between runs. worklane has no config file and one flag is not a reason to start one; if it should persist, that is its own ticket
- **Assert a column heading against the top border row, not the whole screen.** The footer names done too, so `screen.contains("done (0)")` passes on the footer whether the column is drawn or not. Three tests went vacuous that way the moment done was hidden; `headings()` and `footer()` exist so the next one does not. `headings()` locates the row through `board_area()` rather than taking row zero, since the tab row sits above it when more than one board is monitored
### The Search Prompt
- **`search: Option<Search>` is the whole mode**, the shape `detail` uses: "the prompt is open" and "what is in it" cannot disagree, and closing it leaves nothing to reset. `Search` also carries `missed`, set when enter found nothing and cleared by the next edit, since the message is about the query that missed
- **The prompt swallows every key it is given.** `Board::search_key` runs ahead of the action arms in `main.rs` and reports what it took, rather than every arm below asking whether a search is open. Typing `d` into a query must not toggle done and `q` must not quit; with no prompt open it takes nothing, so the dispatch is unchanged for every other state. The rule is on `Board` for the reason `dismiss` is: the arm is not reachable from a test
- **`ctrl-c` is the one key it declines**, because a terminal application always honours it and a prompt that ate it would leave no way off the board. Every *other* control combination is swallowed and does nothing: it must not type its letter, and it must not fall through either, since the action arms match on the code alone and `ctrl-d` would reach the one bound to `d`
- **Esc is consumed by the search before it can mean anything else**, which is the collision e7612de left behind: `esc` and `q` close the overlay, and both have to lose to an open prompt. It falls out of the pre-branch rather than being ordered by hand
- **`first_match` searches the *visible columns*, every card in them, not the rows on screen.** A query that answered differently on a tall terminal and a short one is not a search, and the jump scrolls the match into view anyway. Hidden columns stay out: with done hidden, a match there would put the highlight on a ticket that is not on the board. Reading order is column by column, then top to bottom
- Id and title only, per 3b16540, both lowercased. The title has to be case insensitive to be worth typing, and giving the id the same treatment lets a pasted id match whatever case it was copied in. An empty or all-space query matches **nothing** rather than everything
- **The jump goes through `select_at`, the tail `select_card` already used.** `follow_selection` scrolls the column the card is in, and the offsets are per column and on the `Tab`, so a jump across columns moves the right one; `refresh_detail` keeps an open overlay on the ticket the selection names. A second version of either is how a jump comes to scroll differently from the arrow keys
- **A hit closes the prompt and a miss keeps it open**, marked, with the selection untouched. The query can then be corrected in place instead of retyped from `/`. Doing nothing visible is what makes a reader retype a query that was already right
- **The prompt takes the whole footer row**, because the key list it replaces describes nothing that currently works while every key is going into the buffer. The typed query is drawn in the default foreground and the keys in grey: one is content, the other is chrome. `no match` is brightred beside the query it is about, since grey chrome is what a reader skips
- **The real terminal cursor goes after the query**, not a glyph standing in for one. ratatui shows the cursor only for a frame that asked for it, so `set_cursor_position` is also what says "you are typing" while the query is still empty. Clamped to the row, so a query longer than the terminal leaves it on the last cell
- Both closed footers name `/`, since the jump works with a ticket open as well: it moves the selection and the overlay follows
- Out of scope on purpose, each its own ticket once the input mode exists: `n` and `N` for the next and previous match, searching the description, tags or owner, regex, and filtering the board down to matches rather than selecting one
### Monitoring Several Boards
- `worklane tui <path>...` takes any number of paths, each resolved through `find_worklane_dir` the way the working directory is: the first `.worklane` at or above it. No path is the working directory, so a bare `worklane` and `worklane tui` are unchanged
- The failure **names the path** that had no board, since with several arguments "No .worklane directory found" does not say which one was wrong. Only when a path was given: a bare `worklane` has no path to name and keeps the message every other command gives, which is what its integration test asserts
Generated
+1 -1
View File
@@ -1494,7 +1494,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.13.5"
version = "0.13.6"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.13.5"
version = "0.13.6"
edition = "2024"
[dependencies]
+14
View File
@@ -163,6 +163,15 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
continue;
}
// Ahead of the arms, because a prompt has to swallow every key it is
// given: typing `d` into a query must not toggle the done column and `q`
// must not quit. It reports what it took, so the arms below stay a plain
// match on the keys it did not, and it takes nothing when no prompt is open.
// The rule is `Board::search_key`, where a test can reach it.
if board.search_key(key, screen) {
continue;
}
match key.code {
// One arm, because the two keys mean one thing: close what is open, and
// quit when there is nothing left to close. Two arms carrying one rule
@@ -192,6 +201,11 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
KeyCode::BackTab => board.select_tab(-1, screen),
// Free of the other bindings, and the footer names it in both states.
KeyCode::Char('d') => board.toggle_done(screen),
// An ordinary single-shot action like the rest: it opens the prompt, and
// from the next keypress on `search_key` above has the keyboard. A `/`
// typed into an open prompt is taken there as a character, so this arm
// is only ever the way in.
KeyCode::Char('/') => board.open_search(),
_ => {}
}
}
+563 -5
View File
@@ -13,6 +13,7 @@ use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
use anyhow::{Context, Result};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect, Size};
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
@@ -204,6 +205,19 @@ pub struct Detail {
pub text: String,
}
/// The open search prompt: what has been typed, and whether the last enter missed.
///
/// One field on `Board` rather than a buffer beside a bool saying whether it is open,
/// the shape `detail` uses: "the prompt is open" and "what is in it" then cannot
/// disagree, and there is no state to reset when it closes.
#[derive(Debug, Default)]
pub struct Search {
pub query: String,
/// Set when enter found nothing, cleared by the next edit. The message is about the
/// query that missed, so it goes the moment the query changes.
pub missed: bool,
}
/// What is on screen.
pub struct Board {
/// The monitored boards as tabs, the merge first when there is more than one.
@@ -214,6 +228,8 @@ pub struct Board {
pub detail: Option<Detail>,
/// First visible line of the detail view, counted in wrapped lines.
pub offset: u16,
/// The search prompt while it is open. `None` is the board reading keys as actions.
pub search: Option<Search>,
/// Whether the done column is drawn. Off at startup, and not remembered between
/// runs: worklane has no config file, and one flag is not a reason to start one.
/// Board-wide rather than per tab: it is a preference about the flow, not about a
@@ -249,6 +265,7 @@ impl Board {
tab: 0,
detail: None,
offset: 0,
search: None,
show_done: false,
should_quit: false,
projects,
@@ -420,7 +437,22 @@ impl Board {
return;
}
tab.card = (tab.card as isize + delta).clamp(0, count as isize - 1) as usize;
let column = tab.column;
let card = (tab.card as isize + delta).clamp(0, count as isize - 1) as usize;
self.select_at(column, card, screen);
}
/// Put the selection on one card, then bring it into view and follow it.
///
/// The tail every move shares. `follow_selection` scrolls the column the card is in,
/// and the offsets are per column and on the `Tab`, so a jump across columns moves
/// the right one. `refresh_detail` keeps an open overlay on the ticket the selection
/// names. A second version of either is how a jump comes to scroll differently from
/// the arrow keys.
fn select_at(&mut self, column: usize, card: usize, screen: Size) {
let tab = self.current_mut();
tab.column = column;
tab.card = card;
self.follow_selection(screen);
self.refresh_detail();
}
@@ -491,6 +523,82 @@ impl Board {
}
}
/// Open the prompt on an empty query.
///
/// Empty rather than the last query kept: that search is finished, and reopening on
/// it would make `/` and enter repeat a jump nobody asked for. Repeating a search is
/// `n`, which 3b16540 puts out of its own scope.
pub fn open_search(&mut self) {
self.search = Some(Search::default());
}
/// Feed a keypress to the open prompt, and say whether it was taken.
///
/// The prompt swallows every key it is given, the ones bound to actions included:
/// typing `d` into a query must not toggle the done column and `q` must not quit.
/// That is why this runs ahead of the action arms and reports what it took, rather
/// than every arm below asking whether a search is open. With no prompt open it
/// takes nothing, so the dispatch is unchanged for every other state.
///
/// `ctrl-c` is the one key it declines. A terminal application always honours it, and
/// a prompt that ate it would leave no way off the board without closing the prompt
/// first. Any other control combination is swallowed and does nothing: it must not
/// type its letter, and it must not fall through either, since the action arms match
/// on the code alone and `ctrl-d` would reach the one bound to `d`.
pub fn search_key(&mut self, key: KeyEvent, screen: Size) -> bool {
if self.search.is_none() {
return false;
}
let control = key.modifiers.contains(KeyModifiers::CONTROL);
if control && key.code == KeyCode::Char('c') {
return false;
}
match key.code {
KeyCode::Esc => self.search = None,
KeyCode::Enter => self.jump_to_match(screen),
KeyCode::Backspace => self.edit_query(|query| {
query.pop();
}),
KeyCode::Char(typed) if !control => self.edit_query(|query| query.push(typed)),
_ => {}
}
true
}
/// Change the query, and forget a miss that was about what it used to say.
fn edit_query(&mut self, edit: impl FnOnce(&mut String)) {
if let Some(search) = &mut self.search {
edit(&mut search.query);
search.missed = false;
}
}
/// Take the query to the first match, or say there was none.
///
/// A hit closes the prompt: it has done its job and the reader is back on the board.
/// A miss keeps it open and marks it, so the query can be corrected in place instead
/// of retyped from `/`, and the selection stays exactly where it was.
fn jump_to_match(&mut self, screen: Size) {
let Some(search) = &self.search else { return };
let query = search.query.clone();
let hit = first_match(self.visible(), &query);
match hit {
Some((column, card)) => {
self.search = None;
self.select_at(column, card, screen);
}
None => {
if let Some(search) = &mut self.search {
search.missed = true;
}
}
}
}
/// Scroll the open detail view by whole screenfuls, one line kept for overlap.
///
/// Up and down move the selection, so the scroll is on PageUp and PageDown. That is
@@ -649,6 +757,41 @@ fn merge(per_project: &[Vec<Column>], projects: &[Project]) -> Vec<Column> {
.collect()
}
/// The first card whose id or title holds `query`, as its column and its place in it.
///
/// Reading order: column by column left to right, then top to bottom inside a column,
/// which is how the board is laid out and how it is read.
///
/// Over every card in the columns it is given, not the rows on screen. A query that
/// answered differently on a tall terminal and a short one is not a search, and the jump
/// scrolls the match into view anyway. The caller passes the *visible* columns, so a
/// hidden done column is never searched: selecting a ticket that is not on the board
/// would leave the highlight nowhere.
///
/// Id and title only, per 3b16540, and both lowercased. The title has to be case
/// insensitive to be worth typing; giving the id the same treatment costs nothing and
/// lets a pasted id match whatever case it was copied in.
///
/// An empty query matches nothing rather than everything. Enter on a prompt nobody typed
/// into should leave the selection where it is, not jump to the first card on the board.
fn first_match(columns: &[Column], query: &str) -> Option<(usize, usize)> {
let needle = query.trim().to_lowercase();
if needle.is_empty() {
return None;
}
columns.iter().enumerate().find_map(|(index, column)| {
column
.cards
.iter()
.position(|card| {
card.ticket.id.to_lowercase().contains(&needle)
|| card.ticket.title.to_lowercase().contains(&needle)
})
.map(|card| (index, card))
})
}
/// The fingerprint of every monitored board, so a change in any of them redraws.
fn digest_of(projects: &[Project]) -> u64 {
let mut hasher = DefaultHasher::new();
@@ -1206,6 +1349,14 @@ fn with_ellipsis(row: &str, width: usize) -> String {
}
fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
// The prompt takes the whole row while it is open. The footer is one line and
// already says what the state allows, and with every key going into the buffer the
// key list it replaces describes nothing that currently works.
if let Some(search) = &board.search {
draw_search(frame, search, area);
return;
}
// While done is hidden its count goes here, which is the board's version of the
// summary line `ls` prints above a listing that leaves done out.
let done = match board.show_done {
@@ -1224,10 +1375,12 @@ fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
// the only key left that quits in one press. Naming `q quit` over an open overlay
// would be the fault 1b78a24 was, a footer describing a key by what it used to do.
let keys = match board.detail {
Some(_) => {
format!(" {tabs}←→↑↓ select pgup/pgdn scroll enter/q close {done} ctrl-c quit ")
}
None => format!(" {tabs}←→ column ↑↓ card enter detail {done} q quit "),
Some(_) => format!(
" {tabs}←→↑↓ select pgup/pgdn scroll / search enter/q close {done} ctrl-c quit "
),
None => format!(
" {tabs}←→ column ↑↓ card / search enter detail {done} q quit "
),
};
frame.render_widget(
@@ -1236,6 +1389,39 @@ fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
);
}
/// The prompt, in place of the key list it would otherwise describe wrongly.
///
/// The real terminal cursor goes after the query rather than a glyph standing in for
/// one: ratatui shows the cursor only for a frame that asked for it, and that is also
/// what tells the reader they are in an input while the query is still empty.
///
/// What was typed is drawn in the default foreground and the keys in grey, because one
/// of them is content and the other is chrome. A miss is said beside the query it is
/// about, in brightred, since grey chrome is exactly what a reader skips. Colour
/// accentuates here as it does on a card; the words carry the meaning either way.
fn draw_search(frame: &mut Frame, search: &Search, area: Rect) {
let prompt = format!(" /{}", search.query);
let mut spans = vec![Span::raw(prompt.clone())];
if search.missed {
spans.push(Span::styled(
" no match",
Style::default().fg(Color::BrightRed.into()),
));
}
spans.push(Span::styled(
" enter jump esc cancel ",
Style::default().fg(Color::Grey.into()),
));
frame.render_widget(Paragraph::new(Line::from(spans)), area);
// Held on the row, so a query longer than the terminal leaves the cursor on the last
// cell rather than off the frame.
let at = (prompt.chars().count() as u16).min(area.width.saturating_sub(1));
frame.set_cursor_position((area.x + at, area.y));
}
/// How many tickets are in done on the tab in view, drawn or not.
fn done_count(board: &Board) -> usize {
board
@@ -2706,6 +2892,378 @@ mod tests {
assert!(row.contains("ctrl-c quit"), "nothing says what quits from here:\n{row}");
}
// ------------------------------------------------------------------- searching --
/// A keypress with nothing held, which is what typing into a prompt is.
fn typed(code: KeyCode) -> KeyEvent {
KeyEvent::new(code, KeyModifiers::NONE)
}
fn letter(c: char) -> KeyEvent {
typed(KeyCode::Char(c))
}
/// Type a whole query into an open prompt, one key at a time, the way it arrives.
fn type_query(board: &mut Board, query: &str) {
for c in query.chars() {
assert!(board.search_key(letter(c), SCREEN), "'{c}' was not taken");
}
}
/// A board with something to find in three columns, done included.
fn searchable() -> PathBuf {
let dir = board_dir();
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "Alpha first", "");
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "Beta second", "");
write_ticket(&dir, "committed", "33333333-0000-4000-8000-000000000000", "Gamma third", "");
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Delta finished", "");
dir
}
/// The prompt takes the row, and the board is still drawn behind it.
#[test]
fn the_prompt_replaces_the_footer_and_leaves_the_board_up() {
let dir = searchable();
let mut board = one_board(&dir);
board.open_search();
let screen = render(&board, SCREEN.width, SCREEN.height);
let row = screen.last().expect("no rows rendered");
assert!(row.contains("enter jump"), "{row}");
assert!(row.contains("esc cancel"), "{row}");
assert!(!row.contains("q quit"), "the key list survived the prompt:\n{row}");
assert!(
screen.join("\n").contains("Alpha first"),
"the board went away behind the prompt"
);
type_query(&mut board, "gam");
let row = footer(&board, SCREEN.width, SCREEN.height);
assert!(row.contains("/gam"), "the query is not drawn: {row}");
}
/// The whole point of an input mode. Every one of these keys does something on the
/// board, and none of it may happen while a query is being typed.
#[test]
fn the_prompt_swallows_the_keys_that_are_bound_to_actions() {
let dir = searchable();
let mut board = one_board(&dir);
let before = selected_title(&board);
board.open_search();
for key in [
letter('d'),
letter('q'),
letter('j'),
letter('h'),
typed(KeyCode::Up),
typed(KeyCode::Down),
typed(KeyCode::Left),
typed(KeyCode::Right),
typed(KeyCode::Tab),
typed(KeyCode::PageDown),
] {
assert!(board.search_key(key, SCREEN), "{key:?} was not taken");
}
assert!(!board.show_done, "typing 'd' toggled the done column");
assert!(!board.should_quit, "typing 'q' quit the board");
assert_eq!(selected_title(&board), before, "an arrow moved the selection");
// The letters landed in the query; the keys that are not characters did not.
assert_eq!(board.search.as_ref().map(|s| s.query.as_str()), Some("dqjh"));
}
/// `ctrl-c` is the exception, since a terminal application always honours it. Every
/// other control combination is swallowed and does nothing: it must not type its
/// letter, and it must not reach the action arm that matches on the code alone.
#[test]
fn the_prompt_declines_ctrl_c_and_eats_every_other_control_key() {
let dir = searchable();
let mut board = one_board(&dir);
board.open_search();
let ctrl = |c: char| KeyEvent::new(KeyCode::Char(c), KeyModifiers::CONTROL);
assert!(
!board.search_key(ctrl('c'), SCREEN),
"the prompt ate ctrl-c and left no way off the board"
);
assert!(board.search_key(ctrl('d'), SCREEN), "ctrl-d fell through to the 'd' arm");
assert_eq!(board.search.as_ref().map(|s| s.query.as_str()), Some(""));
}
/// Esc is consumed by the search, so it never reaches the arm that closes an overlay
/// or quits, and it leaves the selection alone.
#[test]
fn esc_leaves_the_search_without_touching_the_selection_or_the_overlay() {
let dir = searchable();
let mut board = one_board(&dir);
board.toggle_detail();
let before = selected_title(&board);
board.open_search();
type_query(&mut board, "gamma");
assert!(board.search_key(typed(KeyCode::Esc), SCREEN), "esc was not taken");
assert!(board.search.is_none(), "the prompt stayed open");
assert!(board.detail.is_some(), "esc reached the overlay arm");
assert!(!board.should_quit, "esc reached the quit arm");
assert_eq!(selected_title(&board), before, "the selection moved on a cancel");
// And the next esc is the overlay's again.
assert!(!board.search_key(typed(KeyCode::Esc), SCREEN));
}
/// The jump itself: enter takes the selection to the match and puts the prompt away.
#[test]
fn enter_selects_the_first_match_and_closes_the_prompt() {
let dir = searchable();
let mut board = one_board(&dir);
board.open_search();
type_query(&mut board, "beta");
assert!(board.search_key(typed(KeyCode::Enter), SCREEN), "enter was not taken");
assert!(board.search.is_none(), "the prompt stayed open on a hit");
assert_eq!(selected_title(&board).as_deref(), Some("Beta second"));
}
/// Reading order, left to right then top to bottom, which is how the board is laid
/// out and how it is read. Not the rows on screen: the second match here is in a
/// column the selection is not in.
#[test]
fn a_match_in_another_column_moves_the_column_and_scrolls_it_into_view() {
let dir = board_dir();
// Enough cards above the match that its column has to scroll to show it.
for n in 0..12 {
write_ticket(
&dir,
"committed",
&format!("1111111{n:x}-0000-4000-8000-000000000000"),
&format!("Filler {n:02}"),
"",
);
}
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "Alpha first", "");
write_ticket(&dir, "committed", "33333333-0000-4000-8000-000000000000", "Zulu last", "");
let mut board = one_board(&dir);
board.open_search();
type_query(&mut board, "zulu");
board.search_key(typed(KeyCode::Enter), SCREEN);
assert_eq!(selected_title(&board).as_deref(), Some("Zulu last"));
assert_eq!(board.current().column, 1, "the column did not move with the card");
assert!(
board.current().offsets[1] > 0,
"the match's column was not scrolled to show it: {:?}",
board.current().offsets
);
// Drawn, not merely selected, which is what follow_selection is for.
let screen = render(&board, SCREEN.width, SCREEN.height).join("\n");
assert!(screen.contains("Zulu last"), "the match is off screen:\n{screen}");
}
/// A hidden column is not on the board, so a match in it would put the highlight
/// nowhere. Revealing done brings it back into range.
#[test]
fn a_hidden_done_column_is_never_searched() {
let dir = searchable();
let mut board = one_board(&dir);
let before = selected_title(&board);
board.open_search();
type_query(&mut board, "delta");
board.search_key(typed(KeyCode::Enter), SCREEN);
assert_eq!(selected_title(&board), before, "a hidden ticket was selected");
assert!(
board.search.as_ref().is_some_and(|search| search.missed),
"a match in a hidden column was reported as a hit"
);
board.search_key(typed(KeyCode::Esc), SCREEN);
board.toggle_done(SCREEN);
board.open_search();
type_query(&mut board, "delta");
board.search_key(typed(KeyCode::Enter), SCREEN);
assert_eq!(selected_title(&board).as_deref(), Some("Delta finished"));
}
/// The id and the title, both case insensitive, and nothing else on the ticket.
#[test]
fn a_search_reads_the_id_and_the_title_and_neither_case_matters() {
let dir = searchable();
let board = one_board(&dir);
let columns = board.visible();
let title_of = |hit: Option<(usize, usize)>| {
hit.map(|(column, card)| columns[column].cards[card].ticket.title.clone())
};
assert_eq!(title_of(first_match(columns, "GAMMA")).as_deref(), Some("Gamma third"));
assert_eq!(title_of(first_match(columns, "gamma")).as_deref(), Some("Gamma third"));
// The seven characters the card prints, in either case.
assert_eq!(title_of(first_match(columns, "3333333")).as_deref(), Some("Gamma third"));
// On the ticket, but not in the id or the title.
assert_eq!(first_match(columns, "A description."), None);
assert_eq!(first_match(columns, "alice"), None);
}
/// Reading order is column by column, then down inside a column, so a query matching
/// several cards lands on the leftmost and highest of them.
#[test]
fn the_first_match_is_the_first_in_reading_order() {
let dir = searchable();
let board = one_board(&dir);
// Every ticket here ends in a letter, so this matches all four.
assert_eq!(first_match(board.visible(), "a"), Some((0, 0)));
// Only the second column's, so the column index moves and the card index does not.
assert_eq!(first_match(board.visible(), "gamma"), Some((1, 0)));
}
/// Doing nothing visible is what makes a reader retype a query that was already
/// right, so a miss is said, the prompt stays open to be corrected, and the selection
/// does not move.
#[test]
fn a_query_matching_nothing_says_so_and_leaves_the_selection_alone() {
let dir = searchable();
let mut board = one_board(&dir);
let before = selected_title(&board);
board.open_search();
type_query(&mut board, "nothing here");
board.search_key(typed(KeyCode::Enter), SCREEN);
assert_eq!(selected_title(&board), before, "the selection moved on a miss");
assert!(board.search.is_some(), "the prompt closed on a miss");
let row = footer(&board, SCREEN.width, SCREEN.height);
assert!(row.contains("no match"), "the miss was silent: {row}");
// The message is about the query that missed, so the next edit takes it away.
board.search_key(typed(KeyCode::Backspace), SCREEN);
let row = footer(&board, SCREEN.width, SCREEN.height);
assert!(!row.contains("no match"), "the miss outlived its query: {row}");
}
/// Backspace edits, and enter on an empty query is a no-op rather than a match on
/// everything: nobody pressing enter on a prompt they have not typed into means
/// "select the first card on the board".
#[test]
fn backspace_edits_the_query_and_an_empty_one_matches_nothing() {
let dir = searchable();
let mut board = one_board(&dir);
let before = selected_title(&board);
board.open_search();
type_query(&mut board, "gamma");
for _ in 0..3 {
board.search_key(typed(KeyCode::Backspace), SCREEN);
}
assert_eq!(board.search.as_ref().map(|s| s.query.as_str()), Some("ga"));
// Past the start is empty, not a panic.
for _ in 0..5 {
board.search_key(typed(KeyCode::Backspace), SCREEN);
}
assert_eq!(board.search.as_ref().map(|s| s.query.as_str()), Some(""));
board.search_key(typed(KeyCode::Enter), SCREEN);
assert_eq!(selected_title(&board), before, "an empty query matched a card");
assert_eq!(first_match(board.visible(), ""), None);
assert_eq!(first_match(board.visible(), " "), None);
}
/// An overlay follows the jump the way it follows the arrow keys, which is what
/// `select_at` sharing `refresh_detail` with `select_card` buys.
#[test]
fn an_open_overlay_follows_the_jump() {
let dir = searchable();
let mut board = one_board(&dir);
board.toggle_detail();
assert!(
board.detail.as_ref().unwrap().text.contains("11111111"),
"{:?}",
board.detail
);
board.open_search();
type_query(&mut board, "gamma");
board.search_key(typed(KeyCode::Enter), SCREEN);
let detail = board.detail.as_ref().expect("the overlay closed on a jump");
assert_eq!(detail.title, "Gamma third");
assert!(detail.text.contains("33333333"), "{detail:?}");
}
/// With no prompt open the keyboard belongs to the action arms, so `search_key` has
/// to take nothing at all. Otherwise the pre-branch would swallow the whole board.
#[test]
fn nothing_is_taken_while_no_prompt_is_open() {
let dir = searchable();
let mut board = one_board(&dir);
for key in [letter('d'), letter('q'), letter('/'), typed(KeyCode::Esc)] {
assert!(!board.search_key(key, SCREEN), "{key:?} was taken with no prompt open");
}
assert!(board.search.is_none());
}
/// Both footers name the key, since the jump works with a ticket open as well: it
/// moves the selection, and the overlay follows.
#[test]
fn both_footers_name_the_search_key() {
let dir = searchable();
let mut board = one_board(&dir);
assert!(footer(&board, 120, 20).contains("/ search"));
board.toggle_detail();
assert!(footer(&board, 120, 20).contains("/ search"));
}
/// The real terminal cursor sits after the query, rather than a glyph standing in for
/// one. ratatui shows the cursor only for a frame that asked for it, so this is also
/// what says "you are typing" while the query is still empty.
#[test]
fn the_cursor_sits_after_the_query_on_the_prompt_row() {
let dir = searchable();
let mut board = one_board(&dir);
board.open_search();
type_query(&mut board, "gam");
let mut terminal =
Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
terminal.draw(|frame| draw(frame, &board)).unwrap();
let at = terminal.get_cursor_position().unwrap();
// The leading space, the `/`, and the three characters typed.
assert_eq!(at.x, 5, "the cursor is not after the query");
assert_eq!(at.y, SCREEN.height - 1, "the cursor left the prompt row");
}
/// `/` is the way in, and only from the action arms: typed into an open prompt it is
/// an ordinary character, which is what makes searching for a path possible.
#[test]
fn the_dispatch_opens_the_search_and_gives_the_prompt_the_keyboard_first() {
let source = include_str!("main.rs")
.split_whitespace()
.collect::<Vec<_>>()
.join(" ");
assert!(
source.contains("if board.search_key(key, screen) { continue; }"),
"the prompt has to be offered every key before the action arms, or typing \
'd' into a query toggles the done column"
);
assert!(
source.contains("KeyCode::Char('/') => board.open_search(),"),
"`/` has to open the prompt from the action arms"
);
}
// ------------------------------------------------------- several boards at once --
/// A project tree: a directory holding a `.worklane`, which is what a path argument