(a1a5d69) Add tags to a ticket with append --tags, keeping the ones it carries, and bump to 0.32.18

`set --tags` writes the whole field, so adding one tag to a ticket that
already carries some meant reading it first and retyping every one of
them. 30a2b34 wrote that down in the skill as the way to do it; this is
the flag that makes it unnecessary.

The merge is idempotent and ordered. A tag the ticket already carries is
reported as no change rather than added twice, which is the point of the
flag: the caller does not have to know what is there. A new one goes on
the end in the order it was given rather than sorting the field under
whoever last touched it. Values are split on commas the way the stored
field is, so `--tags "bug, tui"` names two tags and matches the two a
ticket carrying them already holds; without that the pair would land as
a single tag nothing can filter by and would not match itself on the
next call. `split_tags` is that rule, lifted out of `parse_tags` so the
argument and the field are separated by the same code.

It writes the same `Kind::Tags` entry `set --tags` writes, so `--actor`
and `--actor-from-git` come with it. Tags are logged wherever they move,
and the one command that adds to them without replacing them would
otherwise be the one tag change the log missed. The before and after are
read off the field rather than off the flag, so an append of `beta` onto
`alpha` reads as the pair and not as what the call asked for.

`non_empty` rather than the `clearable` that `set --tags` takes: that
message names `--clear`, and `append` has none, so it would send the
caller looking here for a flag that is `set`'s. A value that is only
separators reaches the handler and is refused there, in the words
`appended_items` refuses an all-blank section with. Emptying the field
stays `set --clear tags`.

`TAG_FLAGS` becomes pairs of command and flag, because `ls --tag` and
`append --tags` are spelled differently and one rule naming both options
would tell fish that each command accepts the other's. `add --tags` and
`set --tags` deliberately get no value rule and are recorded in the
test's `TAG_LIST_FLAGS` instead: they take the whole list, so the token
at the cursor is `bug,tui` and fish replaces a token entire, throwing
away what is already typed. The honesty test now walks `tag` and `tags`
both, so the next tag argument has to say which of the two it is.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-31 23:37:33 +02:00
co-authored by Claude Opus 5
parent b4534eb86d
commit 7470255a22
12 changed files with 374 additions and 35 deletions
+26 -4
View File
@@ -858,14 +858,15 @@ impl ChownArgs {
}
}
/// `append` only offers the sections that hold multiple lines, since appending to a
/// scalar has no meaning.
/// `append` offers the fields something can be added to without disturbing what is
/// already in them: the three sections that hold multiple lines, and Tags, which is a
/// list. Appending to a scalar has no meaning, so there is no `--priority` or `--due`.
#[derive(clap::Args)]
#[command(group(
clap::ArgGroup::new("append_fields")
.required(true)
.multiple(true)
.args(["description", "acceptance", "plan"])
.args(["description", "acceptance", "plan", "tags"])
))]
pub struct AppendArgs {
/// Ticket UUID or title
@@ -882,6 +883,24 @@ pub struct AppendArgs {
/// Add implementation plan steps, numbered on from the last. Repeat the flag
#[arg(short, long, allow_hyphen_values = PROSE)]
pub plan: Vec<String>,
/// Add tags, keeping the ones the ticket already carries. Repeat the flag, or
/// separate them with commas
///
/// `non_empty` rather than the `clearable` that `set --tags` takes. That message
/// names `--clear`, and this command has none: emptying the field is
/// `set --clear tags`, so pointing at a flag that is not here would send the caller
/// looking for it on `append`.
#[arg(short = 'g', long, value_parser = non_empty)]
pub tags: Vec<String>,
/// Only reaches the entry `--tags` writes, since that is the one field of this
/// command's that is logged, exactly as on `set`
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
pub actor_from_git: bool,
}
/// `relate` is the only writer of the Relations section, the way `chown` is the only
@@ -1080,6 +1099,9 @@ mod tests {
// A guard on the walker itself: if it stopped finding commands, every assertion
// above would pass by never running.
assert_eq!(seen, 5, "expected comment, mv, chown, set and assign to carry --actor");
assert_eq!(
seen, 6,
"expected comment, mv, chown, set, append and assign to carry --actor"
);
}
}