(d637288) Add campaign set, and bump to 0.21.0

`campaign add --codename` was the only writer of the field, so a campaign
already on the board could not be given one without editing the file by
hand -- which is every campaign filed before 0.20.0.

A `campaign set`, not a flag on something narrower: the file has more than
one editable thing, and the moment somebody wants to fix a typo in a title
there would be a second command to design. It carries `--title`, which
renames the file the way `set --title` does, and `--codename`, through the
same parser `campaign add` takes. Built out of `set`'s own parts --
`set_title`, `apply`, `report`, and the whole-file no-op comparison -- so
nothing about writing a field lives twice.

The codename goes through `set_or_insert_metadata_field` rather than
`set_metadata_field`: a campaign filed before the field existed has no such
line, and those are exactly the campaigns this is for. That exposed a
second thing -- `Codename` was not in `METADATA_ORDER`, so an inserted line
landed at the end of the block while `campaign_body` writes it under the
ID, two shapes of one file. It is in the list now, directly after ID.

`save_ticket` split into `save_entry` with `save_ticket` and
`save_campaign` as named wrappers, so a campaign gets the same write-then-
rename a ticket has rather than a second copy of it. `write_then_replace`
and `find_entry_file` take the noun, so a failure says "campaign" where it
is one.

No `--description`, filed as 32e98ab: `set` and `append` are a pair for a
prose section, and replacing a description with no way to add a paragraph
is the half that loses the rest of it. No `--owner` and no `--clear`, each
for a reason recorded on the ticket.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-23 12:22:59 +02:00
co-authored by Claude Opus 5
parent 528566d103
commit 72dbdec2ec
12 changed files with 463 additions and 33 deletions
+257
View File
@@ -144,6 +144,21 @@ fn find(worklane: &Path, uuid: &str) -> PathBuf {
panic!("no file for ticket {uuid}");
}
/// A campaign's content by uuid, found rather than named, since `campaign set --title`
/// renames the file and a test that named it would be asserting the old name.
fn campaign_file(worklane: &Path, uuid: &str) -> String {
for entry in fs::read_dir(worklane.join("campaigns"))
.unwrap()
.filter_map(|e| e.ok())
{
if entry.file_name().to_string_lossy().starts_with(uuid) {
return fs::read_to_string(entry.path()).unwrap();
}
}
panic!("no file for campaign {uuid}");
}
fn ticket(worklane: &Path, uuid: &str) -> String {
fs::read_to_string(find(worklane, uuid)).unwrap()
}
@@ -856,3 +871,245 @@ fn a_ticket_search_is_unaffected_by_the_codename_tier() {
assert!(stdout(&out).contains("The member"), "{}", stdout(&out));
let _ = worklane;
}
// ---------------------------------------------------------------- campaign set --
/// The point of the command: a campaign already on the board can be given a codename,
/// which `campaign add --codename` cannot do because `add` files a new one.
#[test]
fn campaign_set_gives_a_filed_campaign_a_codename() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["campaign", "set", "v1 release", "--codename", "beaver"]);
assert!(out.status.success(), "{}", stderr(&out));
assert!(stdout(&out).contains("Updated codename"), "{}", stdout(&out));
let content = campaign_file(&worklane, CAMP_A);
assert!(content.contains("- **Codename**: beaver"), "{content}");
}
/// `create_campaign` writes no Codename line at all, which is every campaign filed before
/// the field existed, so the insertion path is the one this command is actually for.
/// It lands under the ID, where `campaign add` writes it, so a campaign given a codename
/// later is the same file as one filed with it.
#[test]
fn the_codename_is_inserted_under_the_id_when_the_line_is_absent() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
assert!(
!campaign_file(&worklane, CAMP_A).contains("Codename"),
"the fixture changed"
);
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
let content = campaign_file(&worklane, CAMP_A);
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}");
}
/// One parser, so a codename is one thing however it was written. The board draws it as a
/// label with a mark and no quoting, and that does not depend on which command wrote it.
#[test]
fn campaign_set_validates_the_codename_the_way_add_does() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
for value in ["two words", ""] {
let out = run(&temp, &["campaign", "set", "v1 release", "--codename", value]);
assert_eq!(out.status.code(), Some(2), "{value:?}: {}", stderr(&out));
assert!(
!campaign_file(&worklane, CAMP_A).contains("Codename"),
"{value:?} was written"
);
}
// And the message is the one `campaign add` gives, since the parser is the same.
let out = run(&temp, &["campaign", "set", "v1 release", "--codename", "two words"]);
assert!(stderr(&out).contains("single word"), "{}", stderr(&out));
}
/// A bare `campaign set <campaign>` is a usage error rather than a silent no-op, exactly
/// as it is for `set`.
#[test]
fn campaign_set_with_no_field_is_a_usage_error() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["campaign", "set", "v1 release"]);
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
assert!(
!campaign_file(&worklane, CAMP_A).contains("Codename"),
"something was written"
);
}
/// Replacing the title renames the file, keeping the uuid, the way `set --title` does. That
/// is the reason this is a `set` rather than a flag on something narrower.
#[test]
fn campaign_set_renames_the_file_with_the_title() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
// A member first, so the rename has something to break.
run(&temp, &["assign", "v1 release", MEMBER]);
let out = run(
&temp,
&[
"campaign",
"set",
"v1 release",
"--title",
"First public release",
],
);
assert!(out.status.success(), "{}", stderr(&out));
let names = campaigns(&worklane);
assert!(
names.contains(&format!("{CAMP_A}_first-public-release.md")),
"not renamed: {names:?}"
);
assert!(
!names.contains(&format!("{CAMP_A}_v1-release.md")),
"the old file is still there: {names:?}"
);
let content = campaign_file(&worklane, CAMP_A);
assert!(content.starts_with("# First public release\n"), "{content}");
// The uuid is kept, so membership survives the rename: it is stored on the member as
// the uuid, and nothing has to be rewritten when the campaign is renamed.
assert!(content.contains(&format!("- **ID**: {CAMP_A}")), "{content}");
let out = run(&temp, &["ls", "--campaign", "First public release"]);
assert!(
stdout(&out).contains("The member"),
"membership was lost: {}",
stdout(&out)
);
}
/// Both fields in one call, since the group is `multiple`.
#[test]
fn campaign_set_takes_the_title_and_the_codename_together() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(
&temp,
&[
"campaign",
"set",
"v1 release",
"-t",
"First public release",
"-c",
"v1",
],
);
assert!(out.status.success(), "{}", stderr(&out));
assert!(stdout(&out).contains("title, codename"), "{}", stdout(&out));
let content = campaign_file(&worklane, CAMP_A);
assert!(content.starts_with("# First public release\n"), "{content}");
assert!(content.contains("- **Codename**: v1"), "{content}");
}
/// The whole-file comparison `set` and `chown` use, so writing what is already there
/// writes nothing and says so.
#[test]
fn setting_the_codename_a_campaign_already_has_writes_nothing() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
let before = campaign_file(&worklane, CAMP_A);
let out = run(&temp, &["campaign", "set", "v1", "-c", "v1"]);
assert!(out.status.success(), "{}", stderr(&out));
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the file was rewritten");
}
/// A codename set here resolves the campaign afterwards, which is the whole point of the
/// field being typable: the tier is in the shared resolver, not in `campaign add`.
#[test]
fn a_codename_set_afterwards_resolves_the_campaign() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["campaign", "set", "v1 release", "-c", "beaver"]);
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)
);
}
/// Nothing else in the file moves. A campaign carries prose and an owner this command
/// cannot reach, and a hand-written section has to survive an edit to a field.
#[test]
fn content_the_command_cannot_reach_survives_a_set() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let path = worklane
.join("campaigns")
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
let original = fs::read_to_string(&path).unwrap();
fs::write(
&path,
original.replace("## Metadata", "## Notes\nA handwritten note.\n\n## Metadata"),
)
.unwrap();
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
let content = campaign_file(&worklane, CAMP_A);
assert!(content.contains("A handwritten note."), "{content}");
assert!(content.contains("What has to ship together."), "{content}");
assert!(content.contains("- **Owner**: alice"), "{content}");
assert!(!content.contains("**Status**"), "a status was invented: {content}");
}
/// A campaign that does not resolve leaves everything alone, the answer `assign` already
/// gives an unknown campaign.
#[test]
fn an_unknown_campaign_is_refused_and_nothing_is_written() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["campaign", "set", "nothing-by-that-name", "-c", "v1"]);
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
assert!(stderr(&out).contains("No campaign found"), "{}", stderr(&out));
assert!(
!campaign_file(&worklane, CAMP_A).contains("Codename"),
"something was written"
);
assert!(
!campaign_file(&worklane, CAMP_B).contains("Codename"),
"something was written"
);
}
/// No `--description`: `set` and `append` are a pair for a prose section, and a way to
/// replace a description with no way to add a paragraph is half of it. Pinned so the
/// omission stays a decision rather than becoming an oversight somebody fills in.
#[test]
fn campaign_set_offers_no_description_and_no_owner() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let out = run(&temp, &["campaign", "set", "--help"]);
let help = stdout(&out);
assert!(help.contains("--codename"), "{help}");
assert!(help.contains("--title"), "{help}");
assert!(!help.contains("--description"), "{help}");
assert!(!help.contains("--owner"), "{help}");
assert!(!help.contains("--clear"), "{help}");
}