Compare commits

..
3 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 b63b60eefc (4dea61c) Load the completion script into fish and ask it what it offers, and bump to 0.32.19
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>
2026-08-31 23:54:48 +02:00
Ansho ReiandClaude Opus 5 7470255a22 (a1a5d69) Add tags to a ticket with append --tags, keeping the ones it carries, and bump to 0.32.18
`set --tags` writes the whole field, so adding one tag to a ticket that
already carries some meant reading it first and retyping every one of
them. 30a2b34 wrote that down in the skill as the way to do it; this is
the flag that makes it unnecessary.

The merge is idempotent and ordered. A tag the ticket already carries is
reported as no change rather than added twice, which is the point of the
flag: the caller does not have to know what is there. A new one goes on
the end in the order it was given rather than sorting the field under
whoever last touched it. Values are split on commas the way the stored
field is, so `--tags "bug, tui"` names two tags and matches the two a
ticket carrying them already holds; without that the pair would land as
a single tag nothing can filter by and would not match itself on the
next call. `split_tags` is that rule, lifted out of `parse_tags` so the
argument and the field are separated by the same code.

It writes the same `Kind::Tags` entry `set --tags` writes, so `--actor`
and `--actor-from-git` come with it. Tags are logged wherever they move,
and the one command that adds to them without replacing them would
otherwise be the one tag change the log missed. The before and after are
read off the field rather than off the flag, so an append of `beta` onto
`alpha` reads as the pair and not as what the call asked for.

`non_empty` rather than the `clearable` that `set --tags` takes: that
message names `--clear`, and `append` has none, so it would send the
caller looking here for a flag that is `set`'s. A value that is only
separators reaches the handler and is refused there, in the words
`appended_items` refuses an all-blank section with. Emptying the field
stays `set --clear tags`.

`TAG_FLAGS` becomes pairs of command and flag, because `ls --tag` and
`append --tags` are spelled differently and one rule naming both options
would tell fish that each command accepts the other's. `add --tags` and
`set --tags` deliberately get no value rule and are recorded in the
test's `TAG_LIST_FLAGS` instead: they take the whole list, so the token
at the cursor is `bug,tui` and fish replaces a token entire, throwing
away what is already typed. The honesty test now walks `tag` and `tags`
both, so the next tag argument has to say which of the two it is.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-31 23:37:33 +02:00
Ansho ReiandClaude Opus 5 b4534eb86d (a9bd6f0) Recall typed lines with up and down, kept in .wlhistory, and bump to 0.32.17
The lines typed at the command prompt are walked with up and down and kept
in .wlhistory in the board's own folder, so a recall spans runs rather than
one opening of the prompt.

One Recall per tab, parallel to Board::tabs, so the tab in view decides
which list up walks: a project's lines are the ones naming its ticket ids.
The merge tab is no board, so it keeps its lines for the run and writes no
file, the answer current_project already gives a command typed there.

The position sits on Prompt and the lines on Recall, so closing the prompt
forgets the position and not the lines. A failed write is silent and an
unreadable file is an empty recall: the line is in memory either way.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-28 12:40:21 +02:00
14 changed files with 1131 additions and 38 deletions
+17 -3
View File
@@ -96,7 +96,7 @@ and this file is for what someone changing worklane's own code needs.
- **Strict on the way in, tolerant on the way out.** `util::due_date` still cuts `2026-12-31T09:30:00Z` down to its date. A file written before the parser existed, or by hand, can hold one and still has to render; refusing to display what is already stored would punish the reader for the writer's mistake
- An empty `--due` keeps the clearing message rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is the flag that does it
- **`campaign add --codename` is validated at parse time by `codename`**, which is `non_empty` plus one word. The board draws it as a label with a mark and no quoting, so `~beaver release` on that row reads as two labels and the second one is not a campaign; a title is where a sentence goes. Nothing else is checked: there is no registry of codenames, the same reason `ls --tag` refuses to validate a tag, and a length limit would be a number invented in the parser when the row that draws it already drops a label it cannot hold
- **There are two empty-value parsers, and which one an argument takes is the point.** `non_empty` says only that the value cannot be empty, for the arguments with no empty form: the `ls` filters, `relate`'s targets, and `set --title`, which addresses the ticket and names its file. `clearable` names `--clear`, for the arguments whose field does have one: `set --tags`, `--due` through `iso_date`, and the `chown` user. One message for both would either lie about `ls --tag` or leave the useful half unsaid. `add --due` takes the second one because `iso_date` is shared, and the answer it points at is a command later rather than the omission that would do it now, which is close enough to be worth the shared parser
- **There are two empty-value parsers, and which one an argument takes is the point.** `non_empty` says only that the value cannot be empty, for the arguments with no empty form: the `ls` filters, `relate`'s targets, and `set --title`, which addresses the ticket and names its file. `clearable` names `--clear`, for the arguments whose field does have one: `set --tags`, `--due` through `iso_date`, and the `chown` user. One message for both would either lie about `ls --tag` or leave the useful half unsaid. `add --due` takes the second one because `iso_date` is shared, and the answer it points at is a command later rather than the omission that would do it now, which is close enough to be worth the shared parser. **`append --tags` is the one place the field has an empty form and the argument still takes `non_empty`**: `append` has no `--clear` of its own, so naming one would send the caller looking on this command for a flag that is `set`'s
- **A status is a `util::Status`, not a string.** `mv --status` and the `ls` positional take the value enum, so an unknown status is a usage error at parse time naming the four, exit 2, and no handler checks. That is the same bargain `--due` and `--priority` take, and it is what lets the shells complete the four for free. `Status::ALL` is the flow order, which `status_dirs()` and `cmd_mv` both read rather than spelling the names again, and `DONE` is defined from it
- The ticket positionals (`show <id>`, `mv <ticket>`, `comment <ticket>`) are also left alone, so a search term starting with a hyphen is a usage error. Reachable now that a hyphen-leading title can be stored: use the UUID, or put the flags first and separate with `--`, as in `mv --status committed -- -leading-title`
- A bare `--` is a value when it follows an option (`--title -- ` stores `--`) and clap's end-of-options marker when it sits in a positional. So a `comment` body of exactly `--` needs its own separator, `comment <ticket> -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop
@@ -111,8 +111,12 @@ and this file is for what someone changing worklane's own code needs.
- **What clap does and does not emit.** It emits the possible values of an *option*, which is why `mv --status <TAB>` needs nothing here, and nothing for a *positional*, which is why the `ls` status and the `completions` shell are listed in the fish half. Both lists are read off the enums with `possible_values`, never written out, so a fifth status appears in the script on its own
- **Position is counted, not inferred.** The four `__worklane_*` predicates all read `$tokens[2]` and the token count rather than using `__fish_seen_subcommand_from`, because `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen, and because matching against the ticket list would run worklane again inside the condition. `first_arg_of` and `second_arg_of` count a top-level command's arguments, `nested_arg_of` matches a parent and a child so `campaign show <TAB>` can be told from `chown alice <TAB>`, which sit at the same token count, and `command_is` asks only which command this is, at any position in it
- **Every rule carrying `-l` needs a `__worklane_command_is`, and `every_rule_naming_an_option_is_scoped_to_a_command` is what enforces it.** A bare `complete -c worklane -l tag` does not just complete that option's values, it tells fish the whole tool accepts `--tag`: `worklane init --<TAB>` offered six options that only `relate` and `ls` have. Fixed in 55ee6e3. `__fish_seen_subcommand_from ls` is not the scope to use, for the nesting reason above
- **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 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 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
- **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
- **`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
- **`worklane tags` is the third, and it is a command rather than a mode on `ls`.** Two reasons: `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. Alphabetical and case sensitive, matching the filter, so `bug` and `Bug` list separately and land next to each other, which is where a near-duplicate is spotted. Every status, done included: a tag that has fallen out of use is still part of what the vocabulary has been. `assets/PLAN.md` used to tell the agent to count tags with a `show` per ticket, and now points here
@@ -370,6 +374,16 @@ and this file is for what someone changing worklane's own code needs.
- **The keys' width comes off the row before the line is windowed**, so a long command does not push them off the end; a message takes the row from the keys instead, since the reader has just been told something and `esc` and `enter` still do what they did. `prompt_window` anchors the window on the cursor's right edge, which costs the text *after* the cursor on a long line: keeping both ends needs a scroll offset in state, and the draw is where the width is known and the state is not writable
- `: command` is named in every footer state, because the key works in every one of them, and the prompt's own key is drawn as `↵ run`
### The Prompt's Recall
- **`up` and `down` walk the lines already typed, and the lines are on disk.** `.wlhistory` in the board's own folder, appended as each line is entered. It is the one file under `.worklane` the board writes rather than a command, and the only one that is not markdown, which is the cost of a recall worth having: a board is opened and closed all day, and one that emptied on quit would only help inside a single sitting
- **`Recall` is per tab, parallel to `Board::tabs`**, so the tab in view decides which list `up` walks. A project's lines are the ones naming its ticket ids, and handing another board's `mv` back on this one would offer an id that resolves to nothing there. The tabs are fixed for the run, so the two vectors cannot drift, and the same index that picks the tab picks the recall
- **The merge tab has no file.** It is the one tab that is not a board, `current_project` answers `None` there and a command typed there is refused for that reason, so there is nothing to attribute a line to. Those lines are still recalled for the run: every one of them was refused, and a refused line is the one most worth getting back. When ebc5755 routes a merge line to the board its card names, that board's file is the one to append to
- **The position is on `Prompt` and the lines are on `Recall`**, so closing the prompt forgets the position and not the lines: the next `:` opens at the end of the list again, which is where a shell opens. `pending` holds the half typed line `up` walked away from, and walking `down` past the newest entry puts it back, so leaving a command to look for an older one never costs it
- **The ends are stops, not wraps.** `up` on the oldest line leaves it up rather than cycling round to the newest, which is what a shell does with it; `down` with no walk under way does nothing, since there is nothing in front of a line still being typed and emptying the row would be a keypress that destroys work. **An empty recall does nothing at all**, and that includes leaving the line alone, or `up` on a board nobody has typed at would be a way to lose what is half written
- **The line is kept before anything can refuse it.** A refused line never reached a handler and the fix is usually two characters, which is what the walk exists to save. Consecutive duplicates are kept once, against what is already held, so the rule spans runs as well as one sitting; a blank line is no command and is not kept. Nothing is trimmed
- **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
### 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
@@ -468,7 +482,7 @@ and this file is for what someone changing worklane's own code needs.
- **A mechanical entry renders as one line and a comment as it always did.** A field change is one fact, and a paragraph for it would bury the comments it sits between. The labels are padded to `Kind::LABEL_WIDTH`, `campaign` being the longest of the four, so the bodies line up under each other
- **A campaign entry records `Campaign::name`, the codename or failing that the title, never the uuid the field holds.** Settled when the entry is written, not left to the renderer: a log is a record, and resolving at read time would let an entry change meaning when a campaign is renamed. A `before` uuid the board no longer has reads `_missing_`, the way the Campaign field itself renders a dangling one, and a ticket never assigned starts from `_Not set_` (f774a33)
- **`--actor` is on every command that writes an entry**, spelled from one `ACTOR_HELP` in `command.rs`: a flag documented differently on each command reads as four flags. `--actor-from-git` rides beside it from its own one string, the same way. On `chown` it sits beside `user`, which is the ticket's new assignee — the two are different questions and that command answers both
- **`set --actor` reaches only the entry `--tags` writes**, since tags are the one field of that command's that is logged. Documented on the flag rather than left for a reader to notice from the absence of entries
- **`set --actor` reaches only the entry `--tags` writes**, since tags are the one field of that command's that is logged. Documented on the flag rather than left for a reader to notice from the absence of entries. `append --actor` is the same flag for the same reason: `append --tags` moves the same field, so it writes the same `Kind::Tags` entry, and a tag added without replacing the rest would otherwise be the one tag change the log missed
### Shipping the Agent Assets
- The skill is embedded with `include_str!` from `assets/SKILL.md`, not copied by an install script. `cargo install` places binaries and nothing else, so an installed document that is not in the binary is a document that drifts from it
Generated
+1 -1
View File
@@ -1503,7 +1503,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.32.16"
version = "0.32.19"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.32.16"
version = "0.32.19"
edition = "2024"
[dependencies]
+1 -1
View File
@@ -12,7 +12,7 @@ Worklane is a local Kanban flow for agentic software development.
| `worklane show <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring. A campaign is addressed the same way, plus its exact codename, which wins over all three. Ends with the ticket's history: every comment on it and every change to its status, owner or tags, oldest first, each naming who made it |
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions. `--status discarded` is exempt and reachable from anywhere, for a ticket that will not be done; leaving `discarded` is a backward move and needs `-f`. Discarding is refused while open tickets are blocked by the ticket, `-f` overrides. Records a `status` entry in the ticket's history, after the move: a refused or no-op move records nothing. `--actor` names the writer of that entry |
| `worklane set <ticket>` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID. `--clear <field>` returns a field to unset instead, repeatable, taking `due`, `tags`, `priority`, `description`, `acceptance` or `plan`, and writing back exactly what `add` writes for a field it was never given. No `title`, which addresses the ticket, and no `owner`, which is `chown`'s. Replacing and clearing the same field in one call is refused. `--tags` records a `tags` entry in the ticket's history, with the tags before and after, and it is the only field of this command's that is logged; `--actor` names the writer of that entry |
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last |
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`, or to the tags with `--tags`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last. `--tags` keeps the tags the ticket already carries, ignores one it already has, and takes several as a repeated flag or separated by commas, the way the field itself is written; it is the counterpart to `set --tags`, which replaces the whole field. It records a `tags` entry in the ticket's history, and `--actor` names the writer of that entry, this command's only logged field as it is `set`'s. Emptying a field is `set --clear`, which has no counterpart here |
| `worklane relate <ticket>` | Records an edge to another ticket with `--blocked-by`, `--regression-of` or `--relates-to`, each repeatable. At least one required. Only the ticket named is written; `show` derives the other end by scanning, and a derived row that reads exactly like a stored one is drawn once. `relates to` on a ticket whose target already stores it reports no change, since it is the same edge; `blocked by` and `regression of` read differently from the far end, so a mutual pair is two rows. `mv` refuses to move a ticket blocked by one that is not done, unless `-f`. `--clear <kind> <target>` takes an edge off instead, repeatable, the kind spelled either way, `blocked-by` or `blocked by`. The target resolves against the edges the ticket holds first, by id prefix, which is the only way to reach one whose ticket has been deleted, then as an ordinary ticket search. An edge the ticket does not hold reports no change; a target naming nothing at all is an error. Recording and clearing the same edge in one call is refused |
| `worklane chown <user> <ticket>` | Sets the Owner field, the only command that writes it. Free text, checked against nothing. User first and ticket second, after Unix `chown`. `worklane chown --clear <ticket>` returns the field to unset, taking the ticket in the flag since there is no user to give, and not to the git user `add` falls back to. Records an `owner` entry in the ticket's history, with the owner before and after; `--actor` names who made the change, which is not the same as the user argument |
| `worklane check <ticket> [criteria...]` | Ticks acceptance criteria, each by number as shown by `show` or by a substring. Several in one call, or `all` for every one of them. Prompts with the numbered list if none is given, or errors with it when there is no terminal |
+14 -8
View File
@@ -169,16 +169,21 @@ worklane set 1b78a24 --clear due # take a value away again
worklane set 1b78a24 --clear tags --clear plan # as many fields as you like
worklane append 1b78a24 --acceptance "One more criterion"
worklane append 1b78a24 --description "What was learned since."
worklane append 1b78a24 --tags tui # add a tag, keeping the ones there
worklane chown alice 1b78a24 # hand the ticket to someone
worklane chown --clear 1b78a24 # hand it back to nobody
```
`set` replaces, `append` adds, `--clear` empties. `set --tags` overwrites the whole
field: to add a tag to a ticket that already carries one, replace the value with every
tag separated by commas. Neither `set` nor `append` has `--owner` or `--status`: owner
is `chown`'s and status is `mv`'s, so each field has exactly one writer. A field set to
the value it already holds is reported unchanged and nothing is written, and so is a
field cleared that was already unset.
field, so **use `append --tags` to add a tag to a ticket that already carries some**: it
keeps what is there, and a tag the ticket already has is reported as no change rather
than added twice, so you do not have to read the ticket first. Several in one call by
repeating the flag or by separating them with commas, `--tags "bug, tui"`, since that is
how the field itself is written. Reach for `set --tags` when the whole list is being
replaced, and `set --clear tags` to empty it: `append` has neither. Neither `set` nor
`append` has `--owner` or `--status`: owner is `chown`'s and status is `mv`'s, so each
field has exactly one writer. A field set to the value it already holds is reported
unchanged and nothing is written, and so is a field cleared that was already unset.
**`--clear` takes the field as its value**, one of `due`, `tags`, `priority`,
`description`, `acceptance` or `plan`, and repeats. It writes back exactly what `add`
@@ -339,8 +344,8 @@ existing ticket will have been written from a different angle.
`show` ends with a HISTORY block: every comment on the ticket and every change to its
status, owner, tags or campaign, oldest first, each naming who made it. You do not write
these by hand. `mv`, `chown`, `set --tags` and `assign` record themselves, and a call
that changes nothing records nothing. A campaign move is recorded by codename, or by
these by hand. `mv`, `chown`, `set --tags`, `append --tags` and `assign` record
themselves, and a call that changes nothing records nothing. A campaign move is recorded by codename, or by
title for a campaign that has none, not by the uuid the field holds.
```
@@ -380,7 +385,8 @@ you to move a ticket, or to put words on the board as their comment, so name the
the flag — the move was theirs and the words are theirs, and an entry carrying your name
reads later as though you decided both. Otherwise leave it off, unless your instructions
say to use it. It is spelled the same on every command that writes an entry: `comment`,
`mv`, `chown`, `set` and `assign`.
`mv`, `chown`, `set`, `append` and `assign`. On the last two it reaches only the entry
`--tags` writes, since that is the one field either of them logs.
Acting for the person without knowing how they spell themselves? `--actor-from-git`
attributes the entry to the detected git user instead of `WORKLANE_ACTOR`, so their name
+16 -3
View File
@@ -358,7 +358,7 @@ export const set = tool({
export const append = tool({
description:
"Add to a section of an existing worklane ticket without replacing what is there. The description gains a new paragraph; acceptance criteria and plan steps are added to the end of their lists, with steps numbered on from the last. Ticked criteria and handwritten content are left alone. To replace a section outright, use set.",
"Add to an existing worklane ticket without replacing what is there. The description gains a new paragraph; acceptance criteria and plan steps are added to the end of their lists, with steps numbered on from the last; tags are added to the ones the ticket already carries. Ticked criteria and handwritten content are left alone. To replace a section or the whole tag list outright, use set.",
args: {
ticket: tool.schema
.string()
@@ -375,6 +375,14 @@ export const append = tool({
.string()
.describe("Implementation plan steps to add, one per line.")
.optional(),
tags: tool.schema
.string()
.describe("Tags to add, comma separated, keeping the ones the ticket already carries. A tag it already has is reported as no change rather than added twice, so the ticket does not have to be read first.")
.optional(),
actor: tool.schema
.string()
.describe("Who the entry is attributed to. Only reaches the entry tags writes, since that is the one field of this command's that is logged. If omitted, WORKLANE_ACTOR is used, then the git user.")
.optional(),
},
async execute(args: Record<string, any>, context: ToolContext) {
if (!args.ticket) {
@@ -395,9 +403,14 @@ export const append = tool({
if (args.plan) {
itemLines(args.plan).forEach((line: string) => cmd.push("--plan", line));
}
if (args.tags) cmd.push("--tags", args.tags);
// Last, and not counted as a field: the length check below is what refuses a call
// that names nothing to add, and an actor alone adds nothing. Same shape as set.
const fields = cmd.length;
if (args.actor) cmd.push("--actor", args.actor);
if (cmd.length === 2) {
return "Error appending: give at least one section to add to";
if (fields === 2) {
return "Error appending: give at least one field to add to";
}
try {
+26 -4
View File
@@ -858,14 +858,15 @@ impl ChownArgs {
}
}
/// `append` only offers the sections that hold multiple lines, since appending to a
/// scalar has no meaning.
/// `append` offers the fields something can be added to without disturbing what is
/// already in them: the three sections that hold multiple lines, and Tags, which is a
/// list. Appending to a scalar has no meaning, so there is no `--priority` or `--due`.
#[derive(clap::Args)]
#[command(group(
clap::ArgGroup::new("append_fields")
.required(true)
.multiple(true)
.args(["description", "acceptance", "plan"])
.args(["description", "acceptance", "plan", "tags"])
))]
pub struct AppendArgs {
/// Ticket UUID or title
@@ -882,6 +883,24 @@ pub struct AppendArgs {
/// Add implementation plan steps, numbered on from the last. Repeat the flag
#[arg(short, long, allow_hyphen_values = PROSE)]
pub plan: Vec<String>,
/// Add tags, keeping the ones the ticket already carries. Repeat the flag, or
/// separate them with commas
///
/// `non_empty` rather than the `clearable` that `set --tags` takes. That message
/// names `--clear`, and this command has none: emptying the field is
/// `set --clear tags`, so pointing at a flag that is not here would send the caller
/// looking for it on `append`.
#[arg(short = 'g', long, value_parser = non_empty)]
pub tags: Vec<String>,
/// Only reaches the entry `--tags` writes, since that is the one field of this
/// command's that is logged, exactly as on `set`
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
pub actor_from_git: bool,
}
/// `relate` is the only writer of the Relations section, the way `chown` is the only
@@ -1080,6 +1099,9 @@ mod tests {
// A guard on the walker itself: if it stopped finding commands, every assertion
// above would pass by never running.
assert_eq!(seen, 5, "expected comment, mv, chown, set and assign to carry --actor");
assert_eq!(
seen, 6,
"expected comment, mv, chown, set, append and assign to carry --actor"
);
}
}
+81 -13
View File
@@ -64,12 +64,22 @@ pub const CAMPAIGN_NESTED_COMMANDS: [(&str, &str); 3] = [
/// Options whose value is a campaign.
pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
/// Options whose value is a tag.
/// 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.
pub const TAG_FLAGS: [&str; 1] = ["tag"];
///
/// 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.
///
@@ -110,7 +120,16 @@ fn fish_dynamic() -> String {
.collect::<Vec<_>>()
.join("; or ");
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
let tag_flags = flag_list(&TAG_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}"))
@@ -218,8 +237,10 @@ complete -c worklane -n '__worklane_command_is ls' {campaign_flags} \
# 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.
complete -c worklane -n '__worklane_command_is ls' {tag_flags} \
-x -a '(worklane tags | cut -f1,3)'
#
# 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
@@ -410,14 +431,28 @@ mod tests {
/// 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 arg.get_id().as_str() != "tag" {
if !matches!(arg.get_id().as_str(), "tag" | "tags") {
continue;
}
seen += 1;
@@ -440,13 +475,18 @@ mod tests {
continue;
};
let pair = (name.as_str(), long);
assert!(
TAG_FLAGS.contains(&long),
"`worklane {name} --{long}` takes a tag but is not in TAG_FLAGS"
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, 3, "expected ls --tag, tags add and tags set");
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
@@ -472,8 +512,30 @@ mod tests {
fn every_listed_command_is_a_real_subcommand() {
let cli = command();
let known: Vec<&str> = cli.get_subcommands().map(|c| c.get_name()).collect();
for name in TICKET_COMMANDS.iter().chain(TICKET_SECOND_COMMANDS.iter()) {
assert!(known.contains(name), "no such subcommand: {name}");
// 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"
);
}
}
@@ -587,10 +649,16 @@ mod tests {
.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(),
2,
"expected the ls --tag rule and the tags set one: {reading:?}"
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}");
+71
View File
@@ -1135,12 +1135,83 @@ pub fn cmd_append(args: &AppendArgs, start: &Path, sink: &mut Sink) -> Result<()
changed.push(section.label);
}
// Through `apply`, unlike the sections above: appending a section always adds
// something, and appending a tag the ticket already carries is the no-op this flag
// exists to make free.
if !args.tags.is_empty() {
let next =
set_metadata_field(&content, "Tags", &appended_tags(&content, &args.tags)?, &title)?;
apply(&mut content, &mut changed, "tags", next);
}
// The only way to reach here with nothing to write is a `--tags` the ticket already
// satisfied, since every other field on this command adds or refuses. Reported in the
// words `set` uses for the same answer.
if changed.is_empty() {
report(sink, &[], &title, "Appended to")?;
return Ok(());
}
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
// Tags are logged wherever they change, so the one command that adds to them without
// replacing them logs too. Same shape as `set`'s, down to the before and after being
// read off the field rather than off the flag: what the entry records is where the
// field went, not what this call asked for.
if changed.contains(&"tags") {
write_entry(
&worklane_dir,
&uuid,
Kind::Tags,
&change(
&parse_ticket_field(&original, "Tags"),
&parse_ticket_field(&content, "Tags"),
),
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
"",
)?;
}
report(sink, &changed, &title, "Appended to")?;
Ok(())
}
/// The ticket's tags with the call's merged onto the end, or the refusal for a call that
/// named none.
///
/// A tag the ticket already carries is not added a second time, which is the whole
/// difference from `set --tags`: appending means the caller does not have to know what is
/// there already, so naming one that is reports no change rather than doubling it. New
/// ones go on the end in the order they were given rather than sorted, so the field goes
/// on reading as what was added when.
///
/// The values are split on commas the way the stored field is, so `--tags "bug, tui"`
/// names two tags and matches the two a ticket carrying them already holds. Without that
/// the pair would land as a single tag nothing can filter by, which is what `tag_value`
/// refuses outright for the vocabulary; here it is split instead, because `set --tags`
/// takes the comma form on this same field and refusing it on its counterpart would be a
/// trap.
///
/// A call whose every value comes out blank is refused rather than written, the way
/// [`appended_items`] refuses one: `--tags ","` names nothing, and writing the field back
/// unchanged would report an append that never happened. Emptying the field is
/// `set --clear tags`.
fn appended_tags(content: &str, values: &[String]) -> Result<String> {
let added: Vec<String> = values.iter().flat_map(|value| split_tags(value)).collect();
if added.is_empty() {
return Err(anyhow!("Nothing to append to the tags: every value given was blank"));
}
let mut tags = parse_tags(content);
for tag in added {
if !tags.contains(&tag) {
tags.push(tag);
}
}
Ok(tags.join(", "))
}
/// Record a relation from one ticket to another.
///
/// One side is written and the inverse is derived wherever it is shown. `blocked by`
+488 -1
View File
@@ -14,6 +14,7 @@
use std::collections::hash_map::DefaultHasher;
use std::collections::{BTreeMap, HashMap};
use std::hash::{Hash, Hasher};
use std::io::Write as _;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
@@ -35,6 +36,15 @@ use crate::util::*;
/// How long the event poll waits before letting the tick run.
pub const POLL: Duration = Duration::from_millis(250);
/// The file the lines typed on a board are kept in, in the board's own folder beside the
/// status directories.
///
/// The one file under `.worklane` the board writes rather than a command, and the only
/// one that is not markdown: it is a list of lines, read by nobody but the prompt. Not in
/// `digest`, so appending to it never counts as the tree moving and never provokes a
/// reload.
pub const RECALL_FILE: &str = ".wlhistory";
/// The tab that throws every monitored board into one set of columns.
///
/// Lowercase like the column headings, since it sits in the same row of chrome and is
@@ -720,6 +730,16 @@ pub struct Prompt {
/// the cursor leaves it up, since the line it is about has not changed. `Search::missed`
/// is the same rule with nothing to say but "no match".
pub refused: Option<String>,
/// How far back `up` has walked into the tab's [`Recall`], or `None` while the line on
/// the row is the reader's own.
///
/// Here rather than on the recall, so closing the prompt forgets the position and not
/// the lines: the next `:` opens at the end of the list again, which is where a shell
/// opens. The lines outlive one opening of the prompt and the position does not.
position: Option<usize>,
/// The half typed line `up` walked away from, put back by walking down past the newest
/// entry. `Some` exactly while `position` is.
pending: Option<String>,
}
impl Prompt {
@@ -810,6 +830,92 @@ impl Prompt {
self.cursor = from;
self.refused = None;
}
/// Put a recalled line on the row with the cursor at its end, the way a shell hands
/// one back: what a reader does with a recalled command is append to it or fix its
/// tail, and the end is where both start.
///
/// The message about the last enter goes with it, for the reason every edit in `key`
/// takes it away: it was about a line that is no longer on the row.
fn show(&mut self, line: String) {
self.cursor = line.len();
self.line = line;
self.refused = None;
}
}
/// The lines already typed against one tab, and the file they outlive the run in.
///
/// One per tab and parallel to [`Board::tabs`], so the tab in view decides which list `up`
/// walks. A project's lines are the ones naming its ticket ids, and handing another
/// board's `mv` back on this one would offer an id that resolves to nothing there. The
/// tabs are fixed for the run, so the two cannot drift apart.
///
/// `file` is `None` on the merge tab, which is the one tab that is not a board.
/// `Board::current_project` resolves to nothing there and a command typed there is refused
/// for that reason, see ebc5755, so there is no board to attribute the line to and nothing
/// to append it to. Those lines are still recalled for the run: a refused line is the one
/// most worth getting back, and it goes when the board does.
pub struct Recall {
/// Oldest first, so `up` walks backwards from the end.
lines: Vec<String>,
/// The board's own [`RECALL_FILE`], or `None` for a recall that is kept nowhere.
file: Option<PathBuf>,
}
impl Recall {
/// What a board has already been typed at, oldest first.
///
/// A file that is missing or unreadable is an empty recall rather than a failure. A
/// board with no history yet is the ordinary case and not worth a message, and one
/// whose file cannot be read is a convenience gone rather than a board that will not
/// start. Blank lines are dropped on the way in, so a file truncated or edited by hand
/// cannot put an empty entry in the walk.
fn load(dir: &Path) -> Self {
let file = dir.join(RECALL_FILE);
let lines = std::fs::read_to_string(&file)
.unwrap_or_default()
.lines()
.filter(|line| !line.trim().is_empty())
.map(str::to_string)
.collect();
Recall { lines, file: Some(file) }
}
/// A recall with no file behind it, which is the merge tab's.
fn unkept() -> Self {
Recall { lines: Vec::new(), file: None }
}
/// Keep a line that was entered, and append it to the file.
///
/// Consecutive duplicates are kept once, so holding `up` steps through distinct
/// commands rather than through the same `mv` typed four times. The rule is applied
/// against what is already held, which after a [`load`](Self::load) is the file's last
/// line, so it spans runs as well as one sitting. A blank line is no command and is
/// not kept.
///
/// Nothing is trimmed: the file is every line ever typed against that board.
///
/// **A write that fails is silent.** The line is in `lines` either way, so the recall
/// still works for the run on a board whose folder is read only, and a notice about a
/// history file would be about the one thing the reader did not ask for. The line
/// itself is what they asked for, and `run` already has the row for what came of it.
fn keep(&mut self, line: &str) {
if line.trim().is_empty() || self.lines.last().is_some_and(|last| last == line) {
return;
}
self.lines.push(line.to_string());
let Some(file) = &self.file else { return };
let _ = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(file)
.and_then(|mut handle| handle.write_all(format!("{line}\n").as_bytes()));
}
}
/// What a line that ends half typed is waiting for, or nothing when it is whole.
@@ -1297,6 +1403,9 @@ pub struct Board {
pub visibility: Visibility,
pub should_quit: bool,
projects: Vec<Project>,
/// The lines typed against each tab, parallel to `tabs`. See [`Recall`] for why it is
/// per tab rather than one list for the board.
recalls: Vec<Recall>,
digest: u64,
}
@@ -1316,6 +1425,15 @@ impl Board {
}
tabs.extend(projects.iter().map(|project| Tab::new(project.name.clone())));
// One per tab and in the same order, the merge's first when there is one. Read here
// rather than at the first `:`, so a board that has been typed at before opens with
// the walk already behind it and no keypress pays for a file read.
let mut recalls: Vec<Recall> = Vec::new();
if projects.len() > 1 {
recalls.push(Recall::unkept());
}
recalls.extend(projects.iter().map(|project| Recall::load(&project.dir)));
let mut board = Board {
tabs,
tab: 0,
@@ -1328,6 +1446,7 @@ impl Board {
visibility: Visibility::default(),
should_quit: false,
projects,
recalls,
digest: 0,
};
board.reload()?;
@@ -1371,6 +1490,16 @@ impl Board {
&mut self.tabs[self.tab]
}
/// The recall of the tab in view: the lines `up` walks there, and where a line entered
/// there is kept.
///
/// Indexed by `tab` like `current`, because `recalls` is built parallel to `tabs` and
/// both are fixed for the run. Switching tabs therefore switches the recall with it,
/// with nothing to keep in step.
fn recall_mut(&mut self) -> &mut Recall {
&mut self.recalls[self.tab]
}
/// The project whose board the tab in view is showing, or nothing on the merge.
///
/// The merge tab is the one tab that is not a board: its cards came from several
@@ -2220,6 +2349,11 @@ impl Board {
match key.code {
KeyCode::Esc if !control => self.prompt = None,
KeyCode::Enter if !control => self.submit(screen),
// The mode's, like `esc` and `enter`, and for the same reason: the walk is over
// the tab's lines and the line on the row is only where it lands, so it takes
// the whole board rather than the prompt alone.
KeyCode::Up if !control => self.recall_back(),
KeyCode::Down if !control => self.recall_forward(),
_ => {
if let Some(prompt) = &mut self.prompt {
prompt.key(key, control);
@@ -2230,6 +2364,62 @@ impl Board {
true
}
/// `up`: one line further back, or the newest line when the reader is still on their
/// own.
///
/// The line being typed is put aside on the first press and comes back on the way down,
/// so walking away from a half typed command never costs it. The oldest line is a stop
/// rather than a wrap, which is what a shell does with it: holding `up` settles on the
/// far end instead of cycling past it and offering the newest line again.
///
/// An empty recall does nothing, and that includes leaving the line alone. `up` on a
/// board that has not been typed at must not be a way to lose what is on the row.
fn recall_back(&mut self) {
// Two fields, borrowed apart: the lines are read while the prompt is written to.
let lines = &self.recalls[self.tab].lines;
let Some(prompt) = self.prompt.as_mut() else {
return;
};
let at = match (prompt.position, lines.len()) {
(_, 0) => return,
(None, len) => {
prompt.pending = Some(prompt.line.clone());
len - 1
}
(Some(0), _) => return,
(Some(at), _) => at - 1,
};
prompt.position = Some(at);
prompt.show(lines[at].clone());
}
/// `down`: one line nearer the present, and past the newest the line that was being
/// typed, which is where the walk started.
///
/// `down` with no walk under way does nothing. There is nothing in front of a line the
/// reader is still typing, and emptying the row would be a keypress that destroys work.
fn recall_forward(&mut self) {
let lines = &self.recalls[self.tab].lines;
let Some(prompt) = self.prompt.as_mut() else {
return;
};
let Some(at) = prompt.position else { return };
if at + 1 < lines.len() {
prompt.position = Some(at + 1);
prompt.show(lines[at + 1].clone());
return;
}
// Off the end of the walk and back on the reader's own line, which is unset when
// `up` was pressed on an empty row.
let pending = prompt.pending.take().unwrap_or_default();
prompt.position = None;
prompt.show(pending);
}
/// What enter does with the line: run the command it resolved to, or say why it did
/// not resolve to one.
///
@@ -2249,12 +2439,19 @@ impl Board {
/// and the reason both are true of one field.
fn submit(&mut self, screen: Size) {
let Some(prompt) = &self.prompt else { return };
let (line, cursor) = (prompt.line.clone(), prompt.cursor);
// Kept before anything can refuse it, since a line that was refused is the one most
// worth getting back: the fix is usually two characters, and retyping it from `:`
// is what the walk exists to stop. `keep` drops a blank line and a repeat of the
// line already at the end, so neither needs deciding here.
self.recall_mut().keep(&line);
// Before clap sees anything, because a line ending inside a quote is not a line
// that failed to parse: it is one the reader has not finished typing, and handing
// its half-open argument to clap would report a grammar fault about a sentence
// nobody finished.
let split = split_line(&prompt.line, prompt.cursor);
let split = split_line(&line, cursor);
if let Some(open) = unclosed_message(split.unclosed) {
self.refuse(open.to_string());
return;
@@ -8424,6 +8621,296 @@ approach";
);
}
// ------------------------------------------------------------------- the recall --
/// Press a key on the open prompt and assert it was taken, which every key there is.
fn press_prompt(board: &mut Board, code: KeyCode) {
assert!(board.prompt_key(typed(code), SCREEN), "{code:?} was not taken");
}
/// What a board has kept, oldest first, whatever tab it is on.
fn kept(board: &Board) -> &[String] {
&board.recalls[board.tab].lines
}
/// What the file holds, or nothing when there is no file to read.
fn recall_file(dir: &Path) -> Option<String> {
std::fs::read_to_string(dir.join(RECALL_FILE)).ok()
}
/// The walk itself: `up` hands back the previous line, repeated presses go further
/// back, and `down` comes forward again and returns the line that was being typed.
#[test]
fn up_walks_back_through_the_lines_and_down_comes_forward_to_the_half_typed_one() {
let (_root, mut board) = runnable();
for line in ["ls backlog", "show 1111111"] {
run_line(&mut board, line);
}
board.open_prompt();
type_line(&mut board, "comm");
press_prompt(&mut board, KeyCode::Up);
assert_eq!(
prompt_line(&board),
Some("show 1111111"),
"up did not hand back the last line"
);
press_prompt(&mut board, KeyCode::Up);
assert_eq!(prompt_line(&board), Some("ls backlog"), "up did not walk further back");
// The oldest line is a stop, not a wrap onto the newest again.
press_prompt(&mut board, KeyCode::Up);
assert_eq!(prompt_line(&board), Some("ls backlog"), "up wrapped past the oldest line");
press_prompt(&mut board, KeyCode::Down);
assert_eq!(prompt_line(&board), Some("show 1111111"), "down did not come forward");
press_prompt(&mut board, KeyCode::Down);
assert_eq!(prompt_line(&board), Some("comm"), "the half typed line was lost");
// Nothing in front of the reader's own line, so down there does nothing.
press_prompt(&mut board, KeyCode::Down);
assert_eq!(prompt_line(&board), Some("comm"), "down emptied the row");
}
/// The cursor lands at the end of a recalled line, since what a reader does with one is
/// append to it or fix its tail.
#[test]
fn a_recalled_line_arrives_with_the_cursor_at_its_end() {
let (_root, mut board) = runnable();
run_line(&mut board, "ls backlog");
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
type_line(&mut board, " --tag bug");
assert_eq!(
prompt_line(&board),
Some("ls backlog --tag bug"),
"the cursor was not at the end of the recalled line"
);
}
/// An empty recall does nothing at all, and that includes leaving the row alone: `up` on
/// a board nobody has typed at must not be a way to lose a half typed command.
#[test]
fn up_on_a_board_with_no_lines_leaves_the_row_alone() {
let (_root, mut board) = runnable();
board.open_prompt();
type_line(&mut board, "mv 111");
press_prompt(&mut board, KeyCode::Up);
press_prompt(&mut board, KeyCode::Down);
assert_eq!(prompt_line(&board), Some("mv 111"), "an arrow touched the line");
assert!(kept(&board).is_empty(), "a line nobody entered was kept");
}
/// The line this is most needed for. A refused line never reached a handler, and the fix
/// is usually two characters, so it has to be recallable like any other.
#[test]
fn a_line_that_was_refused_is_recalled_too() {
let (_root, mut board) = runnable();
run_line(&mut board, "mb 1111111 --status committed");
assert!(refused(&board).is_some(), "the typo was not refused");
// The prompt is still open on the refused line, so this is the next opening of it.
board.prompt = None;
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
assert_eq!(
prompt_line(&board),
Some("mb 1111111 --status committed"),
"the refused line was not kept"
);
}
/// Holding `up` steps through distinct commands rather than through the same `mv` typed
/// four times.
#[test]
fn consecutive_duplicates_are_kept_once() {
let (root, mut board) = runnable();
run_line(&mut board, "ls backlog");
run_line(&mut board, "ls backlog");
run_line(&mut board, "show 1111111");
run_line(&mut board, "ls backlog");
assert_eq!(
kept(&board),
["ls backlog", "show 1111111", "ls backlog"],
"the repeat was kept twice, or a line away from its repeat was folded into it"
);
let dir = root.join(".worklane");
assert_eq!(
recall_file(&dir).unwrap_or_default(),
"ls backlog\nshow 1111111\nls backlog\n",
"the file and the walk disagree"
);
}
/// The point of the file: the lines outlive the run. A board is opened and closed all
/// day, and a recall that empties on quit only helps inside a single sitting.
#[test]
fn the_lines_go_in_the_board_folder_and_come_back_on_the_next_run() {
let (root, mut board) = runnable();
let dir = root.join(".worklane");
run_line(&mut board, "ls backlog");
assert_eq!(recall_file(&dir).as_deref(), Some("ls backlog\n"), "nothing was written");
drop(board);
// The next run of the board over the same tree, which is what a quit and a restart
// leaves behind.
let mut next = Board::new(projects(&[], root.as_ref()).unwrap()).unwrap();
assert_eq!(kept(&next), ["ls backlog"], "the file was not read back");
next.open_prompt();
press_prompt(&mut next, KeyCode::Up);
assert_eq!(prompt_line(&next), Some("ls backlog"), "the previous run is not recalled");
// And the duplicate rule spans the two runs, since it is applied to what was loaded.
run_line(&mut next, "ls backlog");
assert_eq!(kept(&next), ["ls backlog"], "the file's last line was repeated");
}
/// One file per board, and the walk follows the tab. A project's lines are the ones
/// naming its ticket ids, and handing another board's `mv` back here would offer an id
/// that resolves to nothing.
#[test]
fn each_tab_walks_the_lines_of_its_own_board() {
let (first, one) = runnable();
let (second, two) = runnable();
let mut board = Board::new(vec![
project_at(&one.projects[0].dir),
project_at(&two.projects[0].dir),
])
.unwrap();
// A delta and not an index, so the two project tabs are one step apart from the
// merge the board opens on.
board.select_tab(1, SCREEN);
assert_eq!(board.tab, 1, "the first project tab is not where one step lands");
run_line(&mut board, "ls backlog");
board.prompt = None;
board.select_tab(1, SCREEN);
assert_eq!(board.tab, 2, "the second project tab is not the next step");
run_line(&mut board, "show 1111111");
board.prompt = None;
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
assert_eq!(
prompt_line(&board),
Some("show 1111111"),
"the second tab walked the first's"
);
board.prompt = None;
board.select_tab(-1, SCREEN);
assert_eq!(board.tab, 1, "the step back missed the first project tab");
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
assert_eq!(prompt_line(&board), Some("ls backlog"), "the first tab lost its own line");
assert_eq!(kept(&board), ["ls backlog"], "the other tab's line reached this one");
assert_eq!(
recall_file(&first.join(".worklane")).as_deref(),
Some("ls backlog\n"),
"the first board's file"
);
assert_eq!(
recall_file(&second.join(".worklane")).as_deref(),
Some("show 1111111\n"),
"the second board's file"
);
}
/// The merge tab is not a board, so there is nothing to attribute its lines to. They are
/// still recalled for the run, since every one of them was refused and a refused line is
/// the one worth getting back.
#[test]
fn a_line_typed_on_the_merge_tab_is_recalled_for_the_run_and_written_nowhere() {
let (first, one) = runnable();
let (second, two) = runnable();
let mut board = Board::new(vec![
project_at(&one.projects[0].dir),
project_at(&two.projects[0].dir),
])
.unwrap();
assert_eq!(board.tab, 0, "the merge is not the tab the board opens on");
run_line(&mut board, "mv 1111111 --status committed");
assert!(refused(&board).is_some(), "the merge tab ran the command somewhere");
board.prompt = None;
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
assert_eq!(
prompt_line(&board),
Some("mv 1111111 --status committed"),
"the merge tab did not recall its own line"
);
for dir in [first.join(".worklane"), second.join(".worklane")] {
assert_eq!(
recall_file(&dir),
None,
"a merge line landed on a board: {}",
dir.display()
);
}
}
/// A board whose folder cannot take the file still recalls within the run. The line is
/// what the reader asked for and it is on the row either way, so a failed write is
/// silent rather than a notice about the one thing nobody asked for.
#[test]
fn a_file_that_cannot_be_written_still_recalls_for_the_run() {
let (root, _board) = runnable();
let dir = root.join(".worklane");
// A directory where the file goes: the read fails, and so does every append.
std::fs::create_dir_all(dir.join(RECALL_FILE)).unwrap();
let mut board = Board::new(projects(&[], root.as_ref()).unwrap()).unwrap();
assert!(kept(&board).is_empty(), "an unreadable file was not an empty recall");
run_line(&mut board, "ls backlog");
assert!(board.prompt.is_none(), "the command was refused: {:?}", refused(&board));
assert_eq!(kept(&board), ["ls backlog"], "the line was lost with the write");
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
assert_eq!(prompt_line(&board), Some("ls backlog"), "the recall stopped working");
}
/// The swallow contract, restated with something in the recall: the arrows now do
/// something inside the prompt, and it still must not be the thing they do on the board.
#[test]
fn the_arrows_walk_the_recall_and_never_the_cards() {
let (_root, mut board) = runnable();
run_line(&mut board, "ls backlog");
board.prompt = None;
let before = selected_title(&board);
let column = board.current().column;
board.open_prompt();
press_prompt(&mut board, KeyCode::Up);
press_prompt(&mut board, KeyCode::Down);
press_prompt(&mut board, KeyCode::Up);
assert_eq!(selected_title(&board), before, "an arrow moved the selection");
assert_eq!(board.current().column, column, "an arrow changed column");
assert_eq!(prompt_line(&board), Some("ls backlog"), "the walk did not happen");
}
// ------------------------------------------------------------------ the copy key --
/// A sink that records what it was handed, standing in for the clipboard.
+10
View File
@@ -1608,6 +1608,16 @@ pub fn parse_tags(content: &str) -> Vec<String> {
return Vec::new();
}
split_tags(&value)
}
/// The tags in one comma-separated value, trimmed and without the empty ones.
///
/// Split out of [`parse_tags`] because a value typed on the command line is separated the
/// same way the stored field is: `append --tags "bug, tui"` names two tags, and merging
/// that into what a ticket already carries has to see two or it stores the pair as one
/// tag and adds it again on the next call.
pub fn split_tags(value: &str) -> Vec<String> {
value
.split(',')
.map(str::trim)
+226
View File
@@ -68,6 +68,232 @@ fn fish_is_offered_every_status() {
assert!(out.contains("-a 'backlog committed reviewing done discarded' -d status"));
}
/// A board holding one ticket and one tag, for the rules whose values come off a board.
///
/// Returned with the ticket's id and the tag, since the assertions are that those exact
/// strings are what fish offers.
fn board() -> (assert_fs::TempDir, String, String) {
let temp = assert_fs::TempDir::new().unwrap();
let mut init = Command::cargo_bin(BIN_NAME).unwrap();
init.current_dir(temp.path()).arg("init").assert().success();
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
add.current_dir(temp.path())
.args(["add", "--title", "A ticket to complete", "--tags", "atag"])
.assert()
.success();
let mut ls = Command::cargo_bin(BIN_NAME).unwrap();
let listed = ls
.current_dir(temp.path())
.args(["ls", "--ids"])
.assert()
.success();
let listed = String::from_utf8(listed.get_output().stdout.clone()).unwrap();
let id = listed.split('\t').next().unwrap().trim().to_string();
(temp, id, "atag".to_string())
}
/// What fish would actually offer for a half-typed line, or `None` when fish is absent.
///
/// `complete -C` is fish's own answer to "what are the candidates here", so this asks the
/// question a person at a prompt asks rather than searching the script for the rule that
/// ought to produce the answer. Each candidate is a name and, after a tab, its description.
///
/// **The shell is pointed at the binary under test and stood in a real board**, which is
/// what makes the dynamic half testable at all: its rules are command substitutions calling
/// `worklane ls --ids` and `worklane tags`, so with no board and no binary they return
/// nothing and every assertion about them would pass on an empty answer. The directory of
/// `CARGO_BIN_EXE_worklane` goes on the front of PATH so the substitution runs this build
/// rather than whatever is installed.
///
/// **`fish_complete_path` is emptied first, and without that line this test cannot fail.**
/// `complete -C` autoloads completions for the command it is asked about, so a developer
/// who has ever run `worklane completions fish > ~/.config/fish/completions/worklane.fish`
/// gets that file merged into the answer. It was written by some earlier version of this
/// binary and answers for whatever the rules used to be: the first draft of this test
/// passed against a deliberately broken scope because the installed copy still had the
/// working one. Emptying the path is what makes the sourced script the only source.
fn candidates(board: &assert_fs::TempDir, line: &str) -> Option<Vec<String>> {
// Beside the board rather than in it: a rule that fires nothing falls back to listing
// the directory, and a script sitting in there would appear among the candidates and
// read like an answer.
let holder = assert_fs::TempDir::new().unwrap();
let path = holder.path().join("worklane.fish");
std::fs::write(&path, script("fish")).unwrap();
let bin_dir = std::path::Path::new(BIN_NAME).parent().unwrap();
let inherited = std::env::var("PATH").unwrap_or_default();
let asked = std::process::Command::new("fish")
.current_dir(board.path())
.env("PATH", format!("{}:{inherited}", bin_dir.display()))
.arg("-c")
.arg(format!(
"set fish_complete_path; source {}; complete -C '{line}'",
path.display()
))
.output();
match asked {
Ok(out) => Some(
String::from_utf8_lossy(&out.stdout)
.lines()
.map(str::to_string)
.collect(),
),
Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
Err(err) => panic!("could not run fish: {err}"),
}
}
/// The name half of a candidate, dropping the description fish takes after the tab.
fn names(candidates: &[String]) -> Vec<&str> {
candidates
.iter()
.map(|line| line.split('\t').next().unwrap_or(line))
.collect()
}
/// **Ask fish what it offers, instead of asserting that the rule that should make it
/// offer that is in the file.**
///
/// Every other test here reads the script as text, which cannot tell a rule that fires
/// from one whose condition stopped matching. That is how a completion actually breaks:
/// the clap definition moves, a list or a `__worklane_command_is` scope no longer names
/// anything, and the rule sits in the file offering nothing. Loading it into a real fish
/// and asking for the candidates is the only check that can see the difference.
///
/// **Asserting the values, not only the names, is the point.** clap emits every option's
/// name on its own, so `--tags` and `--blocked-by` are offered whether or not the dynamic
/// half loaded: an assertion that they appear passes with every hand-written rule deleted.
/// What those rules add is the candidates *after* the flag, and that is what is pinned
/// here, against the board `board()` puts under the shell.
///
/// Descriptions are read off deliberately and not asserted: every option carrying a
/// hand-written rule currently loses the help text clap gave it, which is its own ticket
/// rather than something to pin as correct here.
///
/// **Skipped when fish is not on PATH, and it says so.** There is no CI here and fish is
/// the shell this tool is written for, so failing a machine that never had it would be a
/// guard nobody could satisfy. A missing fish means the check did not run, not that it
/// passed.
#[test]
fn fish_offers_the_commands_the_statuses_and_the_values() {
let (temp, id, tag) = board();
let Some(commands) = candidates(&temp, "worklane ") else {
eprintln!("skipped: fish is not on PATH, so nothing asked it for candidates");
return;
};
for command in [
"add", "ls", "show", "mv", "set", "append", "relate", "campaign",
] {
assert!(
names(&commands).contains(&command),
"`worklane <TAB>` never offers {command}"
);
}
// The `ls` status positional, which clap emits nothing for, so this answer comes from
// the dynamic half alone and an empty one means that half stopped loading.
let statuses = candidates(&temp, "worklane ls ").unwrap();
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
assert!(
names(&statuses).contains(&status),
"`worklane ls <TAB>` never offers {status}"
);
}
let shells = candidates(&temp, "worklane completions ").unwrap();
for shell in ["fish", "bash", "zsh"] {
assert!(
names(&shells).contains(&shell),
"`worklane completions <TAB>` never offers {shell}"
);
}
// Every rule whose values come off the board, one per list it is generated from.
let ticket_value = [
("worklane show ", "TICKET_COMMANDS"),
("worklane chown alice ", "TICKET_SECOND_COMMANDS"),
("worklane relate --blocked-by ", "TICKET_FLAGS"),
("worklane chown --clear ", "the chown --clear rule"),
];
for (line, list) in ticket_value {
let offered = candidates(&temp, line).unwrap();
assert!(
names(&offered).contains(&id.as_str()),
"`{line}<TAB>` never offers the one ticket on the board, so {list} is not reaching it: {offered:?}"
);
}
let tag_value = [
("worklane ls --tag ", "TAG_FLAGS"),
("worklane append --tags ", "TAG_FLAGS"),
("worklane tags set ", "TAG_NESTED_COMMANDS"),
];
for (line, list) in tag_value {
let offered = candidates(&temp, line).unwrap();
assert!(
names(&offered).contains(&tag.as_str()),
"`{line}<TAB>` never offers the one tag on the board, so {list} is not reaching it: {offered:?}"
);
}
}
/// **The script is handed to fish, which parses it without running it.**
///
/// The fish half is a hand-written `format!` string carrying single quotes, command
/// substitutions and backslash line continuations, and every text assertion in this file
/// is a `contains`, which a broken script satisfies exactly as well as a correct one.
/// `--no-execute` is the parse without the run.
///
/// **What it catches is a script that does not parse**: quotes still open at the end of
/// the file, an unclosed block. That is narrower than it sounds and the limit is worth
/// writing down, because it was measured rather than assumed. An apostrophe interpolated
/// into a `-d` description partway down the file re-balances against the next quote and
/// parses, corrupting every rule in between while this test passes; the same apostrophe in
/// the *last* rule reaches the end unbalanced and is caught. So this is a floor, not an
/// oracle, and `fish_offers_the_commands_the_statuses_and_the_flags` is the one that reads
/// what the rules actually do.
///
/// Only fish, because only fish gets a hand-written half. What the other four shells are
/// given is clap's output whole, which `no_other_shell_gets_the_fish_half` pins, so a
/// syntax error there would be clap's bug and not this repo's to catch.
///
/// **Skipped when fish is not on PATH, and it says so.** The trade is deliberate: there is
/// no CI here and fish is the shell this tool is written for, so failing a machine that
/// never had it would be a guard nobody could satisfy. A missing fish means the check did
/// not run, not that it passed.
#[test]
fn fish_parses_the_script_it_is_given() {
let temp = assert_fs::TempDir::new().unwrap();
let path = temp.path().join("worklane.fish");
std::fs::write(&path, script("fish")).unwrap();
let parsed = std::process::Command::new("fish")
.arg("--no-execute")
.arg(&path)
.output();
let out = match parsed {
Ok(out) => out,
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
eprintln!("skipped: fish is not on PATH, so the generated script went unparsed");
return;
}
Err(err) => panic!("could not run fish: {err}"),
};
assert!(
out.status.success(),
"fish refuses the script `worklane completions fish` writes:\n{}",
String::from_utf8_lossy(&out.stderr)
);
}
#[test]
fn an_unknown_shell_is_a_usage_error() {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
+134
View File
@@ -676,6 +676,140 @@ fn append_requires_at_least_one_section() {
assert_eq!(run(&temp, &["append", UUID]).status.code(), Some(2));
}
/// The reason the flag exists: `set --tags` writes the whole field, so adding one tag to
/// a ticket that already carries some meant knowing and retyping every one of them.
#[test]
fn append_adds_a_tag_and_keeps_the_ones_already_there() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["append", UUID, "--tags", "beta"]);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
let content = ticket(&worklane);
assert!(content.contains("- **Tags**: alpha, beta"), "{content}");
// The sections and the other fields are as untouched as they are by any other append
assert!(content.contains("- [x] Crit one\n- [ ] Crit two\n"), "{content}");
assert!(content.contains("- **Priority**: 3"), "{content}");
}
/// Idempotent on purpose: the caller of an append does not have to know what is there
/// already, so naming a tag the ticket carries is reported as no change and writes
/// nothing, the way an unchanged field is everywhere else.
#[test]
fn append_ignores_a_tag_the_ticket_already_carries() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
let out = run(&temp, &["append", UUID, "--tags", "alpha"]);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
assert!(
String::from_utf8_lossy(&out.stdout).contains("No changes to"),
"{:?}",
String::from_utf8_lossy(&out.stdout)
);
assert_eq!(ticket(&worklane), before);
// And the one already there is not added a second time beside a new one
run(&temp, &["append", UUID, "--tags", "alpha", "--tags", "beta"]);
assert!(
ticket(&worklane).contains("- **Tags**: alpha, beta"),
"{}",
ticket(&worklane)
);
}
/// Two spellings for the same call, because the stored field is comma separated too and
/// `set --tags` takes that form on this very field: refusing it on the counterpart would
/// be a trap. New tags land in the order they were given, after the ones already there.
#[test]
fn append_takes_several_tags_by_repeated_flag_or_by_comma() {
for args in [
vec!["append", UUID, "--tags", "bug", "--tags", "tui"],
vec!["append", UUID, "--tags", "bug, tui"],
vec!["append", UUID, "-g", "bug,tui"],
] {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &args);
assert!(
out.status.success(),
"{args:?}: {:?}",
String::from_utf8_lossy(&out.stderr)
);
assert!(ticket(&worklane).contains("- **Tags**: alpha, bug, tui"), "{args:?}");
}
}
/// A value that names no tag is refused rather than written, the way an all-blank section
/// value is: `--tags ","` adds nothing, and writing the field back unchanged would report
/// an append that never happened. Emptying the field is `set --clear tags`.
#[test]
fn append_refuses_a_tags_value_that_names_nothing() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
// Empty at the parser, before the ticket is even resolved
let empty = run(&temp, &["append", UUID, "--tags", ""]);
assert_eq!(empty.status.code(), Some(2));
assert!(
String::from_utf8_lossy(&empty.stderr).contains("value cannot be empty"),
"{:?}",
String::from_utf8_lossy(&empty.stderr)
);
// The message must not name a `--clear` this command does not have
assert!(
!String::from_utf8_lossy(&empty.stderr).contains("use --clear"),
"{:?}",
String::from_utf8_lossy(&empty.stderr)
);
// Separators only, which the parser cannot see is empty
let blank = run(&temp, &["append", UUID, "--tags", ", ,"]);
assert_eq!(blank.status.code(), Some(1));
assert!(
String::from_utf8_lossy(&blank.stderr).contains("Nothing to append to the tags"),
"{:?}",
String::from_utf8_lossy(&blank.stderr)
);
assert_eq!(ticket(&worklane), before);
}
/// A ticket with no tags starts the list rather than appending to the sentinel.
#[test]
fn append_writes_the_first_tag_over_the_unset_sentinel() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
add.current_dir(temp.path())
.args(["add", "--title", "Untagged"])
.assert()
.success();
let uuid = fs::read_dir(worklane.join("backlog"))
.unwrap()
.filter_map(|e| e.ok())
.map(|e| e.file_name().into_string().unwrap())
.next()
.map(|name| name.split('_').next().unwrap().to_string())
.unwrap();
run(&temp, &["append", &uuid, "--tags", "bug"]);
let content = ticket(&worklane);
assert!(content.contains("- **Tags**: bug"), "{content}");
assert!(!content.contains("_None_"), "{content}");
}
/// Owner belongs to chown and status to mv, so neither command offers them.
#[test]
fn neither_command_can_write_owner_or_status() {
+45 -3
View File
@@ -275,6 +275,36 @@ fn clearing_the_tags_writes_a_tags_entry() {
assert!(entry.starts_with("**Tags**\nalpha → _None_\n"), "{entry:?}");
}
/// Tags are logged wherever they change, so the command that adds to them logs the same
/// entry the one that replaces them does. The values come off the field rather than off
/// the flag, so the entry records where the field went and not what the call added: an
/// append of `beta` onto `alpha` reads as the pair, not as `beta`.
#[test]
fn appending_a_tag_writes_a_tags_entry() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog");
run(&temp, &["append", UUID, "--tags", "beta"]);
let entry = only_entry(&worklane, "tags");
assert!(entry.starts_with("**Tags**\nalpha → alpha, beta\n"), "{entry:?}");
}
/// The sections are not logged, and appending to one is not a tag change: an append that
/// touches no tag writes nothing, so the log does not fill with the edits it deliberately
/// leaves out.
#[test]
fn appending_to_a_section_writes_nothing() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog");
run(&temp, &["append", UUID, "--acceptance", "One more criterion"]);
assert_eq!(entries(&worklane), vec![]);
}
/// The entry names the campaign the way a reader knows it, the codename, not the uuid
/// the field actually holds. A ticket never assigned starts from the sentinel an unset
/// field reads as everywhere else.
@@ -433,6 +463,7 @@ fn a_no_op_edit_writes_nothing() {
vec!["mv", UUID, "--status", "backlog"],
vec!["chown", "alice", UUID],
vec!["set", UUID, "--tags", "alpha"],
vec!["append", UUID, "--tags", "alpha"],
] {
let out = run(&temp, &args);
assert!(
@@ -577,10 +608,11 @@ fn the_actor_flag_names_the_writer_on_every_command_that_writes_one() {
run(&temp, &["mv", UUID, "--status", "committed", "--actor", "opencode"]);
run(&temp, &["chown", "bob", UUID, "--actor", "opencode"]);
run(&temp, &["set", UUID, "--tags", "beta", "--actor", "opencode"]);
run(&temp, &["append", UUID, "--tags", "gamma", "--actor", "opencode"]);
run(&temp, &["assign", "v1", UUID, "--actor", "opencode"]);
let found = entries(&worklane);
assert_eq!(found.len(), 5, "{found:?}");
assert_eq!(found.len(), 6, "{found:?}");
for (name, content) in found {
assert!(content.contains("**Author**: opencode"), "{name}: {content:?}");
}
@@ -609,10 +641,11 @@ fn actor_from_git_names_the_git_user_on_every_command_that_writes_one() {
run_for_the_human(&temp, &["mv", UUID, "--status", "committed", "--actor-from-git"]);
run_for_the_human(&temp, &["chown", "bob", UUID, "--actor-from-git"]);
run_for_the_human(&temp, &["set", UUID, "--tags", "beta", "--actor-from-git"]);
run_for_the_human(&temp, &["append", UUID, "--tags", "gamma", "--actor-from-git"]);
run_for_the_human(&temp, &["assign", "v1", UUID, "--actor-from-git"]);
let found = entries(&worklane);
assert_eq!(found.len(), 5, "{found:?}");
assert_eq!(found.len(), 6, "{found:?}");
for (name, content) in found {
assert!(content.contains("**Author**: Ansho Rei"), "{name}: {content:?}");
}
@@ -627,7 +660,7 @@ fn actor_and_actor_from_git_are_refused_together() {
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog");
let calls: [&[&str]; 5] = [
let calls: [&[&str]; 6] = [
&[
"comment",
UUID,
@@ -662,6 +695,15 @@ fn actor_and_actor_from_git_are_refused_together() {
"opencode",
"--actor-from-git",
],
&[
"append",
UUID,
"--tags",
"beta",
"--actor",
"opencode",
"--actor-from-git",
],
&[
"assign",
"v1",