(8a7fe6c) Read a flag by either spelling, on the prompt and in the fish rules, and bump to 0.33.8
`:mv --status ` offered the five statuses on the board and `:mv -s `
offered nothing: argument_at read the typed word with strip_prefix("--"),
so a word spelled with one hyphen was not a flag to it and fell through to
the positional arm, which counted a position that was not there.
long_name translates the letter through the command that holds the flag, so
the tables stay keyed on the long name and nothing here keeps a second list
of every option's letter. One letter, never a cluster: `mv -fs done` would
make the last letter the honest answer, but --title, --acceptance and a
comment body all take a leading hyphen on purpose, and a criterion typed as
`-fixes the offset` must not be answered with statuses.
The fish half had the same hole in its dynamic rules alone, which were
written as `-l <flag>`: `append -g <TAB>` offered nothing where
`append --tags <TAB>` offered the board's tags. fish_option reads the letter
off the definition per command, so an option given one tomorrow is offered
under it the day it is given. Clap's own generated rules already carried
both spellings, which is why a shell answered `mv -s ` and the board did
not.
a_short_flag_answers_what_its_long_spelling_answers walks every option with
both spellings on every command and nested command and pins that the two
answer the same, so this cannot come back one flag at a time.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
298e00eb33
commit
fbd752afc9
+148
-8
@@ -111,6 +111,36 @@ pub const TAG_NESTED_COMMANDS: [(&str, &str); 1] = [("tags", "set")];
|
||||
/// every target.
|
||||
pub const RELATION_KIND_FLAGS: [(&str, &str); 1] = [("relate", "clear")];
|
||||
|
||||
/// The long name of the flag a typed word spells, or nothing where it is not a flag.
|
||||
///
|
||||
/// `--status` is its own name and `-s` is clap's to translate, off the command that holds
|
||||
/// the flag: a table of the shorts kept here would be a second list of every option the
|
||||
/// tool has, and it would go wrong the first time one was given a letter.
|
||||
///
|
||||
/// **One letter, never a cluster.** `mv -fs done` is force and status and it is `status`
|
||||
/// that takes the word after it, so the last letter of a cluster would be the honest
|
||||
/// answer — but `--title`, `--description`, `--acceptance`, `--plan` and a comment body all
|
||||
/// take a leading hyphen on purpose, and reading `-fixes the offset` as a cluster would
|
||||
/// offer statuses inside a criterion. A clustered short is rare on a board where the line
|
||||
/// is typed a word at a time; a hyphen-leading prose value is a documented feature.
|
||||
fn long_name(arg: &str, holder: Option<&clap::Command>) -> Option<String> {
|
||||
if let Some(long) = arg.strip_prefix("--") {
|
||||
return (!long.is_empty()).then(|| long.to_string());
|
||||
}
|
||||
|
||||
let mut letters = arg.strip_prefix('-')?.chars();
|
||||
let short = match (letters.next(), letters.next()) {
|
||||
(Some(letter), None) => letter,
|
||||
_ => return None,
|
||||
};
|
||||
|
||||
holder?
|
||||
.get_arguments()
|
||||
.find(|option| option.get_short() == Some(short))
|
||||
.and_then(|option| option.get_long())
|
||||
.map(str::to_string)
|
||||
}
|
||||
|
||||
/// What an argument of a typed line names, where worklane can answer what goes there.
|
||||
///
|
||||
/// The board's command prompt completes against this: the tables above say *what* the
|
||||
@@ -178,8 +208,10 @@ pub fn argument_at(args: &[String], index: usize) -> Option<Argument> {
|
||||
.or(group);
|
||||
|
||||
// A flag's value is the argument after it, which is where the flag sits whether the
|
||||
// value is half typed or has not been started.
|
||||
if let Some(flag) = args.get(index - 1).and_then(|arg| arg.strip_prefix("--")) {
|
||||
// value is half typed or has not been started. Spelled long or short: `-s` is the same
|
||||
// flag as `--status` and the row has to answer both, which is what `long_name` is for.
|
||||
if let Some(flag) = args.get(index - 1).and_then(|arg| long_name(arg, holder)) {
|
||||
let flag = flag.as_str();
|
||||
if TICKET_FLAGS.contains(&(verb, flag)) {
|
||||
return Some(Argument::Ticket);
|
||||
}
|
||||
@@ -281,8 +313,9 @@ fn fish_dynamic() -> String {
|
||||
let ticket_flags = TICKET_FLAGS
|
||||
.iter()
|
||||
.map(|(command, flag)| {
|
||||
let option = fish_option(command, flag);
|
||||
format!(
|
||||
"complete -c worklane -n '__worklane_command_is {command}' -l {flag} \\\n \
|
||||
"complete -c worklane -n '__worklane_command_is {command}' {option} \\\n \
|
||||
-x -a '(worklane ls --ids)'"
|
||||
)
|
||||
})
|
||||
@@ -299,12 +332,13 @@ fn fish_dynamic() -> String {
|
||||
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join("; or ");
|
||||
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
|
||||
let campaign_flags = flag_list("ls", &CAMPAIGN_FLAGS);
|
||||
let tag_flags = TAG_FLAGS
|
||||
.iter()
|
||||
.map(|(command, flag)| {
|
||||
let option = fish_option(command, flag);
|
||||
format!(
|
||||
"complete -c worklane -n '__worklane_command_is {command}' -l {flag} \\\n \
|
||||
"complete -c worklane -n '__worklane_command_is {command}' {option} \\\n \
|
||||
-x -a '(worklane tags | cut -f1,3)'"
|
||||
)
|
||||
})
|
||||
@@ -442,15 +476,40 @@ 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 {
|
||||
/// Option names as fish wants them on a `complete` line, `-s o -l one -l two`, for the
|
||||
/// options of one command.
|
||||
fn flag_list(command: &str, flags: &[&str]) -> String {
|
||||
flags
|
||||
.iter()
|
||||
.map(|flag| format!("-l {flag}"))
|
||||
.map(|flag| fish_option(command, flag))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
/// One option as fish names it: its long name, and its letter where clap gave it one.
|
||||
///
|
||||
/// `-s g -l tags` rather than `-l tags` alone, or `append -g <TAB>` offers nothing where
|
||||
/// `append --tags <TAB>` offers the board's tags — the same hole the board's own prompt had
|
||||
/// until `long_name`, and the reason one table answers both halves is that neither may
|
||||
/// answer a spelling the other does not. The letter is read off the definition and never
|
||||
/// written here, so an option given one tomorrow is offered under it the day it is given.
|
||||
fn fish_option(command: &str, flag: &str) -> String {
|
||||
let cli = crate::command::Cli::command();
|
||||
let short = cli
|
||||
.find_subcommand(command)
|
||||
.and_then(|command| {
|
||||
command
|
||||
.get_arguments()
|
||||
.find(|option| option.get_long() == Some(flag))
|
||||
})
|
||||
.and_then(|option| option.get_short());
|
||||
|
||||
match short {
|
||||
Some(letter) => format!("-s {letter} -l {flag}"),
|
||||
None => format!("-l {flag}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// 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
|
||||
@@ -774,6 +833,87 @@ mod tests {
|
||||
assert!(shells.contains(&"fish".to_string()), "{shells:?}");
|
||||
}
|
||||
|
||||
/// The fish half names an option by its letter too, wherever clap gave it one, so a
|
||||
/// dynamic rule answers both spellings the way the prompt does.
|
||||
#[test]
|
||||
fn a_fish_rule_names_the_option_by_its_letter_as_well() {
|
||||
let script = fish_dynamic();
|
||||
|
||||
// `append --tags` is the one flag in these tables with a letter, and it is the
|
||||
// whole reason the rule is rendered rather than written: `-g` offered nothing.
|
||||
assert!(
|
||||
script.contains("-s g -l tags"),
|
||||
"the tags rule does not name its letter:\n{script}"
|
||||
);
|
||||
|
||||
// And one without stays as it was, rather than gaining an empty `-s`.
|
||||
assert!(script.contains("-l campaign"), "{script}");
|
||||
assert!(!script.contains("-s "), "an option with no letter got one:\n{script}");
|
||||
|
||||
// Read off the definition, never written here.
|
||||
assert_eq!(fish_option("append", "tags"), "-s g -l tags");
|
||||
assert_eq!(fish_option("ls", "tag"), "-l tag");
|
||||
assert_eq!(fish_option("ls", "nosuchflag"), "-l nosuchflag");
|
||||
}
|
||||
|
||||
/// A flag spelled short answers exactly what the same flag spelled long answers, on
|
||||
/// every command and every option that has both.
|
||||
///
|
||||
/// Walked off the clap definition rather than listed, so an option given a letter
|
||||
/// tomorrow is covered the day it is given one. `-s` was the report: `mv --status `
|
||||
/// offered the five statuses and `mv -s ` offered nothing, because the row read a flag
|
||||
/// by its two hyphens. A boolean's two spellings agree as well, both answering nothing,
|
||||
/// which is the same statement about a value that is not there.
|
||||
#[test]
|
||||
fn a_short_flag_answers_what_its_long_spelling_answers() {
|
||||
let cli = crate::command::Cli::command();
|
||||
let mut seen = 0;
|
||||
|
||||
for command in cli.get_subcommands() {
|
||||
let children: Vec<(String, &clap::Command)> = command
|
||||
.get_subcommands()
|
||||
.map(|child| (format!("{} {}", command.get_name(), child.get_name()), child))
|
||||
.collect();
|
||||
|
||||
for (line, holder) in
|
||||
std::iter::once((command.get_name().to_string(), command)).chain(children)
|
||||
{
|
||||
for option in holder.get_arguments() {
|
||||
let (Some(short), Some(long)) = (option.get_short(), option.get_long()) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
seen += 1;
|
||||
assert_eq!(
|
||||
at_cursor(&format!("{line} -{short} ")),
|
||||
at_cursor(&format!("{line} --{long} ")),
|
||||
"`-{short}` and `--{long}` answer differently on `{line}`"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
assert!(seen > 20, "only {seen} options had both spellings, which is too few");
|
||||
}
|
||||
|
||||
/// The two the report named, spelled out, so the walk above cannot pass by finding
|
||||
/// nothing on either spelling.
|
||||
#[test]
|
||||
fn a_short_flag_reaches_the_values_and_the_board() {
|
||||
let listed: Vec<String> = Status::ALL.iter().map(|s| s.as_str().to_string()).collect();
|
||||
assert_eq!(values("mv -s "), Some(listed), "`-s` offers no statuses");
|
||||
assert_eq!(values("mv -s bac"), values("mv --status bac"), "half typed");
|
||||
|
||||
// A tag, which comes off the board rather than out of the enum.
|
||||
assert_eq!(at_cursor("append -g "), Some(Argument::Tag { declared: false }));
|
||||
|
||||
// And a cluster is deliberately not read, because `--title`, `--acceptance` and a
|
||||
// comment body all take a leading hyphen: a value spelled `-fixes the offset` must
|
||||
// not be read as `-s` and answered with statuses.
|
||||
assert_eq!(at_cursor("mv -fs "), None);
|
||||
assert_eq!(at_cursor("comment 1b78a24 -fs "), None);
|
||||
}
|
||||
|
||||
/// The flag on a nested command is answered the same way, from the enum: nothing here
|
||||
/// knows what a campaign's states are, and the values reach the prompt and fish alike
|
||||
/// the day a fourth one is added to `CampaignState`.
|
||||
|
||||
Reference in New Issue
Block a user