Compare commits

...
1 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 239d951b8c (9688d34) Add tags set, and bump to 0.26.0
A tag declared with the wrong annotation was stuck with it, which is 32e98ab's
hole arriving before the writer rather than after. The campaigns entry on this
board was already in that state: it reserved the singular for the campaign
command, and stopped being true the moment that tag was rolled in.

`worklane tags set <tag> --annotation` replaces the whole annotation.
`--annotation` is required, so a bare call is a usage error rather than a
silent no-op, and an empty one writes the placeholder, which is why there is
no `--clear`. `add` and `set` refuse what the other is for, each naming the
other, so which one wrote a line is never a question of which was typed.

No `--force`: a codename is guarded because a campaign is addressed by it,
where an annotation is prose written to be revised. No rename: the tag is the
key, so changing it means rewriting the Tags field of every ticket carrying
it.

`report` grew `report_in`, which takes the colour. `report` paints its subject
green and green means title, so a tag could not reuse it: a tag is drawn in a
`TAG_COLORS` slot or it is drawn wrong. Same wording, decision passed in,
which is the trade `paint` makes with `color_text`.

The no-op compares the rendered file rather than the annotation, the way
`apply` compares content for a ticket field.

`tags set` takes a tag the board already has, so it joins the new
`TAG_NESTED_COMMANDS` and gets a fish rule offering `worklane tags`; `tags
add` stays ruleless in `TAG_NEW_COMMANDS`. The guard now names both lists, so
the next tag positional has to pick one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 16:09:03 +02:00
7 changed files with 252 additions and 13 deletions
Generated
+1 -1
View File
@@ -1503,7 +1503,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.25.0"
version = "0.26.0"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.25.0"
version = "0.26.0"
edition = "2024"
[dependencies]
+38 -2
View File
@@ -490,13 +490,14 @@ pub struct CampaignAddArgs {
/// break a script for the sake of symmetry. So the bare form stays the listing, and `tags
/// ls` is the same thing spelled the way `campaign ls` is.
///
/// No `set`: changing an annotation is 9688d34, and a half of `add`/`set` that only ever
/// declares is the honest half to ship first.
#[derive(clap::Subcommand)]
pub enum TagCommand {
/// Declare a tag, and what it means
Add(TagAddArgs),
/// Replace what a declared tag means
Set(TagSetArgs),
/// List the tags the board carries, and how many tickets carry each
Ls,
}
@@ -518,6 +519,41 @@ pub struct TagAddArgs {
pub annotation: Vec<String>,
}
/// What can be replaced on a tag that is already declared: what it means, and nothing else.
///
/// No `--force`, unlike [`CampaignSetArgs`]. A codename is guarded because once a campaign
/// has one it is how the campaign is addressed, on every card and at every command line, so
/// replacing it silently breaks the way it is referred to. An annotation is prose written to
/// be revised and nothing addresses anything by it, so a guard would stand in front of the
/// command's whole purpose.
///
/// No rename. The tag *is* the key, so changing it means rewriting the Tags field of every
/// ticket carrying it. That is a migration, not a flag on `set`.
///
/// No `--clear`. An annotation is emptied with `--annotation ""`, which writes the same
/// placeholder a tag declared without one gets, so a second spelling would add nothing.
/// [`Clearable`] is a ticket's fields anyway, per [`SetArgs`].
///
/// `--annotation` is required, so a bare `worklane tags set <tag>` is a usage error rather
/// than a silent no-op, exactly as the group on [`CampaignSetArgs`] makes it for a campaign.
#[derive(clap::Args)]
pub struct TagSetArgs {
/// The tag to change, spelled the way it is declared
#[arg(value_parser = tag_value)]
pub tag: String,
/// What the tag means and when it is appropriate, replacing whatever it said before. Use
/// multiple flags for multiline annotations
#[arg(
short,
long,
required = true,
allow_hyphen_values = PROSE,
value_parser = annotation_line
)]
pub annotation: Vec<String>,
}
/// `ls` holds four filters, an output mode and nothing else, which is the boundary the
/// Rust Style rule in AGENTS.md names: two of the filters are adjacent `Option<String>`
/// values that a caller can swap silently, so the mode that joined them came as a
+27 -6
View File
@@ -66,6 +66,15 @@ pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
/// one where `ls --ids` answers the tickets.
pub const TAG_FLAGS: [&str; 1] = ["tag"];
/// Nested commands whose first argument is a tag the board already has.
///
/// `tags set` changes what a declared tag means, so the values it takes are exactly the
/// ones `worklane tags` prints. `tags add` is deliberately absent: the tag it takes is one
/// the board does not have yet, so offering the ones it does would offer exactly the values
/// it refuses. Which of the two a new tag positional belongs to is what
/// `no_tag_taking_option_is_missing` makes somebody decide.
pub const TAG_NESTED_COMMANDS: [(&str, &str); 1] = [("tags", "set")];
pub fn generate(shell: Shell, out: &mut dyn io::Write) -> io::Result<()> {
let mut command = crate::command::Cli::command();
clap_complete::generate(shell, &mut command, "worklane", out);
@@ -92,6 +101,11 @@ fn fish_dynamic() -> String {
.join("; or ");
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
let tag_flags = flag_list(&TAG_FLAGS);
let tag_nested = TAG_NESTED_COMMANDS
.iter()
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
.collect::<Vec<_>>()
.join("; or ");
let statuses = possible_values(Status::value_variants());
let shells = possible_values(Shell::value_variants());
let skills = SKILLS
@@ -182,6 +196,11 @@ complete -c worklane -n '__worklane_command_is ls' {campaign_flags} \
# worth reading: it says which spelling the board actually uses.
complete -c worklane -n '__worklane_command_is ls' {tag_flags} -x -a '(worklane tags)'
# And `tags set` names one that is already declared, so it reads the same listing. `tags
# add` has no rule on purpose: it takes a tag the board does not have, so the candidates
# here are the values it refuses.
complete -c worklane -n '{tag_nested}' -a '(worklane tags)'
# `chown --clear` names the ticket in the flag too, since with no user to give there is
# no second positional to put it in. Scoped to `chown`, unlike the rule above: `set`
# has a `--clear` of its own that takes a field name, and clap already offers those.
@@ -377,16 +396,18 @@ mod tests {
let name = path.join(" ");
let Some(long) = arg.get_long() else {
let nested = match path.as_slice() {
let known = match path.as_slice() {
[parent, child] => {
TAG_NEW_COMMANDS.contains(&(parent.as_str(), child.as_str()))
let pair = (parent.as_str(), child.as_str());
TAG_NESTED_COMMANDS.contains(&pair) || TAG_NEW_COMMANDS.contains(&pair)
}
_ => false,
};
assert!(
nested,
"`worklane {name}` takes a tag as a positional, \
which the fish block has no rule for"
known,
"`worklane {name}` takes a tag as a positional, so it belongs in \
TAG_NESTED_COMMANDS if the tag already exists and TAG_NEW_COMMANDS if it \
does not"
);
continue;
};
@@ -397,7 +418,7 @@ mod tests {
);
}
assert_eq!(seen, 2, "expected ls --tag and tags add");
assert_eq!(seen, 3, "expected ls --tag, tags add and tags set");
}
/// **Every rule naming an option has to say which command it belongs to.** A bare
+61 -3
View File
@@ -8,7 +8,7 @@ use std::path::Path;
use crate::campaign::*;
use crate::command::{
AddArgs, AppendArgs, CampaignAddArgs, CampaignSetArgs, CheckArgs, ChownArgs, LsArgs,
RelateArgs, SetArgs, TagAddArgs,
RelateArgs, SetArgs, TagAddArgs, TagSetArgs,
};
use crate::install;
use crate::tag::{TAGS_FILE, TagIndex, tags_path};
@@ -872,12 +872,23 @@ fn apply(content: &mut String, changed: &mut Vec<&'static str>, field: &'static
}
fn report(fields: &[&str], title: &str, verb: &str) {
report_in(fields, title, Color::Green, verb)
}
/// The same, for a subject that is not a title.
///
/// Green means title, everywhere, so the one caller whose subject is a tag cannot use it:
/// a tag is drawn in a `TAG_COLORS` slot or it is drawn wrong, and green is deliberately
/// not one of them. The colour is passed in rather than decided here, which is the trade
/// `paint` makes with `color_text`, and it keeps the wording in one place so a tag reports
/// a no-op in the same words a ticket does.
fn report_in(fields: &[&str], title: &str, color: Color, verb: &str) {
if fields.is_empty() {
println!("No changes to '{}'", color_text(title, Color::Green));
println!("No changes to '{}'", color_text(title, color));
return;
}
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, Color::Green));
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, color));
}
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
@@ -1296,6 +1307,53 @@ pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
Ok(())
}
/// Replace what a declared tag means.
///
/// The other half of `tags add`, and the half `campaign` still lacks for its description,
/// 32e98ab. An annotation is the sentence a whole team files tickets against, so getting it
/// wrong once must not be permanent.
///
/// **A tag that is not declared is refused rather than declared here.** `add` and `set` are
/// a pair, each refusing what the other is for, so which of the two wrote a line is never a
/// question of which one happened to be typed. The refusal names the other command, the way
/// `add`'s names this one.
///
/// The no-op compares the rendered file rather than the annotation, which is what `apply`
/// does for a ticket: the file is the thing that would be written, so it is the thing worth
/// asking whether the write would change.
pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
let worklane_dir = find_worklane_dir(start)?;
let mut index = TagIndex::load(&worklane_dir)?;
if !index.declared(&args.tag) {
return Err(anyhow!(
"No tag '{}' is declared, so nothing was written. \
Use `worklane tags add` to declare it",
args.tag
));
}
let original = index.render();
index.declare(&args.tag, &trim_blank_ends(&args.annotation).join("\n"));
let next = index.render();
let mut changed: Vec<&'static str> = Vec::new();
if original != next {
changed.push("annotation");
write_then_replace(
&worklane_dir,
&tags_path(&worklane_dir),
TAGS_FILE,
&next,
TAG,
&args.tag,
)?;
}
report_in(&changed, &args.tag, tag_color(&args.tag), "Updated");
Ok(())
}
/// Replace fields on a campaign that is already filed.
///
/// `cmd_set` for a campaign, and built out of the same parts: `set_title` for the heading,
+1
View File
@@ -88,6 +88,7 @@ fn main() -> Result<()> {
cmd_tags(&worklane_dir)
}
Some(TagCommand::Add(args)) => cmd_tag_add(&args, &start),
Some(TagCommand::Set(args)) => cmd_tag_set(&args, &start),
},
// No board either, for the reason `install-skill` has none: a completion script
// is generated from the clap definition and is the same wherever it is run.
+123
View File
@@ -411,3 +411,126 @@ fn the_bare_form_and_ls_are_the_same_listing() {
assert_eq!(bare.stdout, group.stdout);
assert_eq!(String::from_utf8_lossy(&bare.stdout), "bug\t1\ncli\t1\n");
}
// -------------------------------------------------- changing what a tag means --
/// The replacement lands, and replaces rather than appends.
#[test]
fn tags_set_replaces_what_a_tag_means() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug", "-a", "The first sentence."]);
let out = run(&temp, &["tags", "set", "bug", "-a", "The second sentence."]);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert_eq!(declared(&temp, "bug").as_deref(), Some("The second sentence."));
assert!(!vocabulary(&temp).contains("first"), "the old annotation survived");
}
/// Paragraph breaks survive the round trip, which is the whole difference between an
/// annotation and a one-line description of a tag.
#[test]
fn a_multiline_annotation_survives_being_set() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug"]);
run(
&temp,
&[
"tags",
"set",
"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."));
}
/// Set to what it already says, nothing is written and the command says so, the way `set`
/// and `chown` report a field that already holds the value.
#[test]
fn setting_an_annotation_to_what_it_already_says_writes_nothing() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug", "-a", "The sentence."]);
let before = fs::metadata(temp.path().join(".worklane").join("tags.md"))
.unwrap()
.modified()
.unwrap();
let out = run(&temp, &["tags", "set", "bug", "-a", "The sentence."]);
assert!(out.status.success());
assert!(String::from_utf8_lossy(&out.stdout).contains("No changes"), "{out:?}");
let after = fs::metadata(temp.path().join(".worklane").join("tags.md"))
.unwrap()
.modified()
.unwrap();
assert_eq!(before, after, "the file was rewritten for a no-op");
}
/// `add` and `set` are a pair, each refusing what the other is for, so the refusal names
/// the other command rather than leaving it to be found.
#[test]
fn setting_a_tag_that_is_not_declared_is_refused_and_names_add() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug"]);
let out = run(&temp, &["tags", "set", "cli", "-a", "Anything."]);
assert!(!out.status.success());
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("tags add"), "{stderr}");
assert!(declared(&temp, "cli").is_none(), "the tag was declared by set");
}
/// A bare `tags set <tag>` is a usage error. Nothing to write is a mistake in the call, not
/// a command that quietly does nothing.
#[test]
fn setting_nothing_is_a_usage_error() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug", "-a", "The sentence."]);
let out = run(&temp, &["tags", "set", "bug"]);
assert_eq!(out.status.code(), Some(2), "{out:?}");
assert_eq!(declared(&temp, "bug").as_deref(), Some("The sentence."));
}
/// An annotation can be emptied back to the placeholder, which is the state a tag declared
/// without one is already in. That is why there is no `--clear`.
#[test]
fn an_annotation_can_be_emptied_back_to_the_placeholder() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug", "-a", "The sentence."]);
run(&temp, &["tags", "set", "bug", "-a", ""]);
assert_eq!(declared(&temp, "bug").as_deref(), Some("_No annotation provided._"));
}
/// The other tags keep their sections, since the whole file is re-rendered on every write.
#[test]
fn setting_one_annotation_leaves_the_others_alone() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
run(&temp, &["tags", "add", "bug", "-a", "About bugs."]);
run(&temp, &["tags", "add", "tui", "-a", "About the board."]);
run(&temp, &["tags", "set", "bug", "-a", "Rewritten."]);
assert_eq!(declared(&temp, "bug").as_deref(), Some("Rewritten."));
assert_eq!(declared(&temp, "tui").as_deref(), Some("About the board."));
}