(55ee6e3) Complete campaigns and tags, and bump to 0.19.0

Every argument naming a campaign or a tag fell through to nothing: `campaign
show <TAB>`, `assign <TAB>`, `ls --campaign <TAB>` and `ls --tag <TAB>`. Neither
value had a listing a completion could parse.

`campaign ls --ids` is the same flag and the same two fields as `ls --ids`,
since it answers the same question about a different object. It skips the member
counting the decorated listing does, because `members()` reads every ticket on
the board and the caller is a shell on a keypress, and it prints nothing on an
empty board where the decorated listing prints a sentence.

Tags get a command rather than a mode on `ls`. `ls --tag <tag>` answers what
carries a tag and cannot answer what tags exist, which is the question a
grooming sweep starts from, and a `--tags` beside a `--tag` is one letter from a
filter that means something else. `worklane tags` prints the tag, a tab and the
count, alphabetical and case sensitive like the filter, so `bug` and `Bug` list
separately and land next to each other. assets/PLAN.md used to tell the agent to
count the vocabulary with a `show` per ticket; it now points here.

The fish half gains `__worklane_nested_arg_of`, which matches a parent and a
child, because `campaign show <TAB>` and `chown alice <TAB>` sit at the same
token count and the two counting helpers cannot tell them apart.

It also gains `__worklane_command_is`, which fixes a leak the campaign and tag
rules would have joined. A bare `complete -c worklane -l tag` does not only
complete that option's values, it tells fish the whole tool accepts `--tag`:
`worklane init --<TAB>` offered `--blocked-by`, `--regression-of`,
`--relates-to` and three others. `relate`'s three were already leaking that way,
so all of them are scoped now rather than leaving a correctly scoped twin beside
a wrong one. `__fish_seen_subcommand_from ls` is not the scope to use, since
`campaign ls` is an `ls` fish has seen.

The honesty tests grow to five lists and one walker, `every_argument`, since
they differ only in the id they look for. Each asserts how many arguments it
found, so a walker that stopped finding them fails rather than passing every
assertion by never running it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-23 01:16:51 +02:00
co-authored by Claude Opus 5
parent 6a800fb385
commit c65e1b4ed7
12 changed files with 571 additions and 40 deletions
+236 -21
View File
@@ -42,6 +42,30 @@ pub const TICKET_SECOND_COMMANDS: [&str; 2] = ["chown", "assign"];
/// Options whose value is a ticket, as `relate` takes three of.
pub const TICKET_FLAGS: [&str; 3] = ["blocked-by", "regression-of", "relates-to"];
/// Subcommands whose first positional is a campaign.
///
/// `assign` alone, which takes the campaign first and the ticket second. Kept honest by
/// the same test the ticket lists are.
pub const CAMPAIGN_COMMANDS: [&str; 1] = ["assign"];
/// Nested subcommands whose first argument is a campaign, as `parent child`.
///
/// `campaign show` is the only one, and it is why the fish half needs a third position
/// helper: its argument is the *third* token, where `__worklane_first_arg_of` reads the
/// second and `__worklane_second_arg_of` counts a top-level command's arguments. Neither
/// can tell `campaign show <TAB>` from `chown alice <TAB>` by position.
pub const CAMPAIGN_NESTED_COMMANDS: [(&str, &str); 1] = [("campaign", "show")];
/// Options whose value is a campaign.
pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
/// Options whose value is a tag.
///
/// Its own list rather than a line in the block below, because the values come from a
/// different command: a tag is not an object with an id, so `worklane tags` answers this
/// one where `ls --ids` answers the tickets.
pub const TAG_FLAGS: [&str; 1] = ["tag"];
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);
@@ -59,11 +83,15 @@ pub fn generate(shell: Shell, out: &mut dyn io::Write) -> io::Result<()> {
fn fish_dynamic() -> String {
let ticket_commands = TICKET_COMMANDS.join(" ");
let ticket_second_commands = TICKET_SECOND_COMMANDS.join(" ");
let ticket_flags = TICKET_FLAGS
let ticket_flags = flag_list(&TICKET_FLAGS);
let campaign_commands = CAMPAIGN_COMMANDS.join(" ");
let campaign_nested = CAMPAIGN_NESTED_COMMANDS
.iter()
.map(|flag| format!("-l {flag}"))
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
.collect::<Vec<_>>()
.join(" ");
.join("; or ");
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
let tag_flags = flag_list(&TAG_FLAGS);
let statuses = possible_values(Status::value_variants());
let shells = possible_values(Shell::value_variants());
let skills = SKILLS
@@ -87,7 +115,7 @@ complete -c worklane -f
# The exception, and the reason the line above is not the whole story: `tui` takes
# project paths, as many as you like. Directories only, since each is resolved to the
# first `.worklane` at or above it.
complete -c worklane -n '__fish_seen_subcommand_from tui' \
complete -c worklane -n '__worklane_command_is tui' \
-a '(__fish_complete_directories)' -d project
# Position is counted rather than inferred from what has been typed: matching against
@@ -108,6 +136,28 @@ function __worklane_second_arg_of
test (count $tokens) -eq 3; and contains -- $tokens[2] $argv
end
# The first argument of a nested subcommand, `worklane campaign show <TAB>`. Three tokens
# with both names matched, rather than the token counting the two above do: `campaign show`
# puts its argument where a top-level command puts its second, so counting alone would
# offer campaigns to `chown alice <TAB>` and tickets here.
function __worklane_nested_arg_of
set -l tokens (commandline -opc)
test (count $tokens) -eq 3; and test "$tokens[2]" = "$argv[1]"; and test "$tokens[3]" = "$argv[2]"
end
# Which command this is, at any position in it. `$tokens[2]` again rather than
# `__fish_seen_subcommand_from`, and for the reason spelled out above: `campaign ls` is an
# `ls` that fish has seen, so scoping `--tag` with fish's own helper would offer it under a
# command that does not take it.
#
# A rule carrying `-l` needs one of these. Without it fish takes the option as one the
# whole tool accepts, and `worklane init --<TAB>` offered `--blocked-by`, `--tag` and four
# others that only `relate` and `ls` have.
function __worklane_command_is
set -l tokens (commandline -opc)
test (count $tokens) -ge 2; and contains -- $tokens[2] $argv
end
# No `-d`: `ls --ids` prints the id and the title separated by a tab, which is fish's
# own form for a candidate and its description, so every ticket carries its own.
complete -c worklane \
@@ -116,12 +166,26 @@ complete -c worklane \
# `relate` takes its targets as option values, so they are completed by flag rather
# than by position.
complete -c worklane {ticket_flags} -x -a '(worklane ls --ids)'
complete -c worklane -n '__worklane_command_is relate' {ticket_flags} \
-x -a '(worklane ls --ids)'
# Campaigns, from `campaign ls --ids`, in the three places one is named: `assign`'s first
# argument, `campaign show`'s only one, and `ls --campaign`.
complete -c worklane \
-n '__worklane_first_arg_of {campaign_commands}; or {campaign_nested}' \
-a '(worklane campaign ls --ids)'
complete -c worklane -n '__worklane_command_is ls' {campaign_flags} \
-x -a '(worklane campaign ls --ids)'
# Tags come from `worklane tags` rather than from a listing of objects, since a tag has no
# id. The count after the tab lands as fish's description, which is what makes the list
# worth reading: it says which spelling the board actually uses.
complete -c worklane -n '__worklane_command_is ls' {tag_flags} -x -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.
complete -c worklane -n '__fish_seen_subcommand_from chown' -l clear -x -a '(worklane ls --ids)'
complete -c worklane -n '__worklane_command_is chown' -l clear -x -a '(worklane ls --ids)'
# clap emits the four for `mv --status`, which is an option, but the fish generator
# emits nothing for the possible values of a positional. So the one place a status is
@@ -136,6 +200,15 @@ complete -c worklane -n '__worklane_first_arg_of install-skill' -a '{skills}' -d
)
}
/// Option names as fish wants them on a `complete` line, `-l one -l two`.
fn flag_list(flags: &[&str]) -> String {
flags
.iter()
.map(|flag| format!("-l {flag}"))
.collect::<Vec<_>>()
.join(" ")
}
/// The names a `ValueEnum` accepts, for a fish `-a` list.
///
/// Read off the enum rather than written out, so a status or a shell added to either one
@@ -162,29 +235,68 @@ mod tests {
cli
}
/// Every argument in the tool, as the path that reaches it and the argument itself.
///
/// One walker for the honesty tests below, rather than each one repeating the
/// traversal: they differ only in which id they are looking for. Two levels, which is
/// as deep as the tool goes, and `help` is skipped because clap generates it and it
/// takes no object of ours.
fn every_argument() -> Vec<(Vec<String>, clap::Arg)> {
let cli = command();
let mut found = Vec::new();
for subcommand in cli.get_subcommands() {
let name = subcommand.get_name().to_string();
if name == "help" {
continue;
}
for arg in subcommand.get_arguments() {
found.push((vec![name.clone()], arg.clone()));
}
for nested in subcommand.get_subcommands() {
let child = nested.get_name().to_string();
if child == "help" {
continue;
}
for arg in nested.get_arguments() {
found.push((vec![name.clone(), child.clone()], arg.clone()));
}
}
}
found
}
/// Every subcommand that takes a ticket must be listed, at the position it takes it,
/// or it silently loses completion.
///
/// The nested subcommands are not walked. `campaign` is the only one, none of its
/// three takes a ticket, and the token counting above could not tell them apart if
/// one did. A ticket argument added under `campaign` needs the fish block reworked,
/// not another name in a list.
/// Nested subcommands are walked now that `__worklane_nested_arg_of` exists, but
/// nothing under `campaign` takes a ticket, so a nested one is a panic rather than a
/// list: it would need a rule of its own in the fish block, and a name in a list here
/// would look like it already had one.
#[test]
fn no_ticket_taking_subcommand_is_missing() {
for subcommand in command().get_subcommands() {
let name = subcommand.get_name();
for positional in subcommand.get_positionals() {
// `show` calls it `id`; everything else calls it `ticket`.
if !matches!(positional.get_id().as_str(), "ticket" | "id") {
continue;
}
match positional.get_index() {
for (path, arg) in every_argument() {
// `show` calls it `id`; everything else calls it `ticket`.
if !matches!(arg.get_id().as_str(), "ticket" | "id") {
continue;
}
let name = path.join(" ");
if arg.is_positional() {
assert_eq!(
path.len(),
1,
"`worklane {name}` takes a nested ticket argument, \
which needs a rule in the fish block"
);
let top = path[0].as_str();
match arg.get_index() {
Some(1) => assert!(
TICKET_COMMANDS.contains(&name),
TICKET_COMMANDS.contains(&top),
"`worklane {name}` takes a ticket first but is not in TICKET_COMMANDS"
),
Some(2) => assert!(
TICKET_SECOND_COMMANDS.contains(&name),
TICKET_SECOND_COMMANDS.contains(&top),
"`worklane {name}` takes a ticket second but is not in \
TICKET_SECOND_COMMANDS"
),
@@ -194,6 +306,97 @@ mod tests {
}
}
/// The same for campaigns, which is why the lists above are three rather than one:
/// a campaign is named as a first positional, as a nested subcommand's only argument,
/// and as an option value, and each needs a different rule in the fish block.
#[test]
fn no_campaign_taking_argument_is_missing() {
let mut seen = 0;
for (path, arg) in every_argument() {
if arg.get_id().as_str() != "campaign" {
continue;
}
seen += 1;
let name = path.join(" ");
if let Some(long) = arg.get_long() {
assert!(
CAMPAIGN_FLAGS.contains(&long),
"`worklane {name} --{long}` takes a campaign but is not in CAMPAIGN_FLAGS"
);
continue;
}
assert_eq!(
arg.get_index(),
Some(1),
"`worklane {name}` takes a campaign somewhere the fish block has no rule for"
);
match path.as_slice() {
[top] => assert!(
CAMPAIGN_COMMANDS.contains(&top.as_str()),
"`worklane {name}` takes a campaign first but is not in CAMPAIGN_COMMANDS"
),
[parent, child] => assert!(
CAMPAIGN_NESTED_COMMANDS.contains(&(parent.as_str(), child.as_str())),
"`worklane {name}` takes a campaign but is not in CAMPAIGN_NESTED_COMMANDS"
),
_ => panic!("`worklane {name}` is nested deeper than the fish block goes"),
}
}
// A guard on the walker itself: if it stopped finding arguments, every assertion
// above would pass by never running.
assert_eq!(seen, 3, "expected assign, campaign show and ls --campaign");
}
/// Tags have their own list because their values come from `worklane tags` rather than
/// from a listing of objects, so a second tag-taking option would need that rule and
/// not the campaign one.
#[test]
fn no_tag_taking_option_is_missing() {
let mut seen = 0;
for (path, arg) in every_argument() {
if arg.get_id().as_str() != "tag" {
continue;
}
seen += 1;
let name = path.join(" ");
let long = arg.get_long().unwrap_or_else(|| {
panic!(
"`worklane {name}` takes a tag as a positional, \
which the fish block has no rule for"
)
});
assert!(
TAG_FLAGS.contains(&long),
"`worklane {name} --{long}` takes a tag but is not in TAG_FLAGS"
);
}
assert_eq!(seen, 1, "expected ls --tag");
}
/// **Every rule naming an option has to say which command it belongs to.** A bare
/// `complete -c worklane -l tag` tells fish the whole tool takes `--tag`, so
/// `worklane init --<TAB>` offered six options that only `relate` and `ls` have. This
/// is what stops the next rule being written the same way.
#[test]
fn every_rule_naming_an_option_is_scoped_to_a_command() {
let script = fish_dynamic();
// Rules are one logical line, continued with a trailing backslash.
for rule in script.replace("\\\n", " ").lines() {
if !rule.starts_with("complete") || !rule.contains("-l ") {
continue;
}
assert!(
rule.contains("__worklane_command_is"),
"this rule declares an option for the whole tool: {rule}"
);
}
}
#[test]
fn every_listed_command_is_a_real_subcommand() {
let cli = command();
@@ -212,7 +415,7 @@ mod tests {
.lines()
.find(|line| line.starts_with("complete") && line.contains("-l clear"))
.expect("chown --clear has a rule of its own");
assert!(rule.contains("__fish_seen_subcommand_from chown"), "{rule}");
assert!(rule.contains("__worklane_command_is chown"), "{rule}");
assert!(rule.contains("worklane ls --ids"), "{rule}");
let chown = command().find_subcommand("chown").expect("chown exists").clone();
assert!(
@@ -256,6 +459,18 @@ mod tests {
assert!(script.contains("worklane-review"));
}
/// The two listings the campaign and tag rules read, which are separate commands
/// because a campaign has an id and a tag does not.
#[test]
fn the_fish_script_asks_worklane_for_its_campaigns_and_tags() {
let script = fish_dynamic();
assert!(script.contains("worklane campaign ls --ids"), "{script}");
assert!(script.contains("worklane tags"), "{script}");
// The nested position, which neither of the two counting helpers can reach.
assert!(script.contains("__worklane_nested_arg_of campaign show"), "{script}");
assert!(script.contains("__worklane_first_arg_of assign"), "{script}");
}
/// The one status positional and the one shell positional, which clap does not emit
/// possible values for. Read off the enums, so a fifth status would appear here on
/// its own.