(3686dd6) Open a command prompt on the board with : and parse what is typed, and bump to 0.32.15
The board reads. Changing anything meant quitting it and retyping an id that was already selected. So `:` opens a one line editor in the footer and the line is a worklane command, spelled exactly as the shell spells it. This is the mode and the grammar check, not the doing. Enter tokenises the line with split_line, prepends the binary's own name and hands the arguments to the same Cli definition the shell reaches, so a flag added to a command is typeable here the day it is added and no list of verbs lives on the board to go stale. A line that resolves is named and the prompt closes; a line that does not keeps the prompt open with the line intact and clap's own message, cut back to what fits a row. Running it is 53ffb94, and the notice and the `↵ check` key both say so rather than reading like a move that happened. The prompt owns the keyboard while it is open, the contract search_key and picker_key already keep, and declines ctrl-c for the same reason they do. A line that ends inside a quote never reaches clap, which is what the splitter's Unclosed state is for. --help is caught, or clap's page lands on the alternate screen the way an unsunk println! would. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
bf7d8e05d8
commit
f16e2aba0c
@@ -351,6 +351,18 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- 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
|
||||
|
||||
### The Command Prompt
|
||||
- **`prompt: Option<Prompt>` is the whole mode**, the shape `search` and `detail` use: open and content cannot disagree, and closing it leaves nothing to reset. `Prompt` carries the line, the cursor as a byte offset into it, and `refused`, which is `Search::missed` with something to say
|
||||
- **`Board::prompt_key` is third in the pre-dispatch**, beside `search_key` and `picker_key` and on the same contract: while a command is being typed `q` is a letter, `d` leaves the columns alone and `tab` stays out of the project tabs, and `ctrl-c` is the one key declined. It takes no `Size`, because nothing it does measures the board — the keypress that will is 53ffb94, which redraws on what the command wrote. Only one of the two prompts can be open at once: `:` is reachable from the action arms alone, and while either has the keyboard the other's key is a character in a line
|
||||
- **`esc` and `enter` are the mode's own keys and are answered in `prompt_key`; everything else belongs to the line and goes to `Prompt::key`.** That is also what keeps the borrow straight, since closing the prompt takes the whole board and editing takes only the prompt. Left, right, home, end, backspace and `ctrl-w` behave as they do in a shell, and `ctrl-w` eats the separators behind the cursor before the word behind those, so one press at the end of `mv 1b78a24 ` takes the id. There is deliberately no `tab`: suggesting the selected ticket is 00a14e7, and until then it is a key that must not reach the tabs
|
||||
- **The grammar is clap's, with nothing restated.** The line is tokenised by `split_line`, the binary's own name goes in front, and the arguments go to the same `Cli` definition the shell reaches, so a flag added to a command is typeable here the day it is added. Through `Cli::command().try_get_matches_from_mut` rather than `try_parse_from`, for what the matches give back: `command_name` walks the subcommands to name what resolved (`campaign show`, not `campaign`) instead of a `match` over every variant, which would be a second list of every verb the CLI has and one that goes stale silently
|
||||
- **`refused` is cleared by an edit and not by a movement.** The message is about the line, and moving the cursor does not change the line. `Prompt::key` clears it in the three arms that write to the line
|
||||
- **A line that ends inside a quote never reaches clap.** That is what `Unclosed` is for: a grammar complaint about a sentence nobody finished describes the wrong thing. Enter on an empty line, or one of nothing but separators, closes the prompt with nothing said, the way `esc` does — the bare form of the CLI opens a board and there is one on the screen
|
||||
- **Enter resolves the line and does not run it**, so the notice says `parsed, not run yet` rather than reading like a move that happened, and the prompt's own key is drawn as `↵ check`. Both are replaced by 53ffb94, which is the ticket that runs it; naming the key `run` here would be the fault 1b78a24 was, in the other direction
|
||||
- **What a refused line shows is clap's own message with the usage block cut off**, which is also what drops the `--help` line after it. `--help` is the exception: it parses as an error of the kind that means *print this* and what it would print is a page, so it is caught and answered in a row's worth of words, or clap's help lands on the alternate screen the way an unsunk `println!` would. `--version` goes through the ordinary path, because what it prints is one line by construction. `ColorChoice::Never` on the command, so nothing that reaches the row carries an escape
|
||||
- **The keys' width comes off the row before the line is windowed**, so a long command does not push them off the end; a message takes the row from the keys instead, since the reader has just been told something and `esc` and `enter` still do what they did. `prompt_window` anchors the window on the cursor's right edge, which costs the text *after* the cursor on a long line: keeping both ends needs a scroll offset in state, and the draw is where the width is known and the state is not writable
|
||||
- `: command` is named in every footer state, because the key works in every one of them
|
||||
|
||||
### Splitting a Typed Line
|
||||
- **`split_line` is the whole module, and it knows nothing about `Board`.** The command prompt reads one string and clap reads an argv, so `comment 1b78a24 the offset was never passed` has to be tokenised before anything can parse it: split on whitespace it is five arguments and `comment` takes two. A pure function over the line and the cursor is what makes every rule reachable from a unit test, and it is in a file of its own rather than in `tui.rs`, which is eleven thousand lines already
|
||||
- **The rules are the shell's, because that is what the prompt promises**: the line is spelled there exactly as it is spelled in the shell. Runs of whitespace separate arguments, single and double quotes group one, a backslash escapes the next character *except* inside single quotes where it is a backslash, and an explicitly empty `''` is an argument that exists and is empty — which is what `--title ""` being a usage error rather than a silent clear depends on. A leading hyphen is not special here: whether `--foo` is a flag or the text of a criterion is clap's question, and `PROSE` already answers it
|
||||
|
||||
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.32.14"
|
||||
version = "0.32.15"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.32.14"
|
||||
version = "0.32.15"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
+17
-2
@@ -8,8 +8,9 @@ mod completions;
|
||||
mod handlers;
|
||||
mod history;
|
||||
mod install;
|
||||
/// Nothing in the binary splits a line yet: the prompt that will is 3686dd6, and the
|
||||
/// allow goes when it lands. The tests are what drive it in the meantime.
|
||||
/// The command prompt reads `split_line` and `unclosed`; `cursor_arg` and `at_new_arg` are
|
||||
/// what completing an argument needs and nothing reads them yet, so the allow stays until
|
||||
/// 00a14e7 and 952a9f8 land. The tests are what drive them in the meantime.
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
mod split;
|
||||
mod tag;
|
||||
@@ -219,6 +220,14 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
continue;
|
||||
}
|
||||
|
||||
// And the command prompt, third, on the same contract: while a command is being
|
||||
// typed `q` is a letter, `d` leaves the columns alone and `tab` stays out of the
|
||||
// project tabs. No screen, because nothing it does measures the board yet. The
|
||||
// rule is `Board::prompt_key`, where a test can reach it.
|
||||
if board.prompt_key(key) {
|
||||
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
|
||||
@@ -262,6 +271,12 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
// at an open picker is taken by `picker_key` to open the picker's own
|
||||
// query, so this arm is only ever the way in to the board's prompt.
|
||||
KeyCode::Char('/') => board.open_search(),
|
||||
// The way in to the command prompt, and the same single-shot arm `/` is:
|
||||
// from the next keypress on, `prompt_key` above has the keyboard. A `:`
|
||||
// typed into either open prompt is a character there and one pressed at an
|
||||
// open picker is swallowed by it, so this arm is only ever the way in from
|
||||
// the board itself. Free of every existing binding.
|
||||
KeyCode::Char(':') => board.open_prompt(),
|
||||
// `y` as in yank, for the readers this board is for, and the only letter
|
||||
// left that a vim hand would reach for. The clipboard is handed in rather
|
||||
// than reached for inside `Board`, so the suite can drive both answers.
|
||||
|
||||
+822
-1
@@ -23,7 +23,9 @@ use ratatui::text::{Line, Span, Text};
|
||||
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs, Wrap};
|
||||
|
||||
use crate::campaign::{CAMPAIGNS_DIR, CampaignIndex, Standing};
|
||||
use crate::command::Cli;
|
||||
use crate::history::{HistoryPart, history_parts, history_root, read_history};
|
||||
use crate::split::{Unclosed, split_line};
|
||||
use crate::tag::{NO_ANNOTATION, TAGS_FILE, TagIndex};
|
||||
use crate::util::*;
|
||||
|
||||
@@ -696,6 +698,177 @@ pub struct Search {
|
||||
pub missed: bool,
|
||||
}
|
||||
|
||||
/// The open command prompt: the line, where the cursor is in it, and what the last enter
|
||||
/// had to say about it.
|
||||
///
|
||||
/// One field on `Board` rather than a buffer beside a bool, for the reason [`Search`] is
|
||||
/// one: "the prompt is open" and "what is in it" cannot disagree, and closing it leaves
|
||||
/// nothing to reset.
|
||||
///
|
||||
/// The cursor is a byte offset into `line`, which is what `String` inserts and removes at
|
||||
/// and what [`crate::split::split_line`] reads. Every key that moves it moves it by whole
|
||||
/// characters, so it is never inside one.
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Prompt {
|
||||
pub line: String,
|
||||
pub cursor: usize,
|
||||
/// What the last enter could not do, cleared by the next edit of the line. The message
|
||||
/// is about the line that was refused, so it goes the moment the line changes; moving
|
||||
/// the cursor leaves it up, since the line it is about has not changed. `Search::missed`
|
||||
/// is the same rule with nothing to say but "no match".
|
||||
pub refused: Option<String>,
|
||||
}
|
||||
|
||||
impl Prompt {
|
||||
/// Every key that only edits the line or moves the cursor, which is all of them but
|
||||
/// `esc` and `enter`: those two are the mode's rather than the line's, and they are
|
||||
/// answered by [`Board::prompt_key`] before it gets here.
|
||||
///
|
||||
/// Left, right, home, end, backspace and `ctrl-w` behave as they do in a shell. There
|
||||
/// is no `tab`: suggesting the selected ticket is 00a14e7, and until then it is a key
|
||||
/// that must not reach the project tabs. Every other control combination lands on the
|
||||
/// last arm and does nothing, which is what stops `ctrl-d` reaching the action bound
|
||||
/// to `d`.
|
||||
fn key(&mut self, key: KeyEvent, control: bool) {
|
||||
match key.code {
|
||||
KeyCode::Left if !control => self.cursor = self.left_of(),
|
||||
KeyCode::Right if !control => self.cursor = self.right_of(),
|
||||
KeyCode::Home if !control => self.cursor = 0,
|
||||
KeyCode::End if !control => self.cursor = self.line.len(),
|
||||
// The three that change the line, so the message about what it used to say goes
|
||||
// with it. Movement above deliberately does not clear it.
|
||||
KeyCode::Backspace if !control => self.cut(self.left_of()),
|
||||
KeyCode::Char('w') if control => self.cut(self.word_start()),
|
||||
KeyCode::Char(typed) if !control => {
|
||||
self.line.insert(self.cursor, typed);
|
||||
self.cursor += typed.len_utf8();
|
||||
self.refused = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
/// The offset one character to the left of the cursor, or the cursor itself at the
|
||||
/// start of the line. By characters, so a cursor never lands inside one.
|
||||
fn left_of(&self) -> usize {
|
||||
match self.line[..self.cursor].chars().next_back() {
|
||||
Some(c) => self.cursor - c.len_utf8(),
|
||||
None => self.cursor,
|
||||
}
|
||||
}
|
||||
|
||||
/// The same one character to the right, or the cursor itself at the end.
|
||||
fn right_of(&self) -> usize {
|
||||
match self.line[self.cursor..].chars().next() {
|
||||
Some(c) => self.cursor + c.len_utf8(),
|
||||
None => self.cursor,
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the word before the cursor starts, which is what `ctrl-w` takes off: the
|
||||
/// separators immediately behind the cursor, and then the run of everything that is
|
||||
/// not one behind those.
|
||||
///
|
||||
/// The separators first, so `ctrl-w` at the end of `mv 1b78a24 ` takes the id rather
|
||||
/// than the space alone, which is what a shell does with it.
|
||||
fn word_start(&self) -> usize {
|
||||
let back = |at: usize| {
|
||||
self.line[..at]
|
||||
.chars()
|
||||
.next_back()
|
||||
.map(|c| (at - c.len_utf8(), c))
|
||||
};
|
||||
|
||||
let mut at = self.cursor;
|
||||
while let Some((before, c)) = back(at) {
|
||||
if !c.is_whitespace() {
|
||||
break;
|
||||
}
|
||||
at = before;
|
||||
}
|
||||
while let Some((before, c)) = back(at) {
|
||||
if c.is_whitespace() {
|
||||
break;
|
||||
}
|
||||
at = before;
|
||||
}
|
||||
|
||||
at
|
||||
}
|
||||
|
||||
/// Take everything between `from` and the cursor off the line, and put the cursor
|
||||
/// where it was taken from. Nothing to remove writes nothing.
|
||||
fn cut(&mut self, from: usize) {
|
||||
if from >= self.cursor {
|
||||
return;
|
||||
}
|
||||
|
||||
self.line.replace_range(from..self.cursor, "");
|
||||
self.cursor = from;
|
||||
self.refused = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// What a line that ends half typed is waiting for, or nothing when it is whole.
|
||||
///
|
||||
/// The splitter reports the state rather than raising an error, and this is the sentence
|
||||
/// the row carries for it. Said here rather than at the call site so the three states are
|
||||
/// spelled in one place.
|
||||
fn unclosed_message(unclosed: Unclosed) -> Option<&'static str> {
|
||||
match unclosed {
|
||||
Unclosed::Closed => None,
|
||||
Unclosed::Single => Some("the line ends inside a ' quote"),
|
||||
Unclosed::Double => Some("the line ends inside a \" quote"),
|
||||
Unclosed::Escape => Some("the line ends on a backslash"),
|
||||
}
|
||||
}
|
||||
|
||||
/// What clap resolved the line to, as the words a reader typed: `mv`, or `campaign show`
|
||||
/// for a command inside a group.
|
||||
///
|
||||
/// Off the matches rather than off a `match` on `Command`, which would be a second list of
|
||||
/// every verb the CLI has — one that goes stale the day a command is added, and silently,
|
||||
/// since a missing arm would only ever be seen by whoever typed that verb. `None` is the
|
||||
/// bare form, which names no command at all.
|
||||
fn command_name(matches: &clap::ArgMatches) -> Option<String> {
|
||||
let (name, inner) = matches.subcommand()?;
|
||||
|
||||
Some(match command_name(inner) {
|
||||
Some(rest) => format!("{name} {rest}"),
|
||||
None => name.to_string(),
|
||||
})
|
||||
}
|
||||
|
||||
/// The one line the row carries for a line clap would not take.
|
||||
///
|
||||
/// Clap's own message, because the grammar is clap's: a complaint written here would
|
||||
/// describe a rule this file does not own. What is dropped is the usage block and the
|
||||
/// `--help` line after it, which are a paragraph — the synopsis is d7e493e's, and until
|
||||
/// then the row says what is wrong rather than what would have been right.
|
||||
///
|
||||
/// `--help` is the exception. It parses as an error of the kind that means *print this*,
|
||||
/// and what it would print is a page: caught here, or clap's help lands on the alternate
|
||||
/// screen the way an unsunk `println!` would. `--version` goes through the ordinary path
|
||||
/// because what it prints is one line by construction, which is exactly what fits.
|
||||
fn refusal(err: &clap::Error) -> String {
|
||||
if matches!(
|
||||
err.kind(),
|
||||
clap::error::ErrorKind::DisplayHelp
|
||||
| clap::error::ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
|
||||
) {
|
||||
return "help is a page and this is a row: try it in a shell".to_string();
|
||||
}
|
||||
|
||||
let rendered = err.render().to_string();
|
||||
rendered
|
||||
.lines()
|
||||
.take_while(|line| !line.starts_with("Usage:"))
|
||||
.map(str::trim)
|
||||
.filter(|line| !line.is_empty())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
/// A line the footer carries in place of the key list until the next keypress.
|
||||
///
|
||||
/// The board otherwise says everything by drawing it, and a copy leaves nothing on the
|
||||
@@ -1073,6 +1246,10 @@ pub struct Board {
|
||||
pub offset: u16,
|
||||
/// The search prompt while it is open. `None` is the board reading keys as actions.
|
||||
pub search: Option<Search>,
|
||||
/// The command prompt while it is open, on the same terms as `search`. Only one of the
|
||||
/// two can be open at once: `:` is reachable from the action arms alone, and while
|
||||
/// either prompt has the keyboard the other's key is a character in a line.
|
||||
pub prompt: Option<Prompt>,
|
||||
/// The campaign picker while it is open, on the same terms as `search`.
|
||||
pub picker: Option<Picker>,
|
||||
/// What the last action said, until the next keypress takes it away.
|
||||
@@ -1109,6 +1286,7 @@ impl Board {
|
||||
detail: None,
|
||||
offset: 0,
|
||||
search: None,
|
||||
prompt: None,
|
||||
picker: None,
|
||||
notice: None,
|
||||
visibility: Visibility::default(),
|
||||
@@ -1920,6 +2098,113 @@ impl Board {
|
||||
}
|
||||
}
|
||||
|
||||
/// Open the command prompt on an empty line.
|
||||
///
|
||||
/// Empty rather than the last line kept, for the reason `open_search` opens empty: the
|
||||
/// command that was typed has been dealt with, and reopening on it would make `:` and
|
||||
/// enter repeat something nobody asked for. Recalling a line is `a9bd6f0`.
|
||||
pub fn open_prompt(&mut self) {
|
||||
self.prompt = Some(Prompt::default());
|
||||
}
|
||||
|
||||
/// Feed a keypress to the open command prompt, and say whether it was taken.
|
||||
///
|
||||
/// The same contract as `search_key` and `picker_key`, and it runs beside them for the
|
||||
/// same reason: the prompt owns the keyboard while it is open, so `q` typed into a
|
||||
/// command has to be a letter, `d` must not rotate the columns and `tab` must not
|
||||
/// change project. `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.
|
||||
///
|
||||
/// `esc` and `enter` are the mode's own two keys and are answered here; everything else
|
||||
/// belongs to the line and goes to `Prompt::key`. That split is also what keeps the
|
||||
/// borrow straight: closing the prompt takes the whole board, editing takes the prompt.
|
||||
///
|
||||
/// No screen: nothing here measures the board. The keypress that will is 53ffb94, which
|
||||
/// redraws on what the command wrote.
|
||||
pub fn prompt_key(&mut self, key: KeyEvent) -> bool {
|
||||
if self.prompt.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 if !control => self.prompt = None,
|
||||
KeyCode::Enter if !control => self.submit(),
|
||||
_ => {
|
||||
if let Some(prompt) = &mut self.prompt {
|
||||
prompt.key(key, control);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
true
|
||||
}
|
||||
|
||||
/// What enter does with the line: name the command it resolved to, or say why it did
|
||||
/// not resolve to one.
|
||||
///
|
||||
/// The grammar is clap's, with nothing restated. The line is tokenised the way a shell
|
||||
/// tokenises one, the binary's own name is put in front of the arguments, and the
|
||||
/// result goes to the same `Cli` definition the shell reaches: a flag added to a
|
||||
/// command is typeable here the day it is added, and no list of verbs lives on the
|
||||
/// board to go stale.
|
||||
///
|
||||
/// A line that resolves closes the prompt and says what it resolved to, in the footer's
|
||||
/// one channel for saying something in words. **It does not run it** — running is
|
||||
/// 53ffb94 — so the notice says so rather than reading like a move that happened.
|
||||
///
|
||||
/// A line that does not resolve keeps the prompt open with the line and the cursor
|
||||
/// exactly as they were, and puts the message on the row, so a typo is corrected in
|
||||
/// place instead of retyped from `:`. That is `Search`'s hit-closes-miss-stays rule,
|
||||
/// and the reason both are true of one field.
|
||||
fn submit(&mut self) {
|
||||
let Some(prompt) = &self.prompt else { return };
|
||||
|
||||
// Before clap sees anything, because a line ending inside a quote is not a line
|
||||
// that failed to parse: it is one the reader has not finished typing, and handing
|
||||
// its half-open argument to clap would report a grammar fault about a sentence
|
||||
// nobody finished.
|
||||
let split = split_line(&prompt.line, prompt.cursor);
|
||||
if let Some(open) = unclosed_message(split.unclosed) {
|
||||
self.refuse(open.to_string());
|
||||
return;
|
||||
}
|
||||
|
||||
// Enter on an empty line closes the prompt and leaves the board as it was, the way
|
||||
// esc does. A line of nothing but separators is the same line: it names no command,
|
||||
// and the bare form of the CLI opens a board, which is already on the screen.
|
||||
if split.args.is_empty() {
|
||||
self.prompt = None;
|
||||
return;
|
||||
}
|
||||
|
||||
let mut command = <Cli as clap::CommandFactory>::command().color(clap::ColorChoice::Never);
|
||||
let argv = std::iter::once(command.get_name().to_string()).chain(split.args);
|
||||
|
||||
match command.try_get_matches_from_mut(argv) {
|
||||
// No subcommand is the bare form, which opens a board: there is one on the
|
||||
// screen, so there is nothing to name and nothing to do but close.
|
||||
Ok(matches) => {
|
||||
self.prompt = None;
|
||||
if let Some(named) = command_name(&matches) {
|
||||
self.notice = Some(Notice::done(format!("{named}: parsed, not run yet")));
|
||||
}
|
||||
}
|
||||
Err(err) => self.refuse(refusal(&err)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Keep the prompt open, with the line untouched, carrying what enter had to say.
|
||||
fn refuse(&mut self, message: String) {
|
||||
if let Some(prompt) = &mut self.prompt {
|
||||
prompt.refused = Some(message);
|
||||
}
|
||||
}
|
||||
|
||||
/// The string the copy key puts on the clipboard: the selected card's short id.
|
||||
///
|
||||
/// A method here rather than a line inside the arm that copies, so what gets copied
|
||||
@@ -3734,6 +4019,14 @@ fn key_hints(hints: &[(&str, &str)]) -> Vec<Span<'static>> {
|
||||
}
|
||||
|
||||
fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
|
||||
// The command prompt takes the whole row on the same terms as the search prompt below,
|
||||
// and is asked first: an input cannot be covered, and it is the newest of the three
|
||||
// things that can hold the row. Only one of the two prompts can be open at a time.
|
||||
if let Some(prompt) = &board.prompt {
|
||||
draw_prompt(frame, prompt, area);
|
||||
return;
|
||||
}
|
||||
|
||||
// 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.
|
||||
@@ -3831,6 +4124,7 @@ fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
|
||||
("←→↑↓", "select"),
|
||||
("pgup/pgdn", "scroll"),
|
||||
("/", "search"),
|
||||
(":", "command"),
|
||||
("y", "copy id"),
|
||||
("↵/q", "close"),
|
||||
]),
|
||||
@@ -3840,13 +4134,19 @@ fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
|
||||
("↵", height),
|
||||
("pgup/pgdn", "scroll"),
|
||||
("/", "search"),
|
||||
(":", "command"),
|
||||
]);
|
||||
if let Some(copied) = copied {
|
||||
hints.push(("y", copied));
|
||||
}
|
||||
}
|
||||
(false, Focus::Cards) => {
|
||||
hints.extend([("←→", "column"), ("↑↓", "card"), ("/", "search")]);
|
||||
hints.extend([
|
||||
("←→", "column"),
|
||||
("↑↓", "card"),
|
||||
("/", "search"),
|
||||
(":", "command"),
|
||||
]);
|
||||
hints.extend_from_slice(filter);
|
||||
hints.extend([("y", "copy id"), ("↵", "detail")]);
|
||||
}
|
||||
@@ -3907,6 +4207,85 @@ fn draw_search(frame: &mut Frame, search: &Search, area: Rect) {
|
||||
frame.set_cursor_position((area.x + at, area.y));
|
||||
}
|
||||
|
||||
/// What the row spends on the command prompt before the line starts: its own opening space
|
||||
/// and the key that opened it, drawn where a search draws its `/`.
|
||||
const PROMPT_OPENING: &str = " :";
|
||||
|
||||
/// The command prompt, in place of the key list, and the line windowed to what is left of
|
||||
/// the row.
|
||||
///
|
||||
/// The keys are drawn the way `draw_search` draws its two, and their width is taken off the
|
||||
/// row *before* the line is windowed, so they keep their place rather than being pushed off
|
||||
/// the end by a long command. A message takes the row from them instead: the reader has
|
||||
/// just been told something and that is the thing to read, while `esc` and `enter` still do
|
||||
/// what they did. It is brightred beside the line it is about, the one thing on the row
|
||||
/// that is neither a key nor what was typed, which is where `no match` sits.
|
||||
///
|
||||
/// `check` and not `run`: enter resolves the line and names it, and running it is 53ffb94.
|
||||
/// A row naming a key by what it does not do yet is the fault 1b78a24 was, in the other
|
||||
/// direction.
|
||||
fn draw_prompt(frame: &mut Frame, prompt: &Prompt, area: Rect) {
|
||||
let keys = key_hints(&[("↵", "check"), ("esc", "cancel")]);
|
||||
let spent: usize = PROMPT_OPENING.chars().count()
|
||||
+ KEY_GAP.chars().count()
|
||||
+ keys
|
||||
.iter()
|
||||
.map(|span| span.content.chars().count())
|
||||
.sum::<usize>();
|
||||
|
||||
// At least one cell, so a terminal too narrow for the keys still draws a cursor to type
|
||||
// at rather than nothing at all.
|
||||
let room = (area.width as usize).saturating_sub(spent).max(1);
|
||||
let (visible, at) = prompt_window(&prompt.line, prompt.cursor, room);
|
||||
|
||||
let mut spans = vec![Span::raw(format!("{PROMPT_OPENING}{visible}"))];
|
||||
match &prompt.refused {
|
||||
Some(message) => spans.push(Span::styled(
|
||||
format!("{KEY_GAP}{message}"),
|
||||
Style::default().fg(Color::BrightRed.into()),
|
||||
)),
|
||||
None => {
|
||||
spans.push(Span::raw(KEY_GAP));
|
||||
spans.extend(keys);
|
||||
}
|
||||
}
|
||||
|
||||
frame.render_widget(Paragraph::new(Line::from(spans)), area);
|
||||
|
||||
// Held on the row, the way the search prompt holds its own: a line longer than the
|
||||
// terminal leaves the cursor on the last cell rather than off the frame.
|
||||
let column = (PROMPT_OPENING.chars().count() + at) as u16;
|
||||
frame.set_cursor_position((area.x + column.min(area.width.saturating_sub(1)), area.y));
|
||||
}
|
||||
|
||||
/// The part of `line` a field `room` cells wide shows with the cursor at `cursor`, and the
|
||||
/// column the cursor lands on inside it.
|
||||
///
|
||||
/// The window is anchored on the cursor's right edge, so a line longer than the row scrolls
|
||||
/// as it is typed instead of being cut off at the end of the field, and scrolls back as the
|
||||
/// cursor moves left. What it costs is the text *after* the cursor on a long line, which is
|
||||
/// off the window until the cursor reaches it. A window that kept both ends needs a scroll
|
||||
/// offset held in state, and the draw is where the width is known and the state is not
|
||||
/// writable, so that offset would have to be maintained by every key that moves the cursor
|
||||
/// against a width the keypress cannot see.
|
||||
///
|
||||
/// Counted in characters, which is what the rest of this row is measured in. The cursor is
|
||||
/// counted rather than sliced, so an offset that is somehow not on a character boundary
|
||||
/// gives a window rather than a panic on the board.
|
||||
fn prompt_window(line: &str, cursor: usize, room: usize) -> (String, usize) {
|
||||
let before = line
|
||||
.char_indices()
|
||||
.take_while(|(offset, _)| *offset < cursor)
|
||||
.count();
|
||||
|
||||
// One cell of the field is the cursor's own, so a line whose head fills the row keeps
|
||||
// the cursor on it rather than one cell past its end.
|
||||
let start = before.saturating_sub(room.saturating_sub(1));
|
||||
let visible = line.chars().skip(start).take(room).collect();
|
||||
|
||||
(visible, before - start)
|
||||
}
|
||||
|
||||
/// The picker's footer: its query while one is open, and the keys it answers to otherwise.
|
||||
///
|
||||
/// The same division `draw_search` makes, and the same reason for it: while every printable
|
||||
@@ -6940,6 +7319,448 @@ approach";
|
||||
);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ the command prompt --
|
||||
|
||||
/// A keypress with control held, which is how `ctrl-w` and `ctrl-c` arrive.
|
||||
fn ctrl(c: char) -> KeyEvent {
|
||||
KeyEvent::new(KeyCode::Char(c), KeyModifiers::CONTROL)
|
||||
}
|
||||
|
||||
/// Type a whole line into an open command prompt, one key at a time, the way it arrives.
|
||||
fn type_line(board: &mut Board, line: &str) {
|
||||
for c in line.chars() {
|
||||
assert!(board.prompt_key(letter(c)), "'{c}' was not taken");
|
||||
}
|
||||
}
|
||||
|
||||
fn prompt_line(board: &Board) -> Option<&str> {
|
||||
board.prompt.as_ref().map(|prompt| prompt.line.as_str())
|
||||
}
|
||||
|
||||
/// What the last enter had to say, or nothing.
|
||||
fn refused(board: &Board) -> Option<&str> {
|
||||
board
|
||||
.prompt
|
||||
.as_ref()
|
||||
.and_then(|prompt| prompt.refused.as_deref())
|
||||
}
|
||||
|
||||
/// Press enter on the open prompt, which is the whole of what this ticket does.
|
||||
fn submit(board: &mut Board) {
|
||||
assert!(board.prompt_key(typed(KeyCode::Enter)), "enter was not taken");
|
||||
}
|
||||
|
||||
/// The prompt takes the row, names its own two keys, and the board is still behind it.
|
||||
#[test]
|
||||
fn the_command_prompt_replaces_the_footer_and_draws_the_line_and_its_cursor() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
board.open_prompt();
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
let row = screen.last().expect("no rows rendered");
|
||||
|
||||
assert!(row.contains("↵ check"), "{row}");
|
||||
assert!(row.contains("esc cancel"), "{row}");
|
||||
assert!(!row.contains("quit"), "the key list survived the prompt:\n{row}");
|
||||
assert!(
|
||||
screen.join("\n").contains("Alpha first"),
|
||||
"the board went away behind the prompt"
|
||||
);
|
||||
|
||||
type_line(&mut board, "mv 1111111");
|
||||
let row = footer(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(row.contains(" :mv 1111111"), "the line is not drawn: {row}");
|
||||
|
||||
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 ten characters typed.
|
||||
assert_eq!(at.x, 12, "the cursor is not after the line");
|
||||
assert_eq!(at.y, SCREEN.height - 1, "the cursor left the prompt row");
|
||||
}
|
||||
|
||||
/// The line is edited where the cursor is, not at its end, which is the difference
|
||||
/// between a command line and the search prompt's append-only query.
|
||||
#[test]
|
||||
fn the_line_is_edited_at_a_cursor_the_way_a_shell_edits_one() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "mv 1111111");
|
||||
|
||||
board.prompt_key(typed(KeyCode::Home));
|
||||
type_line(&mut board, "x");
|
||||
assert_eq!(prompt_line(&board), Some("xmv 1111111"), "home did not reach the front");
|
||||
|
||||
// Backspace takes the character before the cursor, not the last one on the line.
|
||||
board.prompt_key(typed(KeyCode::Backspace));
|
||||
assert_eq!(prompt_line(&board), Some("mv 1111111"));
|
||||
|
||||
board.prompt_key(typed(KeyCode::Right));
|
||||
board.prompt_key(typed(KeyCode::Right));
|
||||
type_line(&mut board, "!");
|
||||
assert_eq!(prompt_line(&board), Some("mv! 1111111"));
|
||||
|
||||
board.prompt_key(typed(KeyCode::Left));
|
||||
board.prompt_key(typed(KeyCode::Backspace));
|
||||
assert_eq!(prompt_line(&board), Some("m! 1111111"));
|
||||
|
||||
// `ctrl-w` takes the word before the cursor, and the separators behind the cursor
|
||||
// with it, so a second press takes the word before those rather than the space.
|
||||
board.prompt_key(typed(KeyCode::End));
|
||||
board.prompt_key(ctrl('w'));
|
||||
assert_eq!(prompt_line(&board), Some("m! "));
|
||||
board.prompt_key(ctrl('w'));
|
||||
assert_eq!(prompt_line(&board), Some(""));
|
||||
|
||||
// Nothing to take is nothing done, at either end.
|
||||
board.prompt_key(typed(KeyCode::Backspace));
|
||||
board.prompt_key(ctrl('w'));
|
||||
board.prompt_key(typed(KeyCode::Left));
|
||||
assert_eq!(prompt_line(&board), Some(""));
|
||||
|
||||
// A cursor counted in bytes still moves by whole characters, so a backspace over a
|
||||
// multi-byte one takes the character rather than splitting it.
|
||||
type_line(&mut board, "comment é");
|
||||
board.prompt_key(typed(KeyCode::Backspace));
|
||||
assert_eq!(prompt_line(&board), Some("comment "));
|
||||
}
|
||||
|
||||
/// 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 command is being typed.
|
||||
#[test]
|
||||
fn the_command_prompt_swallows_the_keys_that_are_bound_to_actions() {
|
||||
let first = searchable();
|
||||
let second = board_dir();
|
||||
let mut board = boards(&[("alpha", &first), ("beta", &second)]);
|
||||
|
||||
let before = selected_title(&board);
|
||||
board.open_prompt();
|
||||
|
||||
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::BackTab),
|
||||
typed(KeyCode::PageDown),
|
||||
] {
|
||||
assert!(board.prompt_key(key), "{key:?} was not taken");
|
||||
}
|
||||
|
||||
assert!(!board.should_quit, "typing 'q' quit the board");
|
||||
assert_eq!(board.visibility, Visibility::Neither, "typing 'd' rotated the columns");
|
||||
assert_eq!(selected_title(&board), before, "an arrow moved the selection");
|
||||
assert_eq!(board.tab, 0, "tab changed project from under the prompt");
|
||||
// The letters landed in the line; the keys that are not characters did not.
|
||||
assert_eq!(prompt_line(&board), Some("dqjh"));
|
||||
}
|
||||
|
||||
/// `ctrl-c` is the exception, since a terminal application always honours it. Every
|
||||
/// other control combination is swallowed and does nothing but the one that is bound.
|
||||
#[test]
|
||||
fn the_command_prompt_declines_ctrl_c_and_eats_every_other_control_key() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
board.open_prompt();
|
||||
|
||||
assert!(
|
||||
!board.prompt_key(ctrl('c')),
|
||||
"the prompt ate ctrl-c and left no way off the board"
|
||||
);
|
||||
|
||||
assert!(board.prompt_key(ctrl('d')), "ctrl-d fell through to the 'd' arm");
|
||||
assert_eq!(prompt_line(&board), Some(""), "a control key typed its letter");
|
||||
}
|
||||
|
||||
/// Both ways of leaving with nothing done, and neither touches anything behind the row.
|
||||
#[test]
|
||||
fn esc_and_enter_on_an_empty_line_leave_the_board_as_it_was() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let before = selected_title(&board);
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "mv 1111111");
|
||||
|
||||
assert!(board.prompt_key(typed(KeyCode::Esc)), "esc was not taken");
|
||||
assert!(board.prompt.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");
|
||||
assert!(board.notice.is_none(), "a cancel said something in the footer");
|
||||
|
||||
// And the next esc is the overlay's again.
|
||||
assert!(!board.prompt_key(typed(KeyCode::Esc)));
|
||||
|
||||
board.open_prompt();
|
||||
submit(&mut board);
|
||||
assert!(board.prompt.is_none(), "enter on an empty line left the prompt open");
|
||||
assert!(board.notice.is_none(), "an empty line named a command");
|
||||
|
||||
// A line of nothing but separators names no command either.
|
||||
board.open_prompt();
|
||||
type_line(&mut board, " ");
|
||||
submit(&mut board);
|
||||
assert!(board.prompt.is_none(), "a line of spaces left the prompt open");
|
||||
assert!(board.notice.is_none(), "a line of spaces named a command");
|
||||
}
|
||||
|
||||
/// A line clap takes closes the prompt and is named, in the footer's one channel for
|
||||
/// saying something in words. It is *not* run here, and the notice has to say so.
|
||||
#[test]
|
||||
fn enter_names_the_command_the_line_resolved_to_and_closes_the_prompt() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "mv 1111111 --status committed");
|
||||
submit(&mut board);
|
||||
|
||||
assert!(board.prompt.is_none(), "the prompt stayed open on a line clap took");
|
||||
let row = footer(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(row.contains("mv"), "the command was not named: {row}");
|
||||
assert!(row.contains("not run"), "the notice reads like the move happened: {row}");
|
||||
|
||||
// A command inside a group is named by the words that reach it, off the matches
|
||||
// rather than a list of verbs kept here.
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "campaign show v1");
|
||||
submit(&mut board);
|
||||
let row = footer(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(row.contains("campaign show"), "the group was not named: {row}");
|
||||
|
||||
// And the reason the line is tokenised at all: `comment` takes two arguments, so a
|
||||
// body split on whitespace would be five and clap would refuse it.
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "comment 1111111 \"the offset was never passed\"");
|
||||
submit(&mut board);
|
||||
assert!(board.prompt.is_none(), "a quoted body was refused: {:?}", refused(&board));
|
||||
}
|
||||
|
||||
/// A line clap will not take keeps the prompt open with the line intact, so a typo is
|
||||
/// corrected in place instead of retyped from `:`. The message is clap's own, cut back
|
||||
/// to the part that fits a row.
|
||||
#[test]
|
||||
fn a_refused_line_keeps_the_prompt_open_and_shows_clap_without_the_usage_block() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "mv");
|
||||
submit(&mut board);
|
||||
|
||||
assert_eq!(prompt_line(&board), Some("mv"), "the line was not kept");
|
||||
let message = refused(&board).expect("nothing was said about a line clap refused");
|
||||
assert!(message.contains("required"), "not clap's own message: {message}");
|
||||
assert!(!message.contains("Usage:"), "the usage block reached the row: {message}");
|
||||
assert!(!message.contains('\n'), "the message is a paragraph, not a row: {message}");
|
||||
assert!(!message.contains('\x1b'), "clap coloured the message: {message:?}");
|
||||
|
||||
let row = footer(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(row.contains(" :mv"), "the line left the row: {row}");
|
||||
assert!(row.contains("required"), "the message is not on the row: {row}");
|
||||
assert!(
|
||||
!row.contains("esc cancel"),
|
||||
"the keys and the message shared the row: {row}"
|
||||
);
|
||||
|
||||
// The message is about the line, so moving the cursor keeps it and an edit takes it.
|
||||
board.prompt_key(typed(KeyCode::Left));
|
||||
assert!(
|
||||
refused(&board).is_some(),
|
||||
"moving the cursor cleared a message about a line that had not changed"
|
||||
);
|
||||
type_line(&mut board, "x");
|
||||
assert!(refused(&board).is_none(), "the message outlived the line it was about");
|
||||
}
|
||||
|
||||
/// `--help` parses as an error of the kind that means *print this*, and what it would
|
||||
/// print is a page: uncaught, clap's help lands on the alternate screen the way an
|
||||
/// unsunk `println!` would. `--version` is one line by construction, so it says itself.
|
||||
#[test]
|
||||
fn help_and_version_put_nothing_over_the_board() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
|
||||
for line in ["--help", "-h", "mv --help"] {
|
||||
board.open_prompt();
|
||||
type_line(&mut board, line);
|
||||
submit(&mut board);
|
||||
|
||||
let message = refused(&board).unwrap_or_else(|| panic!("`{line}` said nothing"));
|
||||
assert!(!message.contains('\n'), "`{line}` put a page on the row: {message}");
|
||||
assert!(message.contains("help"), "`{line}` said something else: {message}");
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(
|
||||
screen.join("\n").contains("Alpha first"),
|
||||
"`{line}` printed over the board"
|
||||
);
|
||||
board.prompt_key(typed(KeyCode::Esc));
|
||||
}
|
||||
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "--version");
|
||||
submit(&mut board);
|
||||
let message = refused(&board).expect("`--version` said nothing");
|
||||
assert!(
|
||||
message.contains(env!("CARGO_PKG_VERSION")),
|
||||
"`--version` did not say the version: {message}"
|
||||
);
|
||||
assert!(!message.contains('\n'), "the version is not one line: {message}");
|
||||
}
|
||||
|
||||
/// The splitter reports a half-typed line as a state rather than an error, and this is
|
||||
/// what the prompt does with it: nothing goes to clap, because a grammar complaint about
|
||||
/// a sentence nobody finished is a complaint about the wrong thing.
|
||||
#[test]
|
||||
fn a_line_that_ends_inside_a_quote_is_never_handed_to_clap() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
|
||||
board.open_prompt();
|
||||
type_line(&mut board, "comment 1111111 \"the offset");
|
||||
submit(&mut board);
|
||||
|
||||
assert_eq!(
|
||||
prompt_line(&board),
|
||||
Some("comment 1111111 \"the offset"),
|
||||
"the line was not kept"
|
||||
);
|
||||
let message = refused(&board).expect("nothing was said about an open quote");
|
||||
assert!(message.contains("quote"), "{message}");
|
||||
|
||||
// Closing it makes the same line a command.
|
||||
type_line(&mut board, "\"");
|
||||
submit(&mut board);
|
||||
assert!(
|
||||
board.prompt.is_none(),
|
||||
"a closed quote was still refused: {:?}",
|
||||
refused(&board)
|
||||
);
|
||||
}
|
||||
|
||||
/// A line longer than the row scrolls under the cursor instead of being cut off at the
|
||||
/// end of the field, and scrolls back as the cursor moves left.
|
||||
#[test]
|
||||
fn a_line_longer_than_the_row_scrolls_with_the_cursor() {
|
||||
// The window itself, which is where the rule lives.
|
||||
assert_eq!(prompt_window("mv", 2, 10), ("mv".to_string(), 2));
|
||||
assert_eq!(prompt_window("", 0, 10), (String::new(), 0));
|
||||
assert_eq!(prompt_window("abcdefghij", 10, 5), ("ghij".to_string(), 4));
|
||||
assert_eq!(prompt_window("abcdefghij", 0, 5), ("abcde".to_string(), 0));
|
||||
assert_eq!(prompt_window("abcdefghij", 7, 5), ("defgh".to_string(), 4));
|
||||
// One cell wide is still a cursor to type at rather than a panic.
|
||||
assert_eq!(prompt_window("abc", 3, 1), (String::new(), 0));
|
||||
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
board.open_prompt();
|
||||
type_line(&mut board, &format!("mv {}", "a".repeat(200)));
|
||||
|
||||
let row = footer(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(!row.contains(":mv"), "the head of the line held the row: {row}");
|
||||
assert!(row.contains("esc cancel"), "a long line pushed the keys off: {row}");
|
||||
|
||||
let mut terminal = Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
|
||||
terminal.draw(|frame| draw(frame, &board)).unwrap();
|
||||
assert!(
|
||||
terminal.get_cursor_position().unwrap().x < SCREEN.width,
|
||||
"the cursor left the frame"
|
||||
);
|
||||
|
||||
// Home takes the window back to the front of the line.
|
||||
board.prompt_key(typed(KeyCode::Home));
|
||||
let row = footer(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(
|
||||
row.contains(" :mv aaa"),
|
||||
"the window did not follow the cursor back: {row}"
|
||||
);
|
||||
}
|
||||
|
||||
/// `:` is the way in, and only from the action arms: typed into either open prompt it is
|
||||
/// an ordinary character, and pressed at an open picker it belongs to the picker.
|
||||
#[test]
|
||||
fn a_colon_typed_into_the_search_or_the_picker_opens_nothing() {
|
||||
let dir = searchable();
|
||||
// A campaign to pick, since an empty picker says so rather than opening. Its own
|
||||
// uuid, not one of the tickets': nothing here resolves either, and a shared prefix
|
||||
// in a fixture reads as a claim that it matters.
|
||||
write_campaign(
|
||||
&dir,
|
||||
"55555555-0000-4000-8000-000000000000",
|
||||
"First public release",
|
||||
"v1",
|
||||
"For a public tag.",
|
||||
);
|
||||
let mut board = one_board(&dir);
|
||||
|
||||
board.open_search();
|
||||
assert!(board.search_key(letter(':'), SCREEN), "':' was not taken by the search");
|
||||
assert!(board.prompt.is_none(), "the search prompt opened a command prompt");
|
||||
assert_eq!(board.search.as_ref().map(|search| search.query.as_str()), Some(":"));
|
||||
board.search_key(typed(KeyCode::Esc), SCREEN);
|
||||
|
||||
board.open_picker(PickerKind::Campaign, SCREEN);
|
||||
assert!(board.picker_key(letter(':'), SCREEN), "':' was not taken by the picker");
|
||||
assert!(board.prompt.is_none(), "the picker opened a command prompt");
|
||||
assert!(board.picker.is_some(), "':' closed the picker");
|
||||
|
||||
// And inside the picker's own query it is a character like any other.
|
||||
board.picker_key(letter('/'), SCREEN);
|
||||
board.picker_key(letter(':'), SCREEN);
|
||||
assert_eq!(
|
||||
board
|
||||
.picker
|
||||
.as_ref()
|
||||
.and_then(|picker| picker.query.clone())
|
||||
.as_deref(),
|
||||
Some(":"),
|
||||
);
|
||||
assert!(board.prompt.is_none(), "the picker's query opened a command prompt");
|
||||
}
|
||||
|
||||
/// The row names the keys that work, and `:` works in every state the board is in.
|
||||
#[test]
|
||||
fn every_footer_names_the_command_key() {
|
||||
let dir = searchable();
|
||||
let mut board = one_board(&dir);
|
||||
|
||||
assert!(footer(&board, 120, 20).contains(": command"), "the board's own footer");
|
||||
board.toggle_detail();
|
||||
assert!(footer(&board, 120, 20).contains(": command"), "the modal footer");
|
||||
}
|
||||
|
||||
/// The prompt has to be offered every key before the action arms, and `:` has to be the
|
||||
/// way in from the board itself. Neither is reachable from a test, so the dispatch is
|
||||
/// read as text, the way the search prompt's own contract is.
|
||||
#[test]
|
||||
fn the_dispatch_opens_the_command_prompt_and_gives_it_the_keyboard_first() {
|
||||
let source = include_str!("main.rs")
|
||||
.split_whitespace()
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
|
||||
assert!(
|
||||
source.contains("if board.prompt_key(key) { continue; }"),
|
||||
"the prompt has to be offered every key before the action arms, or typing \
|
||||
'd' into a command toggles the done column"
|
||||
);
|
||||
assert!(
|
||||
source.contains("KeyCode::Char(':') => board.open_prompt(),"),
|
||||
"`:` has to open the prompt from the action arms"
|
||||
);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ the copy key --
|
||||
|
||||
/// A sink that records what it was handed, standing in for the clipboard.
|
||||
|
||||
Reference in New Issue
Block a user