Compare commits

..
2 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 2298d3373a (8528c50) Hide the done column in the tui until d asks for it, and bump to 0.8.2
Done only grows. It already holds more tickets than the other three columns
together, so a quarter of the width was going to the column least often read
while the ones being worked got squeezed for it.

Not a new opinion: `ls` already counts done in its summary and leaves it out of
the listing below. The board now does the same, and the footer carries the
count while the column is hidden, which is the board's version of that summary
line. It reads `d show done (17)` while hidden and `d hide done` while shown,
so the count only appears where a column heading is not already carrying it.
The modal footer names the key too, since it works with a ticket open.

Hiding is a change to what is drawn, never to what is read. `reload` still
scans the done directory and `digest` still watches it, so the count is right
and revealing the column needs no rescan.

`visible()` returns a prefix of the columns rather than a filter, which is what
keeps `column` and `offsets` valid as indices into either. It is derived from
where DONE actually sits rather than assuming the last slot, and a test pins
done as last: a status inserted after it would otherwise hide two columns in
silence. DONE is now a constant, since `ls` and the board are two readers of
the same rule.

Hiding the column under the selection moves the selection to the last drawn
column and closes an open detail view. Refreshing the modal onto whichever
ticket the selection landed on was the alternative, and it swaps what someone
is reading without saying so, which is how a person acts on the wrong ticket.
Showing done again is a no-op for the selection, since a column is appended
rather than inserted.

Three existing tests asserted a column heading with `screen.contains("done
(0)")` over the whole render, and the new footer holds that string whether the
column is drawn or not, so all three passed for the wrong reason the moment
done was hidden. They now assert against the top border row through a
`headings()` helper, with `footer()` beside it.

The choice is not remembered between runs: worklane has no config file, and one
flag is not a reason to start one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-21 16:30:06 +02:00
Ansho ReiandClaude Opus 5 8013c2b74d (d8e78cd) Clear the clippy warnings, and bump to 0.8.1
`cargo clippy --all-targets` was reporting 96 warnings, 14 of them in the
binary. It is now clean from a cold cache, and the 211 tests still pass.

`clippy --fix` took the mechanical ones: needless borrows, `map_or` that is
`is_some_and`, `push_str` of a single character, manual `split_once`, and
`&PathBuf` parameters in the test fixtures. It also moved the `handlers.rs`
test module to the end of the file, which is what `items_after_test_module`
was pointing at.

Three by hand. `cmd_add` took nine parameters threaded from `main`, and now
takes `AddArgs`, which is how `set`, `append` and `check` already pass theirs;
the handler destructures it so the body reads as before, and `add --help` is
unchanged. The collapsed `if` in `content_trim` needed reindenting, since
`--fix` left its body at the old depth. And the two `split_once` rewrites read
as `.split_once(..).map(|(_, value)| value)` rather than clippy's `.map(|x|
x.1)`.

The two eight-argument `create_ticket` test fixtures keep an
`allow(too_many_arguments)` carrying the reason: the lint is right that
twenty-five positional call sites read as a wall of strings, but replacing them
with a named-field struct is a refactor and not a warning sweep. a34a316 tracks
it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-21 15:37:11 +02:00
17 changed files with 521 additions and 243 deletions
+8
View File
@@ -34,6 +34,7 @@ and this file is for what someone changing worklane's own code needs.
- Tests use `assert_cmd` and `assert_fs` for CLI testing - Tests use `assert_cmd` and `assert_fs` for CLI testing
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created - `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands) - `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
- **`cargo clippy --all-targets` is clean. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
## Coding Guidelines ## Coding Guidelines
@@ -43,6 +44,7 @@ and this file is for what someone changing worklane's own code needs.
- Prefer explicit `match` over `unwrap_or_default()` for clarity - Prefer explicit `match` over `unwrap_or_default()` for clarity
- Use `unwrap_or_else(|| expr)` for lazy defaults, `unwrap_or(val)` for eager defaults - Use `unwrap_or_else(|| expr)` for lazy defaults, `unwrap_or(val)` for eager defaults
- Use `anyhow!()` with context strings that include identifying info (e.g. UUID, title) not bare values - Use `anyhow!()` with context strings that include identifying info (e.g. UUID, title) not bare values
- A command whose arguments run past a handful takes a clap `Args` struct, not an inline variant with a matching parameter list: `AddArgs`, `SetArgs`, `AppendArgs`, `CheckArgs`. `add` was nine positional parameters threaded from `main` before it became `AddArgs`, and the handler destructures the struct so the body reads the same as before
### CLI Arguments ### CLI Arguments
- The prose arguments carry `allow_hyphen_values`, via the `PROSE` constant in `command.rs`: `add --title`, `--description`, `--acceptance`, `--plan`, and the `comment` body. Ticket text quotes flag names constantly, and without it a criterion reading `--print is supported` is parsed as a flag and the whole ticket is refused with nothing written - The prose arguments carry `allow_hyphen_values`, via the `PROSE` constant in `command.rs`: `add --title`, `--description`, `--acceptance`, `--plan`, and the `comment` body. Ticket text quotes flag names constantly, and without it a criterion reading `--print is supported` is parsed as a flag and the whole ticket is refused with nothing written
@@ -94,6 +96,12 @@ and this file is for what someone changing worklane's own code needs.
- **The footer names only keys that work.** It read `↑↓ scroll` when nothing scrolled at all, which sends the reader looking for their own mistake. A UI that misdescribes itself is worse than one that is merely incomplete - **The footer names only keys that work.** It read `↑↓ scroll` when nothing scrolled at all, which sends the reader looking for their own mistake. A UI that misdescribes itself is worse than one that is merely incomplete
- The detail view renders with colour off. ratatui draws styled spans, so an escape sequence in a paragraph would be printed as literal bytes. `content_trim` and `format_comments_with` take the colour decision for that reason - The detail view renders with colour off. ratatui draws styled spans, so an escape sequence in a paragraph would be printed as literal bytes. `content_trim` and `format_comments_with` take the colour decision for that reason
- Read only. Moving a card by keypress is a follow-up, deliberately kept out until the watch and render loop were solid - Read only. Moving a card by keypress is a follow-up, deliberately kept out until the watch and render loop were solid
- **Done is hidden until `d` asks for it.** Not a new opinion: `ls` already counts done in its summary and leaves it out of the listing. Done only grows, so a quarter of the width was going to the column least often read. The footer carries its count while it is hidden, which is the board's version of that summary line
- **Hiding is a change to what is drawn, never to what is read.** `reload` still scans the done directory and `digest` still watches it, so the footer count is right and revealing the column needs no rescan. Do not "optimise" that into a conditional scan
- `visible()` returns a prefix of `columns`, not a filter, which is what keeps `column` and `offsets` valid as indices into either. It is derived from where `DONE` actually sits rather than assuming the last slot, and `the_done_column_is_last` pins the assumption. A status inserted after done would otherwise hide two columns in silence
- Hiding the column under the selection moves the selection to the last drawn column and **closes an open detail view**. The alternative, refreshing the modal onto whichever ticket the selection landed on, swaps what someone is reading without saying so, which is how a person acts on the wrong ticket. Showing done again is a no-op for the selection, since a column is appended rather than inserted
- 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
### Shipping the Agent Assets ### Shipping the Agent Assets
- The skill is embedded with `include_str!` from `assets/SKILL.md`, not copied by an install script. `cargo install` places binaries and nothing else, so an installed document that is not in the binary is a document that drifts from it - The skill is embedded with `include_str!` from `assets/SKILL.md`, not copied by an install script. `cargo install` places binaries and nothing else, so an installed document that is not in the binary is a document that drifts from it
Generated
+1 -1
View File
@@ -1494,7 +1494,7 @@ dependencies = [
[[package]] [[package]]
name = "worklane" name = "worklane"
version = "0.8.0" version = "0.8.2"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"assert_cmd", "assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "worklane" name = "worklane"
version = "0.8.0" version = "0.8.2"
edition = "2024" edition = "2024"
[dependencies] [dependencies]
+1 -1
View File
@@ -5,7 +5,7 @@ Worklane is a local Kanban flow for agentic software development.
## Commands ## Commands
| Command | Description | | Command | Description |
|---------|-------------| |---------|-------------|
| `worklane` or `worklane tui` | Opens the board: four status columns, redrawn when the tree changes. Read only. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, `q` to quit | | `worklane` or `worklane tui` | Opens the board: four status columns, redrawn when the tree changes. Read only. Opens on backlog, committed and reviewing; `d` shows or hides done, whose count stays in the footer either way. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, `q` to quit |
| `worklane init` | Creates `.worklane/` with backlog, committed, reviewing, done directories | | `worklane init` | Creates `.worklane/` with backlog, committed, reviewing, done directories |
| `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags | | `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags |
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>` | | `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>` |
+42 -33
View File
@@ -70,39 +70,7 @@ pub enum Command {
Init, Init,
/// Add a new ticket to the backlog /// Add a new ticket to the backlog
Add { Add(AddArgs),
/// Ticket title
#[arg(short, long, allow_hyphen_values = PROSE)]
title: String,
/// Ticket description. Use multiple flags to create multiline descriptions.
#[arg(short, long, allow_hyphen_values = PROSE)]
description: Vec<String>,
/// Acceptance criteria. Accepts multiple flags, each will be interpreted as a single criterium
#[arg(short, long, allow_hyphen_values = PROSE)]
acceptance: Vec<String>,
/// Implementation plan. Accepts multiple flags, each will be interpreted as a single step
#[arg(short, long, allow_hyphen_values = PROSE)]
plan: Vec<String>,
/// Tags (comma-separated)
#[arg(short = 'g', long)]
tags: Vec<String>,
/// Due date (YYYY-MM-DD)
#[arg(long)]
due: Option<String>,
/// Owner
#[arg(short, long)]
owner: Option<String>,
/// Priority, 1 (most urgent) to 5 (least). Left unset if omitted.
#[arg(long, value_parser = priority_level)]
priority: Option<u8>,
},
/// List tickets, optionally filtered by status /// List tickets, optionally filtered by status
#[command(after_help = PRIORITY_LEGEND.as_str())] #[command(after_help = PRIORITY_LEGEND.as_str())]
@@ -176,6 +144,47 @@ pub enum Command {
}, },
} }
/// `add` carries every field a new ticket can hold, so it is a struct rather than an
/// inline variant: nine parameters at the call site is what `too_many_arguments` is
/// for, and `set`, `append` and `check` already pass their arguments this way.
///
/// No `ArgGroup`: `--title` is required on its own, and everything else is optional
/// because a ticket with only a title is a valid thing to file.
#[derive(clap::Args)]
pub struct AddArgs {
/// Ticket title
#[arg(short, long, allow_hyphen_values = PROSE)]
pub title: String,
/// Ticket description. Use multiple flags to create multiline descriptions.
#[arg(short, long, allow_hyphen_values = PROSE)]
pub description: Vec<String>,
/// Acceptance criteria. Accepts multiple flags, each will be interpreted as a single criterium
#[arg(short, long, allow_hyphen_values = PROSE)]
pub acceptance: Vec<String>,
/// Implementation plan. Accepts multiple flags, each will be interpreted as a single step
#[arg(short, long, allow_hyphen_values = PROSE)]
pub plan: Vec<String>,
/// Tags (comma-separated)
#[arg(short = 'g', long)]
pub tags: Vec<String>,
/// Due date (YYYY-MM-DD)
#[arg(long)]
pub due: Option<String>,
/// Owner
#[arg(short, long)]
pub owner: Option<String>,
/// Priority, 1 (most urgent) to 5 (least). Left unset if omitted.
#[arg(long, value_parser = priority_level)]
pub priority: Option<u8>,
}
/// `set` replaces a field outright. Owner is deliberately absent: `chown` owns that /// `set` replaces a field outright. Owner is deliberately absent: `chown` owns that
/// field, and status is `mv`'s, so no field has two writers. /// field, and status is `mv`'s, so no field has two writers.
/// ///
+54 -51
View File
@@ -4,7 +4,7 @@ use std::fs;
use std::io::{BufRead, IsTerminal, Write}; use std::io::{BufRead, IsTerminal, Write};
use std::path::Path; use std::path::Path;
use crate::command::{AppendArgs, CheckArgs, SetArgs}; use crate::command::{AddArgs, AppendArgs, CheckArgs, SetArgs};
use crate::install; use crate::install;
use crate::util::*; use crate::util::*;
@@ -71,7 +71,7 @@ pub fn cmd_ls(
// Show all tickets except done grouped by status // Show all tickets except done grouped by status
for status in &statuses { for status in &statuses {
if *status == "done" { if *status == DONE {
continue; continue;
} }
let status_path = worklane_dir.join(status); let status_path = worklane_dir.join(status);
@@ -105,17 +105,18 @@ fn filter_by_priority(items: Vec<TicketItem>, level: Option<u8>) -> Vec<TicketIt
} }
} }
pub fn cmd_add( pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
title: &str, let AddArgs {
description: &[String], title,
acceptance: &[String], description,
plan: &[String], acceptance,
tags: &[String], plan,
due: &Option<String>, tags,
owner: &Option<String>, due,
priority: Option<u8>, owner,
start: &Path, priority,
) -> Result<()> { } = args;
let owner = match owner { let owner = match owner {
Some(o) => Some(o.clone()), Some(o) => Some(o.clone()),
None => get_git_user(), None => get_git_user(),
@@ -222,7 +223,7 @@ pub fn read_comments(comments_dir: &Path) -> Result<Vec<(String, String, String,
for entry in fs::read_dir(comments_dir)? { for entry in fs::read_dir(comments_dir)? {
let entry = entry?; let entry = entry?;
let path = entry.path(); let path = entry.path();
if path.extension().map_or(false, |e| e == "md") { if path.extension().is_some_and(|e| e == "md") {
let content = fs::read_to_string(&path)?; let content = fs::read_to_string(&path)?;
let filename = path let filename = path
.file_stem() .file_stem()
@@ -232,14 +233,16 @@ pub fn read_comments(comments_dir: &Path) -> Result<Vec<(String, String, String,
let author = content let author = content
.lines() .lines()
.find(|l| l.starts_with("**Author**")) .find(|l| l.starts_with("**Author**"))
.and_then(|l| l.splitn(2, "**Author**:").nth(1)) .and_then(|l| l.split_once("**Author**:"))
.map(|(_, value)| value)
.map(|s| s.trim().to_string()) .map(|s| s.trim().to_string())
.unwrap_or_else(|| "unknown".to_string()); .unwrap_or_else(|| "unknown".to_string());
let time = content let time = content
.lines() .lines()
.find(|l| l.starts_with("**Time**")) .find(|l| l.starts_with("**Time**"))
.and_then(|l| l.splitn(2, "**Time**:").nth(1)) .and_then(|l| l.split_once("**Time**:"))
.map(|(_, value)| value)
.map(|s| s.trim().to_string()) .map(|s| s.trim().to_string())
.unwrap_or_else(|| "unknown".to_string()); .unwrap_or_else(|| "unknown".to_string());
@@ -372,7 +375,7 @@ fn find_ticket_file(dir: &Path, uuid: &str, title: &str) -> Result<String> {
for entry in fs::read_dir(dir)? { for entry in fs::read_dir(dir)? {
let entry = entry?; let entry = entry?;
let path = entry.path(); let path = entry.path();
if !path.extension().map_or(false, |e| e == "md") { if !path.extension().is_some_and(|e| e == "md") {
continue; continue;
} }
@@ -472,7 +475,7 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
if current_status == target_status { if current_status == target_status {
println!( println!(
"Ticket is already in '{}' status.", "Ticket is already in '{}' status.",
color_text(&target_status, Color::Orange) color_text(target_status, Color::Orange)
); );
return Ok(()); return Ok(());
} }
@@ -506,39 +509,6 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
Ok(()) Ok(())
} }
#[cfg(test)]
mod tests {
use super::*;
/// The collision path cannot be provoked from the CLI, since two processes
/// will not share a microsecond, but it is the whole point of the guard.
#[test]
fn a_colliding_stem_takes_the_next_name_and_keeps_the_first() {
let dir = std::env::temp_dir().join(format!("worklane-test-{}", uuid::Uuid::new_v4()));
fs::create_dir_all(&dir).unwrap();
let first = write_new_comment(&dir, "20260820_143012_123456", "first").unwrap();
let second = write_new_comment(&dir, "20260820_143012_123456", "second").unwrap();
let third = write_new_comment(&dir, "20260820_143012_123456", "third").unwrap();
assert_eq!(first, "20260820_143012_123456.md");
assert_eq!(second, "20260820_143012_123456_01.md");
assert_eq!(third, "20260820_143012_123456_02.md");
// Nothing was truncated on the way through
assert_eq!(fs::read_to_string(dir.join(&first)).unwrap(), "first");
assert_eq!(fs::read_to_string(dir.join(&second)).unwrap(), "second");
assert_eq!(fs::read_to_string(dir.join(&third)).unwrap(), "third");
// read_comments sorts on the stem, so the names must sort in write order
let mut names = vec![second.clone(), third.clone(), first.clone()];
names.sort();
assert_eq!(names, vec![first, second, third]);
fs::remove_dir_all(&dir).unwrap();
}
}
pub fn cmd_comment( pub fn cmd_comment(
ticket_id: &str, ticket_id: &str,
body: &str, body: &str,
@@ -899,3 +869,36 @@ pub fn cmd_install_skill(force: bool, print: bool) -> Result<()> {
Ok(()) Ok(())
} }
#[cfg(test)]
mod tests {
use super::*;
/// The collision path cannot be provoked from the CLI, since two processes
/// will not share a microsecond, but it is the whole point of the guard.
#[test]
fn a_colliding_stem_takes_the_next_name_and_keeps_the_first() {
let dir = std::env::temp_dir().join(format!("worklane-test-{}", uuid::Uuid::new_v4()));
fs::create_dir_all(&dir).unwrap();
let first = write_new_comment(&dir, "20260820_143012_123456", "first").unwrap();
let second = write_new_comment(&dir, "20260820_143012_123456", "second").unwrap();
let third = write_new_comment(&dir, "20260820_143012_123456", "third").unwrap();
assert_eq!(first, "20260820_143012_123456.md");
assert_eq!(second, "20260820_143012_123456_01.md");
assert_eq!(third, "20260820_143012_123456_02.md");
// Nothing was truncated on the way through
assert_eq!(fs::read_to_string(dir.join(&first)).unwrap(), "first");
assert_eq!(fs::read_to_string(dir.join(&second)).unwrap(), "second");
assert_eq!(fs::read_to_string(dir.join(&third)).unwrap(), "third");
// read_comments sorts on the stem, so the names must sort in write order
let mut names = vec![second.clone(), third.clone(), first.clone()];
names.sort();
assert_eq!(names, vec![first, second, third]);
fs::remove_dir_all(&dir).unwrap();
}
}
+3 -20
View File
@@ -41,26 +41,7 @@ fn main() -> Result<()> {
// No subcommand opens the board, the way a bare `frig` does. // No subcommand opens the board, the way a bare `frig` does.
None | Some(Command::Tui) => run_tui(&start), None | Some(Command::Tui) => run_tui(&start),
Some(Command::Init) => cmd_init(&start), Some(Command::Init) => cmd_init(&start),
Some(Command::Add { Some(Command::Add(args)) => cmd_add(&args, &start),
title,
description,
acceptance,
plan,
tags,
due,
owner,
priority,
}) => cmd_add(
&title,
&description,
&acceptance,
&plan,
&tags,
&due,
&owner,
priority,
&start,
),
Some(Command::Ls { status, priority }) => { Some(Command::Ls { status, priority }) => {
let worklane_dir = find_worklane_dir(&start)?; let worklane_dir = find_worklane_dir(&start)?;
cmd_ls(&status, priority, &worklane_dir) cmd_ls(&status, priority, &worklane_dir)
@@ -180,6 +161,8 @@ fn run_tui(start: &std::path::Path) -> Result<()> {
KeyCode::Down | KeyCode::Char('j') => board.select_card(1, screen), KeyCode::Down | KeyCode::Char('j') => board.select_card(1, screen),
KeyCode::PageUp => board.scroll_detail(-1, screen), KeyCode::PageUp => board.scroll_detail(-1, screen),
KeyCode::PageDown => board.scroll_detail(1, screen), KeyCode::PageDown => board.scroll_detail(1, screen),
// Free of the other bindings, and the footer names it in both states.
KeyCode::Char('d') => board.toggle_done(screen),
_ => {} _ => {}
} }
} }
+276 -20
View File
@@ -42,6 +42,9 @@ pub struct Board {
pub detail: Option<String>, pub detail: Option<String>,
/// First visible line of the detail view, counted in wrapped lines. /// First visible line of the detail view, counted in wrapped lines.
pub offset: u16, pub offset: u16,
/// 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.
pub show_done: bool,
pub should_quit: bool, pub should_quit: bool,
worklane_dir: PathBuf, worklane_dir: PathBuf,
digest: u64, digest: u64,
@@ -56,6 +59,7 @@ impl Board {
offsets: Vec::new(), offsets: Vec::new(),
detail: None, detail: None,
offset: 0, offset: 0,
show_done: false,
should_quit: false, should_quit: false,
worklane_dir: worklane_dir.to_path_buf(), worklane_dir: worklane_dir.to_path_buf(),
digest: 0, digest: 0,
@@ -109,15 +113,63 @@ impl Board {
Ok(()) Ok(())
} }
/// The columns that are drawn: all of them, or everything up to done.
///
/// A prefix rather than a filter, which is what keeps `column` and `offsets` usable
/// as indices into either. Taken from where done actually is instead of assuming the
/// last slot, with a test pinning done as last so the two cannot drift apart.
pub fn visible(&self) -> &[Column] {
&self.columns[..self.visible_count()]
}
fn visible_count(&self) -> usize {
if self.show_done {
return self.columns.len();
}
match self.columns.iter().position(|column| column.status == DONE) {
Some(index) => index,
None => self.columns.len(),
}
}
/// Show or hide the done column.
///
/// `ls` already holds this opinion: it counts done in its summary and leaves it out
/// of the listing. Done only grows, so a quarter of the width goes to the column
/// least often read while the three being worked get squeezed for it.
///
/// Hiding is a change to what is drawn, never to what is read. The directory stays
/// scanned and stays in the digest, so the count in the footer is right and revealing
/// the column needs no rescan.
pub fn toggle_done(&mut self, screen: Size) {
self.show_done = !self.show_done;
// Showing done again appends a column, so nothing below is reached and the
// selection stays exactly where it was.
if self.column < self.visible_count() {
return;
}
// Hiding the column the selection is in moves it to the last one still drawn.
// An open detail closes with it: it is showing a ticket that is no longer on the
// board, and quietly swapping it for a different ticket is worse than closing.
self.clamp();
self.detail = None;
self.offset = 0;
self.follow_selection(screen);
}
/// Keep the selection on a card that exists, after the board changes under it. /// Keep the selection on a card that exists, after the board changes under it.
fn clamp(&mut self) { fn clamp(&mut self) {
if self.columns.is_empty() { let visible = self.visible_count();
if visible == 0 {
self.column = 0; self.column = 0;
self.card = 0; self.card = 0;
return; return;
} }
self.column = self.column.min(self.columns.len() - 1); self.column = self.column.min(visible - 1);
let count = self.columns[self.column].tickets.len(); let count = self.columns[self.column].tickets.len();
self.card = match count { self.card = match count {
0 => 0, 0 => 0,
@@ -133,11 +185,12 @@ impl Board {
/// Move between columns, keeping the card index where it can land. /// Move between columns, keeping the card index where it can land.
pub fn select_column(&mut self, delta: isize, screen: Size) { pub fn select_column(&mut self, delta: isize, screen: Size) {
if self.columns.is_empty() { if self.visible_count() == 0 {
return; return;
} }
let last = self.columns.len() as isize - 1; // Bounded by what is drawn, so the selection cannot walk into a hidden column.
let last = self.visible_count() as isize - 1;
let next = (self.column as isize + delta).clamp(0, last); let next = (self.column as isize + delta).clamp(0, last);
self.column = next as usize; self.column = next as usize;
self.clamp(); self.clamp();
@@ -326,10 +379,12 @@ pub fn draw(frame: &mut Frame, board: &Board) {
} }
fn draw_columns(frame: &mut Frame, board: &Board, area: Rect) { fn draw_columns(frame: &mut Frame, board: &Board, area: Rect) {
let widths: Vec<Constraint> = board // Only the drawn columns are measured, so hiding done gives its width back to the
.columns // three that are left rather than leaving a gap where it was.
let columns = board.visible();
let widths: Vec<Constraint> = columns
.iter() .iter()
.map(|_| Constraint::Ratio(1, board.columns.len().max(1) as u32)) .map(|_| Constraint::Ratio(1, columns.len().max(1) as u32))
.collect(); .collect();
let areas = Layout::default() let areas = Layout::default()
@@ -337,7 +392,7 @@ fn draw_columns(frame: &mut Frame, board: &Board, area: Rect) {
.constraints(widths) .constraints(widths)
.split(area); .split(area);
for (index, column) in board.columns.iter().enumerate() { for (index, column) in columns.iter().enumerate() {
let focused = index == board.column; let focused = index == board.column;
let title = format!(" {} ({}) ", column.status, column.tickets.len()); let title = format!(" {} ({}) ", column.status, column.tickets.len());
@@ -464,9 +519,16 @@ fn card_lines(ticket: &TicketItem, selected: bool) -> Vec<Line<'static>> {
} }
fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) { fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
// 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 {
true => "d hide done".to_string(),
false => format!("d show done ({})", done_count(board)),
};
let keys = match board.detail { let keys = match board.detail {
Some(_) => " ←→↑↓ select pgup/pgdn scroll enter close q quit ", Some(_) => format!(" ←→↑↓ select pgup/pgdn scroll enter close {done} q quit "),
None => " ←→ column ↑↓ card enter detail q quit ", None => format!(" ←→ column ↑↓ card enter detail {done} q quit "),
}; };
frame.render_widget( frame.render_widget(
@@ -475,6 +537,15 @@ fn draw_footer(frame: &mut Frame, board: &Board, area: Rect) {
); );
} }
/// How many tickets are in done, drawn or not.
fn done_count(board: &Board) -> usize {
board
.columns
.iter()
.find(|column| column.status == DONE)
.map_or(0, |column| column.tickets.len())
}
/// Where the detail overlay sits in the frame. /// Where the detail overlay sits in the frame.
/// ///
/// Inset, so the board stays visible around the edges and the overlay reads as one. /// Inset, so the board stays visible around the edges and the overlay reads as one.
@@ -596,20 +667,201 @@ mod tests {
.collect() .collect()
} }
/// The column headings, which sit on the top border row.
///
/// That row alone, because the footer names done as well: a whole-screen search for
/// `done (0)` passes on the footer whether the column is drawn or not, which is how
/// three of these tests came to be vacuous the moment done was hidden.
fn headings(board: &Board, width: u16, height: u16) -> String {
render(board, width, height).remove(0)
}
fn footer(board: &Board, width: u16, height: u16) -> String {
render(board, width, height).pop().expect("no rows rendered")
}
#[test] #[test]
fn the_board_draws_the_four_statuses_as_columns() { fn the_board_draws_the_four_statuses_as_columns_once_done_is_shown() {
let dir = board_dir(); let dir = board_dir();
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", ""); write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
write_ticket(&dir, "committed", "22222222-0000-4000-8000-000000000000", "Second one", ""); write_ticket(&dir, "committed", "22222222-0000-4000-8000-000000000000", "Second one", "");
let board = Board::new(&dir).unwrap(); let mut board = Board::new(&dir).unwrap();
let screen = render(&board, 120, 20).join("\n"); board.toggle_done(SCREEN);
let row = headings(&board, 120, 20);
for heading in ["backlog (1)", "committed (1)", "reviewing (0)", "done (0)"] { for heading in ["backlog (1)", "committed (1)", "reviewing (0)", "done (0)"] {
assert!(screen.contains(heading), "no {heading:?} in:\n{screen}"); assert!(row.contains(heading), "no {heading:?} in:\n{row}");
} }
} }
/// Done only grows, and it is the column least often read. `ls` already leaves it
/// out of its listing while counting it in the summary; this is the same opinion.
#[test]
fn the_board_opens_with_the_done_column_hidden() {
let dir = board_dir();
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Finished one", "");
let board = Board::new(&dir).unwrap();
assert!(!board.show_done, "done was drawn at startup");
let row = headings(&board, 120, 20);
for heading in ["backlog (1)", "committed (0)", "reviewing (0)"] {
assert!(row.contains(heading), "no {heading:?} in:\n{row}");
}
assert!(!row.contains("done"), "done is still a column:\n{row}");
// Hidden, not unread: the count is right and revealing it needs no rescan.
assert_eq!(board.columns.len(), 4);
assert_eq!(board.visible().len(), 3);
assert_eq!(done_count(&board), 1);
assert!(
!render(&board, 120, 20).join("\n").contains("Finished one"),
"a hidden done ticket was drawn"
);
}
/// The three that are left take the width done was using, rather than leaving a gap.
#[test]
fn the_visible_columns_share_the_full_width() {
let dir = board_dir();
let mut board = Board::new(&dir).unwrap();
let hidden = headings(&board, 120, 20);
assert_eq!(hidden.matches('┌').count(), 3, "{hidden}");
assert!(hidden.ends_with('┐'), "the columns stop short of the edge:\n{hidden}");
board.toggle_done(SCREEN);
let shown = headings(&board, 120, 20);
assert_eq!(shown.matches('┌').count(), 4, "{shown}");
assert!(shown.ends_with('┐'), "{shown}");
}
/// Hiding is a prefix of the columns, which only holds while done is last. The
/// board leans on that, so the assumption is pinned rather than assumed.
#[test]
fn the_done_column_is_last() {
assert_eq!(status_dirs().last(), Some(&DONE));
}
#[test]
fn the_footer_names_the_key_and_carries_the_count_while_done_is_hidden() {
let dir = board_dir();
for (n, title) in [("44444444", "One"), ("55555555", "Two")] {
write_ticket(&dir, "done", &format!("{n}-0000-4000-8000-000000000000"), title, "");
}
let mut board = Board::new(&dir).unwrap();
let hidden = footer(&board, 120, 20);
assert!(hidden.contains("d show done (2)"), "{hidden}");
board.toggle_done(SCREEN);
let shown = footer(&board, 120, 20);
assert!(shown.contains("d hide done"), "{shown}");
// With the column drawn, its own heading carries the count.
assert!(!shown.contains("(2)"), "the count is printed twice:\n{shown}");
}
/// The modal footer names it too, since the key works with a ticket open.
#[test]
fn the_detail_footer_also_names_the_done_key() {
let dir = board_dir();
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let mut board = Board::new(&dir).unwrap();
board.toggle_detail();
let row = footer(&board, 120, 20);
assert!(row.contains("d show done (0)"), "{row}");
assert!(row.contains("pgup/pgdn scroll"), "{row}");
}
/// Hiding the column under the selection has to move it, or it points at nothing.
#[test]
fn hiding_done_under_the_selection_moves_it_to_the_last_visible_column() {
let dir = board_dir();
write_ticket(&dir, "reviewing", "33333333-0000-4000-8000-000000000000", "Ready", "");
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Finished", "");
let mut board = Board::new(&dir).unwrap();
board.toggle_done(SCREEN);
board.select_column(3, SCREEN);
assert_eq!(board.selected().map(|t| t.title.clone()), Some("Finished".to_string()));
board.toggle_done(SCREEN);
assert_eq!(board.column, 2, "the selection stayed on a column that is gone");
assert_eq!(board.selected().map(|t| t.title.clone()), Some("Ready".to_string()));
}
/// And an open detail of a done ticket goes with it: showing a ticket that is no
/// longer on the board is worse than closing, and swapping it for a different
/// ticket without saying so is worse than both.
#[test]
fn hiding_done_closes_a_detail_view_of_a_done_ticket() {
let dir = board_dir();
write_ticket(&dir, "reviewing", "33333333-0000-4000-8000-000000000000", "Ready", "");
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Finished", "");
let mut board = Board::new(&dir).unwrap();
board.toggle_done(SCREEN);
board.select_column(3, SCREEN);
board.toggle_detail();
assert!(board.detail.is_some());
board.toggle_done(SCREEN);
assert!(board.detail.is_none(), "{:?}", board.detail);
}
/// A ticket being read in a column that is not going anywhere stays open.
#[test]
fn hiding_done_leaves_a_detail_view_of_another_ticket_open() {
let dir = board_dir();
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let mut board = Board::new(&dir).unwrap();
board.toggle_detail();
board.toggle_done(SCREEN);
board.toggle_done(SCREEN);
assert!(board.detail.is_some(), "an unrelated detail view was closed");
}
/// Done is appended rather than inserted, so showing it moves nothing.
#[test]
fn showing_done_again_leaves_the_selection_where_it_was() {
let dir = board_dir();
write_ticket(&dir, "committed", "22222222-0000-4000-8000-000000000000", "Alpha", "");
write_ticket(&dir, "committed", "33333333-0000-4000-8000-000000000000", "Beta", "");
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Finished", "");
let mut board = Board::new(&dir).unwrap();
board.select_column(1, SCREEN);
board.select_card(1, SCREEN);
let (column, card) = (board.column, board.card);
board.toggle_done(SCREEN);
assert_eq!((board.column, board.card), (column, card));
assert_eq!(board.selected().map(|t| t.title.clone()), Some("Beta".to_string()));
}
/// The selection cannot walk into a column that is not drawn.
#[test]
fn the_selection_stops_at_the_last_visible_column() {
let dir = board_dir();
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Finished", "");
let mut board = Board::new(&dir).unwrap();
board.select_column(9, SCREEN);
assert_eq!(board.column, 2);
assert!(board.selected().is_none(), "the selection reached the done column");
board.toggle_done(SCREEN);
board.select_column(9, SCREEN);
assert_eq!(board.column, 3);
assert_eq!(board.selected().map(|t| t.title.clone()), Some("Finished".to_string()));
}
/// The card has to carry enough to identify the ticket without opening it. /// The card has to carry enough to identify the ticket without opening it.
#[test] #[test]
fn a_card_shows_the_short_id_title_owner_and_due() { fn a_card_shows_the_short_id_title_owner_and_due() {
@@ -630,12 +882,13 @@ mod tests {
fn an_empty_status_renders_as_an_empty_column() { fn an_empty_status_renders_as_an_empty_column() {
let dir = board_dir(); let dir = board_dir();
let board = Board::new(&dir).unwrap(); let mut board = Board::new(&dir).unwrap();
assert_eq!(board.columns.len(), 4); assert_eq!(board.columns.len(), 4);
let screen = render(&board, 120, 20).join("\n"); board.toggle_done(SCREEN);
let row = headings(&board, 120, 20);
for status in status_dirs() { for status in status_dirs() {
assert!(screen.contains(&format!("{status} (0)")), "{screen}"); assert!(row.contains(&format!("{status} (0)")), "{row}");
} }
} }
@@ -643,11 +896,13 @@ mod tests {
#[test] #[test]
fn a_missing_status_directory_is_still_a_column() { fn a_missing_status_directory_is_still_a_column() {
let dir = board_dir(); let dir = board_dir();
std::fs::remove_dir_all(dir.join("done")).unwrap(); std::fs::remove_dir_all(dir.join(DONE)).unwrap();
let board = Board::new(&dir).unwrap(); let mut board = Board::new(&dir).unwrap();
assert_eq!(board.columns.len(), 4); assert_eq!(board.columns.len(), 4);
assert!(render(&board, 120, 20).join("\n").contains("done (0)"));
board.toggle_done(SCREEN);
assert!(headings(&board, 120, 20).contains("done (0)"));
} }
#[test] #[test]
@@ -1244,4 +1499,5 @@ mod tests {
assert_ne!(tui, ratatui::style::Color::Reset, "level {level} has no colour"); assert_ne!(tui, ratatui::style::Color::Reset, "level {level} has no colour");
} }
} }
} }
+22 -11
View File
@@ -189,7 +189,7 @@ pub fn slug(title: &str) -> String {
pub fn get_git_user() -> Option<String> { pub fn get_git_user() -> Option<String> {
std::process::Command::new("git") std::process::Command::new("git")
.args(&["config", "user.name"]) .args(["config", "user.name"])
.output() .output()
.ok() .ok()
.and_then(|out| { .and_then(|out| {
@@ -256,7 +256,7 @@ pub fn resolve_ticket(search: &str, worklane_dir: &Path) -> Result<(String, Stri
let entries = fs::read_dir(&status_path)?; let entries = fs::read_dir(&status_path)?;
for entry in entries.filter_map(|e| e.ok()) { for entry in entries.filter_map(|e| e.ok()) {
let path = entry.path(); let path = entry.path();
if !path.extension().map_or(false, |e| e == "md") { if !path.extension().is_some_and(|e| e == "md") {
continue; continue;
} }
let content = match fs::read_to_string(&path) { let content = match fs::read_to_string(&path) {
@@ -326,16 +326,16 @@ pub fn format_comments_with(
} }
let mut result = String::new(); let mut result = String::new();
result.push_str("\n"); result.push('\n');
result.push_str(&paint("COMMENTS", Color::Orange, colored)); result.push_str(&paint("COMMENTS", Color::Orange, colored));
result.push_str(&format!("\n{}\n", "─".repeat(20))); result.push_str(&format!("\n{}\n", "─".repeat(20)));
for (_filename, author, time, body) in comments { for (_filename, author, time, body) in comments {
result.push_str("\n"); result.push('\n');
result.push_str(&paint(&format!("From {} ({})", author, time), Color::Cyan, colored)); result.push_str(&paint(&format!("From {} ({})", author, time), Color::Cyan, colored));
result.push_str("\n"); result.push('\n');
if !body.is_empty() { if !body.is_empty() {
result.push_str(&" ".to_string()); result.push_str(" ");
result.push_str(body); result.push_str(body);
} }
result.push('\n'); result.push('\n');
@@ -429,8 +429,11 @@ pub fn content_trim(content: &str, colored: bool) -> String {
} }
// Standard markdown link colorization in cyan // Standard markdown link colorization in cyan
if line.contains("[") && line.contains("(") && line.contains("]") { if line.contains("[")
if let Some(start) = line.find("[") { && line.contains("(")
&& line.contains("]")
&& let Some(start) = line.find("[")
{
let bracket_text = &line[start..]; let bracket_text = &line[start..];
if let Some(end_bracket) = bracket_text.find("](") { if let Some(end_bracket) = bracket_text.find("](") {
let link_start = start + end_bracket + 1; let link_start = start + end_bracket + 1;
@@ -442,7 +445,6 @@ pub fn content_trim(content: &str, colored: bool) -> String {
} }
} }
} }
}
// Regular content - colorize **bold** in magenta // Regular content - colorize **bold** in magenta
result.push_str(&colorize_bold(line, colored)); result.push_str(&colorize_bold(line, colored));
@@ -453,7 +455,7 @@ pub fn content_trim(content: &str, colored: bool) -> String {
} }
pub fn colorize_ordered(line: &str) -> String { pub fn colorize_ordered(line: &str) -> String {
if line.chars().next().map_or(true, |c| !c.is_ascii_digit()) { if line.chars().next().is_none_or(|c| !c.is_ascii_digit()) {
return line.to_string(); return line.to_string();
} }
@@ -1093,9 +1095,18 @@ pub fn trim_blank_ends(values: &[String]) -> &[String] {
} }
pub fn status_dirs() -> Vec<&'static str> { pub fn status_dirs() -> Vec<&'static str> {
vec!["backlog", "committed", "reviewing", "done"] vec!["backlog", "committed", "reviewing", DONE]
} }
/// The end of the flow, and the one status both views treat differently: `ls` counts it
/// in the summary and leaves it out of the listing, and the board hides its column until
/// asked. Named because that rule now has two readers.
///
/// It is deliberately last in `status_dirs()`. The board leans on that: hiding done drops
/// the final column, so the other three keep their indices and the selection only has to
/// be handled when it is sitting on done itself.
pub const DONE: &str = "done";
/// Lowest and highest level a ticket can carry. 1 is the most urgent, which is /// Lowest and highest level a ticket can carry. 1 is the most urgent, which is
/// what the `p1` to `p3` tags this replaced already meant. /// what the `p1` to `p3` tags this replaced already meant.
pub const PRIORITY_RANGE: std::ops::RangeInclusive<u8> = 1..=5; pub const PRIORITY_RANGE: std::ops::RangeInclusive<u8> = 1..=5;
+21 -21
View File
@@ -2,7 +2,7 @@ use assert_cmd::Command;
use assert_fs::fixture::{PathChild, PathCreateDir}; use assert_fs::fixture::{PathChild, PathCreateDir};
use assert_fs::TempDir; use assert_fs::TempDir;
use std::fs; use std::fs;
use std::path::PathBuf; use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane"); const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
@@ -23,7 +23,7 @@ fn add_creates_ticket_in_backlog() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("add") .arg("add")
.args(["--title", "Test ticket"]) .args(["--title", "Test ticket"])
.assert() .assert()
@@ -46,7 +46,7 @@ fn add_formats_ticket_correctly() {
setup_worklane(&temp); setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args([ .args([
"add", "add",
"--title", "--title",
@@ -103,7 +103,7 @@ fn add_joins_multiple_descriptions() {
setup_worklane(&temp); setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args([ .args([
"add", "add",
"--title", "Multi desc ticket", "--title", "Multi desc ticket",
@@ -132,7 +132,7 @@ fn add_with_optional_fields_uses_defaults() {
setup_worklane(&temp); setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Minimal ticket"]) .args(["add", "--title", "Minimal ticket"])
.assert() .assert()
.success(); .success();
@@ -156,13 +156,13 @@ fn add_allows_duplicate_titles() {
setup_worklane(&temp); setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Existing title"]) .args(["add", "--title", "Existing title"])
.assert() .assert()
.success(); .success();
let mut cmd2 = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd2 = Command::cargo_bin(BIN_NAME).unwrap();
cmd2.current_dir(&temp.path()) cmd2.current_dir(temp.path())
.args(["add", "--title", "Existing title"]) .args(["add", "--title", "Existing title"])
.assert() .assert()
.success(); .success();
@@ -182,7 +182,7 @@ fn add_file_has_uuid_prefix() {
setup_worklane(&temp); setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "UUID test"]) .args(["add", "--title", "UUID test"])
.assert() .assert()
.success(); .success();
@@ -207,7 +207,7 @@ fn add_writes_the_priority_field() {
Command::cargo_bin(BIN_NAME) Command::cargo_bin(BIN_NAME)
.unwrap() .unwrap()
.current_dir(&temp.path()) .current_dir(temp.path())
.args(["add", "--title", "Urgent thing", "--priority", "1"]) .args(["add", "--title", "Urgent thing", "--priority", "1"])
.assert() .assert()
.success(); .success();
@@ -227,7 +227,7 @@ fn add_leaves_priority_unset_when_omitted() {
Command::cargo_bin(BIN_NAME) Command::cargo_bin(BIN_NAME)
.unwrap() .unwrap()
.current_dir(&temp.path()) .current_dir(temp.path())
.args(["add", "--title", "Whenever"]) .args(["add", "--title", "Whenever"])
.assert() .assert()
.success(); .success();
@@ -250,7 +250,7 @@ fn add_rejects_a_level_outside_the_range() {
// read as a flag. // read as a flag.
for bad in ["0", "6", "high", "-1"] { for bad in ["0", "6", "high", "-1"] {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Bad level", &format!("--priority={bad}")]) .args(["add", "--title", "Bad level", &format!("--priority={bad}")])
.assert() .assert()
.failure(); .failure();
@@ -272,7 +272,7 @@ fn add_accepts_prose_values_that_begin_with_a_hyphen() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "-t is a flag name"]) .args(["add", "--title", "-t is a flag name"])
.args(["--description", "-x does nothing"]) .args(["--description", "-x does nothing"])
.args(["--acceptance", "--print should be supported"]) .args(["--acceptance", "--print should be supported"])
@@ -300,7 +300,7 @@ fn add_still_accepts_the_equals_form() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title=-x equals form"]) .args(["add", "--title=-x equals form"])
.args(["--acceptance=--print via equals"]) .args(["--acceptance=--print via equals"])
.assert() .assert()
@@ -322,7 +322,7 @@ fn add_stores_a_title_that_is_only_hyphens() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", bare]) .args(["add", "--title", bare])
.assert() .assert()
.success(); .success();
@@ -344,7 +344,7 @@ fn add_still_rejects_a_mistyped_flag_on_a_non_prose_argument() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Mistyped", flag, "--bogus"]) .args(["add", "--title", "Mistyped", flag, "--bogus"])
.assert() .assert()
.failure(); .failure();
@@ -363,7 +363,7 @@ fn add_rejects_arguments_after_a_bare_separator() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Sep", "--", "--title", "second"]) .args(["add", "--title", "Sep", "--", "--title", "second"])
.assert() .assert()
.failure(); .failure();
@@ -372,7 +372,7 @@ fn add_rejects_arguments_after_a_bare_separator() {
assert_eq!(count, 0); assert_eq!(count, 0);
} }
fn only_ticket(worklane: &PathBuf) -> String { fn only_ticket(worklane: &Path) -> String {
let files: Vec<_> = fs::read_dir(worklane.join("backlog")) let files: Vec<_> = fs::read_dir(worklane.join("backlog"))
.unwrap() .unwrap()
.filter_map(|e| e.ok()) .filter_map(|e| e.ok())
@@ -390,7 +390,7 @@ fn add_keeps_a_paragraph_break_in_the_description() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Two Paras"]) .args(["add", "--title", "Two Paras"])
.args(["--description", "First paragraph."]) .args(["--description", "First paragraph."])
.args(["--description", ""]) .args(["--description", ""])
@@ -406,7 +406,7 @@ fn add_keeps_a_paragraph_break_in_the_description() {
// And it survives the round trip back out // And it survives the round trip back out
let mut show = Command::cargo_bin(BIN_NAME).unwrap(); let mut show = Command::cargo_bin(BIN_NAME).unwrap();
show.current_dir(&temp.path()).args(["show", "Two Paras"]); show.current_dir(temp.path()).args(["show", "Two Paras"]);
let stdout = String::from_utf8(show.assert().success().get_output().stdout.clone()).unwrap(); let stdout = String::from_utf8(show.assert().success().get_output().stdout.clone()).unwrap();
assert!( assert!(
stdout.contains("First paragraph.\n\nSecond paragraph."), stdout.contains("First paragraph.\n\nSecond paragraph."),
@@ -421,7 +421,7 @@ fn add_discards_blank_descriptions_at_either_end() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Padded"]) .args(["add", "--title", "Padded"])
.args(["--description", ""]) .args(["--description", ""])
.args(["--description", " "]) .args(["--description", " "])
@@ -444,7 +444,7 @@ fn add_treats_an_all_blank_description_as_none() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["add", "--title", "Blank"]) .args(["add", "--title", "Blank"])
.args(["--description", ""]) .args(["--description", ""])
.args(["--description", " "]) .args(["--description", " "])
+4 -4
View File
@@ -2,7 +2,7 @@ use assert_cmd::Command;
use assert_fs::TempDir; use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir}; use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs; use std::fs;
use std::path::PathBuf; use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane"); const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
const UUID: &str = "475534a3-8a0d-45cb-9a97-39c251dd8e39"; const UUID: &str = "475534a3-8a0d-45cb-9a97-39c251dd8e39";
@@ -20,7 +20,7 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
/// One criterion already ticked, one handwritten line inside the section, and a /// One criterion already ticked, one handwritten line inside the section, and a
/// checkbox in the description that must not be counted as a criterion. /// checkbox in the description that must not be counted as a criterion.
fn create_ticket(worklane: &PathBuf) { fn create_ticket(worklane: &Path) {
// Written without line continuations on purpose: a trailing `\` strips the next // Written without line continuations on purpose: a trailing `\` strips the next
// line's leading whitespace, so the indented line would arrive unindented and the // line's leading whitespace, so the indented line would arrive unindented and the
// test would prove nothing about preserving it. // test would prove nothing about preserving it.
@@ -55,11 +55,11 @@ fn create_ticket(worklane: &PathBuf) {
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output { fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).args(args); cmd.current_dir(temp.path()).args(args);
cmd.assert().get_output().clone() cmd.assert().get_output().clone()
} }
fn ticket(worklane: &PathBuf) -> String { fn ticket(worklane: &Path) -> String {
fs::read_to_string(worklane.join("backlog").join(format!("{}_check-me.md", UUID))).unwrap() fs::read_to_string(worklane.join("backlog").join(format!("{}_check-me.md", UUID))).unwrap()
} }
+16 -16
View File
@@ -2,7 +2,7 @@ use assert_cmd::Command;
use assert_fs::fixture::{PathChild, PathCreateDir}; use assert_fs::fixture::{PathChild, PathCreateDir};
use assert_fs::TempDir; use assert_fs::TempDir;
use std::fs; use std::fs;
use std::path::PathBuf; use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane"); const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
@@ -18,7 +18,7 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
} }
fn create_ticket( fn create_ticket(
worklane_dir: &PathBuf, worklane_dir: &Path,
status: &str, status: &str,
title: &str, title: &str,
) -> String { ) -> String {
@@ -53,7 +53,7 @@ fn comment_creates_file_with_valid_ticket_uuid() {
let uuid = create_ticket(&worklane, "backlog", "Test Ticket"); let uuid = create_ticket(&worklane, "backlog", "Test Ticket");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, "This is a test comment"]) .args([&uuid, "This is a test comment"])
.assert() .assert()
@@ -78,7 +78,7 @@ fn comment_creates_file_with_valid_ticket_title() {
create_ticket(&worklane, "committed", "My Ticket"); create_ticket(&worklane, "committed", "My Ticket");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args(["My Ticket", "Testing title lookup"]) .args(["My Ticket", "Testing title lookup"])
.assert() .assert()
@@ -105,7 +105,7 @@ fn comment_includes_git_user_and_body() {
let uuid = create_ticket(&worklane, "backlog", "Comment Test"); let uuid = create_ticket(&worklane, "backlog", "Comment Test");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, "My comment body"]) .args([&uuid, "My comment body"])
.assert() .assert()
@@ -129,7 +129,7 @@ fn comment_stored_in_timestamped_file() {
let uuid = create_ticket(&worklane, "done", "Timestamp Test"); let uuid = create_ticket(&worklane, "done", "Timestamp Test");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, "Timestamp test"]) .args([&uuid, "Timestamp test"])
.assert() .assert()
@@ -156,7 +156,7 @@ fn comment_creates_comments_directory() {
assert!(!comments_dir.exists()); assert!(!comments_dir.exists());
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, "Create dir test"]) .args([&uuid, "Create dir test"])
.assert() .assert()
@@ -173,7 +173,7 @@ fn comment_uses_owner_flag_when_provided() {
let uuid = create_ticket(&worklane, "backlog", "Owner Test"); let uuid = create_ticket(&worklane, "backlog", "Owner Test");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, "Test comment with owner"]) .args([&uuid, "Test comment with owner"])
.arg("-o") .arg("-o")
@@ -198,7 +198,7 @@ fn comment_falls_back_to_git_user_when_owner_omitted() {
let uuid = create_ticket(&worklane, "done", "Fallback Test"); let uuid = create_ticket(&worklane, "done", "Fallback Test");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, "Test comment fallback"]) .args([&uuid, "Test comment fallback"])
.assert() .assert()
@@ -225,7 +225,7 @@ fn comments_added_back_to_back_are_both_kept() {
for body in ["first comment", "second comment", "third comment"] { for body in ["first comment", "second comment", "third comment"] {
Command::cargo_bin(BIN_NAME) Command::cargo_bin(BIN_NAME)
.unwrap() .unwrap()
.current_dir(&temp.path()) .current_dir(temp.path())
.arg("comment") .arg("comment")
.args([&uuid, body]) .args([&uuid, body])
.assert() .assert()
@@ -241,7 +241,7 @@ fn comments_added_back_to_back_are_both_kept() {
// And show has to render them in the order they were added // And show has to render them in the order they were added
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg(&uuid); cmd.current_dir(temp.path()).arg("show").arg(&uuid);
let assert = cmd.assert().success(); let assert = cmd.assert().success();
let stdout = String::from_utf8(assert.get_output().stdout.clone()).unwrap(); let stdout = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
@@ -261,7 +261,7 @@ fn comment_accepts_a_body_that_begins_with_a_hyphen() {
for body in ["--print is the flag I mean", "-f skips the check", "-"] { for body in ["--print is the flag I mean", "-f skips the check", "-"] {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["comment", &uuid, body]) .args(["comment", &uuid, body])
.assert() .assert()
.success(); .success();
@@ -289,13 +289,13 @@ fn comment_needs_a_separator_for_a_hyphen_leading_ticket() {
let mut without = Command::cargo_bin(BIN_NAME).unwrap(); let mut without = Command::cargo_bin(BIN_NAME).unwrap();
without without
.current_dir(&temp.path()) .current_dir(temp.path())
.args(["comment", "-leading", "a body"]) .args(["comment", "-leading", "a body"])
.assert() .assert()
.failure(); .failure();
let mut with = Command::cargo_bin(BIN_NAME).unwrap(); let mut with = Command::cargo_bin(BIN_NAME).unwrap();
with.current_dir(&temp.path()) with.current_dir(temp.path())
.args(["comment", "--", "-leading", "a body"]) .args(["comment", "--", "-leading", "a body"])
.assert() .assert()
.success(); .success();
@@ -315,7 +315,7 @@ fn a_bare_double_hyphen_body_needs_a_separator() {
let mut without = Command::cargo_bin(BIN_NAME).unwrap(); let mut without = Command::cargo_bin(BIN_NAME).unwrap();
let assert = without let assert = without
.current_dir(&temp.path()) .current_dir(temp.path())
.args(["comment", &uuid, "--"]) .args(["comment", &uuid, "--"])
.assert() .assert()
.failure(); .failure();
@@ -327,7 +327,7 @@ fn a_bare_double_hyphen_body_needs_a_separator() {
); );
let mut with = Command::cargo_bin(BIN_NAME).unwrap(); let mut with = Command::cargo_bin(BIN_NAME).unwrap();
with.current_dir(&temp.path()) with.current_dir(temp.path())
.args(["comment", &uuid, "--", "--"]) .args(["comment", &uuid, "--", "--"])
.assert() .assert()
.success(); .success();
+14 -14
View File
@@ -17,7 +17,7 @@ fn setup_worklane(temp: &TempDir) -> std::path::PathBuf {
} }
fn create_ticket( fn create_ticket(
worklane_dir: &std::path::PathBuf, worklane_dir: &std::path::Path,
status: &str, status: &str,
title: &str, title: &str,
owner: &str, owner: &str,
@@ -71,7 +71,7 @@ fn ls_without_status_shows_overview() {
create_ticket(&worklane, "done", "Feature D", "dave", "2026-09-01"); create_ticket(&worklane, "done", "Feature D", "dave", "2026-09-01");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("ls").assert().success(); cmd.current_dir(temp.path()).arg("ls").assert().success();
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("BACKLOG")); assert!(stdout.contains("BACKLOG"));
@@ -94,7 +94,7 @@ fn ls_with_status_filters_tickets() {
create_ticket(&worklane, "reviewing", "Feature C", "charlie", "2026-08-01"); create_ticket(&worklane, "reviewing", "Feature C", "charlie", "2026-08-01");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("ls").args(["committed"]); cmd.current_dir(temp.path()).arg("ls").args(["committed"]);
cmd.assert().success(); cmd.assert().success();
@@ -107,7 +107,7 @@ fn ls_with_invalid_status_fails() {
let temp = TempDir::new().unwrap(); let temp = TempDir::new().unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("ls") .arg("ls")
.args(["nonexistent"]) .args(["nonexistent"])
.assert() .assert()
@@ -124,7 +124,7 @@ fn ls_listed_tickets_sorted_alphabetically() {
create_ticket(&worklane, "backlog", "Mango", "charlie", "2026-08-01"); create_ticket(&worklane, "backlog", "Mango", "charlie", "2026-08-01");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("ls") .arg("ls")
.args(["backlog"]) .args(["backlog"])
.assert() .assert()
@@ -146,7 +146,7 @@ fn ls_empty_status_shows_message() {
// Intentionally leave "done" empty // Intentionally leave "done" empty
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("ls") .arg("ls")
.args(["done"]) .args(["done"])
.assert() .assert()
@@ -164,7 +164,7 @@ fn ls_displays_owner_and_due() {
create_ticket(&worklane, "backlog", "Test ticket", "alice", "2026-12-31"); create_ticket(&worklane, "backlog", "Test ticket", "alice", "2026-12-31");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("ls") .arg("ls")
.args(["backlog"]) .args(["backlog"])
.assert() .assert()
@@ -191,7 +191,7 @@ fn ls_handles_short_and_non_ascii_filenames() {
} }
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("ls").arg("backlog").assert().success(); cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
assert_eq!(stdout.matches("Odd Name").count(), 3); assert_eq!(stdout.matches("Odd Name").count(), 3);
@@ -209,7 +209,7 @@ fn ls_survives_a_malformed_created_at() {
.unwrap(); .unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("ls").arg("backlog").assert().success(); cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Bad Date")); assert!(stdout.contains("Bad Date"));
@@ -217,7 +217,7 @@ fn ls_survives_a_malformed_created_at() {
assert!(!stdout.contains("日本語")); assert!(!stdout.contains("日本語"));
} }
fn create_ticket_with_priority(worklane_dir: &std::path::PathBuf, title: &str, priority: &str) { fn create_ticket_with_priority(worklane_dir: &std::path::Path, title: &str, priority: &str) {
let slug: String = title.to_lowercase().replace(' ', "-"); let slug: String = title.to_lowercase().replace(' ', "-");
let body = format!( let body = format!(
"# {}\n\n## Metadata\n\n- **ID**: 00000000-0000-0000-0000-00000000000{}\n\ "# {}\n\n## Metadata\n\n- **ID**: 00000000-0000-0000-0000-00000000000{}\n\
@@ -242,7 +242,7 @@ fn ls_sorts_by_priority_then_title() {
create_ticket(&worklane, "backlog", "No priority at all", "alice", "_Not set_"); create_ticket(&worklane, "backlog", "No priority at all", "alice", "_Not set_");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("ls").arg("backlog"); cmd.current_dir(temp.path()).arg("ls").arg("backlog");
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
let at = |needle: &str| stdout.find(needle).unwrap_or_else(|| panic!("{needle} missing")); let at = |needle: &str| stdout.find(needle).unwrap_or_else(|| panic!("{needle} missing"));
@@ -261,7 +261,7 @@ fn ls_filters_by_priority_and_composes_with_status() {
create_ticket_with_priority(&worklane, "Lower one", "3"); create_ticket_with_priority(&worklane, "Lower one", "3");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["ls", "backlog", "--priority", "1"]); .args(["ls", "backlog", "--priority", "1"]);
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Urgent one")); assert!(stdout.contains("Urgent one"));
@@ -269,7 +269,7 @@ fn ls_filters_by_priority_and_composes_with_status() {
// Same filter without a status, through the grouped listing // Same filter without a status, through the grouped listing
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).args(["ls", "--priority", "3"]); cmd.current_dir(temp.path()).args(["ls", "--priority", "3"]);
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Lower one")); assert!(stdout.contains("Lower one"));
assert!(!stdout.contains("Urgent one")); assert!(!stdout.contains("Urgent one"));
@@ -285,7 +285,7 @@ fn ls_shows_a_mark_for_the_level() {
create_ticket(&worklane, "backlog", "Nothing set", "alice", "_Not set_"); create_ticket(&worklane, "backlog", "Nothing set", "alice", "_Not set_");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("ls").arg("backlog"); cmd.current_dir(temp.path()).arg("ls").arg("backlog");
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
// Piped, so no escapes: the glyph is carrying the level by itself // Piped, so no escapes: the glyph is carrying the level by itself
+23 -18
View File
@@ -2,7 +2,7 @@ use assert_cmd::Command;
use assert_fs::TempDir; use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir}; use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs; use std::fs;
use std::path::PathBuf; use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane"); const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
@@ -17,8 +17,13 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
worklane.path().to_path_buf() worklane.path().to_path_buf()
} }
/// Every metadata field a ticket has, positionally. The lint is right that the call
/// site reads as a wall of strings, and the fix is a struct with named fields, but
/// that is a change to thirteen call sites in this file alone and belongs in its own
/// commit rather than in a warning sweep.
#[allow(clippy::too_many_arguments)]
fn create_ticket( fn create_ticket(
worklane_dir: &PathBuf, worklane_dir: &Path,
status: &str, status: &str,
title: &str, title: &str,
description: &str, description: &str,
@@ -89,7 +94,7 @@ fn mv_forwards_from_backlog_to_committed() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -133,7 +138,7 @@ fn mv_blocks_backward_move() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -163,7 +168,7 @@ fn mv_allows_backward_move_with_force() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -197,7 +202,7 @@ fn mv_blocks_nonsequential_forward_move() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -227,7 +232,7 @@ fn mv_allows_skipping_stages_with_force() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -259,7 +264,7 @@ fn mv_ignores_already_in_same_status() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -290,7 +295,7 @@ fn mv_rejects_invalid_status() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -320,7 +325,7 @@ fn mv_uses_ticket_id_for_resolution() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -354,7 +359,7 @@ fn mv_keeps_status_in_sync_across_consecutive_moves() {
for target in ["committed", "reviewing"] { for target in ["committed", "reviewing"] {
Command::cargo_bin(BIN_NAME) Command::cargo_bin(BIN_NAME)
.unwrap() .unwrap()
.current_dir(&temp.path()) .current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -392,7 +397,7 @@ fn mv_repairs_legacy_status_field() {
Command::cargo_bin(BIN_NAME) Command::cargo_bin(BIN_NAME)
.unwrap() .unwrap()
.current_dir(&temp.path()) .current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -415,7 +420,7 @@ fn mv_fails_when_status_field_is_missing() {
fs::write(&path, "# No Status\n\n## Metadata\n\n- **Owner**: jack\n").unwrap(); fs::write(&path, "# No Status\n\n## Metadata\n\n- **Owner**: jack\n").unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("mv") .arg("mv")
.arg("abc123def4567") .arg("abc123def4567")
.arg("--status") .arg("--status")
@@ -498,7 +503,7 @@ fn mv_never_leaves_stale_content_in_the_target_directory() {
chmod(&source, 0o444); chmod(&source, 0o444);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["mv", "abc123def4567", "--status", "committed"]) .args(["mv", "abc123def4567", "--status", "committed"])
.assert() .assert()
.success(); .success();
@@ -541,7 +546,7 @@ fn mv_leaves_the_ticket_in_one_place_when_the_move_fails() {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let assert = cmd let assert = cmd
.current_dir(&temp.path()) .current_dir(temp.path())
.args(["mv", "abc123def4567", "--status", "committed"]) .args(["mv", "abc123def4567", "--status", "committed"])
.assert() .assert()
.failure(); .failure();
@@ -569,7 +574,7 @@ fn mv_leaves_the_ticket_in_one_place_when_the_move_fails() {
let mut retry = Command::cargo_bin(BIN_NAME).unwrap(); let mut retry = Command::cargo_bin(BIN_NAME).unwrap();
retry retry
.current_dir(&temp.path()) .current_dir(temp.path())
.args(["mv", "abc123def4567", "--status", "committed"]) .args(["mv", "abc123def4567", "--status", "committed"])
.assert() .assert()
.success(); .success();
@@ -595,7 +600,7 @@ fn mv_leaves_nothing_behind_on_success() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["mv", "abc123def4567", "--status", "committed"]) .args(["mv", "abc123def4567", "--status", "committed"])
.assert() .assert()
.success(); .success();
@@ -625,7 +630,7 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
} }
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.args(["mv", "22222222", "--status", "committed"]) .args(["mv", "22222222", "--status", "committed"])
.assert() .assert()
.success(); .success();
+6 -6
View File
@@ -2,7 +2,7 @@ use assert_cmd::Command;
use assert_fs::TempDir; use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir}; use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs; use std::fs;
use std::path::PathBuf; use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane"); const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
const UUID: &str = "475534a3-8a0d-45cb-9a97-39c251dd8e39"; const UUID: &str = "475534a3-8a0d-45cb-9a97-39c251dd8e39";
@@ -20,7 +20,7 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
/// A fully populated ticket, with one criterion already ticked and a section the tool /// A fully populated ticket, with one criterion already ticked and a section the tool
/// knows nothing about, so every test can check both survive. /// knows nothing about, so every test can check both survive.
fn create_ticket(worklane: &PathBuf) -> String { fn create_ticket(worklane: &Path) -> String {
let filename = format!("{}_original-title.md", UUID); let filename = format!("{}_original-title.md", UUID);
fs::write( fs::write(
worklane.join("backlog").join(&filename), worklane.join("backlog").join(&filename),
@@ -61,11 +61,11 @@ fn create_ticket(worklane: &PathBuf) -> String {
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output { fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).args(args); cmd.current_dir(temp.path()).args(args);
cmd.assert().get_output().clone() cmd.assert().get_output().clone()
} }
fn ticket(worklane: &PathBuf) -> String { fn ticket(worklane: &Path) -> String {
let entry = fs::read_dir(worklane.join("backlog")) let entry = fs::read_dir(worklane.join("backlog"))
.unwrap() .unwrap()
.filter_map(|e| e.ok()) .filter_map(|e| e.ok())
@@ -74,7 +74,7 @@ fn ticket(worklane: &PathBuf) -> String {
fs::read_to_string(entry.path()).unwrap() fs::read_to_string(entry.path()).unwrap()
} }
fn stray_files(worklane: &PathBuf) -> Vec<String> { fn stray_files(worklane: &Path) -> Vec<String> {
fs::read_dir(worklane) fs::read_dir(worklane)
.unwrap() .unwrap()
.filter_map(|e| e.ok()) .filter_map(|e| e.ok())
@@ -327,7 +327,7 @@ fn append_replaces_an_empty_section_rather_than_following_its_placeholder() {
let worklane = setup_worklane(&temp); let worklane = setup_worklane(&temp);
let mut add = Command::cargo_bin(BIN_NAME).unwrap(); let mut add = Command::cargo_bin(BIN_NAME).unwrap();
add.current_dir(&temp.path()) add.current_dir(temp.path())
.args(["add", "--title", "Bare ticket"]) .args(["add", "--title", "Bare ticket"])
.assert() .assert()
.success(); .success();
+20 -17
View File
@@ -16,8 +16,11 @@ fn setup_worklane(temp: &TempDir) -> std::path::PathBuf {
worklane.path().to_path_buf() worklane.path().to_path_buf()
} }
/// Same fixture, same trade as `cmd_mv.rs`: positional today, a struct when the call
/// sites in both files are converted together.
#[allow(clippy::too_many_arguments)]
fn create_ticket( fn create_ticket(
worklane_dir: &std::path::PathBuf, worklane_dir: &std::path::Path,
status: &str, status: &str,
title: &str, title: &str,
description: &str, description: &str,
@@ -86,7 +89,7 @@ fn show_displays_ticket_by_full_uuid() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("abc123def456789012345678901234567890") .arg("abc123def456789012345678901234567890")
.assert() .assert()
@@ -118,7 +121,7 @@ fn show_displays_ticket_by_partial_uuid() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("abc123def4567890") .arg("abc123def4567890")
.assert() .assert()
@@ -147,7 +150,7 @@ fn show_displays_ticket_by_title() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("login") .arg("login")
.assert() .assert()
@@ -178,7 +181,7 @@ fn show_displays_ticket_by_partial_title() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("fix") .arg("fix")
.assert() .assert()
@@ -206,7 +209,7 @@ fn show_shows_both_uuid_and_title_in_output() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("test") .arg("test")
.assert() .assert()
@@ -222,7 +225,7 @@ fn show_fails_for_nonexistent_ticket() {
setup_worklane(&temp); setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("nonexistent") .arg("nonexistent")
.assert() .assert()
@@ -259,7 +262,7 @@ fn show_asks_for_disambiguation_when_multiple_matches() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg("est"); cmd.current_dir(temp.path()).arg("show").arg("est");
let stderr = get_stderr(&mut cmd); let stderr = get_stderr(&mut cmd);
assert!(stderr.contains("Multiple tickets found")); assert!(stderr.contains("Multiple tickets found"));
@@ -299,7 +302,7 @@ fn show_reports_ambiguity_on_stderr_with_a_failing_exit() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("ambiguous") .arg("ambiguous")
.assert() .assert()
@@ -333,7 +336,7 @@ fn show_disambiguates_tickets_with_short_filenames() {
.unwrap(); .unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg("short"); cmd.current_dir(temp.path()).arg("show").arg("short");
let stderr = get_stderr(&mut cmd); let stderr = get_stderr(&mut cmd);
assert!(stderr.contains("Multiple tickets found")); assert!(stderr.contains("Multiple tickets found"));
@@ -356,7 +359,7 @@ fn show_disambiguates_tickets_with_non_ascii_filenames() {
} }
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg("accented"); cmd.current_dir(temp.path()).arg("show").arg("accented");
let stderr = get_stderr(&mut cmd); let stderr = get_stderr(&mut cmd);
assert!(stderr.contains("Multiple tickets found")); assert!(stderr.contains("Multiple tickets found"));
@@ -383,7 +386,7 @@ fn show_searches_across_all_statuses() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()) cmd.current_dir(temp.path())
.arg("show") .arg("show")
.arg("committed") .arg("committed")
.assert() .assert()
@@ -408,7 +411,7 @@ fn show_renders_the_priority_mark_beside_the_number() {
.unwrap(); .unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg("Prio"); cmd.current_dir(temp.path()).arg("show").arg("Prio");
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
// Mark for the eye, number still there for the file's sake // Mark for the eye, number still there for the file's sake
@@ -438,7 +441,7 @@ fn show_prints_the_title_once() {
); );
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg("Once Only"); cmd.current_dir(temp.path()).arg("show").arg("Once Only");
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
assert_eq!( assert_eq!(
@@ -467,7 +470,7 @@ fn show_renders_the_metadata_as_an_aligned_table() {
.unwrap(); .unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg("Table"); cmd.current_dir(temp.path()).arg("show").arg("Table");
let stdout = get_stdout(&mut cmd); let stdout = get_stdout(&mut cmd);
// Every value starts in the same column, sized by the longest field name // Every value starts in the same column, sized by the longest field name
@@ -500,7 +503,7 @@ fn ticket_with(worklane: &std::path::Path, status: &str, uuid: &str, title: &str
fn show(temp: &TempDir, search: &str) -> std::process::Output { fn show(temp: &TempDir, search: &str) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).arg("show").arg(search); cmd.current_dir(temp.path()).arg("show").arg(search);
cmd.assert().get_output().clone() cmd.assert().get_output().clone()
} }
@@ -546,7 +549,7 @@ fn show_resolves_the_short_id_the_listing_prints() {
ticket_with(&worklane, "backlog", uuid, "Alpha", "alpha"); ticket_with(&worklane, "backlog", uuid, "Alpha", "alpha");
let mut ls = Command::cargo_bin(BIN_NAME).unwrap(); let mut ls = Command::cargo_bin(BIN_NAME).unwrap();
ls.current_dir(&temp.path()).args(["ls", "backlog"]); ls.current_dir(temp.path()).args(["ls", "backlog"]);
let listing = String::from_utf8(ls.assert().success().get_output().stdout.clone()).unwrap(); let listing = String::from_utf8(ls.assert().success().get_output().stdout.clone()).unwrap();
// Take the id exactly as printed, so this couples to the display width rather // Take the id exactly as printed, so this couples to the display width rather
+1 -1
View File
@@ -15,7 +15,7 @@ fn setup_worklane(temp: &TempDir) {
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output { fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(&temp.path()).args(args); cmd.current_dir(temp.path()).args(args);
cmd.assert().get_output().clone() cmd.assert().get_output().clone()
} }