Every check over the completions read the script as text. A `contains` cannot tell a rule that fires from one whose condition stopped matching, and that is how a completion actually breaks: the clap definition moves, a list or a `__worklane_command_is` scope stops naming anything, and the rule sits in the file offering nothing while every assertion passes. So the generated script is sourced into a throwaway fish standing in a real board, with this build's directory on the front of PATH, and `complete -C` is compared against the ticket and the tag that board was given. Four deliberate breakages were used to size it: renaming the `ls` status scope, dropping `append` from `TAG_FLAGS`, renaming a flag in `TICKET_FLAGS` and dropping `show` from `TICKET_COMMANDS`. All four now fail, each naming the list at fault. **Assert the values, not the flag names.** clap emits every option's name on its own, so `--tags` and `--blocked-by` are offered with the whole dynamic half deleted; the first draft asserted those names and caught only one of the four. What the hand-written rules add is the candidates after the flag, and that is what a board under the shell makes checkable. Two traps, both paid for once. `complete -C` autoloads `~/.config/fish/completions/worklane.fish`, so the first draft passed against a deliberately broken scope because the copy installed in August still had the working rule: `set fish_complete_path` with no value is what makes the sourced script the only source, and without that line the test cannot fail. And the script is written beside the board rather than in it, since a rule that fires nothing falls back to listing the directory and the script would read as an answer. `fish --no-execute` comes with it as the floor: it catches a script that does not parse. Narrower than it sounds, and measured rather than assumed, so the limit is written on the test. An apostrophe in a `-d` description partway down re-balances against the next quote and parses, corrupting every rule in between; the same apostrophe in the last rule reaches the end unbalanced and is caught. `every_listed_command_is_a_real_subcommand` widens to every list that names a command, `CAMPAIGN_COMMANDS`, `TAG_FLAGS` and the two nested lists, so a stale entry fails by name instead of through a rule count. The counts themselves stay hardcoded and now say why: the walkers go clap → list and never see an extra entry, so the count is what catches one, and deriving it from the lists it checks would grow with the bogus entry and pass. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
727 lines
32 KiB
Rust
727 lines
32 KiB
Rust
//! Shell completions.
|
|
//!
|
|
//! Two halves, because neither alone is enough.
|
|
//!
|
|
//! `clap_complete` generates the structure (subcommands, flags, their arguments)
|
|
//! straight from the clap definition, so a new flag never needs remembering here. But it
|
|
//! can only offer values it knows at compile time, and the value worth completing for
|
|
//! worklane is the ticket, which lives in the board the command is run above.
|
|
//!
|
|
//! So the fish output gets a hand-written block appended that asks worklane itself. That
|
|
//! costs one `worklane ls --ids` per keypress, which measured at 2.5ms in release on a
|
|
//! board of seventy-five tickets, comfortably below anything a person notices.
|
|
//!
|
|
//! Status values are half clap's: `Status` is a `ValueEnum`, so clap emits every one
|
|
//! of them for `mv --status`, but the fish generator does not emit possible values for
|
|
//! a *positional* and `ls <status>` gets nothing. Same for `completions <shell>`. So
|
|
//! the block below lists those two, from the enums rather than by hand.
|
|
|
|
use std::io;
|
|
|
|
use clap::{CommandFactory, ValueEnum};
|
|
use clap_complete::Shell;
|
|
|
|
use crate::install::SKILLS;
|
|
use crate::util::{RelationKind, Status};
|
|
|
|
/// Subcommands whose first positional is a ticket.
|
|
///
|
|
/// Kept honest by a test rather than by memory: a new ticket-taking subcommand that is
|
|
/// missing here silently loses completion, which nothing else would catch.
|
|
pub const TICKET_COMMANDS: [&str; 8] = [
|
|
"show", "mv", "comment", "set", "append", "relate", "check", "uncheck",
|
|
];
|
|
|
|
/// Subcommands whose *second* positional is the ticket, because they name two things.
|
|
///
|
|
/// `chown alice <ticket>` and `assign "v1 release" <ticket>`, which put the ticket
|
|
/// second deliberately, see AGENTS.md. The first argument of each is a user or a
|
|
/// campaign, and neither is completed.
|
|
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`, `campaign set` and `campaign append`, and they are why the fish half
|
|
/// needs a third position helper: their 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); 3] = [
|
|
("campaign", "show"),
|
|
("campaign", "set"),
|
|
("campaign", "append"),
|
|
];
|
|
|
|
/// Options whose value is a campaign.
|
|
pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
|
|
|
|
/// Options whose value is a tag, as the command that takes it and the flag's long name.
|
|
///
|
|
/// 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.
|
|
///
|
|
/// Pairs rather than the flat list the other flag lists are, because the two spellings
|
|
/// differ: `ls --tag` filters on one and `append --tags` adds them, so a single rule
|
|
/// naming both options would tell fish that each command takes the other's flag. One
|
|
/// rule per pair instead.
|
|
///
|
|
/// `add --tags` and `set --tags` are deliberately absent. Both take the *whole* list, so
|
|
/// the token being completed is `bug,tui` and fish replaces a token entire: offering one
|
|
/// tag there would throw away the ones already typed. `append --tags` is the one where
|
|
/// naming a single tag is the ordinary call.
|
|
pub const TAG_FLAGS: [(&str, &str); 2] = [("ls", "tag"), ("append", "tags")];
|
|
|
|
/// 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);
|
|
|
|
if shell == Shell::Fish {
|
|
write!(out, "{}", fish_dynamic())?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// The dynamic half, appended to what clap generated.
|
|
///
|
|
/// Fish merges completions from every `complete` call, so these add to the generated
|
|
/// rules rather than replacing them.
|
|
fn fish_dynamic() -> String {
|
|
let ticket_commands = TICKET_COMMANDS.join(" ");
|
|
let ticket_second_commands = TICKET_SECOND_COMMANDS.join(" ");
|
|
let ticket_flags = flag_list(&TICKET_FLAGS);
|
|
let relation_kinds = RelationKind::ALL
|
|
.iter()
|
|
.map(|kind| kind.flag())
|
|
.collect::<Vec<_>>()
|
|
.join(" ");
|
|
let campaign_commands = CAMPAIGN_COMMANDS.join(" ");
|
|
let campaign_nested = CAMPAIGN_NESTED_COMMANDS
|
|
.iter()
|
|
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
|
|
.collect::<Vec<_>>()
|
|
.join("; or ");
|
|
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
|
|
let tag_flags = TAG_FLAGS
|
|
.iter()
|
|
.map(|(command, flag)| {
|
|
format!(
|
|
"complete -c worklane -n '__worklane_command_is {command}' -l {flag} \\\n \
|
|
-x -a '(worklane tags | cut -f1,3)'"
|
|
)
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
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
|
|
.iter()
|
|
.map(|skill| skill.name)
|
|
.collect::<Vec<_>>()
|
|
.join(" ");
|
|
|
|
format!(
|
|
r#"
|
|
# ---------------------------------------------------------------------------
|
|
# Dynamic values, appended by `worklane completions fish`. Fish accumulates
|
|
# completions, so these add to the generated rules above.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
# Almost every argument worklane takes names something on the board rather than
|
|
# something on disk, so stop fish falling back to the directory listing. Without this,
|
|
# `worklane show 1b78a24 <TAB>` offers Cargo.toml and src/.
|
|
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 '__worklane_command_is tui' \
|
|
-a '(__fish_complete_directories)' -d project
|
|
|
|
# Position is counted rather than inferred from what has been typed: matching against
|
|
# the ticket list would run worklane again inside the condition, and would also keep
|
|
# offering tickets after one had been chosen.
|
|
#
|
|
# The subcommand is the second token, so its first argument is being typed once two
|
|
# tokens are there. `$tokens[2]` rather than `__fish_seen_subcommand_from`, because
|
|
# `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen,
|
|
# and their arguments are not what these complete.
|
|
function __worklane_first_arg_of
|
|
set -l tokens (commandline -opc)
|
|
test (count $tokens) -eq 2; and contains -- $tokens[2] $argv
|
|
end
|
|
|
|
function __worklane_second_arg_of
|
|
set -l tokens (commandline -opc)
|
|
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 \
|
|
-n '__worklane_first_arg_of {ticket_commands}; or __worklane_second_arg_of {ticket_second_commands}' \
|
|
-a '(worklane ls --ids)'
|
|
|
|
# `relate` takes its targets as option values, so they are completed by flag rather
|
|
# than by position.
|
|
complete -c worklane -n '__worklane_command_is relate' {ticket_flags} \
|
|
-x -a '(worklane ls --ids)'
|
|
|
|
# `--clear` is the one flag here whose first value is not a ticket, so it is not in
|
|
# `TICKET_FLAGS`: it takes the kind and then the target, and offering a board listing where
|
|
# the kind goes would be offering values it refuses. The kinds come from `RelationKind`
|
|
# rather than being spelled again. The target gets no rule at all, deliberately: fish
|
|
# completes the value after the flag, and the case this flag exists for is a target whose
|
|
# ticket is gone, which no listing of the board can offer.
|
|
complete -c worklane -n '__worklane_command_is relate' -l clear -x -a '{relation_kinds}'
|
|
|
|
# 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. Three fields now, the tag, its count and its annotation, and fish takes everything
|
|
# after the *first* tab as one description, so the count is dropped here rather than landing
|
|
# in the middle of the prose. `cut` and not `string replace` because the columns are what is
|
|
# being picked, and `cut -f1` is how a script reads this listing anyway.
|
|
#
|
|
# What is left is the annotation, and a tag the board carries but has never declared has
|
|
# none: it is offered with no description at all, which is the near-duplicate the file was
|
|
# added to catch. The count used to be the description and said the same thing more weakly.
|
|
#
|
|
# One rule per command, from `TAG_FLAGS`: `ls --tag` and `append --tags` are spelled
|
|
# differently, so a single rule naming both options would offer each under the other.
|
|
{tag_flags}
|
|
|
|
# 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 | cut -f1,3)'
|
|
|
|
# `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 '__worklane_command_is chown' -l clear -x -a '(worklane ls --ids)'
|
|
|
|
# clap emits the statuses 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
|
|
# positional needs them listed, and the same goes for the shell below.
|
|
complete -c worklane -n '__worklane_first_arg_of ls' -a '{statuses}' -d status
|
|
complete -c worklane -n '__worklane_first_arg_of completions' -a '{shells}' -d shell
|
|
|
|
# Shipped with the binary, so this list comes from `install::SKILLS` and cannot fall
|
|
# behind it.
|
|
complete -c worklane -n '__worklane_first_arg_of install-skill' -a '{skills}' -d skill
|
|
"#
|
|
)
|
|
}
|
|
|
|
/// 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
|
|
/// is offered without anybody remembering this file. A variant marked hidden is left out,
|
|
/// which is what `to_possible_value` returning `None` means.
|
|
fn possible_values<T: ValueEnum>(variants: &[T]) -> String {
|
|
variants
|
|
.iter()
|
|
.filter_map(|variant| variant.to_possible_value())
|
|
.map(|value| value.get_name().to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(" ")
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
/// Built, not just derived: an index is assigned when the command is built, and the
|
|
/// positionals of an unbuilt one all report `None`.
|
|
fn command() -> clap::Command {
|
|
let mut cli = crate::command::Cli::command();
|
|
cli.build();
|
|
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.
|
|
///
|
|
/// 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 (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(&top),
|
|
"`worklane {name}` takes a ticket first but is not in TICKET_COMMANDS"
|
|
),
|
|
Some(2) => assert!(
|
|
TICKET_SECOND_COMMANDS.contains(&top),
|
|
"`worklane {name}` takes a ticket second but is not in \
|
|
TICKET_SECOND_COMMANDS"
|
|
),
|
|
index => panic!("`worklane {name}` takes a ticket at position {index:?}"),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 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, 5,
|
|
"expected assign, campaign show, campaign set, campaign append and ls --campaign"
|
|
);
|
|
}
|
|
|
|
/// Commands whose tag positional names a tag that does not exist yet.
|
|
///
|
|
/// `tags add` declares a word the board has never carried, so completing it from
|
|
/// `worklane tags` would offer exactly the values the command refuses. Recorded rather
|
|
/// than skipped, so the *next* tag positional has to say which it is: `tags set` takes
|
|
/// a tag that is already declared and wants a rule in the fish block, and the test
|
|
/// below fails until it gets one or lands here.
|
|
///
|
|
/// In the test module because nothing outside it reads the list; the rule it encodes is
|
|
/// about what the fish block is missing, which is a test's question.
|
|
const TAG_NEW_COMMANDS: [(&str, &str); 1] = [("tags", "add")];
|
|
|
|
/// Options taking a whole comma-separated list of tags rather than one.
|
|
///
|
|
/// `add --tags` and `set --tags` write the field entire, so what is being typed at the
|
|
/// cursor is `bug,tui` and fish replaces a token whole: a rule offering one tag there
|
|
/// would throw away the ones already in the token. `append --tags` adds to what is
|
|
/// there, so a single tag is the ordinary value and it earns a rule. Recorded rather
|
|
/// than skipped, for the reason `TAG_NEW_COMMANDS` is: the next `--tags` has to say
|
|
/// which of the two it is.
|
|
const TAG_LIST_FLAGS: [(&str, &str); 2] = [("add", "tags"), ("set", "tags")];
|
|
|
|
/// 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.
|
|
///
|
|
/// Both spellings are walked, `tag` and `tags`: they are the same object under two
|
|
/// argument names, and looking at only the singular is how `set --tags` went years
|
|
/// without anybody deciding whether it wanted a rule.
|
|
#[test]
|
|
fn no_tag_taking_option_is_missing() {
|
|
let mut seen = 0;
|
|
for (path, arg) in every_argument() {
|
|
if !matches!(arg.get_id().as_str(), "tag" | "tags") {
|
|
continue;
|
|
}
|
|
seen += 1;
|
|
let name = path.join(" ");
|
|
|
|
let Some(long) = arg.get_long() else {
|
|
let known = match path.as_slice() {
|
|
[parent, child] => {
|
|
let pair = (parent.as_str(), child.as_str());
|
|
TAG_NESTED_COMMANDS.contains(&pair) || TAG_NEW_COMMANDS.contains(&pair)
|
|
}
|
|
_ => false,
|
|
};
|
|
assert!(
|
|
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;
|
|
};
|
|
|
|
let pair = (name.as_str(), long);
|
|
assert!(
|
|
TAG_FLAGS.contains(&pair) || TAG_LIST_FLAGS.contains(&pair),
|
|
"`worklane {name} --{long}` takes a tag, so it belongs in TAG_FLAGS if one \
|
|
tag is the ordinary value and TAG_LIST_FLAGS if the value is the whole list"
|
|
);
|
|
}
|
|
|
|
assert_eq!(
|
|
seen, 6,
|
|
"expected ls --tag, tags add, tags set, add --tags, set --tags and append --tags"
|
|
);
|
|
}
|
|
|
|
/// **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();
|
|
let known: Vec<&str> = cli.get_subcommands().map(|c| c.get_name()).collect();
|
|
|
|
// Every list that names a top-level command, not only the ticket ones. The others
|
|
// were reachable only through the rule counts below, which fail with `expected 3,
|
|
// got 4` and name nothing: a stale entry is a `complete` line whose condition never
|
|
// matches, so fish offers nothing and says nothing about why.
|
|
let top = TICKET_COMMANDS
|
|
.iter()
|
|
.chain(TICKET_SECOND_COMMANDS.iter())
|
|
.chain(CAMPAIGN_COMMANDS.iter())
|
|
.copied()
|
|
.chain(TAG_FLAGS.iter().map(|(command, _)| *command));
|
|
|
|
for name in top {
|
|
assert!(known.contains(&name), "no such subcommand: {name}");
|
|
}
|
|
|
|
for (parent, child) in CAMPAIGN_NESTED_COMMANDS.iter().chain(TAG_NESTED_COMMANDS.iter()) {
|
|
let sub = cli
|
|
.find_subcommand(parent)
|
|
.unwrap_or_else(|| panic!("no such subcommand: {parent}"));
|
|
assert!(
|
|
sub.find_subcommand(child).is_some(),
|
|
"`worklane {parent}` has no `{child}` subcommand"
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Three commands carry a `--clear` and each one takes something different: `chown`
|
|
/// takes the ticket, `relate` takes the kind and then the target, and `set` takes a
|
|
/// field name clap already offers. So each rule is scoped to its own command, and a
|
|
/// bare search for `-l clear` cannot tell them apart, which is what this used to do.
|
|
#[test]
|
|
fn each_clear_flag_is_completed_for_its_own_command() {
|
|
let script = fish_dynamic();
|
|
let cli = command();
|
|
|
|
let rule_for = |name: &str| {
|
|
let scope = format!("__worklane_command_is {name}");
|
|
script
|
|
.lines()
|
|
.find(|line| {
|
|
line.starts_with("complete")
|
|
&& line.contains("-l clear")
|
|
&& line.contains(&scope)
|
|
})
|
|
.unwrap_or_else(|| panic!("no --clear rule for {name}:\n{script}"))
|
|
};
|
|
|
|
let has_clear = |name: &str| {
|
|
cli.find_subcommand(name)
|
|
.unwrap_or_else(|| panic!("no such subcommand: {name}"))
|
|
.get_arguments()
|
|
.any(|arg| arg.get_long() == Some("clear"))
|
|
};
|
|
|
|
// `chown --clear` names the ticket in the flag, so the flag completes tickets.
|
|
assert!(has_clear("chown"), "`chown` has no --clear for the rule to complete");
|
|
assert!(rule_for("chown").contains("worklane ls --ids"), "{}", rule_for("chown"));
|
|
|
|
// `relate --clear` takes the kind first, so it offers the kinds and not a board
|
|
// listing: tickets there would be candidates the flag refuses. The target, the
|
|
// second value, is deliberately left uncompleted.
|
|
assert!(has_clear("relate"), "`relate` has no --clear for the rule to complete");
|
|
let relate = rule_for("relate");
|
|
for kind in RelationKind::ALL {
|
|
assert!(relate.contains(kind.flag()), "{kind:?} is not offered: {relate}");
|
|
}
|
|
assert!(
|
|
!relate.contains("worklane ls --ids"),
|
|
"tickets offered where the kind goes: {relate}"
|
|
);
|
|
|
|
assert!(
|
|
!TICKET_FLAGS.contains(&"clear"),
|
|
"--clear in TICKET_FLAGS would offer tickets to `set --clear`, which takes a field"
|
|
);
|
|
}
|
|
|
|
/// The flags completed as tickets have to be `relate`'s actual flags, or the rule
|
|
/// completes an option nothing accepts.
|
|
#[test]
|
|
fn every_ticket_flag_is_a_real_option() {
|
|
let relate = command()
|
|
.find_subcommand("relate")
|
|
.expect("relate exists")
|
|
.clone();
|
|
let known: Vec<String> = relate
|
|
.get_arguments()
|
|
.filter_map(|arg| arg.get_long().map(str::to_string))
|
|
.collect();
|
|
for flag in TICKET_FLAGS {
|
|
assert!(known.contains(&flag.to_string()), "`relate` has no --{flag}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_fish_script_asks_worklane_for_its_tickets() {
|
|
let script = fish_dynamic();
|
|
assert!(script.contains("worklane ls --ids"));
|
|
// Both positions, in one rule.
|
|
assert!(script.contains("__worklane_first_arg_of show"));
|
|
assert!(script.contains("__worklane_second_arg_of chown assign"));
|
|
// Nothing here takes a file, bar the one that does.
|
|
assert!(script.contains("complete -c worklane -f\n"));
|
|
assert!(script.contains("__fish_complete_directories"));
|
|
// Generated from `install::SKILLS`, so every shipped skill is in it.
|
|
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}");
|
|
}
|
|
|
|
/// Every rule that reads the tag listing drops the count, because `worklane tags` prints
|
|
/// three fields and fish takes everything after the first tab as the description. Left
|
|
/// whole, a tag would be described as its count, a tab and its annotation.
|
|
///
|
|
/// Pinned per rule rather than once over the script: a rule added later that reads
|
|
/// `worklane tags` raw is the bug this catches, and it would not show up in a single
|
|
/// `contains`.
|
|
#[test]
|
|
fn every_tag_rule_takes_the_annotation_as_its_description() {
|
|
let script = fish_dynamic();
|
|
|
|
let reading: Vec<&str> = script
|
|
.lines()
|
|
.filter(|line| line.contains("(worklane tags"))
|
|
.collect();
|
|
|
|
// **Hardcoded on purpose, and not derivable from the lists above.** This number is
|
|
// what catches an entry naming a command or a flag that does not exist: the walkers
|
|
// go clap → list and never see an extra, so a bogus `("bogus", "nope")` in
|
|
// `TAG_FLAGS` produces a fourth rule and only this count notices. Writing it as
|
|
// `TAG_FLAGS.len() + TAG_NESTED_COMMANDS.len()` would grow with the bogus entry and
|
|
// pass, which is the improvement to not make.
|
|
assert_eq!(
|
|
reading.len(),
|
|
3,
|
|
"expected the ls --tag rule, the append --tags one and the tags set one: {reading:?}"
|
|
);
|
|
for line in reading {
|
|
assert!(line.contains("(worklane tags | cut -f1,3)"), "{line}");
|
|
}
|
|
}
|
|
|
|
/// 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.
|
|
#[test]
|
|
fn the_fish_script_lists_the_statuses_and_the_shells() {
|
|
let script = fish_dynamic();
|
|
for status in Status::ALL {
|
|
assert!(
|
|
script.contains(status.as_str()),
|
|
"the ls positional is never offered {}",
|
|
status.as_str()
|
|
);
|
|
}
|
|
assert!(script.contains("-a 'backlog committed reviewing done discarded' -d status"));
|
|
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
|
|
assert!(script.contains(shell), "the shell positional is never offered {shell}");
|
|
}
|
|
}
|
|
|
|
/// The statuses for `mv --status` are clap's, which is half of why `Status` is a
|
|
/// `ValueEnum`. If clap ever stops emitting them, the fish half has to carry them
|
|
/// too, and this is what says so.
|
|
#[test]
|
|
fn clap_emits_the_statuses_for_the_status_flag() {
|
|
let mut out = Vec::new();
|
|
generate(Shell::Fish, &mut out).expect("generates");
|
|
let script = String::from_utf8(out).expect("utf8");
|
|
let flag = script
|
|
.lines()
|
|
.find(|line| line.contains("using_subcommand mv") && line.contains("-l status"))
|
|
.expect("mv --status has a rule of its own");
|
|
assert!(flag.contains("backlog"), "{flag}");
|
|
}
|
|
|
|
#[test]
|
|
fn generating_fish_produces_both_halves() {
|
|
let mut out = Vec::new();
|
|
generate(Shell::Fish, &mut out).expect("generates");
|
|
let script = String::from_utf8(out).expect("utf8");
|
|
// clap's half.
|
|
assert!(script.contains("complete -c worklane"));
|
|
assert!(script.contains("install-skill"));
|
|
// Ours.
|
|
assert!(script.contains("__worklane_first_arg_of"));
|
|
}
|
|
|
|
#[test]
|
|
fn other_shells_get_only_the_generated_half() {
|
|
for shell in [Shell::Bash, Shell::Zsh] {
|
|
let mut out = Vec::new();
|
|
generate(shell, &mut out).expect("generates");
|
|
let script = String::from_utf8(out).expect("utf8");
|
|
assert!(
|
|
!script.contains("__worklane_first_arg_of"),
|
|
"fish-only helpers leaked into {shell}"
|
|
);
|
|
}
|
|
}
|
|
}
|