(451fb83) Add a discarded status for work that will not be done, and bump to 0.31.0

The flow ended at done, so a ticket that turned out to be a duplicate or
obsolete had nowhere to go: it sat in the backlog or was deleted by hand,
which destroyed the record and left every relation to it dangling. Discarded
is a fifth status with its own directory, keeping the invariant that the
filename, the Status field and the directory agree, and keeping done meaning
the work landed.

Entering it is allowed from any status without -f, because discarding is not
a stage of work. Discarded sits last in Status::ALL, which is what makes the
rest fall out rather than needing cases: nothing follows it, so a discard
clears no stamp and a ticket abandoned from reviewing keeps the journey it
made, and every move out is a backward move, so un-discarding needs -f.

The two dependency guards now look opposite ways. check_blockers asks what a
ticket waits on and gates work moves; check_dependents asks who waits on it
and gates the discard, because those plans depended on work about to be
declared never-happening. Both skip targets that are themselves terminal.

Status::FLOW is the four stages the board draws, so a discarded column on
screen stays a136d13's ticket and done stays the last drawn column. Every
tree walker keeps using Status::ALL, or a discarded ticket would be
unaddressable.

util::is_open replaces three spellings of "not done and not discarded",
across mv, ls and the campaign standing. The board's blocked mark goes
through it as well: that path was only accidentally correct, since a
discarded blocker is absent from the FLOW columns, and drawing the column
later would have diverged it from what mv allows.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-24 19:44:14 +02:00
co-authored by Claude Fable 5
parent c03f47c52d
commit 5bf0fd1bfe
14 changed files with 572 additions and 74 deletions
+40
View File
@@ -1703,3 +1703,43 @@ fn a_campaign_with_no_description_section_is_refused() {
assert_eq!(fs::read_to_string(&path).unwrap(), before, "the file was written");
}
}
/// A discarded member counts as finished. The work was decided out of the campaign
/// rather than left in it, and counting it as outstanding would hold the campaign open
/// forever over a ticket nobody will ever do.
#[test]
fn a_discarded_member_counts_as_finished() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
run(&temp, &["assign", "v1 release", OTHER]);
// Two members, one done and one in the backlog: open and half finished.
let listing = stdout(&run(&temp, &["campaign", "ls"]));
assert!(listing.contains("v1 release | 1/2 done [open]"), "{listing}");
let discarded = run(&temp, &["mv", MEMBER, "--status", "discarded"]);
assert!(discarded.status.success(), "{}", stderr(&discarded));
let listing = stdout(&run(&temp, &["campaign", "ls"]));
assert!(listing.contains("v1 release | 2/2 done [done]"), "{listing}");
}
/// `campaign show` groups the members by status, and a discarded one has a group to
/// land in rather than dropping out of the campaign it belongs to.
#[test]
fn campaign_show_lists_a_discarded_member() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
assert!(
run(&temp, &["mv", MEMBER, "--status", "discarded"])
.status
.success()
);
let shown = stdout(&run(&temp, &["campaign", "show", "aa11"]));
assert!(shown.contains("The member"), "the discarded member is gone: {shown}");
}
+2 -2
View File
@@ -62,10 +62,10 @@ fn no_other_shell_gets_the_fish_half() {
#[test]
fn fish_is_offered_every_status() {
let out = script("fish");
for status in ["backlog", "committed", "reviewing", "done"] {
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
assert!(out.contains(status), "fish is never offered {status}");
}
assert!(out.contains("-a 'backlog committed reviewing done' -d status"));
assert!(out.contains("-a 'backlog committed reviewing done discarded' -d status"));
}
#[test]
+44
View File
@@ -903,3 +903,47 @@ fn ls_ids_prints_the_same_order_the_listing_does() {
let seen = positions(&stdout, ["Oldest", "Newest", "Unstamped"]);
assert!(seen[0] < seen[1] && seen[1] < seen[2], "{stdout}");
}
/// Discarded is the other terminal status, so the decorated listing leaves it out the
/// way it leaves done out: it is counted in the summary and not listed. The positional
/// and `--ids` still reach it, since a ticket nobody will work still has to be nameable.
#[test]
fn ls_hides_discarded_but_counts_and_can_name_it() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
temp.child(".worklane")
.child("discarded")
.create_dir_all()
.unwrap();
create_ticket_with_id(
&worklane,
"backlog",
"Still open",
"aaaaaaa1-0000-0000-0000-000000000001",
"bug",
);
create_ticket_with_id(
&worklane,
"discarded",
"Abandoned",
"ccccccc3-0000-0000-0000-000000000003",
"bug",
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls");
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Still open"), "{stdout}");
assert!(!stdout.contains("Abandoned"), "discarded was listed: {stdout}");
assert!(stdout.contains("DISCARDED"), "discarded is not counted: {stdout}");
// Nameable both ways, the way done is.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
assert!(get_stdout(&mut cmd).contains("Abandoned"));
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "discarded"]);
assert!(get_stdout(&mut cmd).contains("Abandoned"));
}
+216
View File
@@ -1144,3 +1144,219 @@ fn mv_does_not_restamp_a_no_op_move() {
assert_eq!(ticket_at(&worklane, "committed", &filename), before);
}
// ---------------------------------------------------------------- discarded --
/// Discarding is not a stage of work, so it is reachable from wherever the ticket
/// stands and needs no `-f`: a backlog ticket that turns out to be a duplicate should
/// not have to be walked through committed and reviewing to be abandoned.
#[test]
fn mv_discards_from_every_status_without_force() {
for from in ["backlog", "committed", "reviewing", "done"] {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = stamped_ticket(&worklane, from);
let out = move_ticket(&temp, "cccc3333", "discarded", false);
assert!(
out.status.success(),
"discarding from {from}: {}",
String::from_utf8_lossy(&out.stderr)
);
assert!(
worklane.join("discarded").join(&filename).exists(),
"the ticket did not land in discarded from {from}"
);
assert_eq!(md_files(&worklane.join(from)).len(), 0, "left behind in {from}");
}
}
/// The fixture board has the four directories the tool shipped with. The first discard
/// on a board that predates the status creates the fifth rather than refusing.
#[test]
fn mv_creates_the_discarded_directory_on_a_board_that_predates_it() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = stamped_ticket(&worklane, "backlog");
assert!(
!worklane.join("discarded").exists(),
"the fixture already had the directory"
);
let out = move_ticket(&temp, "cccc3333", "discarded", false);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(worklane.join("discarded").join(&filename).exists());
}
/// Leaving discarded is a backward move, which is the rule that already needs `-f`.
/// Un-discarding is a correction rather than a stage, so it is allowed under it.
#[test]
fn leaving_discarded_needs_force() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = stamped_ticket(&worklane, "backlog");
assert!(
move_ticket(&temp, "cccc3333", "discarded", false)
.status
.success()
);
let refused = move_ticket(&temp, "cccc3333", "backlog", false);
assert!(!refused.status.success());
assert!(
String::from_utf8_lossy(&refused.stderr).contains("--force"),
"{}",
String::from_utf8_lossy(&refused.stderr)
);
assert!(worklane.join("discarded").join(&filename).exists());
let forced = move_ticket(&temp, "cccc3333", "backlog", true);
assert!(forced.status.success(), "{}", String::from_utf8_lossy(&forced.stderr));
assert!(worklane.join("backlog").join(&filename).exists());
}
/// The guard looks the other way round from `check_blockers`: a ticket being abandoned
/// owes nothing to what it waits on, but the tickets waiting on *it* recorded a
/// dependency on work that is about to be declared never-happening.
#[test]
fn mv_refuses_to_discard_a_ticket_open_tickets_are_blocked_by() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_gated_pair(&worklane, &temp, "backlog");
let out = move_ticket(&temp, "bbbb2222", "discarded", false);
assert!(!out.status.success());
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("Gated Task"), "the dependent is not named: {stderr}");
assert!(stderr.contains("--force"), "{stderr}");
assert!(
!worklane.join("discarded").exists(),
"a refused discard made the directory"
);
}
/// `-f` is the caller saying they looked at the dependents.
#[test]
fn mv_discards_a_blocked_from_ticket_with_force() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_gated_pair(&worklane, &temp, "backlog");
let out = move_ticket(&temp, "bbbb2222", "discarded", true);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
}
/// A dependent that is itself finished or abandoned is nobody's plan, so it does not
/// hold up the discard.
#[test]
fn a_done_or_discarded_dependent_does_not_hold_up_a_discard() {
for status in ["done", "discarded"] {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_gated_pair(&worklane, &temp, "backlog");
assert!(
move_ticket(&temp, "aaaa1111", status, true).status.success(),
"the dependent could not be moved to {status}"
);
let out = move_ticket(&temp, "bbbb2222", "discarded", false);
assert!(
out.status.success(),
"a {status} dependent held up the discard: {}",
String::from_utf8_lossy(&out.stderr)
);
}
}
/// A discarded blocker satisfies the block the way a done one does: there is nothing
/// left to wait for. Whether the dependent still makes sense was asked when the blocker
/// was discarded, which is the refusal above.
#[test]
fn a_discarded_blocker_does_not_block() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_gated_pair(&worklane, &temp, "backlog");
assert!(
move_ticket(&temp, "bbbb2222", "discarded", true)
.status
.success()
);
let out = move_ticket(&temp, "aaaa1111", "committed", false);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(worklane.join("committed").join(&filename).exists());
}
/// Entering discarded clears no stamp, which is what discarded being last in
/// `Status::ALL` buys: a ticket abandoned from reviewing keeps the journey it made, so
/// the log still says how far it got before it was dropped.
#[test]
fn discarding_keeps_the_stamps_the_ticket_already_had() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = stamped_ticket(&worklane, "backlog");
assert!(
move_ticket(&temp, "cccc3333", "committed", false)
.status
.success()
);
assert!(
move_ticket(&temp, "cccc3333", "reviewing", false)
.status
.success()
);
let before = ticket_at(&worklane, "reviewing", &filename);
let committed_on = field(&before, "Committed On").expect(&before);
let submitted_on = field(&before, "Submitted On").expect(&before);
assert!(
move_ticket(&temp, "cccc3333", "discarded", false)
.status
.success()
);
let after = ticket_at(&worklane, "discarded", &filename);
assert_eq!(
field(&after, "Committed On").as_deref(),
Some(committed_on.as_str()),
"{after}"
);
assert_eq!(
field(&after, "Submitted On").as_deref(),
Some(submitted_on.as_str()),
"{after}"
);
assert!(field(&after, "Discarded On").is_some(), "no discard stamp: {after}");
assert!(
field(&after, "Completed On").is_none(),
"a discard claimed the ticket was done"
);
}
/// The other end of the same rule: a forced move back out of discarded truncates the
/// journey at the target the way every backward move does.
#[test]
fn un_discarding_drops_the_discard_stamp() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = stamped_ticket(&worklane, "backlog");
assert!(
move_ticket(&temp, "cccc3333", "discarded", false)
.status
.success()
);
assert!(
move_ticket(&temp, "cccc3333", "committed", true)
.status
.success()
);
let content = ticket_at(&worklane, "committed", &filename);
assert!(field(&content, "Discarded On").is_none(), "{content}");
assert!(field(&content, "Committed On").is_some(), "{content}");
}