(1db02e5) Give the board a tags file, and bump to 0.25.0

The board carried twenty-four tags and defined none of them. `campaign` and
`campaigns` were both on it, one ticket each side, and nothing on disk could
have caught that.

`.worklane/tags.md` is the vocabulary: one level-two heading per tag, its
annotation as the prose under it, alphabetical by byte so a near-duplicate
lands next to what it duplicates. `worklane tags add <tag> --annotation`
writes it, `init` creates it empty, and `tags add` creates it on demand for a
board that predates it.

Declaring a tag tags no ticket, and tagging a ticket declares nothing. The
counts stay derived from the status directories, so the file and the board can
disagree; reporting that disagreement is 9564ac9.

`tags` becomes a group with an optional subcommand. The bare form is still the
listing, byte for byte, because the shipped fish completion calls it that way
to fill in `ls --tag`; `tags ls` is the same arm.

Every write re-renders the whole file from the parsed vocabulary rather than
splicing one section, which is why an unreadable file is an error in
`TagIndex::load` where an unreadable campaigns directory is an empty index:
empty here would mean erased.

`no_tag_taking_option_is_missing` used to panic on any tag positional. It now
allows what `TAG_NEW_COMMANDS` records, which is `tags add` alone: the tag it
takes does not exist yet, so completing it from `worklane tags` would offer
exactly the values it refuses.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-23 15:47:05 +02:00
co-authored by Claude Opus 5
parent b1dbf3ed75
commit f515d69930
8 changed files with 739 additions and 16 deletions
+236
View File
@@ -4,6 +4,11 @@
//! tags exist, which is the question a grooming sweep starts from. So the properties
//! under test are the ones that question needs: every status counted, case kept apart,
//! alphabetical order, and an output a shell can parse.
//!
//! `tags add` is the other half of the same question. The listing reports the vocabulary
//! the tickets *carry*; the file reports the one the board *intends*, and the tests below
//! are mostly about the two being allowed to disagree without either one damaging the
//! other.
use assert_cmd::Command;
use assert_fs::TempDir;
@@ -175,3 +180,234 @@ fn tags_skips_a_missing_status_directory() {
assert_eq!(tags(&temp), vec!["bug\t1"]);
}
// ------------------------------------------------------------- the vocabulary --
fn vocabulary(temp: &TempDir) -> String {
fs::read_to_string(temp.path().join(".worklane").join("tags.md")).unwrap()
}
/// The section a tag holds in the file, heading excluded, or `None` when it is not
/// declared. Cut out of the file rather than asserted against a whole rendering, so a
/// change to the preamble does not fail every test here.
fn declared(temp: &TempDir, tag: &str) -> Option<String> {
let file = vocabulary(temp);
let (_, rest) = file.split_once(&format!("\n## {tag}\n"))?;
let body = match rest.split_once("\n## ") {
Some((body, _)) => body,
None => rest,
};
Some(body.trim().to_string())
}
/// The declaration lands in the file, with the annotation under it.
#[test]
fn tags_add_declares_a_tag_with_what_it_means() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let out = run(
&temp,
&[
"tags",
"add",
"bug",
"--annotation",
"Something the binary does wrong.",
],
);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert_eq!(declared(&temp, "bug").as_deref(), Some("Something the binary does wrong."));
}
/// Several flags are several lines, and an empty one is a paragraph break, the way a
/// description is written.
#[test]
fn an_annotation_takes_several_lines_and_a_paragraph_break() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(
&temp,
&[
"tags",
"add",
"bug",
"-a",
"What it is.",
"-a",
"",
"-a",
"When to use it.",
],
);
assert_eq!(declared(&temp, "bug").as_deref(), Some("What it is.\n\nWhen to use it."));
}
/// A tag can be declared with nothing said about it. The word being agreed on is worth
/// recording before anyone has written the sentence.
#[test]
fn a_tag_can_be_declared_without_an_annotation() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let out = run(&temp, &["tags", "add", "cli"]);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert_eq!(declared(&temp, "cli").as_deref(), Some("_No annotation provided._"));
}
/// Refused rather than overwritten, and the refusal names what does overwrite it: an
/// annotation is the sentence a team files tickets against, not something to replace by
/// typing `add` twice.
#[test]
fn declaring_a_tag_twice_is_refused_and_names_the_command_that_replaces_it() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug", "-a", "The first sentence."]);
let out = run(&temp, &["tags", "add", "bug", "-a", "A different sentence."]);
assert!(!out.status.success());
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("tags set"), "{stderr}");
assert_eq!(declared(&temp, "bug").as_deref(), Some("The first sentence."));
}
/// A comma is what separates one tag from the next, so a value carrying one could never be
/// matched by `--tag`. Refused at parse, with nothing written.
#[test]
fn a_tag_the_filter_could_never_match_is_refused() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
for value in ["bug,cli", ""] {
let out = run(&temp, &["tags", "add", value]);
assert!(!out.status.success(), "'{value}' was accepted");
}
// Nothing was written on the way past, not even the empty file.
assert!(!temp.path().join(".worklane").join("tags.md").exists());
}
/// Surrounding space is trimmed rather than refused, because a ticket's Tags field is read
/// that way too: ` bug ` on a card is the tag `bug`, and the vocabulary has to agree.
#[test]
fn a_padded_tag_is_declared_under_its_trimmed_name() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", " bug "]);
assert!(declared(&temp, "bug").is_some(), "{}", vocabulary(&temp));
}
/// An annotation line that would be read back as a heading is refused, since it would split
/// the section and declare whatever followed it.
#[test]
fn an_annotation_that_would_read_as_a_heading_is_refused() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let out = run(&temp, &["tags", "add", "bug", "-a", "## cli"]);
assert!(!out.status.success());
assert!(!temp.path().join(".worklane").join("tags.md").exists());
}
/// The file is made on demand, the way `campaign add` makes the campaigns directory: a board
/// that predates the vocabulary must not need `worklane init` run over it.
#[test]
fn the_file_is_created_on_a_board_that_predates_it() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
assert!(!temp.path().join(".worklane").join("tags.md").exists());
run(&temp, &["tags", "add", "bug"]);
assert!(declared(&temp, "bug").is_some());
}
/// `init` writes it, so a new board has one file shape rather than two.
#[test]
fn init_writes_the_vocabulary_beside_the_status_directories() {
let temp = TempDir::new().unwrap();
let out = run(&temp, &["init"]);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
let file = vocabulary(&temp);
assert!(file.starts_with("# Tags"), "{file}");
// The preamble and nothing else: a new board declares no tags.
assert!(!file.contains("\n## "), "{file}");
}
/// A second declaration keeps the first, and the file stays alphabetical: the whole file is
/// re-rendered, so this is the test that the re-render is not a truncation.
#[test]
fn declaring_a_tag_leaves_the_others_alone_and_keeps_the_order() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "tui", "-a", "The board view."]);
run(&temp, &["tags", "add", "bug", "-a", "Something wrong."]);
assert_eq!(declared(&temp, "tui").as_deref(), Some("The board view."));
assert_eq!(declared(&temp, "bug").as_deref(), Some("Something wrong."));
let file = vocabulary(&temp);
assert!(file.find("## bug").unwrap() < file.find("## tui").unwrap(), "{file}");
}
/// A file that is there and cannot be read stops the write rather than being taken for an
/// empty vocabulary. Empty would mean erased, since every declaration re-renders the file.
#[test]
fn a_vocabulary_that_cannot_be_read_is_refused_rather_than_replaced() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
// A directory where the file should be: `read_to_string` fails on it, which a missing
// file does not.
fs::create_dir(worklane.join("tags.md")).unwrap();
let out = run(&temp, &["tags", "add", "bug"]);
assert!(!out.status.success());
assert!(worklane.join("tags.md").is_dir(), "the file was replaced");
// And nothing was staged and left behind.
let stray: Vec<_> = fs::read_dir(&worklane)
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| e.file_name().to_string_lossy().starts_with(".wl-"))
.collect();
assert!(stray.is_empty(), "a temp file was left in .worklane");
}
/// The vocabulary does not touch the listing, which counts tickets. The two disagreeing is
/// the normal state and the thing the file is for.
#[test]
fn a_declared_tag_is_not_a_carried_one() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog", "11111111", "bug");
run(&temp, &["tags", "add", "chore", "-a", "Housekeeping."]);
// `chore` is declared and carried by nothing, `bug` is carried and declared by nothing,
// and the listing still answers only the second question. Reporting both is 9564ac9.
assert_eq!(tags(&temp), vec!["bug\t1"]);
}
/// The bare form is the listing, byte for byte, because the shipped fish completion calls it
/// that way to fill in `ls --tag`. `tags ls` is the same thing spelled as a group.
#[test]
fn the_bare_form_and_ls_are_the_same_listing() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog", "11111111", "bug, cli");
run(&temp, &["tags", "add", "chore"]);
let bare = run(&temp, &["tags"]);
let group = run(&temp, &["tags", "ls"]);
assert!(bare.status.success());
assert_eq!(bare.stdout, group.stdout);
assert_eq!(String::from_utf8_lossy(&bare.stdout), "bug\t1\ncli\t1\n");
}