(00a14e7) Suggest the selected ticket where a ticket argument goes, and accept it with tab, and bump to 0.33.3
The reader has the ticket selected, which is the whole reason to type a command on the board rather than in a shell, so where the line is naming a ticket the selected card's short id is drawn after the cursor in grey and tab takes it into the line. Where a ticket goes is completions.rs's answer, through a new `ticket_argument` over the three tables the fish half is generated from. A copy of the positions on the board would go wrong the next time a command grew a ticket argument, and silently, since the tests guarding the first copy would not read the second. TICKET_FLAGS holds (command, flag) pairs now, the shape TAG_FLAGS already had, and the `chown --clear` rule the fish block wrote out by hand is generated from it. Only chown's --clear names a ticket: relate's takes a kind and set's a field, and the flag alone cannot tell the three apart. The suggestion is derived on every call rather than held on the Prompt, so what the row draws and what tab takes are one answer, and it is offered only with the cursor at the end of the line, while a card is selected, and while the id still starts with what is typed. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
a017f9002e
commit
c714c73a75
+3
-1
@@ -10,8 +10,10 @@ The generated half, the fish half, and what keeps the two honest.
|
||||
- **The strongest completion check loads the script into fish and asks it for candidates.** `fish_offers_the_commands_the_statuses_and_the_values` in `tests/cmd_completions.rs` sources the generated script into a throwaway shell standing in a real board, with this build's directory on the front of PATH, and compares `complete -C` against the ticket and the tag it put there. Every other test in the file reads the script as text, which cannot tell a rule that fires from one whose condition stopped matching, and that is how a completion actually breaks. **Assert the values, not the flag names**: clap emits every option's name on its own, so `--tags` and `--blocked-by` are offered with every hand-written rule deleted; what the dynamic half adds is what comes *after* the flag. Two traps, both paid for once: the shell must have `fish_complete_path` emptied, or `complete -C` autoloads `~/.config/fish/completions/worklane.fish` and answers from whatever version wrote that, which is a guard that 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
|
||||
- **`fish --no-execute` is the floor under that, not an oracle.** It catches a script that does not parse, quotes still open at the end of the file or an unclosed block. Measured, not assumed: an apostrophe interpolated into a `-d` description partway down re-balances against the next quote and parses, corrupting every rule in between while the check passes; the same apostrophe in the last rule reaches the end unbalanced and is caught. Only fish gets this, because only fish gets a hand-written half
|
||||
- **The rule counts in the completion tests are hardcoded on purpose.** The walkers go clap → list and never see an entry naming something that does not exist, so a bogus pair in `TAG_FLAGS` is caught by `every_tag_rule_takes_the_annotation_as_its_description` counting one rule too many. Deriving that number from the lists it checks would grow with the bogus entry and pass. The `seen` totals in the walkers are hardcoded for the mirror reason, and both carry the note
|
||||
- **The five completion lists are kept honest by tests** that walk the clap definition and fail on an argument left out of them. `TICKET_COMMANDS` and `TICKET_SECOND_COMMANDS` by position, `TICKET_FLAGS`, `CAMPAIGN_COMMANDS`, `CAMPAIGN_NESTED_COMMANDS`, `CAMPAIGN_FLAGS` and `TAG_FLAGS` likewise, the last against the test-local `TAG_LIST_FLAGS` and `TAG_NEW_COMMANDS` for the tag arguments that deliberately get no rule. The walk is one function, `every_argument`, since the tests differ only in the id they look for. Each also asserts *how many* it found, so a walker that stopped finding arguments fails rather than passing every assertion by never running them
|
||||
- **The completion lists are kept honest by tests** that walk the clap definition and fail on an argument left out of them. `TICKET_COMMANDS` and `TICKET_SECOND_COMMANDS` by position, `TICKET_FLAGS`, `CAMPAIGN_COMMANDS`, `CAMPAIGN_NESTED_COMMANDS`, `CAMPAIGN_FLAGS` and `TAG_FLAGS` likewise, the last against the test-local `TAG_LIST_FLAGS` and `TAG_NEW_COMMANDS` for the tag arguments that deliberately get no rule. The walk is one function, `every_argument`, since the tests differ only in the id they look for. Each also asserts *how many* it found, so a walker that stopped finding arguments fails rather than passing every assertion by never running them
|
||||
- **A campaign is named in three shapes and a tag in one**, which is why the lists are not one list: a campaign is `assign`'s first positional, the first argument of `campaign show` and `campaign set`, and `ls --campaign`'s value, and each needs a different fish rule. A tag is only ever an option value, and its values come from a different command
|
||||
- **`TICKET_FLAGS` holds pairs, the command and the flag, and every ticket rule in the fish half is generated from it.** Three commands carry a `--clear` and each takes something different: `chown`'s names the ticket, since with no user to give there is no positional for it; `relate`'s takes the kind and then the target; `set`'s takes a field name clap already offers. So the command is half of the fact, and a list of bare flag names could only be scoped by hand, which is what the `chown --clear` rule used to be. `every_ticket_flag_is_a_real_option` walks each pair against the command it names, which a flat list could not do
|
||||
- **The lists answer the board as well as the shell.** `ticket_argument` reads the three ticket lists to say whether the argument at a given index of a typed line is a ticket, which is what the command prompt's suggestion is built on, see [tui-prompts.md](tui-prompts.md). Position is counted there exactly as it is counted here, so the two cannot come to disagree about `mv --status done <ticket>`; a second table on the board would be a copy the tests above never read
|
||||
- **`TAG_FLAGS` holds pairs where the others hold names**, because the two options that take one tag are spelled differently: `ls --tag` filters on one and `append --tags` adds them, so a single rule naming both would tell fish that each command accepts the other's flag. One rule per pair, generated in `fish_dynamic`. `add --tags` and `set --tags` are in the test's `TAG_LIST_FLAGS` instead and get no rule: they take the *whole* list, so the token at the cursor is `bug,tui` and fish replaces a token entire, which would throw away what is already typed. The test walks both `tag` and `tags`, so the next one has to say which of the two it is
|
||||
- **`ls --ids` is the machine-readable listing**, and one of the three outputs in the tree meant to be parsed: the short id, a tab, the title, unstyled. Two fields because fish reads what follows a tab as the description and a script reads `cut -f1`. It includes done, which the decorated listing leaves out, because a completion has to be able to name a finished ticket, and it skips a missing status directory rather than refusing, because an error printed over a shell prompt is worse than no candidates. The filters still apply, and an unknown `--campaign` is still refused
|
||||
- **`campaign ls --ids` is the same flag and the same two fields for the other object**, and it deliberately skips the member counting the decorated listing does: `members()` reads every ticket on the board, and the caller here is a shell filling in candidates on a keypress. It also prints nothing on an empty board, where the decorated listing prints a sentence, because a sentence offered as a candidate is worse than no candidates
|
||||
|
||||
+14
-1
@@ -19,7 +19,7 @@ The three input modes on the board and the key that copies an id off it.
|
||||
## The Command Prompt
|
||||
- **`prompt: Option<Prompt>` is the whole mode**, the shape `search` and `detail` use: open and content cannot disagree, and closing it leaves nothing to reset. `Prompt` carries the line, the cursor as a byte offset into it, and `refused`, which is `Search::missed` with something to say
|
||||
- **`Board::prompt_key` is third in the pre-dispatch**, beside `search_key` and `picker_key` and on the same contract: while a command is being typed `q` is a letter, `d` leaves the columns alone and `tab` stays out of the project tabs, and `ctrl-c` is the one key declined. It takes a `Size` for enter's sake: running a command reloads the board and then has to bring the ticket it moved back into view, which is the measurement `follow_selection` takes. Only one of the two prompts can be open at once: `:` is reachable from the action arms alone, and while either has the keyboard the other's key is a character in a line
|
||||
- **`esc` and `enter` are the mode's own keys and are answered in `prompt_key`; everything else belongs to the line and goes to `Prompt::key`.** That is also what keeps the borrow straight, since closing the prompt takes the whole board and editing takes only the prompt. Left, right, home, end, backspace and `ctrl-w` behave as they do in a shell, and `ctrl-w` eats the separators behind the cursor before the word behind those, so one press at the end of `mv 1b78a24 ` takes the id. There is deliberately no `tab`: suggesting the selected ticket is 00a14e7, and until then it is a key that must not reach the tabs
|
||||
- **`esc` and `enter` are the mode's own keys and are answered in `prompt_key`; everything else belongs to the line and goes to `Prompt::key`.** That is also what keeps the borrow straight, since closing the prompt takes the whole board and editing takes only the prompt. Left, right, home, end, backspace and `ctrl-w` behave as they do in a shell, and `ctrl-w` eats the separators behind the cursor before the word behind those, so one press at the end of `mv 1b78a24 ` takes the id. `tab` is the mode's too, for the reason the recall walk is: what it takes is made of the selected card and the line is only where it lands
|
||||
- **The grammar is clap's, with nothing restated.** The line is tokenised by `split_line`, the binary's own name goes in front, and the arguments go to the same `Cli` definition the shell reaches, so a flag added to a command is typeable here the day it is added. Through `Cli::command().try_get_matches_from_mut` rather than `try_parse_from`, for what the matches give back: `command_name` walks the subcommands to name what resolved (`campaign show`, not `campaign`) instead of a `match` over every variant, which would be a second list of every verb the CLI has and one that goes stale silently
|
||||
- **`refused` is cleared by an edit and not by a movement.** The message is about the line, and moving the cursor does not change the line. `Prompt::key` clears it in the three arms that write to the line
|
||||
- **A line that ends inside a quote never reaches clap.** That is what `Unclosed` is for: a grammar complaint about a sentence nobody finished describes the wrong thing. Enter on an empty line, or one of nothing but separators, closes the prompt with nothing said, the way `esc` does — the bare form of the CLI opens a board and there is one on the screen
|
||||
@@ -46,6 +46,19 @@ The three input modes on the board and the key that copies an id off it.
|
||||
- **A failed write is silent, and an unreadable file is an empty recall.** The line is in memory either way, so the walk works for the run on a board whose folder cannot be written, and a board with no history yet is the ordinary case rather than something to say. A notice about a history file would be about the one thing the reader did not ask for
|
||||
- **`.wlhistory` is not in `digest`.** Appending to it must not read as the tree moving, or every command typed would provoke a reload of every board on top of the one `run` already does
|
||||
|
||||
## The Prompt's Suggestion
|
||||
- **The reader has the ticket selected, which is the whole reason to type a command on the board rather than in a shell.** So where the line is naming a ticket, the selected card's short id is drawn after the cursor and `tab` takes it into the line. Retyping seven characters off the card in front of you is the friction the prompt exists to remove
|
||||
- **Where a ticket goes is `completions.rs`'s answer, not a table written here.** `ticket_argument` reads `TICKET_COMMANDS`, `TICKET_SECOND_COMMANDS` and `TICKET_FLAGS`, which `no_ticket_taking_subcommand_is_missing` and `every_ticket_flag_is_a_real_option` keep honest against clap's own definition. A second copy of the positions on the board would go wrong the next time a command grew a ticket argument, and it would go wrong *silently*, since the test guarding the first copy would not read the second
|
||||
- **The ticket is not always the first argument, which is what a naive version gets wrong.** `chown alice <ticket>` and `assign v1 <ticket>` put it second on purpose, `relate x --blocked-by <ticket>` puts it in a flag, and `chown --clear <ticket>` does too, since with no user to give there is no positional for it. Nothing is offered where the argument is something else: `relate --clear` wants a kind, `set --clear` wants a field name, and `chown`'s first argument is a user
|
||||
- **Position is counted, exactly as the fish half counts it**, so `mv --status done <ticket>` is not recognised: the ticket is `mv`'s first positional and the third argument on the line. That is the fish rules' limit as well, and one table answering both is worth more than two tables disagreeing about the corner
|
||||
- **`TICKET_FLAGS` holds pairs, command and flag, where it used to hold bare flag names.** Three commands carry a `--clear` and only `chown`'s names a ticket, so the command is half of the fact. It also took the last hand-written ticket rule out of the fish block: every one of them is generated from the table now, and `every_ticket_flag_is_a_real_option` walks each pair against the command it names
|
||||
- **It is derived on every call and held nowhere.** `Board::suggestion` is asked once by the draw and once by `tab`, so what is on the row and what the key takes cannot disagree, and there is no field to go stale when the line is edited or the selection moves. That is also what "any other key drops it" means: nothing is dropped, because nothing was kept
|
||||
- **Only with the cursor at the end of the line.** The suggestion is drawn after the cursor and `tab` inserts it there, so with a command continuing past the cursor both would land in the middle of something already typed. A shell's own suggestion keeps the same rule
|
||||
- **Only while the selected id still starts with what is typed**, and what is drawn is the rest of it rather than the whole. A suggestion that no longer matches the argument under it describes nothing, and once the whole id is typed there is nothing left to add, so a second `tab` cannot double it
|
||||
- **Nothing with no card under the selection.** On the frame the selection is on a campaign or a tag, and neither is a ticket: `y` copies what the frame names there, and this deliberately does not
|
||||
- **Grey, which is what the palette already spends on a value that is not one.** It is not in the line until `tab` puts it there, and the reader has to tell the two apart at a glance. It takes what the line leaves of the field rather than a field of its own, so a long command loses the offer instead of pushing `esc` and `enter` off the row. The terminal cursor sits on its first cell, which is where the cursor already was
|
||||
- **The row does not name `tab`.** The prompt names its two mode keys and no more — `ctrl-w`, the arrows and home and end are unnamed there as well — and the suggestion under the cursor is its own affordance
|
||||
|
||||
## Splitting a Typed Line
|
||||
- **`split_line` is the whole module, and it knows nothing about `Board`.** The command prompt reads one string and clap reads an argv, so `comment 1b78a24 the offset was never passed` has to be tokenised before anything can parse it: split on whitespace it is five arguments and `comment` takes two. A pure function over the line and the cursor is what makes every rule reachable from a unit test, and it is in a file of its own rather than in `tui.rs`, which is eleven thousand lines already
|
||||
- **The rules are the shell's, because that is what the prompt promises**: the line is spelled there exactly as it is spelled in the shell. Runs of whitespace separate arguments, single and double quotes group one, a backslash escapes the next character *except* inside single quotes where it is a backslash, and an explicitly empty `''` is an argument that exists and is empty — which is what `--title ""` being a usage error rather than a silent clear depends on. A leading hyphen is not special here: whether `--foo` is a flag or the text of a criterion is clap's question, and `PROSE` already answers it
|
||||
|
||||
Reference in New Issue
Block a user