(74904dc) Let a ticket field be cleared back to unset, and bump to 0.18.0

`set --clear <field>` is the one way to take a value away, repeatable, with
the field as a `ValueEnum` value: an unknown one is a usage error listing the
six that are not, and the shells complete them for free. Not a per-field
`--clear-due`, which is a flag per field to keep in step with the one it
undoes, and not an empty value, which is already a paragraph break for a
section and would make an accidentally empty variable a silent delete.

What goes back is what `add` writes for a field it was never given, through
the new `NOT_SET` and `NONE` constants and each section's placeholder, so a
cleared ticket and one filed without the field read the same. Sections are in
scope and go back through `clear_section_body` rather than
`set_section_body`: the latter runs its items through `Section::render`, which
would have written `- [ ] _No acceptance criteria provided._`.

Owner is `chown --clear <ticket>`, so the field keeps its one writer. The flag
carries the ticket because the ticket is chown's second positional and a bare
flag would land it in the user's slot for the handler to read back out, which
is hand-parsing what clap can state. It writes `_Not set_` rather than the git
user: `add` falls back to the git user because it is filing something new, and
an owner taken away says nobody owns this.

The empty-value error split in two rather than being reworded. `non_empty`
says only that the value cannot be empty, for the arguments with no empty
form; `clearable` names `--clear`, for the arguments whose field has one. One
message for both would have lied about `ls --tag`.

Replacing and clearing one field in a single call is refused rather than
resolved by whichever was applied last, and cleared fields are reported as
`Cleared due on '...'` beside `Updated priority on '...'`, since one list
would say `Updated` of a field that was emptied.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-23 00:04:28 +02:00
co-authored by Claude Opus 5
parent 175c1d016d
commit cc5f9b8a46
15 changed files with 810 additions and 92 deletions
+246 -14
View File
@@ -190,7 +190,11 @@ fn set_reports_only_the_fields_that_changed() {
assert!(!stdout.contains("due"), "{stdout:?}");
}
/// An empty scalar looks like a way to clear a field, and clearing is not supported.
/// An empty scalar is still a usage error, and the message now points at the flag that
/// does clear a field, so the two do not contradict each other.
///
/// `--title` is the exception, and says only that the value cannot be empty: a title has
/// no unset state to return to, so there is nothing to point at.
#[test]
fn set_refuses_an_empty_scalar_as_a_usage_error() {
let temp = TempDir::new().unwrap();
@@ -198,12 +202,227 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
create_ticket(&worklane);
let before = ticket(&worklane);
for flag in ["--title", "--due", "--tags"] {
for (flag, expected) in [
("--title", "value cannot be empty"),
("--due", "use --clear"),
("--tags", "use --clear"),
] {
let out = run(&temp, &["set", UUID, flag, ""]);
assert_eq!(out.status.code(), Some(2), "{flag} was accepted");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
assert!(
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
"{flag}: {:?}",
!stderr.contains("not supported"),
"{flag} still says clearing is unsupported: {stderr:?}"
);
}
assert_eq!(ticket(&worklane), before);
}
/// An empty value is a paragraph break for a section, so it cannot also mean empty the
/// section. The error names the flag that does, per section.
#[test]
fn set_refuses_an_empty_section_and_names_the_clear_for_it() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
for (flag, expected) in [
("--description", "--clear description"),
("--acceptance", "--clear acceptance"),
("--plan", "--clear plan"),
] {
let out = run(&temp, &["set", UUID, flag, ""]);
assert_eq!(out.status.code(), Some(1), "{flag} was accepted");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
}
assert_eq!(ticket(&worklane), before);
}
/// Every field `--clear` reaches, in one call, back to what a ticket is born with.
#[test]
fn clear_returns_every_field_it_reaches_to_unset() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(
&temp,
&[
"set", UUID,
"--clear", "due",
"--clear", "tags",
"--clear", "priority",
"--clear", "description",
"--clear", "acceptance",
"--clear", "plan",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
let content = ticket(&worklane);
assert!(content.contains("- **Due**: _Not set_"), "{content}");
assert!(content.contains("- **Tags**: _None_"), "{content}");
assert!(content.contains("- **Priority**: _Not set_"), "{content}");
assert!(
content.contains("## Description\n_No description provided._\n"),
"{content}"
);
assert!(
content.contains("## Acceptance Criteria\n_No acceptance criteria provided._\n"),
"{content}"
);
assert!(
content.contains("## Implementation Plan\n_No implementation plan provided._\n"),
"{content}"
);
// The placeholder goes in bare, not dressed as an item of the section it replaces.
assert!(!content.contains("- [ ] _No"), "{content}");
assert!(!content.contains("1. _No"), "{content}");
// What --clear cannot reach is untouched, the handwritten section included.
assert!(content.starts_with("# Original title\n"), "{content}");
assert!(content.contains("- **Owner**: alice"), "{content}");
assert!(content.contains("- **Status**: backlog"), "{content}");
assert!(
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
"{content}"
);
}
/// A cleared ticket and one that was never given the field have to read the same, or
/// clearing would be its own third state.
#[test]
fn a_cleared_ticket_reads_like_one_filed_without_the_fields() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
run(&temp, &["add", "--title", "Bare"]);
run(
&temp,
&[
"add",
"--title", "Full",
"--description", "A body.",
"--acceptance", "One criterion",
"--plan", "One step",
"--tags", "alpha,beta",
"--due", "2026-09-01",
"--priority", "2",
],
);
let full = added(&worklane, "full");
let out = run(
&temp,
&[
"set", &full.0,
"--clear", "due",
"--clear", "tags",
"--clear", "priority",
"--clear", "description",
"--clear", "acceptance",
"--clear", "plan",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
let cleared = comparable(&fs::read_to_string(&full.1).unwrap());
let bare = comparable(&fs::read_to_string(&added(&worklane, "bare").1).unwrap());
assert_eq!(cleared, bare);
}
/// The uuid and the file of the one ticket whose slug matches, as `add` wrote it.
fn added(worklane: &Path, slug: &str) -> (String, PathBuf) {
let entry = fs::read_dir(worklane.join("backlog"))
.unwrap()
.filter_map(|e| e.ok())
.find(|e| {
e.file_name()
.to_string_lossy()
.ends_with(&format!("_{slug}.md"))
})
.unwrap_or_else(|| panic!("no ticket slugged {slug}"));
let name = entry.file_name().into_string().unwrap();
let uuid = name.split('_').next().unwrap().to_string();
(uuid, entry.path())
}
/// A ticket without the three lines that are different by definition: its title, its
/// uuid and the moment it was filed.
fn comparable(content: &str) -> String {
content
.lines()
.filter(|line| {
!line.starts_with("# ")
&& !line.contains("**ID**:")
&& !line.contains("**Created At**:")
})
.collect::<Vec<_>>()
.join("\n")
}
/// Nothing to take away is not a rewrite, per the same whole-file comparison a
/// replacement uses.
#[test]
fn clearing_a_field_that_is_already_unset_is_no_change() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
let before = ticket(&worklane);
let out = run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
assert!(out.status.success());
assert!(
String::from_utf8_lossy(&out.stdout).contains("No changes"),
"{:?}",
String::from_utf8_lossy(&out.stdout)
);
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
}
/// Replaced and emptied are reported in those words, since a caller doing both in one
/// call cannot tell which happened to which field otherwise.
#[test]
fn clear_is_reported_apart_from_a_replacement() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["set", UUID, "--priority", "1", "--clear", "due"]);
assert!(out.status.success());
let stdout = String::from_utf8_lossy(&out.stdout);
assert!(stdout.contains("Updated priority on 'Original title'"), "{stdout:?}");
assert!(stdout.contains("Cleared due on 'Original title'"), "{stdout:?}");
}
/// Replacing and clearing one field in a single call is a contradiction, and answering
/// it by whichever was applied last would be a silent answer.
#[test]
fn clearing_and_replacing_the_same_field_is_refused() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
for (flag, value, field) in [
("--due", "2026-12-31", "due"),
("--tags", "beta", "tags"),
("--priority", "1", "priority"),
("--acceptance", "A criterion", "acceptance"),
] {
let out = run(&temp, &["set", UUID, flag, value, "--clear", field]);
assert_eq!(out.status.code(), Some(1), "{flag} with --clear {field} was accepted");
assert!(
String::from_utf8_lossy(&out.stderr).contains("contradict each other"),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
}
@@ -211,25 +430,38 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
assert_eq!(ticket(&worklane), before);
}
/// An empty value is a paragraph break for a section, so an all-blank one is a
/// clearing attempt rather than a break.
/// The fields no writer of `set` can reach are not reachable through `--clear` either,
/// and an unknown one is a usage error listing what is.
#[test]
fn set_refuses_to_clear_a_section() {
fn clear_refuses_a_field_it_does_not_own() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
let out = run(&temp, &["set", UUID, "--description", ""]);
assert_eq!(out.status.code(), Some(1));
assert!(
String::from_utf8_lossy(&out.stderr).contains("clearing is not supported"),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
for field in ["owner", "title", "status", "campaign", "relations", "nonsense"] {
let out = run(&temp, &["set", UUID, "--clear", field]);
assert_eq!(out.status.code(), Some(2), "--clear {field} was accepted");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("possible values"), "{field}: {stderr:?}");
}
assert_eq!(ticket(&worklane), before);
}
/// `--clear` on its own satisfies the at-least-one-field rule, since it is a field
/// being written like any other.
#[test]
fn clear_alone_is_enough_of_a_field() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["set", UUID, "--clear", "due"]);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
assert!(ticket(&worklane).contains("- **Due**: _Not set_"));
}
/// A bare `set <ticket>` would otherwise be a silent no-op.
#[test]
fn set_requires_at_least_one_field() {