(61879a4) Surface campaigns on the board, and bump to 0.20.0

A card label and a frame, not a campaign tab. A tab had to say what its
columns are, and a campaign groups across the flow rather than within one
status, so the answer is the four columns filtered: a filter on the board
it already has, not a fifth tab.

So a card names its campaign on the label row, before the tags, marked ~
and bold, and the row drops the tags whole before it drops the campaign.
`c` opens a picker; taking a campaign filters every column to its members
and draws a frame above them carrying the id, the codename, the name, the
opening line of the description and the standing. The standing comes from
the columns, since while a campaign is selected the columns are its
members. `q` takes off one layer at a time: the overlay, the filter, the
board.

The label needs something to say, which the stored uuid is not, so
campaigns gained `Codename`: one word, `v1` or `beaver`, written by
`campaign add --codename` and validated at parse time. `campaign ls`
prints it and `resolve_in` gained an exact-codename tier above the uuid
prefix, or it would be a field you can read and cannot type. Only
campaigns carry the field, so the tier is empty for a ticket and ticket
resolution is unchanged.

The campaigns index is read once per project in `columns_of`, on the pass
that already builds the cards, and `digest` now watches the campaigns
directory: without it a campaign filed elsewhere never reached the picker.
`frame_rows` grew a row, so the two bools deciding the geometry became one
`Chrome` and the row indices are named.

Left out and filed as d637288: nothing can give a codename to a campaign
that is already on the board.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-23 12:09:07 +02:00
co-authored by Claude Opus 5
parent c65e1b4ed7
commit 528566d103
13 changed files with 1945 additions and 104 deletions
+214
View File
@@ -642,3 +642,217 @@ fn an_ambiguous_campaign_lists_the_candidates() {
assert!(message.contains("v1 release"), "{message}");
assert!(message.contains("v2 release"), "{message}");
}
// ------------------------------------------------------------------ codenames --
/// The codename is what the board draws on every card in a campaign, since a uuid does
/// not fit there and a title is a sentence.
#[test]
fn campaign_add_writes_the_codename_under_the_id() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let out = run(
&temp,
&[
"campaign",
"add",
"--title",
"First public release",
"--codename",
"v1",
],
);
assert!(out.status.success(), "{}", stderr(&out));
let name = campaigns(&worklane).remove(0);
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
assert!(content.contains("- **Codename**: v1"), "{content}");
// Under the ID, because that is what it is: a second way to say which campaign this
// is, in a word rather than in thirty-six characters.
let id = content.find("- **ID**:").expect("no id");
let codename = content.find("- **Codename**:").expect("no codename");
let owner = content.find("- **Owner**:").expect("no owner");
assert!(id < codename && codename < owner, "{content}");
}
/// A campaign filed without one carries the line unset rather than not at all, the way
/// `add` writes an unset Due on every ticket: one shape of file is one thing for the
/// parser to be right about, and the line is there to fill in by hand.
#[test]
fn a_campaign_filed_without_a_codename_carries_the_field_unset() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
run(&temp, &["campaign", "add", "--title", "No codename here"]);
let name = campaigns(&worklane).remove(0);
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
assert!(content.contains("- **Codename**: _Not set_"), "{content}");
}
/// One word, checked at parse time like `--due` and `--priority`, because the board draws
/// it as a label with a mark and no quoting: `~beaver release` on that row reads as two
/// labels and the second one is not a campaign.
#[test]
fn a_codename_of_more_than_one_word_is_a_usage_error() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let out = run(
&temp,
&[
"campaign",
"add",
"--title",
"v1 release",
"--codename",
"beaver release",
],
);
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
assert!(stderr(&out).contains("single word"), "{}", stderr(&out));
assert!(campaigns(&worklane).is_empty(), "a campaign was filed anyway");
}
#[test]
fn an_empty_codename_is_a_usage_error() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let out = run(&temp, &["campaign", "add", "--title", "v1 release", "--codename", ""]);
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
assert!(campaigns(&worklane).is_empty(), "a campaign was filed anyway");
}
/// The listing is where the codename is read back, so it goes between the id and the
/// title with the mark the board draws it with: one word for one campaign, spelled the
/// same wherever it is shown.
#[test]
fn campaign_ls_names_the_codename_between_the_id_and_the_title() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_campaign(&worklane, "No codename here", CAMP_B);
run(
&temp,
&[
"campaign",
"add",
"--title",
"First public release",
"-c",
"v1",
],
);
let out = run(&temp, &["campaign", "ls"]);
let listing = stdout(&out);
assert!(listing.contains("~v1 First public release"), "{listing}");
// And a campaign without one spends nothing on it, the way an untagged card spends no
// row.
assert!(listing.contains(") No codename here"), "{listing}");
assert!(!listing.contains("~No codename"), "{listing}");
let _ = worklane;
}
/// `campaign show` renders its metadata as a table, so the field is there to read without
/// anything being written twice.
#[test]
fn campaign_show_renders_the_codename_in_its_metadata() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
run(
&temp,
&[
"campaign",
"add",
"--title",
"First public release",
"-c",
"v1",
],
);
let out = run(&temp, &["campaign", "show", "First public"]);
assert!(stdout(&out).contains("Codename"), "{}", stdout(&out));
assert!(stdout(&out).contains("v1"), "{}", stdout(&out));
let _ = worklane;
}
/// A codename nobody can type is half a field, so it resolves a campaign the way its
/// uuid and its title do. Exact, and ahead of all three: it is a match on a field written
/// for the purpose rather than a substring that could be a coincidence.
#[test]
fn a_campaign_resolves_by_its_codename() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
// Same file, plus a codename, since `create_campaign` writes none.
let path = worklane
.join("campaigns")
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
let content = fs::read_to_string(&path).unwrap();
fs::write(
&path,
content.replace("- **Owner**:", "- **Codename**: beaver\n- **Owner**:"),
)
.unwrap();
let out = run(&temp, &["assign", "beaver", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
assert!(
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
"{}",
ticket(&worklane, MEMBER)
);
// And every other command that takes a campaign, since they share one resolver.
let out = run(&temp, &["campaign", "show", "beaver"]);
assert!(stdout(&out).contains("v1 release"), "{}", stdout(&out));
let out = run(&temp, &["ls", "--campaign", "beaver"]);
assert!(stdout(&out).contains("The member"), "{}", stdout(&out));
}
/// An exact codename beats a title that merely contains the search, which is the whole
/// reason it is a tier of its own: `v2` is a substring of `v2 release` and the exact
/// match has to win outright rather than be reported as ambiguous against it.
#[test]
fn an_exact_codename_beats_a_title_that_contains_the_search() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let path = worklane
.join("campaigns")
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
let content = fs::read_to_string(&path).unwrap();
fs::write(&path, content.replace("- **Owner**:", "- **Codename**: v2\n- **Owner**:")).unwrap();
let out = run(&temp, &["assign", "v2", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
assert!(
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
"the title tier won: {}",
ticket(&worklane, MEMBER)
);
}
/// A ticket carries no codename, so the tier is empty for one and ticket resolution is
/// exactly what it was. Pinned because the tier lives in the shared resolver: this is the
/// half of it that must not have changed.
#[test]
fn a_ticket_search_is_unaffected_by_the_codename_tier() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
// The uuid prefix still wins over a title that quotes it, which is the precedence the
// three tiers were written for.
let out = run(&temp, &["show", "641e3d5"]);
assert!(stdout(&out).contains("The member"), "{}", stdout(&out));
let _ = worklane;
}