(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
+21 -1
View File
@@ -223,6 +223,16 @@ pub enum Command {
ticket: String,
},
/// List the tags the board carries, and how many tickets carry each
///
/// A command rather than a mode on `ls`, for two reasons. `ls --tag <tag>` answers
/// "what is tagged bug" and cannot answer "what tags exist", which is the question a
/// grooming sweep starts from; and a `--tags` beside a `--tag` is one letter away from
/// a filter that means something else.
///
/// The output is machine-readable, like `ls --ids`: the tag, a tab, the count.
Tags,
/// Print a shell completion script
///
/// The structure comes from the clap definition, so a flag added here appears
@@ -263,7 +273,17 @@ pub enum CampaignCommand {
Add(CampaignAddArgs),
/// List campaigns with their member counts
Ls,
Ls {
/// Print one campaign per line as its id and title, tab separated, for a script
/// or a completion
///
/// The same flag and the same two fields as `ls --ids`, since it answers the same
/// question about a different object. Member counts are left out: counting them
/// reads every ticket on the board, and the caller here is a shell filling in a
/// candidate list on a keypress
#[arg(long)]
ids: bool,
},
/// Show a campaign and its members grouped by status
Show {
+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.
+54 -1
View File
@@ -1,5 +1,6 @@
use anyhow::{Result, anyhow};
use chrono::Local;
use std::collections::BTreeMap;
use std::fs;
use std::io::{BufRead, IsTerminal, Write};
use std::path::Path;
@@ -1070,9 +1071,19 @@ pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
/// scan per row rather than one scan reused, and it is deliberate: the alternative is a
/// map from campaign uuid to counts built in a single walk, which is worth writing when
/// a board has enough campaigns to notice and is premature now.
pub fn cmd_campaign_ls(worklane_dir: &Path) -> Result<()> {
pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
let index = CampaignIndex::load(worklane_dir)?;
// Ahead of the empty check, which prints prose: a completion must offer nothing
// rather than offer a sentence, the same bargain `list_ids` takes with a missing
// status directory.
if ids {
for campaign in index.iter() {
println!("{}\t{}", short_id(&campaign.uuid), campaign.title);
}
return Ok(());
}
if index.is_empty() {
println!("No campaigns yet. `worklane campaign add --title` files one.");
return Ok(());
@@ -1100,6 +1111,48 @@ pub fn cmd_campaign_ls(worklane_dir: &Path) -> Result<()> {
Ok(())
}
/// Every tag on the board, with how many tickets carry it.
///
/// The vocabulary itself, which nothing else could answer: `ls --tag` filters by a tag
/// already known, and the decorated listing does not print tags at all. A grooming sweep
/// starts by asking what the vocabulary *is*, and `assets/PLAN.md` used to have to say
/// that the question could only be answered by reading the tickets.
///
/// **Alphabetical, and case sensitive.** `--tag` matches a whole value case sensitively,
/// so `bug` and `Bug` are two tags and listing them as one would hide the reason a filter
/// came back short. Sorting puts them next to each other, which is where a near-duplicate
/// is spotted.
///
/// Machine-readable, the second output in the tree that is: the tag, a tab, the count.
/// Fish reads what follows the tab as a description, a script takes `cut -f1`, and neither
/// wants an escape sequence. Every status, done included, for the reason `ls --ids`
/// includes it: a tag retired months ago is still part of the answer to what the
/// vocabulary has been.
pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
// BTreeMap rather than a sort afterwards: the order is the point, and the counting
// wants a map anyway.
let mut counts: BTreeMap<String, usize> = BTreeMap::new();
for status in status_dirs() {
let status_path = worklane_dir.join(status);
// Skipped rather than refused, as in `list_ids`, and for the same reason.
if !status_path.exists() {
continue;
}
for item in collect_ticket_items(&status_path)? {
for tag in item.tags {
*counts.entry(tag).or_default() += 1;
}
}
}
for (tag, count) in counts {
println!("{}\t{}", tag, count);
}
Ok(())
}
/// Show a campaign, then its members grouped by status.
///
/// Every status is shown, done included, unlike `ls`, which leaves done out of its
+6 -2
View File
@@ -67,9 +67,9 @@ fn main() -> Result<()> {
}
Some(Command::Campaign { command }) => match command {
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
CampaignCommand::Ls => {
CampaignCommand::Ls { ids } => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_campaign_ls(&worklane_dir)
cmd_campaign_ls(&worklane_dir, ids)
}
CampaignCommand::Show { campaign } => {
let worklane_dir = find_worklane_dir(&start)?;
@@ -77,6 +77,10 @@ fn main() -> Result<()> {
}
},
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
Some(Command::Tags) => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_tags(&worklane_dir)
}
// 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.
Some(Command::Completions { shell }) => {