Compare commits

...
5 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 6a800fb385 (bdddc09) Read only the underscore markers as unset, and bump to 0.18.1
`is_unknown_value` accepted `-None-` and `-Not set-` alongside the real
`_None_` and `_Not set_`. The ticket had them down as corrupted output handled
downstream instead of at the source, but the source never existed: `git log -S`
finds both spellings in exactly one commit, 2a96abd, the one that added them to
the check. They were written by analogy with the `**-Status**` field name the mv
splicing bug really did produce, c230d2c, and they have been dead since the day
the function was written.

So this is a deletion with nothing behind it. All five boards on this machine
hold no hyphenated marker in any metadata field, and the only files in this
repo that contain the spellings at all are the two tickets that describe the
bugs, in prose, which `parse_ticket_field` does not read.

A field that somehow holds one now reads as the text it is rather than passing
for unset, which is the right way round for corruption nothing can produce.
`a_hyphenated_marker_is_not_unset` pins that, because the risk here is not the
old code coming back but the analogy being drawn a second time. The
`**-Status**` repair in `is_status_line` is the opposite case and stays: that
corruption was real, and AGENTS.md now says why the two are not alike.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 00:52:39 +02:00
Ansho ReiandClaude Opus 5 4ae7ef03ff Let git blame look through the reformat
`.git-blame-ignore-revs` names 73ffcad, which touched 22 files and decided
nothing, so `git blame` no longer answers "who wrote this line" with the
formatter. Opt in per clone:

    git config blame.ignoreRevsFile .git-blame-ignore-revs

Also records the one thing the fmt rule does not cover: sixteen lines still run
past 100 columns and all sixteen are single string literals rustfmt cannot
break. `format_strings` stays off, since a message is prose and not the
formatter's to rewrite.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 00:23:22 +02:00
Ansho ReiandClaude Opus 5 73ffcad733 Reformat with cargo fmt, and nothing else
Layout only, no behaviour and no wording. 161 hunks across 22 files, 98 of them
rustfmt joining a call or a message onto the one line it fits on. The config it
formats to, and how its four numbers were arrived at, is the commit before this
one.

Separate so that it is reviewable by not being read: nothing here is a decision,
and every decision is next door.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 00:23:04 +02:00
Ansho ReiandClaude Opus 5 964ca342d8 (83d31cd) Make rustfmt the formatter, with a config measured against the tree
cargo fmt --check failed in about 160 places and rustfmt was neither run nor
switched off, so anyone who ran it once produced a diff that buried the change
it was run alongside. It is the formatter now, and the config is what makes
that affordable.

The default config wanted 305 hunks and would have added 1418 lines of pure
layout: its sub-widths (fn_call_width and chain_width at 60) sit far below the
100 columns this tree is written to, so 276 of those hunks were rustfmt
expanding lines that already fit. `use_small_heuristics = "Max"` went the other
way, 308 hunks and 796 lines removed, one-lining if/else and collapsing struct
literals that were split on purpose.

Coordinate descent over the stable width knobs lands at four settings and 161
hunks, 98 of them rustfmt joining calls that fit rather than breaking them.
Sweeping any one of the four in either direction makes the diff bigger, which
is recorded beside them so the next reader measures instead of adjusting by
eye. The reformat itself is the commit after this one, so neither is mixed
with the other.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 00:22:23 +02:00
Ansho ReiandClaude Opus 5 cc5f9b8a46 (74904dc) Let a ticket field be cleared back to unset, and bump to 0.18.0
`set --clear <field>` is the one way to take a value away, repeatable, with
the field as a `ValueEnum` value: an unknown one is a usage error listing the
six that are not, and the shells complete them for free. Not a per-field
`--clear-due`, which is a flag per field to keep in step with the one it
undoes, and not an empty value, which is already a paragraph break for a
section and would make an accidentally empty variable a silent delete.

What goes back is what `add` writes for a field it was never given, through
the new `NOT_SET` and `NONE` constants and each section's placeholder, so a
cleared ticket and one filed without the field read the same. Sections are in
scope and go back through `clear_section_body` rather than
`set_section_body`: the latter runs its items through `Section::render`, which
would have written `- [ ] _No acceptance criteria provided._`.

Owner is `chown --clear <ticket>`, so the field keeps its one writer. The flag
carries the ticket because the ticket is chown's second positional and a bare
flag would land it in the user's slot for the handler to read back out, which
is hand-parsing what clap can state. It writes `_Not set_` rather than the git
user: `add` falls back to the git user because it is filing something new, and
an owner taken away says nobody owns this.

The empty-value error split in two rather than being reworded. `non_empty`
says only that the value cannot be empty, for the arguments with no empty
form; `clearable` names `--clear`, for the arguments whose field has one. One
message for both would have lied about `ls --tag`.

Replacing and clearing one field in a single call is refused rather than
resolved by whichever was applied last, and cleared fields are reported as
`Cleared due on '...'` beside `Updated priority on '...'`, since one list
would say `Updated` of a field that was emptied.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 00:04:28 +02:00
30 changed files with 1298 additions and 586 deletions
+8
View File
@@ -0,0 +1,8 @@
# Revisions that changed layout and nothing else. Teach git to look through them:
#
# git config blame.ignoreRevsFile .git-blame-ignore-revs
#
# Only a commit whose diff is pure formatting belongs here.
# Reformat with cargo fmt, and nothing else
73ffcad73314621e299dc06ee688db9b4c4d6b29
+34 -4
View File
@@ -42,6 +42,20 @@ and this file is for what someone changing worklane's own code needs.
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created, plus `campaigns/` in `cmd_campaign.rs`, which is also where the on-demand creation is tested from a board without it
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
- **`cargo clippy --all-targets` is clean. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
- **`cargo fmt --check` is clean too, and `rustfmt.toml` is what makes that affordable.** rustfmt is the formatter here, run it. The config is four stable width settings and nothing else:
| setting | value | why |
|---|---|---|
| `max_width` | 100 | The tree's own habit, and the measured optimum: 90 costs 268 hunks and 120 costs 194, against 161 at 100 |
| `fn_call_width` | 75 | A call stays whole if it fits in three quarters of the line. rustfmt's default of 60 is what expanded 276 of the 305 hunks the default config wanted |
| `chain_width` | 65 | The same for a method chain |
| `struct_lit_width` | 30 | A small struct literal stays whole, so `Size { width: 120, height: 20 }` is not six lines |
**The numbers were measured, not chosen.** Default rustfmt wanted 305 hunks and would have added 1418 lines of pure layout, because its sub-widths sit far below the 100 columns this tree is written to. `use_small_heuristics = "Max"` went the other way, 308 hunks and 796 lines *removed*, one-lining `if`/`else` and collapsing struct literals that were split on purpose. Coordinate descent over the stable width knobs landed here, at 161 hunks, and 98 of those are rustfmt *joining* calls that fit rather than breaking them. Sweeping any one of these four in either direction makes the diff bigger, so do not adjust one by eye; measure it the same way, with `cargo fmt --check | grep -c '^Diff in'`
- What this does not buy: rustfmt has no rule for "keep parallel arms parallel", so a match whose arms are one line and four lines depending on the length of their contents is what it produces, and that is accepted. Reach for `#[rustfmt::skip]` only where the layout carries meaning a reader needs, not to win an argument about density
- Do not add an unstable option. `cargo fmt` on stable ignores them with a warning, so the tree would format differently for whoever ran nightly
- **Sixteen lines still run past 100 columns and every one of them is a single string literal**, a test fixture or an error message rustfmt cannot break. `format_strings` is deliberately left at its default: turning it on would let the formatter rewrite message text, and a message is prose. So `max_width` is where rustfmt breaks lines, not a limit the tree keeps
- The reformat is `73ffcad`, and `.git-blame-ignore-revs` names it so `git blame` looks through it. Turn that on once per clone with `git config blame.ignoreRevsFile .git-blame-ignore-revs`. A commit belongs in that file only if its diff is pure layout
## Coding Guidelines
@@ -59,7 +73,8 @@ and this file is for what someone changing worklane's own code needs.
- **`--due` is validated at parse time by `iso_date`, the way `--priority` is by `priority_level`.** A date that is not real is a usage error, exit 2, with nothing written, which is the whole point of leaving the scalars without `PROSE`. One parser serves `add` and `set`: the field has one definition of what it accepts, and validating only `add` would leave `set` open, which is the command a grooming sweep actually uses
- **The shape is checked before chrono is asked.** `%Y-%m-%d` accepts an unpadded `2026-8-9`, which would be stored exactly as typed and sort before `2026-10-01` in any string comparison. Checking the length and the two dashes first is what lets a valid date be stored unchanged instead of normalised on the way in, which is the difference between validating and rewriting
- **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 `non_empty`'s message about clearing rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is that clearing is not supported yet
- 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
- **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
- **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
@@ -90,11 +105,24 @@ and this file is for what someone changing worklane's own code needs.
- **One field, one writer.** `set` has no `--owner` (that is `chown`'s) and no `--status` (that is `mv`'s), and neither `add`, `set`, `append` nor `chown` can reach the three status stamps, which `mv` writes as a side effect of the move. Do not add any of them
- `chown` takes the **user first and the ticket second**, after Unix `chown`, and is the only command that does not start with the ticket. Deliberate: the name borrows the Unix association, so the order borrows it too. A swap is left to `resolve_ticket`, which refuses a bare username as a ticket. No argument is inspected to see whether it *also* names a ticket, since such a check would only fire where resolution already fails and would stay silent on the one case it cannot catch, a ticket whose title is the username
- `cmd_chown` is `set_metadata_field` plus `save_ticket`, with the same whole-file no-op comparison `set` uses and the same `report()` output, so nothing about writing a field lives twice
- Sections are a table in `util.rs`: `DESCRIPTION`, `ACCEPTANCE`, `PLAN`, each with a heading, a label, the placeholder `add` writes when empty, and a `SectionKind`. Adding a section later is one entry, not edits in both commands
- `apply()` is the one place an edit is taken or dropped, shared by `set`'s replaced list and its cleared one. It was a closure over the single list until there were two, and two closures carrying one rule is how a later edit changes it for one and not the other
- Sections are a table in `util.rs`: `DESCRIPTION`, `ACCEPTANCE`, `PLAN`, each with a heading, a label, the placeholder `add` writes when empty, a `SectionKind` and the `--clear` value that empties it. Adding a section later is one entry, not edits in both commands
- Everything is targeted line surgery, never a regenerated file. That is what keeps a ticked criterion ticked and a handwritten `## Notes` section intact when an unrelated field changes. `section_body()` finds the lines to touch, `set_metadata_line()` does the metadata, and every other byte is copied through
- Appending to a numbered section continues from the count of steps already there and does not renumber what is above it, so a handwritten line in the section survives exactly as written
- Appending to an empty section replaces the placeholder rather than following it, or the ticket would read `_No description provided._` above its description
- An empty value is a paragraph break for the three sections and a usage error for the scalars, via `non_empty` in `command.rs`. Clearing a field is not supported yet, and the error says so rather than guessing
- An empty value is a paragraph break for the three sections and a usage error for the scalars, via `non_empty` and `clearable` in `command.rs`. Neither spells clearing, and both errors name the flag that does
### Clearing a Field
- **`set --clear <field>` is the one way to take a value away, and it is a flag with the field as its value.** Not a per-field `--clear-due`, which is a flag per field to keep in step with the field it undoes, and not an empty value, which is already a paragraph break for a section and would make an accidentally empty variable a silent delete. Repeatable, so one call empties as many fields as it likes
- **`Clearable` is a `ValueEnum` in `util.rs`**, so an unknown field is a usage error at the door listing the six that are not, and the shells complete them for free. It is also the whole table of what can be cleared: `Due`, `Tags` and `Priority` clear to a sentinel, `Description`, `Acceptance` and `Plan` to their section's placeholder. `Title` is absent because it addresses the ticket and names its file, so there is no state to go back to; `Owner`, `Status`, `Campaign` and the stamps because clearing them through `set` is exactly the second writer the missing `set --owner` exists to prevent
- **What is written is `NOT_SET` and `NONE`, the constants `add` writes.** A cleared ticket and one that was never given the field have to read the same, or clearing would be a third state that every parser then has to know about. `a_cleared_ticket_reads_like_one_filed_without_the_fields` compares the two files byte for byte, which is what keeps a new field honest
- **The placeholder goes into a section bare, via `clear_section_body`.** `set_section_body` runs its items through `Section::render`, which would write `- [ ] _No acceptance criteria provided._`. Both are `replace_section_body` underneath, so the line surgery and the trailing blank line live once
- **The pairing between a section and its `--clear` value is stored on both**, `Clearable::unset` one way and `Section::clear` the other, because the error for an empty value has to name the flag for *that* section and the section's label ("acceptance criteria") is not the flag's value ("acceptance"). `every_clearable_section_points_back_at_the_field_that_clears_it` keeps the two directions from drifting. `RELATIONS.clear` is `None`, the same rule that keeps it out of `section_args`
- **Cleared fields are reported apart from replaced ones**, as `Cleared due on '...'` beside `Updated priority on '...'`. One list would say `Updated` of a field that was emptied, which is the opposite of what a caller needs to read back. The labels are the ones `set` already prints when it *writes* the field, so the two lines name a field the same way
- **Replacing and clearing one field in a single call is refused**, by `SetArgs::contested`. clap cannot express it, because the field arrives as `--clear`'s value rather than in its name, and answering by whichever was applied last is a silent answer to a contradictory call
- **Clearing the owner is `chown --clear <ticket>`, and `--clear` carries the ticket.** Owner has one writer and clearing it cannot introduce a second, so it lives on `chown`; but the ticket is `chown`'s *second* positional, and a bare flag would land it in the user's slot for the handler to read back out, which is hand-parsing what clap can state. The typed call is identical either way. `ChownArgs::target` returns the one shape the constraints allow, and an error rather than a panic for the combination they already refuse
- **Clearing the owner writes `NOT_SET`, not the git user.** `add` falls back to the git user because it is filing something new; an owner taken away says nobody owns this, and putting the person running the command there instead hands them a ticket they were giving up
- Clearing a field that is already unset writes the sentinel that is already there, so the whole-file comparison below reports no change and nothing is written. That is not a special case, and must not become one
- No-op detection compares the whole file before and after each edit, so a field set to the value it already holds is reported unchanged and nothing is written
- `find_ticket_file()` matches on the uuid, never the title. Duplicate titles are allowed, so a title scan can land on a different ticket than the one resolved: `mv <uuid-of-second>` used to move the first ticket sharing its title
- `write_then_replace()` is the only way a ticket file is written. Content first, rename second, so a failure leaves a correct ticket under a stale name rather than a half-written one
@@ -322,7 +350,9 @@ and this file is for what someone changing worklane's own code needs.
- The UUID tier applies from `MIN_ID_SEARCH` (4) characters up. Not 8: `ls` prints `SHORT_ID_WIDTH` (7) characters, so a longer minimum would drop the printed id out of the UUID tier and let any title quoting it win instead. Below the minimum the search is text, so `show 641` is a title search
- The filename tier earns its place by reaching the middle of a UUID, which the prefix tier cannot. It is also why a short UUID search still resolves under a longer minimum, just at the wrong precedence, so a test for the minimum needs a decoy title to be meaningful
- Ambiguous matches (multiple results) print options and exit(1)
- Never return empty strings for required fields — use `_Not set_` or `_None_` as defaults
- Never return empty strings for required fields — use the `NOT_SET` and `NONE` constants in `util.rs`, which are what `add` writes and what `--clear` puts back. `is_unknown_value` reads those two and nothing else
- **`-None-` and `-Not set-` are not unset, and re-adding them would be a mistake with a plausible story behind it.** They were accepted by `is_unknown_value` from the day it was written, by analogy with the `**-Status**` field name the `mv` splicing bug really did produce, c230d2c. But no version of this tool ever wrote a hyphenated *value*: `git log -S` finds both spellings in exactly one commit, the one that added them to the check. Dead from birth, and dropped by bdddc09. `a_hyphenated_marker_is_not_unset` is what stops the analogy being drawn a second time
- **The `**-Status**` repair in `is_status_line` is the opposite case and stays.** That corruption was real, `mv` wrote it, and the repair is what fixes a damaged ticket as it moves. Do not tidy the two away together on the grounds that they look alike
### Git Workflow
- Commit format: `([ticketID]) [short description]`
Generated
+1 -1
View File
@@ -1503,7 +1503,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.17.2"
version = "0.18.1"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.17.2"
version = "0.18.1"
edition = "2024"
[dependencies]
+3 -2
View File
@@ -11,10 +11,10 @@ Worklane is a local Kanban flow for agentic software development.
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>`, `--tag <tag>` and `--campaign <campaign>`, which compose in any combination. `--tag` matches a whole value of the comma-separated Tags field, case sensitively, so `--tag bug` does not list a ticket tagged `bugfix` or one tagged `Bug`. `--ids` prints one ticket per line as its short id, a tab and its title, unstyled, done included, for a script or a completion |
| `worklane show <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring |
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions |
| `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 |
| `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 |
| `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 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. `mv` refuses to move a ticket blocked by one that is not done, unless `-f` |
| `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 <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 |
| `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 |
| `worklane uncheck <ticket> [criteria...]` | Unticks acceptance criteria, addressed the same way |
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
@@ -37,6 +37,7 @@ asks worklane for the one thing only the board knows:
worklane show <TAB> every ticket, id and title, done included
worklane mv <TAB> the same, then --status <TAB> for the four
worklane chown alice <TAB> the ticket, which is the second argument here
worklane chown --clear <TAB> the ticket, which the flag carries here
worklane relate x --blocked-by <TAB>
```
+15 -11
View File
@@ -16,11 +16,12 @@ which command owns which field. Read it too. This document is the judgement.
**Propose the whole set of edits, wait, then apply exactly what was approved.**
Every job here writes to many tickets at once, and no field can be cleared back to unset
yet, so a date written onto the wrong ticket can only be overwritten, never taken off. A wrong
edit to one ticket is a mistake; a wrong sweep is thirty of them with no undo. So a
proposal is a list, one line per intended edit, each naming the ticket and the command
that would make it:
Every job here writes to many tickets at once, and nothing on the board records what a
field held before you wrote to it. `--clear` puts a field back to unset, which is **not
back to what it held**, so a date written over another date is gone. A wrong edit to one
ticket is a mistake; a wrong sweep is thirty of them with no undo. So a proposal is a
list, one line per intended edit, each naming the ticket and the command that would make
it:
```
(1b78a24) priority 3 -> 1 worklane set 1b78a24 --priority 1
@@ -37,10 +38,10 @@ other way is editing the file by hand:
| Field | Writer |
|-------|--------|
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags` |
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags`, and `--clear <field>` to empty one |
| Relations | `worklane relate <ticket> --blocked-by` / `--regression-of` / `--relates-to` |
| Campaign membership | `worklane assign <campaign> <ticket>` |
| Owner | `worklane chown <user> <ticket>` |
| Owner | `worklane chown <user> <ticket>`, and `worklane chown --clear <ticket>` to empty it |
| Status | `worklane mv <ticket> --status <target>` |
**Never edit a ticket file directly.** The filename, the `Status` field and the directory
@@ -101,8 +102,9 @@ What to look for:
A value that is not a real calendar date in that exact form is refused before anything
is written, so a typo costs nothing. `2026-8-9` is refused too: the padding is part of
the format. What is still true is that a date, once written, **cannot be cleared**, only
replaced by another date, so a plan applied to the wrong ticket has no undo.
the format. A date can be taken off again with `worklane set <ticket> --clear due`. What
that cannot do is recover the date that was there before it, so a plan applied over
existing dates still has no undo.
Ask the system what today is rather than assuming it. A plan built on a guessed date is
wrong by however much the guess was wrong.
@@ -119,13 +121,15 @@ The rules a dating plan has to keep:
whole backlog produces a board where every ticket is late, which is the same as no
dates at all.
- **Do not date `done`.** It is finished; a date on it is noise in every listing.
- Leave the rest unset. An unset due date is honest about what has not been planned.
- Leave the rest unset. An unset due date is honest about what has not been planned, and
a date that turned out to be wrong is better cleared than left to read as a plan.
## Tags
`worklane set <ticket> --tags bug,cli` is the writer, and it **replaces the whole
field**. Restate every tag the ticket should keep, or the ones you left out are gone.
This is the single most destructive thing in this document.
This is the single most destructive thing in this document. `--clear tags` empties the
field on purpose, which is a different thing from emptying it by forgetting a tag.
Derive the vocabulary from the board rather than inventing one. Read the tickets, count
what is actually used, and show the count before proposing anything. What to report:
+21 -7
View File
@@ -124,21 +124,34 @@ worklane add \
Editing afterwards, on a ticket in any status:
```
worklane set 1b78a24 --priority 1 # replace a field
worklane set 1b78a24 --priority 1 # replace a field
worklane set 1b78a24 --title "A better title" # renames the file, keeps the uuid
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 chown alice 1b78a24 # hand the ticket to someone
worklane chown --clear 1b78a24 # hand it back to nobody
```
`set` replaces, `append` adds. Neither 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.
`set` replaces, `append` adds, `--clear` empties. 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`
writes for a field it was never given: `_Not set_`, `_None_` for tags, and the section
placeholder. There is no `--clear title`, because a title addresses the ticket and names
its file. There is no `--clear owner` either: that is `chown --clear <ticket>`, which
takes the ticket in the flag since there is no user to give, and returns the field to
unset rather than to the git user. Replacing and clearing the same field in one call is
refused rather than resolved.
`chown` takes the **user first and the ticket second**, after Unix `chown`, which is the
one command here that does not start with the ticket. The user is free text and is
checked against nothing. Swap the two and the call fails, because the username has to
resolve as a ticket.
resolve as a ticket. `--clear` replaces both arguments with the ticket alone.
`worklane init` creates `.worklane/` with the four status directories and the campaigns
directory beside them, for a repo that has no board yet.
@@ -261,6 +274,7 @@ the candidates and exits 1 rather than guessing.
`worklane mv --status committed -- -leading-title`.
- A comment body of exactly `--` needs its own separator:
`worklane comment 1b78a24 -- --`.
- An empty value for a scalar is a usage error. Clearing a field back to unset is not
supported yet.
- An empty value for a scalar is a usage error, not a way to clear the field: use
`--clear`. For a section an empty value is a paragraph break, so it cannot mean empty
the section either, and an all-blank one is refused with the `--clear` for it named.
- Piping is safe: `worklane ls | head -3` exits on the closed pipe instead of panicking.
+3 -3
View File
@@ -24,9 +24,9 @@ fn git_sha() -> String {
.output();
let sha = match output {
Ok(output) if output.status.success() => String::from_utf8_lossy(&output.stdout)
.trim()
.to_string(),
Ok(output) if output.status.success() => {
String::from_utf8_lossy(&output.stdout).trim().to_string()
}
_ => String::new(),
};
+22
View File
@@ -0,0 +1,22 @@
# rustfmt is the formatter for this tree, and these four widths are what make it agree
# with how the tree is already written. Measured, not chosen: the default config wanted
# 305 hunks and +1418 lines of layout, `use_small_heuristics = "Max"` wanted 308 the
# other way, and this lands at 161. The reasoning is in AGENTS.md beside the clippy rule.
#
# Sweeping any one of these in either direction makes the diff bigger. Measure before
# changing one: `cargo fmt --check | grep -c '^Diff in'`.
# The habit the tree is written to, and the measured optimum: 90 costs 268 hunks, 120
# costs 194.
max_width = 100
# A call stays whole if it fits in three quarters of the line. rustfmt's default of 60
# is what expands 276 of the 305 hunks the default config wants.
fn_call_width = 75
# The same for a method chain.
chain_width = 65
# A small struct literal stays whole, so `Size { width: 120, height: 20 }` is not six
# lines. Above the default of 18, which is what explodes it.
struct_lit_width = 30
+2 -7
View File
@@ -32,8 +32,7 @@ pub fn campaigns_dir(worklane_dir: &Path) -> PathBuf {
pub fn ensure_campaigns_dir(worklane_dir: &Path) -> Result<PathBuf> {
let dir = campaigns_dir(worklane_dir);
fs::create_dir_all(&dir)
.map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
fs::create_dir_all(&dir).map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
Ok(dir)
}
@@ -166,11 +165,7 @@ pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> Str
return String::new();
};
reference_cell(
&uuid,
index.get(&uuid).map(|campaign| campaign.title.as_str()),
colored,
)
reference_cell(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()), colored)
}
/// The parts [`content_trim`] cannot render from the ticket file alone.
+101 -18
View File
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
use chrono::NaiveDate;
use crate::util::{PRIORITY_RANGE, RelationKind, Status, priority_legend};
use crate::util::{Clearable, PRIORITY_RANGE, RelationKind, Status, priority_legend};
/// clap wants a `&str` with a long enough lifetime, and the legend is built from
/// the same ramp the listing uses rather than spelled out a second time.
@@ -43,13 +43,31 @@ pub struct Cli {
/// Reject an empty value at parse time, so it lands as a usage error rather than a
/// runtime one.
///
/// An empty value looks like a way to clear a field, and clearing is not supported
/// yet. Refusing it keeps the gap visible and stops an accidentally empty variable
/// from silently blanking a field. Only the scalars use this: for the multi-line
/// sections an empty value is a paragraph break.
/// Two messages rather than one, because the arguments that use this fall into two
/// kinds. A search term or a title has no empty form at all, and that is all this says.
/// A field that *can* be emptied says so and names `--clear`, which is [`clearable`]
/// below: an accidentally empty variable must not blank a field silently, and somebody
/// typing an empty value on purpose is reaching for exactly the flag that does it.
///
/// Only the scalars use either one. For the multi-line sections an empty value is a
/// paragraph break.
fn non_empty(raw: &str) -> Result<String, String> {
if raw.trim().is_empty() {
return Err("value cannot be empty, and clearing a field is not supported yet".to_string());
return Err("value cannot be empty".to_string());
}
Ok(raw.to_string())
}
/// Reject an empty value on an argument whose field can be cleared, and say how.
///
/// The message names no command, because the arguments that use this belong to three:
/// `set --tags`, `set --due`, `add --due` and the `chown` user. `set` and `chown` both
/// take a `--clear`; `add` does not, and there a field is left unset by omitting the
/// flag, which is what the caller was reaching for anyway.
fn clearable(raw: &str) -> Result<String, String> {
if raw.trim().is_empty() {
return Err("value cannot be empty, use --clear to return a field to unset".to_string());
}
Ok(raw.to_string())
@@ -73,7 +91,7 @@ fn non_empty(raw: &str) -> Result<String, String> {
fn iso_date(raw: &str) -> Result<String, String> {
// An empty value keeps the message that explains why it is refused, since somebody
// typing it is reaching for a way to clear the field rather than mistyping a date.
non_empty(raw)?;
clearable(raw)?;
let bytes = raw.as_bytes();
let shaped = raw.len() == 10 && bytes[4] == b'-' && bytes[7] == b'-';
@@ -143,7 +161,7 @@ pub enum Command {
/// Record a relation from one ticket to another
Relate(RelateArgs),
/// Change the owner of a ticket
/// Change the owner of a ticket, or return it to unset
///
/// User first, ticket second, after Unix `chown`. That reverses the ticket-first
/// order `mv`, `comment` and `show` use, deliberately: the name borrows the Unix
@@ -154,14 +172,7 @@ pub enum Command {
/// username usually will not, so the call fails on its own. It is silently wrong
/// only when both arguments resolve, which needs a ticket whose title matches the
/// username.
Chown {
/// New owner. Free text, like `add --owner`, checked against nothing
#[arg(value_parser = non_empty)]
user: String,
/// Ticket UUID or title
ticket: String,
},
Chown(ChownArgs),
/// Open the board view
Tui {
@@ -361,7 +372,7 @@ pub struct AddArgs {
clap::ArgGroup::new("set_fields")
.required(true)
.multiple(true)
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority"])
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority", "clear"])
))]
pub struct SetArgs {
/// Ticket UUID or title
@@ -384,7 +395,7 @@ pub struct SetArgs {
pub plan: Vec<String>,
/// Replace the tags
#[arg(short = 'g', long, value_parser = non_empty)]
#[arg(short = 'g', long, value_parser = clearable)]
pub tags: Vec<String>,
/// Replace the due date (YYYY-MM-DD)
@@ -398,6 +409,78 @@ pub struct SetArgs {
/// Replace the priority, 1 (most urgent) to 5 (least)
#[arg(long, value_parser = priority_level)]
pub priority: Option<u8>,
/// Return a field to unset. Repeat the flag for more than one
///
/// The counterpart to the flag it names, and the only way to take a value away: an
/// empty value is a paragraph break for a section and a usage error for a scalar, so
/// neither can spell this. What goes back is what `add` writes for a field it was
/// never given.
///
/// No `title`, which addresses the ticket and names its file, and no `owner`, which
/// is `chown --clear`'s. The reasoning for each is on `util::Clearable`.
#[arg(long, value_name = "FIELD")]
pub clear: Vec<Clearable>,
}
impl SetArgs {
/// A field this call both replaces and clears, if there is one.
///
/// clap cannot express the conflict, because `--clear` carries the field as a value
/// rather than in the flag's own name. So it is checked once here and refused, rather
/// than resolved by whichever of the two happens to be applied last, which is a
/// silent answer to a contradictory call.
pub fn contested(&self) -> Option<Clearable> {
self.clear.iter().copied().find(|field| match field {
Clearable::Due => self.due.is_some(),
Clearable::Tags => !self.tags.is_empty(),
Clearable::Priority => self.priority.is_some(),
Clearable::Description => !self.description.is_empty(),
Clearable::Acceptance => !self.acceptance.is_empty(),
Clearable::Plan => !self.plan.is_empty(),
})
}
}
/// `chown` is the only writer of Owner, so clearing the field has to live here too, and
/// that is what shapes the arguments.
///
/// **`--clear` carries the ticket rather than being a bare flag.** The ticket is the
/// *second* positional, so `chown --clear 1b78a24` with a plain flag would land the
/// ticket in the user's slot, and reading it back out of there is hand-parsing what clap
/// can state outright. The typed call is the same either way; only who checks it differs.
///
/// The two forms are mutually exclusive, and each argument says so, so a call carrying
/// both is a usage error from clap rather than a decision made here.
#[derive(clap::Args)]
pub struct ChownArgs {
/// New owner. Free text, like `add --owner`, checked against nothing
#[arg(value_parser = clearable, required_unless_present = "clear", conflicts_with = "clear")]
pub user: Option<String>,
/// Ticket UUID or title
#[arg(required_unless_present = "clear", conflicts_with = "clear")]
pub ticket: Option<String>,
/// Return the owner to unset on this ticket, which is named here since there is no
/// user to name
#[arg(long, value_name = "TICKET", value_parser = non_empty)]
pub clear: Option<String>,
}
impl ChownArgs {
/// The ticket the call names, and the owner to write on it, `None` being unset.
///
/// `None` for the pair is unreachable while the constraints above hold, and is an
/// error at the call site rather than a panic, so loosening one of them costs a
/// message instead of a crash.
pub fn target(&self) -> Option<(&str, Option<&str>)> {
match (self.clear.as_deref(), self.user.as_deref(), self.ticket.as_deref()) {
(Some(ticket), None, None) => Some((ticket, None)),
(None, Some(user), Some(ticket)) => Some((ticket, Some(user))),
_ => None,
}
}
}
/// `append` only offers the sections that hold multiple lines, since appending to a
+28 -4
View File
@@ -118,6 +118,11 @@ complete -c worklane \
# than by position.
complete -c worklane {ticket_flags} -x -a '(worklane ls --ids)'
# `chown --clear` names the ticket in the flag too, since with no user to give there is
# no second positional to put it in. Scoped to `chown`, unlike the rule above: `set`
# has a `--clear` of its own that takes a field name, and clap already offers those.
complete -c worklane -n '__fish_seen_subcommand_from chown' -l clear -x -a '(worklane ls --ids)'
# clap emits the four for `mv --status`, which is an option, but the fish generator
# emits nothing for the possible values of a positional. So the one place a status is
# positional needs them listed, and the same goes for the shell below.
@@ -198,6 +203,28 @@ mod tests {
}
}
/// `chown --clear` takes a ticket, so it is completed like one, and only under
/// `chown`: `set --clear` is the same flag name carrying a field.
#[test]
fn chowns_clear_is_completed_with_tickets_and_sets_is_not() {
let script = fish_dynamic();
let rule = script
.lines()
.find(|line| line.starts_with("complete") && line.contains("-l clear"))
.expect("chown --clear has a rule of its own");
assert!(rule.contains("__fish_seen_subcommand_from chown"), "{rule}");
assert!(rule.contains("worklane ls --ids"), "{rule}");
let chown = command().find_subcommand("chown").expect("chown exists").clone();
assert!(
chown.get_arguments().any(|arg| arg.get_long() == Some("clear")),
"`chown` has no --clear for the rule to complete"
);
assert!(
!TICKET_FLAGS.contains(&"clear"),
"--clear in TICKET_FLAGS would offer tickets to `set --clear`, which takes a field"
);
}
/// The flags completed as tickets have to be `relate`'s actual flags, or the rule
/// completes an option nothing accepts.
#[test]
@@ -211,10 +238,7 @@ mod tests {
.filter_map(|arg| arg.get_long().map(str::to_string))
.collect();
for flag in TICKET_FLAGS {
assert!(
known.contains(&flag.to_string()),
"`relate` has no --{flag}"
);
assert!(known.contains(&flag.to_string()), "`relate` has no --{flag}");
}
}
+84 -90
View File
@@ -6,7 +6,7 @@ use std::path::Path;
use crate::campaign::*;
use crate::command::{
AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, LsArgs, RelateArgs, SetArgs,
AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, ChownArgs, LsArgs, RelateArgs, SetArgs,
};
use crate::install;
use crate::util::*;
@@ -16,10 +16,7 @@ pub fn cmd_init(start: &Path) -> Result<()> {
let worklane_dir = dir.join(".worklane");
if worklane_dir.exists() {
println!(
"worklane already initialized in: {}",
worklane_dir.display()
);
println!("worklane already initialized in: {}", worklane_dir.display());
return Ok(());
}
@@ -179,10 +176,7 @@ fn filtered(
campaign: Option<&str>,
tag: Option<&str>,
) -> Vec<TicketItem> {
filter_by_tag(
filter_by_campaign(filter_by_priority(items, level), campaign),
tag,
)
filter_by_tag(filter_by_campaign(filter_by_priority(items, level), campaign), tag)
}
/// Keep only the tickets carrying `tag`, or everything when none was asked for.
@@ -246,9 +240,7 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
let backlog_dir = worklane_dir.join("backlog");
if !backlog_dir.exists() {
return Err(anyhow!(
"Backlog directory not found. Run `worklane init` first."
));
return Err(anyhow!("Backlog directory not found. Run `worklane init` first."));
}
let id = uuid::Uuid::new_v4();
@@ -331,12 +323,7 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
// the write's own failure, named with the ticket and the path the way the other
// writes in the tree name them.
fs::write(&filepath, body).map_err(|e| {
anyhow!(
"Could not write ticket '{}' at {}: {}",
title,
filepath.display(),
e
)
anyhow!("Could not write ticket '{}' at {}: {}", title, filepath.display(), e)
})?;
println!("Created ticket: {}", filename);
@@ -482,12 +469,7 @@ fn write_then_replace(
if let Err(e) = fs::rename(&temp, path) {
let _ = fs::remove_file(&temp);
return Err(anyhow!(
"Could not write ticket '{}' at {}: {}",
title,
path.display(),
e
));
return Err(anyhow!("Could not write ticket '{}' at {}: {}", title, path.display(), e));
}
Ok(())
@@ -558,14 +540,8 @@ fn move_ticket_file(
// The content is correct and in one place by now, so a failure here leaves the
// ticket where it started rather than half moved.
fs::rename(&source, &dest).map_err(|e| {
anyhow!(
"Could not move ticket '{}' to {}: {}",
title,
dest.display(),
e
)
})
fs::rename(&source, &dest)
.map_err(|e| anyhow!("Could not move ticket '{}' to {}: {}", title, dest.display(), e))
}
/// Refuse a move while a ticket it is `blocked by` is not done.
@@ -805,40 +781,47 @@ fn save_ticket(
Ok(())
}
/// Take an edit, or record that it changed nothing.
///
/// Each edit is compared against the content going in, so a field set to the value it
/// already holds is reported as unchanged rather than claimed as an update. That is also
/// what makes clearing an already unset field free: the sentinel it writes is the one
/// already there, so the strings match and nothing is written.
fn apply(content: &mut String, changed: &mut Vec<&'static str>, field: &'static str, next: String) {
if *content != next {
content.clone_from(&next);
changed.push(field);
}
}
fn report(fields: &[&str], title: &str, verb: &str) {
if fields.is_empty() {
println!("No changes to '{}'", color_text(title, Color::Green));
return;
}
println!(
"{} {} on '{}'",
verb,
fields.join(", "),
color_text(title, Color::Green)
);
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, Color::Green));
}
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
if let Some(field) = args.contested() {
let name = field.name();
return Err(anyhow!(
"--{name} and --clear {name} contradict each other, so nothing was written"
));
}
let worklane_dir = find_worklane_dir(start)?;
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
let uuid = parse_ticket_field(&original, "ID");
let mut content = original.clone();
let mut changed: Vec<&str> = Vec::new();
// Each edit is compared against the content going in, so a field set to the value
// it already holds is reported as unchanged rather than claimed as an update.
let mut apply = |content: &mut String, field: &'static str, next: String| {
if *content != next {
content.clone_from(&next);
changed.push(field);
}
};
let mut cleared: Vec<&str> = Vec::new();
if let Some(new_title) = &args.title {
let next = set_title(&content, new_title)?;
apply(&mut content, "title", next);
apply(&mut content, &mut changed, "title", next);
}
for (section, values) in section_args(&args.description, &args.acceptance, &args.plan) {
@@ -849,32 +832,46 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
let items = section.normalise(values);
if items.is_empty() {
return Err(anyhow!(
"An empty {} is not a way to clear the section, and clearing is not supported yet",
section.label
"An empty value is a paragraph break, not a way to empty the {}: use --clear {}",
section.label,
section.clear.map_or("", Clearable::name)
));
}
let next = set_section_body(&content, section, &items)?;
apply(&mut content, section.label, next);
apply(&mut content, &mut changed, section.label, next);
}
if !args.tags.is_empty() {
let next = set_metadata_field(&content, "Tags", &args.tags.join(", "), &title)?;
apply(&mut content, "tags", next);
apply(&mut content, &mut changed, "tags", next);
}
if let Some(due) = &args.due {
let next = set_metadata_field(&content, "Due", due, &title)?;
apply(&mut content, "due", next);
apply(&mut content, &mut changed, "due", next);
}
if let Some(priority) = args.priority {
let next = set_metadata_field(&content, "Priority", &priority.to_string(), &title)?;
apply(&mut content, "priority", next);
apply(&mut content, &mut changed, "priority", next);
}
if changed.is_empty() {
report(&changed, &title, "Updated");
// Last, and into a list of their own. No field can be in both, since `contested`
// refused that above, so the order is free and the report is what decides it: a
// caller is told what was replaced and what was emptied in those words.
for field in &args.clear {
let next = match field.unset() {
Unset::Field { field, sentinel } => {
set_metadata_field(&content, field, sentinel, &title)?
}
Unset::Section(section) => clear_section_body(&content, section)?,
};
apply(&mut content, &mut cleared, field.label(), next);
}
if changed.is_empty() && cleared.is_empty() {
report(&[], &title, "Updated");
return Ok(());
}
@@ -882,7 +879,12 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
save_ticket(&worklane_dir, &status, &uuid, &title, renamed, &content)?;
let shown = args.title.clone().unwrap_or(title);
report(&changed, &shown, "Updated");
if !changed.is_empty() {
report(&changed, &shown, "Updated");
}
if !cleared.is_empty() {
report(&cleared, &shown, "Cleared");
}
Ok(())
}
@@ -895,13 +897,23 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
/// stay silent on the one it cannot, a ticket whose title is the username.
///
/// No-op detection compares the whole file, the way `set` does, so an owner set to the
/// value it already holds is reported unchanged and nothing is written.
pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
/// value it already holds is reported unchanged and nothing is written. The same
/// comparison is what makes clearing an already unset owner free.
///
/// **Clearing writes [`NOT_SET`], not the git user.** `add` falls back to the git user
/// for a ticket it is filing, which is a default for something new; an owner taken away
/// says nobody owns this, and putting the person running the command there instead would
/// hand them a ticket they were giving up.
pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
let (ticket_id, user) = args.target().ok_or_else(|| {
anyhow!("chown takes a user and a ticket, or --clear with the ticket alone")
})?;
let worklane_dir = find_worklane_dir(start)?;
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
let uuid = parse_ticket_field(&original, "ID");
let content = set_metadata_field(&original, "Owner", user, &title)?;
let content = set_metadata_field(&original, "Owner", user.unwrap_or(NOT_SET), &title)?;
if content == original {
report(&[], &title, "Updated");
@@ -910,7 +922,11 @@ pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
report(&["owner"], &title, "Updated");
let verb = match user {
Some(_) => "Updated",
None => "Cleared",
};
report(&["owner"], &title, verb);
Ok(())
}
@@ -985,10 +1001,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
));
}
let relation = Relation {
kind,
target: target_uuid,
};
let relation = Relation { kind, target: target_uuid };
// Already held, either in the file or earlier in this call. Recording it
// twice would read as two dependencies on one ticket.
@@ -1023,11 +1036,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
/// half-written campaign behind. `cmd_add` predates that primitive and still uses the
/// plain write; the difference is noted on the ticket rather than fixed here.
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
let CampaignAddArgs {
title,
description,
owner,
} = args;
let CampaignAddArgs { title, description, owner } = args;
let worklane_dir = find_worklane_dir(start)?;
let dir = ensure_campaigns_dir(&worklane_dir)?;
@@ -1103,10 +1112,7 @@ pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
println!("{}", "─".repeat(campaign.title.chars().count()));
// No relations and no campaign of its own: a campaign is not a ticket, and neither
// belongs to one.
println!(
"\n{}",
content_trim_colored(&campaign.content, &Resolved::default())
);
println!("\n{}", content_trim_colored(&campaign.content, &Resolved::default()));
let grouped = members(worklane_dir, &campaign.uuid)?;
let standing = Standing::of(&grouped);
@@ -1119,10 +1125,7 @@ pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
if items.is_empty() {
continue;
}
println!(
"\n{}",
color_text(&format!("[{}]", status.to_uppercase()), Color::Orange)
);
println!("\n{}", color_text(&format!("[{}]", status.to_uppercase()), Color::Orange));
display_ticket_items(items);
}
@@ -1143,8 +1146,7 @@ pub fn cmd_assign(campaign_search: &str, ticket_id: &str, start: &Path) -> Resul
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
let uuid = parse_ticket_field(&original, "ID");
let content =
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
let content = set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
if content == original {
println!(
@@ -1296,10 +1298,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
.collect();
if !changing.is_empty() {
let lines: Vec<usize> = changing
.iter()
.map(|offset| criteria[*offset].line)
.collect();
let lines: Vec<usize> = changing.iter().map(|offset| criteria[*offset].line).collect();
let updated = set_criteria(&content, &lines, checked);
let uuid = parse_ticket_field(&content, "ID");
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
@@ -1318,12 +1317,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
past.to_string()
};
println!(
"{} {}: {}",
state,
offset + 1,
color_text(&criterion.text, Color::Green)
);
println!("{} {}: {}", state, offset + 1, color_text(&criterion.text, Color::Green));
}
Ok(())
+18 -22
View File
@@ -75,9 +75,10 @@ pub static SKILLS: [Asset; 3] = [SKILL, REVIEW_SKILL, PLAN_SKILL];
/// The skill a name on the command line asks for.
pub fn skill_named(name: &str) -> Result<&'static Asset> {
SKILLS.iter().find(|asset| asset.name == name).ok_or_else(|| {
anyhow!("no skill named {name:?}. This binary ships {}", skill_names())
})
SKILLS
.iter()
.find(|asset| asset.name == name)
.ok_or_else(|| anyhow!("no skill named {name:?}. This binary ships {}", skill_names()))
}
/// The names, for the errors that have to say what there is to choose from.
@@ -173,10 +174,7 @@ mod tests {
let root = root();
let path = SKILL.path(root.path());
assert_eq!(
SKILL.install(root.path(), false).unwrap(),
Outcome::Written(path.clone())
);
assert_eq!(SKILL.install(root.path(), false).unwrap(), Outcome::Written(path.clone()));
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
}
@@ -201,16 +199,10 @@ mod tests {
SKILL.install(root.path(), false).unwrap();
std::fs::write(&path, "hand written\n").unwrap();
assert_eq!(
SKILL.install(root.path(), false).unwrap(),
Outcome::Refused(path.clone())
);
assert_eq!(SKILL.install(root.path(), false).unwrap(), Outcome::Refused(path.clone()));
assert_eq!(std::fs::read_to_string(&path).unwrap(), "hand written\n");
assert_eq!(
SKILL.install(root.path(), true).unwrap(),
Outcome::Written(path.clone())
);
assert_eq!(SKILL.install(root.path(), true).unwrap(), Outcome::Written(path.clone()));
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
}
@@ -254,8 +246,10 @@ mod tests {
"the frontmatter name has to match the directory it installs into"
);
let description = frontmatter_field(asset.content, "description")
.unwrap_or_else(|| panic!("{} ships without a description to trigger on", asset.name));
let description =
frontmatter_field(asset.content, "description").unwrap_or_else(|| {
panic!("{} ships without a description to trigger on", asset.name)
});
assert!(
description.len() > 80,
"{}: the description is what decides whether the skill loads at all",
@@ -311,7 +305,9 @@ mod tests {
if words.next() != Some("worklane") {
continue;
}
let Some(candidate) = words.next() else { continue };
let Some(candidate) = words.next() else {
continue;
};
// A flag before the subcommand, as in the `mv -- -leading-title` example.
if candidate.starts_with("--") && !known.iter().any(|k| k == candidate) {
continue;
@@ -386,9 +382,9 @@ mod tests {
fn the_plan_skill_keeps_the_rules_that_bound_a_sweep() {
for required in [
"Propose the whole set of edits",
"replaces the whole\nfield", // `set --tags` is the destructive one
"cannot be cleared", // and a due date cannot be taken back
"blocked by", // ordering constrains any dating plan
"replaces the whole\nfield", // `set --tags` is the destructive one
"not\nback to what it held", // and --clear is not an undo
"blocked by", // ordering constrains any dating plan
"worklane campaign ls",
"does not touch",
] {
@@ -407,7 +403,7 @@ mod tests {
#[test]
fn the_review_skill_keeps_the_decisions_that_define_it() {
for required in [
"worklane show", // the ticket is read before the code
"worklane show", // the ticket is read before the code
"nothing names the ticket", // and the no-work-found case is answered
"Never tick a criterion",
"Do not move the ticket",
+6 -15
View File
@@ -55,22 +55,16 @@ fn main() -> Result<()> {
let worklane_dir = find_worklane_dir(&start)?;
cmd_show(&id, &worklane_dir)
}
Some(Command::Mv {
ticket,
status,
force,
}) => cmd_mv(&ticket, status, force, &start),
Some(Command::Mv { ticket, status, force }) => cmd_mv(&ticket, status, force, &start),
Some(Command::Set(args)) => cmd_set(&args, &start),
Some(Command::Append(args)) => cmd_append(&args, &start),
Some(Command::Relate(args)) => cmd_relate(&args, &start),
Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start),
Some(Command::Chown(args)) => cmd_chown(&args, &start),
Some(Command::Check(args)) => cmd_check(&args, true, &start),
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
Some(Command::Comment {
ticket,
body,
owner,
}) => cmd_comment(&ticket, &body, &owner, &start),
Some(Command::Comment { ticket, body, owner }) => {
cmd_comment(&ticket, &body, &owner, &start)
}
Some(Command::Campaign { command }) => match command {
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
CampaignCommand::Ls => {
@@ -112,10 +106,7 @@ fn install_panic_hook() {
fn restore_terminal() -> std::io::Result<()> {
crossterm::terminal::disable_raw_mode()?;
crossterm::execute!(
std::io::stdout(),
crossterm::terminal::LeaveAlternateScreen
)
crossterm::execute!(std::io::stdout(), crossterm::terminal::LeaveAlternateScreen)
}
fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()> {
+78 -112
View File
@@ -6,19 +6,19 @@
//!
//! **Read only.** Moving a card by keypress is a follow-up. Everything here observes.
use std::collections::hash_map::DefaultHasher;
use std::collections::HashMap;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
use anyhow::{Context, Result};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use ratatui::Frame;
use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect, Size};
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span, Text};
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs, Wrap};
use ratatui::Frame;
use crate::handlers::read_comments;
use crate::util::*;
@@ -71,10 +71,7 @@ pub fn projects(paths: &[PathBuf], start: &Path) -> Result<Vec<Project>> {
continue;
}
projects.push(Project {
name: project_name(&dir),
dir,
});
projects.push(Project { name: project_name(&dir), dir });
}
Ok(projects)
@@ -315,11 +312,7 @@ impl Board {
if projects.len() > 1 {
tabs.push(Tab::new(ALL.to_string()));
}
tabs.extend(
projects
.iter()
.map(|project| Tab::new(project.name.clone())),
);
tabs.extend(projects.iter().map(|project| Tab::new(project.name.clone())));
let mut board = Board {
tabs,
@@ -775,10 +768,7 @@ fn detail_of(card: &Card) -> Detail {
// Colour off for the text, which is what keeps escapes out of the paragraph, and the
// relations arrive as rows so the board can style them itself.
let mut parts = content_parts(&content, false, &resolved);
parts.push(BodyPart::Text(format!(
"\n{}",
format_comments_with(&comments, false)
)));
parts.push(BodyPart::Text(format!("\n{}", format_comments_with(&comments, false))));
Detail {
title: ticket.title.clone(),
@@ -1136,12 +1126,7 @@ fn draw_columns(frame: &mut Frame, board: &Board, area: Rect) {
};
// An empty status is an empty column, not a column that is not there.
frame.render_widget(
Paragraph::new(lines)
.block(block)
.scroll((offset, 0)),
areas[index],
);
frame.render_widget(Paragraph::new(lines).block(block).scroll((offset, 0)), areas[index]);
}
}
@@ -1285,12 +1270,11 @@ fn card_lines(card: &Card, selected: bool, width: u16) -> Vec<Line<'static>> {
let mut lines = vec![corner_line(left, due_span(&ticket.due), width)];
lines.extend(title_lines(&ticket.title, width).into_iter().map(|line| {
Line::from(Span::styled(
line,
Style::default().add_modifier(emphasis),
))
}));
lines.extend(
title_lines(&ticket.title, width)
.into_iter()
.map(|line| Line::from(Span::styled(line, Style::default().add_modifier(emphasis)))),
);
if let Some(row) = tags_line(&ticket.tags, width) {
lines.push(row);
@@ -1352,10 +1336,7 @@ fn tags_line(tags: &[String], width: u16) -> Option<Line<'static>> {
if index > 0 {
spans.push(Span::raw(" "));
}
spans.push(Span::styled(
format!("#{tag}"),
Style::default().fg(tag_color(tag).into()),
));
spans.push(Span::styled(format!("#{tag}"), Style::default().fg(tag_color(tag).into())));
}
Some(Line::from(spans))
@@ -1399,10 +1380,7 @@ fn due_span(due: &str) -> Option<Span<'static>> {
false => Color::Cyan,
};
Some(Span::styled(
due_date(due).to_string(),
Style::default().fg(colour.into()),
))
Some(Span::styled(due_date(due).to_string(), Style::default().fg(colour.into())))
}
/// `left` at the left, `right` at the right, with the gap between them.
@@ -1490,10 +1468,7 @@ fn title_lines(title: &str, width: u16) -> Vec<String> {
fn chars_in_chunks(word: &str, width: usize) -> Vec<String> {
let chars: Vec<char> = word.chars().collect();
chars
.chunks(width)
.map(|chunk| chunk.iter().collect())
.collect()
chars.chunks(width).map(|chunk| chunk.iter().collect()).collect()
}
/// The row with an ellipsis on the end, making room for it if the row is full.
@@ -1574,10 +1549,7 @@ fn draw_notice(frame: &mut Frame, notice: &Notice, area: Rect) {
false => Style::default(),
};
frame.render_widget(
Paragraph::new(Span::styled(format!(" {}", notice.text), style)),
area,
);
frame.render_widget(Paragraph::new(Span::styled(format!(" {}", notice.text), style)), area);
}
/// The prompt, in place of the key list it would otherwise describe wrongly.
@@ -1595,10 +1567,7 @@ fn draw_search(frame: &mut Frame, search: &Search, area: Rect) {
let mut spans = vec![Span::raw(prompt.clone())];
if search.missed {
spans.push(Span::styled(
" no match",
Style::default().fg(Color::BrightRed.into()),
));
spans.push(Span::styled(" no match", Style::default().fg(Color::BrightRed.into())));
}
spans.push(Span::styled(
" enter jump esc cancel ",
@@ -1737,11 +1706,8 @@ fn draw_detail(frame: &mut Frame, detail: &Detail, offset: u16, area: Rect) {
// keys and a rendered checkbox take, and does not compete with the orange title.
if let Some(indicator) = page_indicator(offset, last, text.height, overlay.width) {
block = block.title_bottom(
Line::from(Span::styled(
indicator,
Style::default().fg(Color::Grey.into()),
))
.right_aligned(),
Line::from(Span::styled(indicator, Style::default().fg(Color::Grey.into())))
.right_aligned(),
);
}
@@ -1865,10 +1831,7 @@ mod tests {
/// The screen the scrolling tests draw on, so the keypress and the draw measure the
/// same overlay.
const SCREEN: Size = Size {
width: 120,
height: 20,
};
const SCREEN: Size = Size { width: 120, height: 20 };
/// The rendered buffer as lines of text, escapes and styling dropped.
fn render(board: &Board, width: u16, height: u16) -> Vec<String> {
@@ -2191,7 +2154,8 @@ mod tests {
/// it drops styling on the way out of the buffer.
fn card_colour(dir: &Path, width: u16, needle: &str) -> Option<ratatui::style::Color> {
let board = one_board(dir);
let inner = card_width(Size { width, height: 20 }, board.tabbed(), board.visible().len(), 0);
let inner =
card_width(Size { width, height: 20 }, board.tabbed(), board.visible().len(), 0);
let ticket = board.selected().expect("no card");
card_lines(ticket, false, inner)
@@ -2432,7 +2396,8 @@ mod tests {
let dir = board_dir();
let before = digest(&dir);
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let path =
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let created = digest(&dir);
assert_ne!(before, created, "a new ticket went unnoticed");
@@ -2448,7 +2413,8 @@ mod tests {
#[test]
fn the_digest_moves_when_a_ticket_is_edited_in_place() {
let dir = board_dir();
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let path =
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let before = digest(&dir);
let content = std::fs::read_to_string(&path).unwrap();
@@ -2462,7 +2428,8 @@ mod tests {
#[test]
fn the_digest_moves_on_an_edit_of_the_same_length() {
let dir = board_dir();
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let path =
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
let content = std::fs::read_to_string(&path).unwrap();
let same_length = content.replace("A description.", "A descriptionA");
@@ -2534,7 +2501,11 @@ mod tests {
#[test]
fn the_card_index_is_clamped_when_the_column_is_shorter() {
let dir = board_dir();
for (n, title) in [("11111111", "Alpha"), ("22222222", "Beta"), ("33333333", "Gamma")] {
for (n, title) in [
("11111111", "Alpha"),
("22222222", "Beta"),
("33333333", "Gamma"),
] {
write_ticket(&dir, "backlog", &format!("{n}-0000-4000-8000-000000000000"), title, "");
}
write_ticket(&dir, "committed", "44444444-0000-4000-8000-000000000000", "Delta", "");
@@ -2572,10 +2543,7 @@ mod tests {
let top = render(&board, SCREEN.width, SCREEN.height).join("\n");
assert!(top.contains("Ticket 01"), "{top}");
assert!(
!top.contains("Ticket 12"),
"the fixture fits without scrolling:\n{top}"
);
assert!(!top.contains("Ticket 12"), "the fixture fits without scrolling:\n{top}");
board.select_card(11, SCREEN);
@@ -2693,10 +2661,7 @@ mod tests {
// holding a scroll position for a highlight it no longer has.
assert_eq!(board.current().card, 2);
let back = render(&board, SCREEN.width, SCREEN.height).join("\n");
assert!(
back.contains("Ticket 03"),
"returning lost the selection:\n{back}"
);
assert!(back.contains("Ticket 03"), "returning lost the selection:\n{back}");
assert!(!back.contains("Ticket 12"), "{back}");
}
@@ -2708,10 +2673,7 @@ mod tests {
fill_column(&dir, "backlog", 12);
// Tall enough that every card fits, so the keypress stores no scroll at all.
let roomy = Size {
width: 120,
height: 60,
};
let roomy = Size { width: 120, height: 60 };
let mut board = one_board(&dir);
board.select_card(11, roomy);
@@ -2804,7 +2766,11 @@ mod tests {
}
let screen = render(&board, SCREEN.width, SCREEN.height);
assert!(screen.join("\n").contains("Line 060"), "nothing scrolled:\n{}", screen.join("\n"));
assert!(
screen.join("\n").contains("Line 060"),
"nothing scrolled:\n{}",
screen.join("\n")
);
let row = overlay_title_row(&screen, SCREEN.width, SCREEN.height);
assert!(row.contains("(1111111)"), "the id scrolled away:\n{row}");
@@ -2956,10 +2922,7 @@ mod tests {
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
// Tall enough that the whole ticket is on screen at once.
let roomy = Size {
width: 120,
height: 60,
};
let roomy = Size { width: 120, height: 60 };
let mut board = one_board(&dir);
board.toggle_detail();
@@ -3203,7 +3166,13 @@ mod tests {
let dir = board_dir();
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "Alpha first", "");
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "Beta second", "");
write_ticket(&dir, "committed", "33333333-0000-4000-8000-000000000000", "Gamma third", "");
write_ticket(
&dir,
"committed",
"33333333-0000-4000-8000-000000000000",
"Gamma third",
"",
);
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Delta finished", "");
dir
}
@@ -3522,8 +3491,7 @@ mod tests {
board.open_search();
type_query(&mut board, "gam");
let mut terminal =
Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
let mut terminal = Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
terminal.draw(|frame| draw(frame, &board)).unwrap();
let at = terminal.get_cursor_position().unwrap();
@@ -3696,9 +3664,9 @@ mod tests {
the OSC 52 write is named"
);
let cleared = source.find("board.clear_notice();").expect(
"a notice that nothing clears sits in the footer for the rest of the session",
);
let cleared = source
.find("board.clear_notice();")
.expect("a notice that nothing clears sits in the footer for the rest of the session");
let prompt = source.find("if board.search_key(key, screen)").unwrap();
assert!(
cleared < prompt,
@@ -3883,10 +3851,7 @@ mod tests {
assert_eq!(project_label("alpha", 38, IDENTITY).as_deref(), Some("alpha"));
// Room for three characters of a longer name, the last of them the ellipsis.
assert_eq!(
project_label("factry-core", 16, IDENTITY).as_deref(),
Some("fa…")
);
assert_eq!(project_label("factry-core", 16, IDENTITY).as_deref(), Some("fa…"));
assert_eq!(project_label("factry-core", 13, IDENTITY), None);
assert_eq!(project_label("alpha", 4, IDENTITY), None);
}
@@ -3984,10 +3949,7 @@ mod tests {
assert!(!marked_blocked(&board, "The waiter"));
let screen = render(&board, 120, 20).join("\n");
assert!(
!screen.contains(BLOCKED_MARK),
"a cleared blocker still marked:\n{screen}"
);
assert!(!screen.contains(BLOCKED_MARK), "a cleared blocker still marked:\n{screen}");
}
/// One open blocker out of two is still a reason not to start, the rule `mv` applies
@@ -4056,7 +4018,11 @@ mod tests {
assert!(wide[0].contains(BLOCKED_MARK), "no mark with room for it: {:?}", wide[0]);
let narrow = card_rows(&board, "The waiter", identity);
assert!(!narrow[0].contains(BLOCKED_MARK), "mark kept over the column: {:?}", narrow[0]);
assert!(
!narrow[0].contains(BLOCKED_MARK),
"mark kept over the column: {:?}",
narrow[0]
);
assert!(narrow[0].contains(&id), "the identity gave way instead: {:?}", narrow[0]);
assert!(narrow[0].chars().count() <= identity as usize, "row over the column");
}
@@ -4209,8 +4175,6 @@ mod tests {
}
}
/// The style of the first cell drawing `symbol`, so a test can ask what colour a
/// glyph actually reached the screen in rather than trusting the span it was built
/// from.
@@ -4291,16 +4255,20 @@ mod tests {
let mut board = one_board(&dir);
board.toggle_detail();
let content = std::fs::read_to_string(
board.selected().expect("no selection").ticket.path.clone(),
)
.unwrap();
let content =
std::fs::read_to_string(board.selected().expect("no selection").ticket.path.clone())
.unwrap();
let rows = relations_for(&content, &dir).unwrap();
let printed = render_relations(&rows, false);
assert!(!printed.is_empty(), "the fixture has no relations");
assert!(
board.detail.as_ref().unwrap().plain().contains(printed.trim_end()),
board
.detail
.as_ref()
.unwrap()
.plain()
.contains(printed.trim_end()),
"the overlay drew a different block than the listing prints: {printed:?}"
);
}
@@ -4467,7 +4435,10 @@ mod tests {
let text = &board.detail.as_ref().expect("no detail").plain();
// Marked for its kind, and the mark sits ahead of the id.
assert!(
text.contains(&format!("blocked by {BLOCKED_MARK} {} (2222222) The target", status_mark(Some("backlog")).0)),
text.contains(&format!(
"blocked by {BLOCKED_MARK} {} (2222222) The target",
status_mark(Some("backlog")).0
)),
"{text:?}"
);
assert!(!text.contains(target), "the bare uuid was drawn: {text:?}");
@@ -4494,7 +4465,10 @@ mod tests {
let text = &board.detail.as_ref().expect("no detail").plain();
assert!(
text.contains(&format!("blocks {BLOCKED_MARK} {} (1111111) A holder", status_mark(Some("backlog")).0)),
text.contains(&format!(
"blocks {BLOCKED_MARK} {} (1111111) A holder",
status_mark(Some("backlog")).0
)),
"{text:?}"
);
}
@@ -4741,11 +4715,7 @@ mod tests {
/// Located on the bottom border row rather than by searching the buffer for a glyph:
/// `p` and `g` are all over the board, and `drawn_color` would answer about whichever
/// card holds the first one.
fn indicator_color(
board: &Board,
width: u16,
height: u16,
) -> Option<ratatui::style::Color> {
fn indicator_color(board: &Board, width: u16, height: u16) -> Option<ratatui::style::Color> {
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
terminal.draw(|frame| draw(frame, board)).unwrap();
let buffer = terminal.backend().buffer().clone();
@@ -4754,9 +4724,7 @@ mod tests {
let row = overlay.y + overlay.height - 1;
(overlay.x..overlay.x + overlay.width - 1)
.find(|x| {
buffer[(*x, row)].symbol() == "p" && buffer[(x + 1, row)].symbol() == "g"
})
.find(|x| buffer[(*x, row)].symbol() == "p" && buffer[(x + 1, row)].symbol() == "g")
.map(|x| buffer[(x, row)].fg)
}
@@ -4783,6 +4751,4 @@ mod tests {
std::fs::remove_dir_all(&dir).ok();
}
}
+372 -129
View File
@@ -44,11 +44,7 @@ pub fn should_use_colors() -> bool {
let no_color = std::env::var("NO_COLOR").ok();
let term = std::env::var("TERM").ok();
colors_wanted(
std::io::stdout().is_terminal(),
no_color.as_deref(),
term.as_deref(),
)
colors_wanted(std::io::stdout().is_terminal(), no_color.as_deref(), term.as_deref())
})
}
@@ -272,9 +268,7 @@ pub fn find_worklane_dir(start: &Path) -> Result<std::path::PathBuf> {
}
}
Err(anyhow!(
"No .worklane directory found. Run `worklane init` first."
))
Err(anyhow!("No .worklane directory found. Run `worklane init` first."))
}
/// Width of the abbreviated id shown by `ls` and by the disambiguation list.
@@ -728,11 +722,7 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
criterion += 1;
result.push_str(&paint(&format!("{}.", criterion), Color::Cyan, colored));
result.push(' ');
result.push_str(&paint(
if checked { "[x]" } else { "[ ]" },
Color::Grey,
colored,
));
result.push_str(&paint(if checked { "[x]" } else { "[ ]" }, Color::Grey, colored));
result.push(' ');
result.push_str(&colorize_bold(text, colored));
result.push('\n');
@@ -936,9 +926,31 @@ fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> Strin
result
}
/// What a scalar metadata field holds when it holds nothing.
///
/// A constant rather than a literal per site, because it is now written on purpose:
/// clearing a field puts it back, and the value it goes back to has to be the one `add`
/// wrote, or a cleared ticket and a never-set one would differ in the file.
pub const NOT_SET: &str = "_Not set_";
/// The same for Tags, which is a list.
///
/// A list that holds nothing reads as none rather than as not set, which is the
/// distinction `add` already makes and clearing has to keep.
pub const NONE: &str = "_None_";
/// Whether a field holds one of the two markers that mean it holds nothing.
///
/// The two constants and nothing else. `-None-` and `-Not set-` were accepted here from
/// the day the function was written, by analogy with the `**-Status**` field name the
/// `mv` splicing bug really did produce, c230d2c. But no version of this tool ever wrote
/// a hyphenated *value*: `git log -S` finds the two spellings in exactly one commit, the
/// one that added them to this line. They were dead from birth, and a ticket that somehow
/// holds one now reads as the text it is rather than being quietly taken for unset, which
/// is the right way round for corruption nobody can produce.
pub fn is_unknown_value(value: &str) -> bool {
let trimmed = value.trim();
trimmed == "_None_" || trimmed == "_Not set_" || trimmed == "-None-" || trimmed == "-Not set-"
trimmed == NONE || trimmed == NOT_SET
}
/// Replace `**bold**` with colour, or leave the line exactly as it is.
@@ -1017,7 +1029,7 @@ pub fn parse_ticket_field(content: &str, field: &str) -> String {
metadata_lines(content)
.find_map(|line| metadata_field_body(line).strip_prefix(&prefix))
.map(|value| value.trim().to_string())
.unwrap_or_else(|| "_Not set_".to_string())
.unwrap_or_else(|| NOT_SET.to_string())
}
fn is_status_line(line: &str) -> bool {
@@ -1094,12 +1106,8 @@ fn remove_metadata_line(content: &str, field: &str) -> Option<String> {
}
pub fn set_status_field(content: &str, target_status: &str, title: &str) -> Result<String> {
set_metadata_line(content, "Status", target_status, is_status_line).ok_or_else(|| {
anyhow!(
"Ticket '{}' has no Status field in its Metadata section",
title
)
})
set_metadata_line(content, "Status", target_status, is_status_line)
.ok_or_else(|| anyhow!("Ticket '{}' has no Status field in its Metadata section", title))
}
/// Rewrite a metadata field other than Status.
@@ -1114,13 +1122,7 @@ pub fn set_metadata_field(content: &str, field: &str, value: &str, title: &str)
set_metadata_line(content, field, value, |line| {
metadata_field_body(line).starts_with(&prefix)
})
.ok_or_else(|| {
anyhow!(
"Ticket '{}' has no {} field in its Metadata section",
title,
field
)
})
.ok_or_else(|| anyhow!("Ticket '{}' has no {} field in its Metadata section", title, field))
}
/// The metadata field naming the campaign a ticket belongs to.
@@ -1371,6 +1373,12 @@ pub struct Section {
/// appending to an empty section replaces the placeholder rather than following it.
pub placeholder: &'static str,
pub kind: SectionKind,
/// The `--clear` value that empties this section, where `set` can reach it at all.
///
/// `None` for Relations, for the same reason it is absent from `section_args`: its
/// only writer is `relate`, so `set` has no way to fill it and no business emptying
/// it either.
pub clear: Option<Clearable>,
}
pub const DESCRIPTION: Section = Section {
@@ -1378,6 +1386,7 @@ pub const DESCRIPTION: Section = Section {
label: "description",
placeholder: "_No description provided._",
kind: SectionKind::Prose,
clear: Some(Clearable::Description),
};
pub const ACCEPTANCE: Section = Section {
@@ -1385,6 +1394,7 @@ pub const ACCEPTANCE: Section = Section {
label: "acceptance criteria",
placeholder: "_No acceptance criteria provided._",
kind: SectionKind::Checklist,
clear: Some(Clearable::Acceptance),
};
pub const PLAN: Section = Section {
@@ -1392,6 +1402,7 @@ pub const PLAN: Section = Section {
label: "implementation plan",
placeholder: "_No implementation plan provided._",
kind: SectionKind::Numbered,
clear: Some(Clearable::Plan),
};
/// The edges to other tickets, one per line.
@@ -1405,6 +1416,7 @@ pub const RELATIONS: Section = Section {
label: "relations",
placeholder: "_No relations._",
kind: SectionKind::Bullets,
clear: None,
};
impl Section {
@@ -1438,6 +1450,105 @@ impl Section {
}
}
/// A field `set --clear` can return to the state a new ticket is born in.
///
/// The names are the flags they undo, so `--clear due` reads as the opposite of
/// `--due`. Three fields a ticket carries are deliberately absent:
///
/// - **Title** has no unset state. It addresses the ticket, it names the file through
/// its slug, and `add` requires it, so there is nothing to go back to.
/// - **Owner** is `chown`'s, and clearing it through `set` would give the field a
/// second writer, which is the rule the missing `set --owner` exists to keep.
/// - **Status**, **Campaign** and the three stamps belong to `mv` and `assign` for the
/// same reason.
#[derive(Copy, Clone, Debug, PartialEq, Eq, clap::ValueEnum)]
pub enum Clearable {
Due,
Tags,
Priority,
Description,
Acceptance,
Plan,
}
/// What clearing a field writes back.
pub enum Unset {
/// A metadata line, back to the sentinel `add` writes when the flag is omitted.
Field {
field: &'static str,
sentinel: &'static str,
},
/// A section body, back to the placeholder `add` writes for an empty one.
Section(&'static Section),
}
impl Clearable {
/// Every field that can be cleared.
///
/// `#[cfg(test)]` because nothing in the binary walks the list: clap emits the
/// values for `--clear` from the `ValueEnum` itself, so the only caller is the suite
/// that checks each one against the ticket it empties.
#[cfg(test)]
pub const ALL: [Clearable; 6] = [
Clearable::Due,
Clearable::Tags,
Clearable::Priority,
Clearable::Description,
Clearable::Acceptance,
Clearable::Plan,
];
/// What clearing the field amounts to.
///
/// The sentinels are [`NOT_SET`] and [`NONE`] rather than strings written out here,
/// so a cleared field is byte-identical to one `add` left alone. That is the whole
/// promise of the command: a ticket that has been cleared and one that was never
/// given the field read the same.
pub fn unset(self) -> Unset {
match self {
Clearable::Due => Unset::Field {
field: "Due",
sentinel: NOT_SET,
},
Clearable::Tags => Unset::Field { field: "Tags", sentinel: NONE },
Clearable::Priority => Unset::Field {
field: "Priority",
sentinel: NOT_SET,
},
Clearable::Description => Unset::Section(&DESCRIPTION),
Clearable::Acceptance => Unset::Section(&ACCEPTANCE),
Clearable::Plan => Unset::Section(&PLAN),
}
}
/// The value the flag takes, as clap spells it.
///
/// Written out rather than read off `to_possible_value`, because it is used in error
/// messages that tell a caller what to type and a `&'static str` is what those want.
/// `the_clear_values_are_the_names_clap_accepts` keeps the two in step.
pub fn name(self) -> &'static str {
match self {
Clearable::Due => "due",
Clearable::Tags => "tags",
Clearable::Priority => "priority",
Clearable::Description => "description",
Clearable::Acceptance => "acceptance",
Clearable::Plan => "plan",
}
}
/// How the change is named in output.
///
/// The label `set` already prints when it *writes* the field, so a cleared field is
/// named the way a replaced one is rather than in the flag's own spelling.
pub fn label(self) -> &'static str {
match self.unset() {
Unset::Field { .. } => self.name(),
Unset::Section(section) => section.label,
}
}
}
/// Whether the line opens with `N. `, the shape a numbered step is stored in.
fn is_numbered_item(line: &str) -> bool {
let digits = line.chars().take_while(|c| c.is_ascii_digit()).count();
@@ -1481,12 +1592,32 @@ fn join_lines(lines: &[String]) -> String {
/// Replace a section's body with `items`, leaving every line outside it untouched.
pub fn set_section_body(content: &str, section: &Section, items: &[String]) -> Result<String> {
replace_section_body(content, section, section.render(items, 1))
}
/// Return a section to the placeholder `add` writes for an empty one.
///
/// Not [`set_section_body`] with the placeholder as its one item: the placeholder is a
/// line of the format rather than content, and `render` would dress it as `- [ ] _No
/// acceptance criteria provided._` in every section but the description. It is the same
/// line `append` already treats as no content, so a cleared section can be appended to
/// without the placeholder being left above what follows it.
pub fn clear_section_body(content: &str, section: &Section) -> Result<String> {
replace_section_body(content, section, vec![section.placeholder.to_string()])
}
/// The line surgery both of the above are, given a body that is already rendered.
fn replace_section_body(
content: &str,
section: &Section,
body_lines: Vec<String>,
) -> Result<String> {
let lines: Vec<&str> = content.lines().collect();
let body = section_body(&lines, section.heading)
.ok_or_else(|| anyhow!("Ticket has no {} section", section.label))?;
let mut out: Vec<String> = lines[..body.start].iter().map(|l| l.to_string()).collect();
out.extend(section.render(items, 1));
out.extend(body_lines);
// One blank line before whatever section follows, matching how `add` writes it.
if body.end < lines.len() {
out.push(String::new());
@@ -1938,10 +2069,7 @@ pub struct Cell {
impl Cell {
fn plain(text: impl Into<String>) -> Self {
Cell {
text: text.into(),
color: None,
}
Cell { text: text.into(), color: None }
}
fn colored(text: impl Into<String>, color: Color) -> Self {
@@ -1979,14 +2107,17 @@ pub fn relation_rows(stored: &[Relation], index: &RelationIndex, uuid: &str) ->
})
.collect();
rows.extend(index.inbound(uuid).into_iter().map(|(kind, holder)| {
RelationRow {
kind,
label: kind.inverse_label(),
uuid: holder.uuid.clone(),
target: target_of(Some(holder)),
}
}));
rows.extend(
index
.inbound(uuid)
.into_iter()
.map(|(kind, holder)| RelationRow {
kind,
label: kind.inverse_label(),
uuid: holder.uuid.clone(),
target: target_of(Some(holder)),
}),
);
rows
}
@@ -2054,11 +2185,7 @@ pub fn relations_for(content: &str, worklane_dir: &Path) -> Result<Vec<RelationR
let stored = parse_relations(content, &title)?;
let index = RelationIndex::load(worklane_dir)?;
Ok(relation_rows(
&stored,
&index,
&parse_ticket_field(content, "ID"),
))
Ok(relation_rows(&stored, &index, &parse_ticket_field(content, "ID")))
}
/// One acceptance criterion as it sits in the file.
@@ -2129,11 +2256,7 @@ pub fn numbered_criteria(criteria: &[Criterion], shown: &[usize]) -> String {
format!(
" {} {} {}",
paint(&format!("{}.", offset + 1), Color::Cyan, colored),
paint(
if criterion.checked { "[x]" } else { "[ ]" },
Color::Grey,
colored
),
paint(if criterion.checked { "[x]" } else { "[ ]" }, Color::Grey, colored),
criterion.text
)
})
@@ -2515,10 +2638,7 @@ pub fn display_ticket_items(items: &[TicketItem]) {
let priority = show_priority(item.priority, colored);
if item.created.is_empty() {
println!(
" {} ({}) {} | Owner: {} | Due: {}",
priority, id, item.title, owner, due
);
println!(" {} ({}) {} | Owner: {} | Due: {}", priority, id, item.title, owner, due);
} else {
let created = paint(&item.created, Color::Cyan, colored);
println!(
@@ -2653,6 +2773,21 @@ mod tests {
}
}
/// The hyphenated spellings are values like any other, and this is what says so.
///
/// They were accepted as unset for months without any version of the tool ever
/// writing one, so the risk this pins is somebody re-adding them by analogy with the
/// `**-Status**` repair in `is_status_line`, which guards a corruption that was real.
#[test]
fn a_hyphenated_marker_is_not_unset() {
for legacy in ["-None-", "-Not set-", "-Nothing-"] {
assert!(
!is_unknown_value(legacy),
"{legacy} is read as unset, so a corrupted field would pass for an empty one"
);
}
}
fn ticket_with_priority(raw: &str) -> String {
format!("# T\n\n## Metadata\n\n- **Priority**: {}\n", raw)
}
@@ -2686,17 +2821,15 @@ mod tests {
#[test]
fn a_field_only_mentioned_in_prose_reads_as_unset() {
let content = "# T\n\n## Description\n- **Due**: 2026-12-31\n\n## Metadata\n\n- **ID**: x\n";
let content =
"# T\n\n## Description\n- **Due**: 2026-12-31\n\n## Metadata\n\n- **ID**: x\n";
assert_eq!(parse_ticket_field(content, "Due"), "_Not set_");
}
#[test]
fn a_field_lookup_needs_the_metadata_heading() {
// No section, no fields: there is nothing to anchor to.
assert_eq!(
parse_ticket_field("# T\n\n- **Owner**: alice\n", "Owner"),
"_Not set_"
);
assert_eq!(parse_ticket_field("# T\n\n- **Owner**: alice\n", "Owner"), "_Not set_");
}
#[test]
@@ -2731,7 +2864,8 @@ mod tests {
#[test]
fn setting_the_status_needs_the_field_in_the_metadata_section() {
// A Status line above the section is prose, so this is a ticket without the field.
let content = "# T\n\n## Description\n- **Status**: backlog\n\n## Metadata\n\n- **ID**: x\n";
let content =
"# T\n\n## Description\n- **Status**: backlog\n\n## Metadata\n\n- **ID**: x\n";
assert!(set_status_field(content, "committed", "T").is_err());
}
@@ -2843,8 +2977,7 @@ mod tests {
#[test]
fn a_line_that_is_not_a_field_is_carried_through() {
let rendered =
render_metadata_table(&["- **ID**: abc", "a hand written note"], false, "");
let rendered = render_metadata_table(&["- **ID**: abc", "a hand written note"], false, "");
assert_eq!(
rendered,
@@ -2989,7 +3122,10 @@ mod tests {
let counted: Vec<Option<Progress>> = items.iter().map(|item| item.criteria).collect();
assert!(counted.contains(&Some(Progress { met: 1, total: 2 })), "{counted:?}");
assert!(counted.contains(&None), "a ticket with no criteria got a count: {counted:?}");
assert!(
counted.contains(&None),
"a ticket with no criteria got a count: {counted:?}"
);
fs::remove_dir_all(&dir).unwrap();
}
@@ -3043,9 +3179,15 @@ mod tests {
/// Absent, unset and empty are one answer: no tags.
#[test]
fn parse_tags_reads_an_unset_or_missing_field_as_none() {
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Tags**: _None_\n"), Vec::<String>::new());
assert_eq!(
parse_tags("# T\n\n## Metadata\n\n- **Tags**: _None_\n"),
Vec::<String>::new()
);
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Tags**:\n"), Vec::<String>::new());
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Owner**: alice\n"), Vec::<String>::new());
assert_eq!(
parse_tags("# T\n\n## Metadata\n\n- **Owner**: alice\n"),
Vec::<String>::new()
);
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Tags**: , ,\n"), Vec::<String>::new());
}
@@ -3102,9 +3244,7 @@ mod tests {
set_or_insert_metadata_field(&content, CAMPAIGN_FIELD, "c-uuid", "T").unwrap();
assert!(
updated.contains(
"- **Owner**: alice\n- **Campaign**: c-uuid\n\n## Notes\nAfter.\n"
),
updated.contains("- **Owner**: alice\n- **Campaign**: c-uuid\n\n## Notes\nAfter.\n"),
"{updated}"
);
}
@@ -3113,9 +3253,8 @@ mod tests {
/// most one campaign.
#[test]
fn a_field_already_there_is_rewritten_rather_than_added() {
let content = with_metadata(
"- **ID**: abc\n- **Campaign**: first\n- **Status**: backlog\n",
);
let content =
with_metadata("- **ID**: abc\n- **Campaign**: first\n- **Status**: backlog\n");
let updated =
set_or_insert_metadata_field(&content, CAMPAIGN_FIELD, "second", "T").unwrap();
@@ -3131,8 +3270,7 @@ mod tests {
let content = "# T\n\n## Description\n- **Campaign**: not a field\n\n\
## Metadata\n\n- **ID**: abc\n- **Status**: backlog\n";
let updated =
set_or_insert_metadata_field(content, CAMPAIGN_FIELD, "c-uuid", "T").unwrap();
let updated = set_or_insert_metadata_field(content, CAMPAIGN_FIELD, "c-uuid", "T").unwrap();
assert!(updated.contains("- **Campaign**: not a field"), "{updated}");
assert!(
@@ -3165,10 +3303,7 @@ mod tests {
let updated =
set_status_stamp(&content, Status::Reviewing, "2026-08-22 10:11:12", "T").unwrap();
assert!(
updated.contains("- **Submitted On**: 2026-08-22 10:11:12"),
"{updated}"
);
assert!(updated.contains("- **Submitted On**: 2026-08-22 10:11:12"), "{updated}");
assert!(!updated.contains("**Committed On**"), "{updated}");
}
@@ -3213,8 +3348,7 @@ mod tests {
- **Status**: reviewing\n",
);
let updated =
set_status_stamp(&content, Status::Done, "2026-08-22 10:11:12", "T").unwrap();
let updated = set_status_stamp(&content, Status::Done, "2026-08-22 10:11:12", "T").unwrap();
assert!(
updated.contains(
@@ -3257,10 +3391,7 @@ mod tests {
#[test]
fn a_campaign_field_that_is_unset_or_absent_reads_as_no_campaign() {
assert_eq!(parse_campaign(&with_metadata("- **ID**: abc\n")), None);
assert_eq!(
parse_campaign(&with_metadata("- **Campaign**: _Not set_\n")),
None
);
assert_eq!(parse_campaign(&with_metadata("- **Campaign**: _Not set_\n")), None);
assert_eq!(
parse_campaign(&with_metadata("- **Campaign**: c-uuid\n")),
Some("c-uuid".to_string())
@@ -3293,10 +3424,7 @@ mod tests {
let rendered = content_trim_colored("# T\n\n## Description\nbody\n", &Resolved::default());
// Eleven characters, not fourteen: the rule used to span "## Description"
assert!(
rendered.starts_with("Description\n───────────\n"),
"{rendered:?}"
);
assert!(rendered.starts_with("Description\n───────────\n"), "{rendered:?}");
}
#[test]
@@ -3308,7 +3436,8 @@ mod tests {
#[test]
fn the_body_leaves_the_title_to_cmd_show() {
let rendered = content_trim_colored("# Only Once\n\n## Description\nbody\n", &Resolved::default());
let rendered =
content_trim_colored("# Only Once\n\n## Description\nbody\n", &Resolved::default());
assert!(!rendered.contains("Only Once"), "{rendered:?}");
// And no gap where it was
@@ -3335,9 +3464,8 @@ mod tests {
#[test]
fn blank_values_are_trimmed_from_the_ends_but_kept_inside() {
let owned = |values: &[&str]| -> Vec<String> {
values.iter().map(|v| v.to_string()).collect()
};
let owned =
|values: &[&str]| -> Vec<String> { values.iter().map(|v| v.to_string()).collect() };
// A break between paragraphs is content
let two_paragraphs = owned(&["First.", "", "Second."]);
@@ -3390,8 +3518,13 @@ mod tests {
#[test]
fn levels_sort_ahead_of_invalid_which_sorts_ahead_of_unset() {
let mut ranks = [Priority::Unset, Priority::Level(5), Priority::Invalid, Priority::Level(1)]
.map(|p| p.rank());
let mut ranks = [
Priority::Unset,
Priority::Level(5),
Priority::Invalid,
Priority::Level(1),
]
.map(|p| p.rank());
ranks.sort();
assert_eq!(
ranks,
@@ -3422,7 +3555,10 @@ mod tests {
#[test]
fn the_glyph_alone_distinguishes_every_state() {
let mut seen = std::collections::HashSet::new();
for state in PRIORITY_RANGE.map(Priority::Level).chain([Priority::Unset, Priority::Invalid]) {
for state in PRIORITY_RANGE
.map(Priority::Level)
.chain([Priority::Unset, Priority::Invalid])
{
let (glyph, _) = priority_mark(state);
assert!(seen.insert(glyph), "{glyph} is used for more than one state");
}
@@ -3485,10 +3621,7 @@ mod tests {
#[test]
fn an_invalid_level_is_marked_wrong_not_unset() {
assert_eq!(priority_mark(Priority::Invalid).0, "??");
assert_ne!(
priority_mark(Priority::Invalid),
priority_mark(Priority::Unset)
);
assert_ne!(priority_mark(Priority::Invalid), priority_mark(Priority::Unset));
}
#[test]
@@ -3519,11 +3652,11 @@ mod tests {
for colour in Color::ALL {
assert!(!colour.ansi().is_empty(), "{colour:?} has no escape");
assert!(colour.ansi().starts_with("\x1b["), "{colour:?} is not an SGR sequence");
assert!(
colour.ansi().starts_with("\x1b["),
"{colour:?} is not an SGR sequence"
seen.insert(ratatui::style::Color::from(colour)),
"{colour:?} shares its ratatui colour"
);
assert!(seen.insert(ratatui::style::Color::from(colour)), "{colour:?} shares its ratatui colour");
}
assert_eq!(seen.len(), Color::ALL.len());
@@ -3550,11 +3683,12 @@ mod tests {
assert_eq!(tag_color("bug"), tag_color("bug"));
assert_eq!(tag_color("frontend"), tag_color("frontend"));
let spread: std::collections::HashSet<Color> =
["bug", "feature", "cli", "tui", "docs", "chore", "output", "skills"]
.iter()
.map(|tag| tag_color(tag))
.collect();
let spread: std::collections::HashSet<Color> = [
"bug", "feature", "cli", "tui", "docs", "chore", "output", "skills",
]
.iter()
.map(|tag| tag_color(tag))
.collect();
assert!(spread.len() > 3, "the mapping collapses the vocabulary: {spread:?}");
}
@@ -3628,7 +3762,10 @@ mod tests {
// The separator the file holds comes back as it went in, spacing and all.
assert_eq!(strip_escapes(&painted), "bug, cli");
assert_eq!(strip_escapes(&metadata_value_cell("Tags", "bug,cli", true, "")), "bug,cli");
assert_eq!(strip_escapes(&metadata_value_cell("Tags", " bug , cli ", true, "")), " bug , cli ");
assert_eq!(
strip_escapes(&metadata_value_cell("Tags", " bug , cli ", true, "")),
" bug , cli "
);
}
/// An unset value stays grey, since the Tags branch sits behind the unknown check.
@@ -3705,7 +3842,13 @@ mod tests {
/// Every one of these reached the old byte offsets from an unvalidated file.
#[test]
fn unparseable_created_at_drops_the_column() {
for value in ["_Not set_", "", "2026-08-20", "日本語日本語日本語", "not a date at all"] {
for value in [
"_Not set_",
"",
"2026-08-20",
"日本語日本語日本語",
"not a date at all",
] {
assert_eq!(format_created_at(value), "", "for {value:?}");
}
}
@@ -3788,7 +3931,74 @@ mod tests {
assert!(error.contains("is not a relation"), "{error}");
assert!(error.contains("blocked by"), "{error}");
assert!(parse_relation("- blocked by").unwrap_err().to_string().contains("no target"));
assert!(
parse_relation("- blocked by")
.unwrap_err()
.to_string()
.contains("no target")
);
}
/// The two directions of the pairing have to agree, or `--clear acceptance` would
/// empty one section while the error message about an empty value named another.
#[test]
fn every_clearable_section_points_back_at_the_field_that_clears_it() {
for field in Clearable::ALL {
if let Unset::Section(section) = field.unset() {
assert_eq!(
section.clear,
Some(field),
"{} does not point back at --clear {}",
section.heading,
field.name()
);
}
}
assert_eq!(RELATIONS.clear, None, "set must not be able to empty Relations");
}
/// The names are written out for the error messages, so this is what keeps them the
/// names clap actually accepts.
#[test]
fn the_clear_values_are_the_names_clap_accepts() {
for field in Clearable::ALL {
let possible = clap::ValueEnum::to_possible_value(&field).expect("not hidden");
assert_eq!(possible.get_name(), field.name());
}
}
/// The sentinel a cleared field goes back to is the one `add` writes for a field it
/// was never given, which is the whole promise of the flag.
#[test]
fn a_cleared_scalar_holds_the_sentinel_add_writes() {
for field in Clearable::ALL {
let Unset::Field { field: name, sentinel } = field.unset() else {
continue;
};
let expected = match name {
"Tags" => NONE,
_ => NOT_SET,
};
assert_eq!(sentinel, expected, "{name}");
assert!(is_unknown_value(sentinel), "{name} clears to something readable as set");
}
}
/// The placeholder goes in as a line of the format, not as an item: dressed by
/// `render` it would read `- [ ] _No acceptance criteria provided._`.
#[test]
fn clearing_a_section_writes_the_bare_placeholder() {
let content =
"# T\n\n## Acceptance Criteria\n- [x] Done\n- [ ] Not\n\n## Metadata\n\n- **ID**: x\n";
let cleared = clear_section_body(content, &ACCEPTANCE).unwrap();
assert!(
cleared.contains(&format!("## Acceptance Criteria\n{}\n", ACCEPTANCE.placeholder)),
"{cleared}"
);
// Everything outside the section is where it was.
assert!(cleared.contains("- **ID**: x"), "{cleared}");
// And a second clear is the same string, which is what makes the no-op free.
assert_eq!(clear_section_body(&cleared, &ACCEPTANCE).unwrap(), cleared);
}
#[test]
@@ -3978,11 +4188,7 @@ mod tests {
let (mark, colour) = relation_mark(kind);
assert!(!mark.is_empty(), "{kind:?} has no mark");
assert!(seen.insert(mark), "{kind:?} shares its mark with another kind");
assert_ne!(
colour,
Color::Green,
"{kind:?} is drawn in the colour that means a title"
);
assert_ne!(colour, Color::Green, "{kind:?} is drawn in the colour that means a title");
}
assert_eq!(seen.len(), 3, "{seen:?}");
@@ -4049,10 +4255,7 @@ mod tests {
// status mark cannot: `?` holds the column so the id does not move, and
// `_missing_` is what says the target is gone.
assert_eq!(
render_relations(
&relation_rows(&stored, &RelationIndex::new(Vec::new()), SELF),
false
),
render_relations(&relation_rows(&stored, &RelationIndex::new(Vec::new()), SELF), false),
format!("blocked by {BLOCKED_MARK} ? (b1b2c3d) _missing_\n")
);
}
@@ -4060,10 +4263,7 @@ mod tests {
#[test]
fn a_ticket_with_no_relations_at_either_end_renders_no_block() {
let index = RelationIndex::new(vec![related(TARGET, "Elsewhere", "backlog", Vec::new())]);
assert_eq!(
render_relations(&relation_rows(&[], &index, SELF), false),
""
);
assert_eq!(render_relations(&relation_rows(&[], &index, SELF), false), "");
}
/// Without the guard every ticket with no ID field relates to every other one that
@@ -4089,7 +4289,20 @@ mod tests {
"# T\n\n## Relations\n- blocked by {}\n\n## Metadata\n\n- **ID**: {}\n",
TARGET, SELF
);
let rendered = content_trim(&content, false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocked by", TARGET, "The blocker", "backlog")], ..Default::default() });
let rendered = content_trim(
&content,
false,
&Resolved {
relations: vec![row(
RelationKind::BlockedBy,
"blocked by",
TARGET,
"The blocker",
"backlog",
)],
..Default::default()
},
);
assert!(
rendered.contains(&format!("Relations\n─────────\n\nblocked by {BLOCKED_MARK} {} (b1b2c3d) The blocker\n\nMetadata", smark("backlog"))),
@@ -4103,8 +4316,22 @@ mod tests {
/// have kept it, ahead of the metadata.
#[test]
fn the_body_injects_the_block_when_the_file_has_no_section() {
let content = format!("# T\n\n## Description\nBody.\n\n## Metadata\n\n- **ID**: {}\n", SELF);
let rendered = content_trim(&content, false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "The gated one", "committed")], ..Default::default() });
let content =
format!("# T\n\n## Description\nBody.\n\n## Metadata\n\n- **ID**: {}\n", SELF);
let rendered = content_trim(
&content,
false,
&Resolved {
relations: vec![row(
RelationKind::BlockedBy,
"blocks",
SELF,
"The gated one",
"committed",
)],
..Default::default()
},
);
assert!(
rendered.contains(&format!("Body.\n\nRelations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) The gated one\n\nMetadata", smark("committed"))),
@@ -4116,9 +4343,22 @@ mod tests {
/// worth more at the end than dropped.
#[test]
fn the_body_appends_the_block_when_there_is_no_metadata() {
let rendered = content_trim("# T\n\n## Description\nBody.\n", false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "X", "done")], ..Default::default() });
let rendered = content_trim(
"# T\n\n## Description\nBody.\n",
false,
&Resolved {
relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "X", "done")],
..Default::default()
},
);
assert!(rendered.ends_with(&format!("Relations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) X\n", smark("done"))), "{rendered:?}");
assert!(
rendered.ends_with(&format!(
"Relations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) X\n",
smark("done")
)),
"{rendered:?}"
);
}
/// No block and a section holding only its placeholder: the section renders as it
@@ -4128,6 +4368,9 @@ mod tests {
let content = "# T\n\n## Relations\n_No relations._\n\n## Metadata\n\n- **ID**: x\n";
let rendered = content_trim(content, false, &Resolved::default());
assert!(rendered.contains("Relations\n─────────\n\n_No relations._\n"), "{rendered:?}");
assert!(
rendered.contains("Relations\n─────────\n\n_No relations._\n"),
"{rendered:?}"
);
}
}
+24 -24
View File
@@ -1,6 +1,6 @@
use assert_cmd::Command;
use assert_fs::fixture::{PathChild, PathCreateDir};
use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs;
use std::path::{Path, PathBuf};
@@ -106,9 +106,12 @@ fn add_joins_multiple_descriptions() {
cmd.current_dir(temp.path())
.args([
"add",
"--title", "Multi desc ticket",
"--description", "Line one",
"--description", "Line two",
"--title",
"Multi desc ticket",
"--description",
"Line one",
"--description",
"Line two",
])
.assert()
.success();
@@ -285,10 +288,7 @@ fn add_accepts_prose_values_that_begin_with_a_hyphen() {
// Stored verbatim, hyphens and all
assert!(content.contains("# -t is a flag name"), "was {content:?}");
assert!(content.contains("-x does nothing"), "was {content:?}");
assert!(
content.contains("- [ ] --print should be supported"),
"was {content:?}"
);
assert!(content.contains("- [ ] --print should be supported"), "was {content:?}");
assert!(content.contains("1. -f skips the check"), "was {content:?}");
}
@@ -308,10 +308,7 @@ fn add_still_accepts_the_equals_form() {
let content = only_ticket(&worklane);
assert!(content.contains("# -x equals form"), "was {content:?}");
assert!(
content.contains("- [ ] --print via equals"),
"was {content:?}"
);
assert!(content.contains("- [ ] --print via equals"), "was {content:?}");
}
/// Never silently dropped: a value that is nothing but hyphens is content.
@@ -328,10 +325,7 @@ fn add_stores_a_title_that_is_only_hyphens() {
.success();
let content = only_ticket(&worklane);
assert!(
content.starts_with(&format!("# {}\n", bare)),
"for {bare:?}: {content:?}"
);
assert!(content.starts_with(&format!("# {}\n", bare)), "for {bare:?}: {content:?}");
}
}
@@ -408,10 +402,7 @@ fn add_keeps_a_paragraph_break_in_the_description() {
let mut show = Command::cargo_bin(BIN_NAME).unwrap();
show.current_dir(temp.path()).args(["show", "Two Paras"]);
let stdout = String::from_utf8(show.assert().success().get_output().stdout.clone()).unwrap();
assert!(
stdout.contains("First paragraph.\n\nSecond paragraph."),
"was {stdout:?}"
);
assert!(stdout.contains("First paragraph.\n\nSecond paragraph."), "was {stdout:?}");
}
/// A break belongs between paragraphs, not against the section headings.
@@ -482,7 +473,14 @@ fn add_stores_a_valid_due_date_unchanged() {
/// and is not a day.
#[test]
fn add_refuses_a_due_date_that_is_not_a_real_iso_date() {
for value in ["next friday", "29-08-2026", "2026-13-01", "2026-02-30", "2026/08/29", ""] {
for value in [
"next friday",
"29-08-2026",
"2026-13-01",
"2026-02-30",
"2026/08/29",
"",
] {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
@@ -530,9 +528,10 @@ fn add_refuses_an_unpadded_due_date_rather_than_padding_it() {
}
/// An empty value keeps the message about clearing, since that is what somebody typing
/// it is reaching for.
/// it is reaching for. On `add` the answer is to omit the flag, but the message names
/// `--clear` because the same parser guards `set --due`, where that is the answer.
#[test]
fn an_empty_due_date_says_clearing_is_not_supported() {
fn an_empty_due_date_points_at_clear() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
@@ -549,7 +548,8 @@ fn an_empty_due_date_says_clearing_is_not_supported() {
)
.to_string();
assert!(stderr.contains("clearing a field is not supported"), "{stderr}");
assert!(stderr.contains("use --clear"), "{stderr}");
assert!(!stderr.contains("not supported"), "{stderr}");
}
fn read_only_ticket(dir: &Path) -> String {
+7 -6
View File
@@ -487,7 +487,12 @@ fn a_campaign_that_no_longer_exists_reads_as_missing() {
let worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
fs::remove_file(worklane.join("campaigns").join(format!("{CAMP_A}_v1-release.md"))).unwrap();
fs::remove_file(
worklane
.join("campaigns")
.join(format!("{CAMP_A}_v1-release.md")),
)
.unwrap();
let out = run(&temp, &["show", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
@@ -578,11 +583,7 @@ fn a_search_that_names_nothing_still_reports_no_ticket() {
let out = run(&temp, &["show", "nothing at all"]);
assert!(!out.status.success());
assert!(
stderr(&out).contains("No ticket found matching"),
"{}",
stderr(&out)
);
assert!(stderr(&out).contains("No ticket found matching"), "{}", stderr(&out));
}
/// A campaign resolves by the same tiers a ticket does, so it can be ambiguous the same
+2 -9
View File
@@ -298,10 +298,7 @@ fn show_numbers_the_criteria() {
assert!(!stdout.contains("4. ["), "the handwritten line was numbered: {stdout:?}");
// And the description checkbox is left as it is, outside the numbering
assert!(
stdout.contains("- [ ] A checkbox in the description"),
"{stdout:?}"
);
assert!(stdout.contains("- [ ] A checkbox in the description"), "{stdout:?}");
}
#[test]
@@ -418,11 +415,7 @@ fn a_batch_that_would_change_nothing_writes_nothing() {
assert!(out.status.success());
let stdout = String::from_utf8_lossy(&out.stdout);
assert_eq!(
stdout.matches("Already checked").count(),
3,
"{stdout:?}"
);
assert_eq!(stdout.matches("Already checked").count(), 3, "{stdout:?}");
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
}
+90 -11
View File
@@ -89,11 +89,7 @@ fn chown_sets_the_owner() {
create_ticket(&worklane);
let out = run(&temp, &["chown", "bob", UUID]);
assert!(
out.status.success(),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
assert!(
String::from_utf8_lossy(&out.stdout).contains("owner"),
"{:?}",
@@ -139,10 +135,7 @@ fn chown_leaves_everything_it_was_not_asked_about_alone() {
run(&temp, &["chown", "bob", UUID]);
let content = ticket(&worklane);
assert!(
content.contains("- [x] Crit one"),
"the tick was lost: {content}"
);
assert!(content.contains("- [x] Crit one"), "the tick was lost: {content}");
assert!(
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
"the unknown section was lost: {content}"
@@ -213,7 +206,8 @@ fn chown_refuses_a_swapped_call() {
assert_eq!(ticket(&worklane), before);
}
/// An empty user looks like a way to clear the field, and clearing is not supported.
/// An empty user is still a usage error, and now points at the flag that does take the
/// owner away.
#[test]
fn chown_refuses_an_empty_user_as_a_usage_error() {
let temp = TempDir::new().unwrap();
@@ -223,11 +217,96 @@ fn chown_refuses_an_empty_user_as_a_usage_error() {
let out = run(&temp, &["chown", "", UUID]);
assert_eq!(out.status.code(), Some(2));
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("use --clear"), "{stderr:?}");
assert!(!stderr.contains("not supported"), "{stderr:?}");
assert_eq!(ticket(&worklane), before);
}
/// The owner goes back to the sentinel, not to the git user: an owner taken away says
/// nobody owns this.
#[test]
fn chown_clear_returns_the_owner_to_unset() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["chown", "--clear", UUID]);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
assert!(
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
String::from_utf8_lossy(&out.stdout).contains("Cleared owner"),
"{:?}",
String::from_utf8_lossy(&out.stdout)
);
let content = ticket(&worklane);
assert!(content.contains("- **Owner**: _Not set_"), "{content}");
// Nothing else on the way past.
assert!(content.contains("- **Status**: backlog"), "{content}");
}
/// The ticket is still resolved the three usual ways when it arrives in the flag.
#[test]
fn chown_clear_resolves_the_ticket_it_is_given() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["chown", "--clear", "Original"]);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
assert!(ticket(&worklane).contains("- **Owner**: _Not set_"));
}
#[test]
fn chown_clear_on_an_unowned_ticket_is_no_change() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
run(&temp, &["chown", "--clear", UUID]);
let before = ticket(&worklane);
let out = run(&temp, &["chown", "--clear", UUID]);
assert!(out.status.success());
assert!(
String::from_utf8_lossy(&out.stdout).contains("No changes"),
"{:?}",
String::from_utf8_lossy(&out.stdout)
);
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
}
/// Setting an owner and clearing it are the two forms of the command, and clap keeps
/// them apart rather than the handler picking one.
#[test]
fn chown_refuses_a_user_and_a_clear_together() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
for args in [
vec!["chown", "bob", "--clear", UUID],
vec!["chown", "bob", UUID, "--clear", UUID],
] {
let out = run(&temp, &args);
assert_eq!(out.status.code(), Some(2), "{args:?} was accepted");
assert!(
String::from_utf8_lossy(&out.stderr).contains("cannot be used with"),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
}
// And a bare --clear still needs the ticket it is meant to name.
let out = run(&temp, &["chown", "--clear"]);
assert_eq!(out.status.code(), Some(2));
assert!(
String::from_utf8_lossy(&out.stderr).contains("a value is required"),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
assert_eq!(ticket(&worklane), before);
}
+2 -6
View File
@@ -1,6 +1,6 @@
use assert_cmd::Command;
use assert_fs::fixture::{PathChild, PathCreateDir};
use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs;
use std::path::{Path, PathBuf};
@@ -17,11 +17,7 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
worklane.path().to_path_buf()
}
fn create_ticket(
worklane_dir: &Path,
status: &str,
title: &str,
) -> String {
fn create_ticket(worklane_dir: &Path, status: &str, title: &str) -> String {
let uuid = uuid::Uuid::new_v4().to_string();
let slug = title
.to_lowercase()
+2 -8
View File
@@ -13,10 +13,7 @@ fn script(shell: &str) -> String {
fn completions_prints_a_script_for_every_shell() {
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
let out = script(shell);
assert!(
out.contains("worklane"),
"the {shell} script never names the command"
);
assert!(out.contains("worklane"), "the {shell} script never names the command");
// Long enough to be a script rather than an empty file with a comment in it.
assert!(out.len() > 500, "the {shell} script is {} bytes", out.len());
}
@@ -56,10 +53,7 @@ fn no_other_shell_gets_the_fish_half() {
!out.contains("__worklane_first_arg_of"),
"fish-only helpers leaked into {shell}"
);
assert!(
!out.contains("worklane ls --ids"),
"the dynamic half leaked into {shell}"
);
assert!(!out.contains("worklane ls --ids"), "the dynamic half leaked into {shell}");
}
}
+13 -8
View File
@@ -54,11 +54,7 @@ fn every_skill_installs_outside_a_worklane_directory() {
assert_eq!(std::fs::read_to_string(installed_plan(&home)).unwrap(), PLAN);
// Once, not per document: it is the one thing to do next, not part of an outcome.
assert_eq!(
stdout.matches("pick it up on their next session").count(),
1,
"{stdout}"
);
assert_eq!(stdout.matches("pick it up on their next session").count(), 1, "{stdout}");
}
/// Narrowing to one document is the exception, and it must leave the others alone.
@@ -72,7 +68,10 @@ fn a_named_skill_installs_only_that_one() {
assert_eq!(out.status.code(), Some(0), "{stdout}");
assert_eq!(std::fs::read_to_string(installed_review(&home)).unwrap(), REVIEW);
assert!(!installed(&home).exists(), "a named install wrote the other document too");
assert!(!installed_plan(&home).exists(), "a named install wrote the other document too");
assert!(
!installed_plan(&home).exists(),
"a named install wrote the other document too"
);
}
/// A name nothing ships is a stop, with the choices in the message: guessing at the
@@ -118,7 +117,10 @@ fn a_modified_copy_is_reported_and_needs_force() {
assert_eq!(out.status.code(), Some(0), "{stdout}");
assert!(stdout.contains("Differs from the version in this binary"), "{stdout}");
assert!(stdout.contains("--force"), "{stdout}");
assert!(stdout.contains("--print"), "the message never says how to compare: {stdout}");
assert!(
stdout.contains("--print"),
"the message never says how to compare: {stdout}"
);
assert_eq!(
std::fs::read_to_string(installed(&home)).unwrap(),
"hand written\n",
@@ -186,7 +188,10 @@ fn print_without_a_name_says_which_names_there_are() {
assert_ne!(out.status.code(), Some(0), "{stderr}");
assert!(stderr.contains("name the skill to print"), "{stderr}");
assert!(stderr.contains("worklane-review"), "{stderr}");
assert!(String::from_utf8_lossy(&out.stdout).is_empty(), "a document was printed anyway");
assert!(
String::from_utf8_lossy(&out.stdout).is_empty(),
"a document was printed anyway"
);
}
/// The command has to be findable by someone who does not already know it exists.
+21 -7
View File
@@ -191,7 +191,11 @@ fn ls_handles_short_and_non_ascii_filenames() {
}
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
cmd.current_dir(temp.path())
.arg("ls")
.arg("backlog")
.assert()
.success();
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout.matches("Odd Name").count(), 3);
@@ -209,7 +213,11 @@ fn ls_survives_a_malformed_created_at() {
.unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
cmd.current_dir(temp.path())
.arg("ls")
.arg("backlog")
.assert()
.success();
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Bad Date"));
@@ -290,7 +298,10 @@ fn ls_shows_a_mark_for_the_level() {
// Piped, so no escapes: the glyph is carrying the level by itself
assert!(!stdout.contains('\u{1b}'));
assert!(stdout.contains("\u{25cf}\u{25cf} "), "no full meter for level 1 in {stdout:?}");
assert!(
stdout.contains("\u{25cf}\u{25cf} "),
"no full meter for level 1 in {stdout:?}"
);
assert!(stdout.contains("\u{25cb}\u{25cb} "), "no empty meter for level 5");
assert!(stdout.contains("\u{b7}\u{b7} "), "no unset mark");
// The raw number is not what the listing shows
@@ -340,7 +351,10 @@ fn ls_filters_by_tag_and_composes_with_status_and_priority() {
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Tagged bug"), "{stdout}");
assert!(stdout.contains("Lower bug"), "{stdout}");
assert!(stdout.contains("Started bug"), "a tagged ticket in another status was dropped");
assert!(
stdout.contains("Started bug"),
"a tagged ticket in another status was dropped"
);
assert!(!stdout.contains("Tagged feature"), "an untagged ticket came through");
// The counts are filtered too, since they are the same collect.
assert!(stdout.contains("[BACKLOG] 2 tickets"), "{stdout}");
@@ -436,8 +450,7 @@ fn ls_never_matches_a_ticket_carrying_no_tags() {
// Nor does an empty tag reach the filter: the value parser refuses it, so nothing is
// listed rather than everything.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", ""]);
cmd.current_dir(temp.path()).args(["ls", "backlog", "--tag", ""]);
cmd.assert().failure().code(2);
}
@@ -584,7 +597,8 @@ fn ls_ids_still_takes_the_filters() {
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]);
cmd.current_dir(temp.path())
.args(["ls", "--ids", "--tag", "cli"]);
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}");
}
+5 -9
View File
@@ -473,7 +473,9 @@ fn stray_files(worklane: &std::path::Path) -> Vec<String> {
.unwrap()
.filter_map(|e| e.ok())
.map(|e| e.file_name().into_string().unwrap())
.filter(|name| !["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str()))
.filter(|name| {
!["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str())
})
.collect();
for dir in ["backlog", "committed", "reviewing", "done"] {
@@ -522,10 +524,7 @@ fn mv_never_leaves_stale_content_in_the_target_directory() {
let moved = worklane.join("committed").join(&filename);
assert!(moved.exists(), "ticket did not move");
let content = fs::read_to_string(&moved).unwrap();
assert!(
content.contains("- **Status**: committed"),
"stale status: {content:?}"
);
assert!(content.contains("- **Status**: committed"), "stale status: {content:?}");
assert!(!content.contains("- **Status**: backlog"), "{content:?}");
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
@@ -631,10 +630,7 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
] {
fs::write(
worklane.join("backlog").join(format!("{}_foo.md", uuid)),
format!(
"# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n",
uuid
),
format!("# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n", uuid),
)
.unwrap();
}
+9 -17
View File
@@ -118,11 +118,7 @@ fn a_target_resolves_by_uuid_prefix_title_or_filename() {
let worklane = board(&temp);
let out = run(&temp, &["relate", GATED, "--blocked-by", search]);
assert!(
out.status.success(),
"{search}: {}",
String::from_utf8_lossy(&out.stderr)
);
assert!(out.status.success(), "{search}: {}", String::from_utf8_lossy(&out.stderr));
assert!(
ticket(&worklane, GATED).contains(&format!("- blocked by {}", BLOCKER)),
"{search}: {}",
@@ -249,11 +245,7 @@ fn a_relation_already_held_reports_no_change_and_writes_nothing() {
let out = run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
assert!(out.status.success());
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
assert_eq!(
ticket(&worklane, GATED),
before,
"the relation was recorded twice"
);
assert_eq!(ticket(&worklane, GATED), before, "the relation was recorded twice");
}
/// One direction is stored. The inverse is derived by a scan, so the ticket at the
@@ -354,7 +346,9 @@ fn show_lists_the_relation_the_other_ticket_holds() {
// `relates to` is symmetric, so it reads the same way from either end.
let shown = stdout(&run(&temp, &["show", FIXED]));
assert!(
shown.contains(&format!("relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one")),
shown.contains(&format!(
"relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one"
)),
"{shown}"
);
}
@@ -382,12 +376,10 @@ fn a_line_that_is_not_a_relation_is_an_error() {
let worklane = board(&temp);
let path = find(&worklane, GATED);
let content = fs::read_to_string(&path)
.unwrap()
.replace(
"## Metadata",
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
);
let content = fs::read_to_string(&path).unwrap().replace(
"## Metadata",
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
);
fs::write(&path, content).unwrap();
let out = run(&temp, &["show", GATED]);
+318 -37
View File
@@ -94,13 +94,20 @@ fn set_replaces_each_field_it_is_given() {
let out = run(
&temp,
&[
"set", UUID,
"--description", "Only paragraph.",
"--acceptance", "New crit",
"--plan", "New step",
"--tags", "beta,gamma",
"--due", "2026-12-31",
"--priority", "1",
"set",
UUID,
"--description",
"Only paragraph.",
"--acceptance",
"New crit",
"--plan",
"New step",
"--tags",
"beta,gamma",
"--due",
"2026-12-31",
"--priority",
"1",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
@@ -190,7 +197,11 @@ fn set_reports_only_the_fields_that_changed() {
assert!(!stdout.contains("due"), "{stdout:?}");
}
/// An empty scalar looks like a way to clear a field, and clearing is not supported.
/// An empty scalar is still a usage error, and the message now points at the flag that
/// does clear a field, so the two do not contradict each other.
///
/// `--title` is the exception, and says only that the value cannot be empty: a title has
/// no unset state to return to, so there is nothing to point at.
#[test]
fn set_refuses_an_empty_scalar_as_a_usage_error() {
let temp = TempDir::new().unwrap();
@@ -198,12 +209,244 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
create_ticket(&worklane);
let before = ticket(&worklane);
for flag in ["--title", "--due", "--tags"] {
for (flag, expected) in [
("--title", "value cannot be empty"),
("--due", "use --clear"),
("--tags", "use --clear"),
] {
let out = run(&temp, &["set", UUID, flag, ""]);
assert_eq!(out.status.code(), Some(2), "{flag} was accepted");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
assert!(
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
"{flag}: {:?}",
!stderr.contains("not supported"),
"{flag} still says clearing is unsupported: {stderr:?}"
);
}
assert_eq!(ticket(&worklane), before);
}
/// An empty value is a paragraph break for a section, so it cannot also mean empty the
/// section. The error names the flag that does, per section.
#[test]
fn set_refuses_an_empty_section_and_names_the_clear_for_it() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
for (flag, expected) in [
("--description", "--clear description"),
("--acceptance", "--clear acceptance"),
("--plan", "--clear plan"),
] {
let out = run(&temp, &["set", UUID, flag, ""]);
assert_eq!(out.status.code(), Some(1), "{flag} was accepted");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
}
assert_eq!(ticket(&worklane), before);
}
/// Every field `--clear` reaches, in one call, back to what a ticket is born with.
#[test]
fn clear_returns_every_field_it_reaches_to_unset() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(
&temp,
&[
"set",
UUID,
"--clear",
"due",
"--clear",
"tags",
"--clear",
"priority",
"--clear",
"description",
"--clear",
"acceptance",
"--clear",
"plan",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
let content = ticket(&worklane);
assert!(content.contains("- **Due**: _Not set_"), "{content}");
assert!(content.contains("- **Tags**: _None_"), "{content}");
assert!(content.contains("- **Priority**: _Not set_"), "{content}");
assert!(
content.contains("## Description\n_No description provided._\n"),
"{content}"
);
assert!(
content.contains("## Acceptance Criteria\n_No acceptance criteria provided._\n"),
"{content}"
);
assert!(
content.contains("## Implementation Plan\n_No implementation plan provided._\n"),
"{content}"
);
// The placeholder goes in bare, not dressed as an item of the section it replaces.
assert!(!content.contains("- [ ] _No"), "{content}");
assert!(!content.contains("1. _No"), "{content}");
// What --clear cannot reach is untouched, the handwritten section included.
assert!(content.starts_with("# Original title\n"), "{content}");
assert!(content.contains("- **Owner**: alice"), "{content}");
assert!(content.contains("- **Status**: backlog"), "{content}");
assert!(
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
"{content}"
);
}
/// A cleared ticket and one that was never given the field have to read the same, or
/// clearing would be its own third state.
#[test]
fn a_cleared_ticket_reads_like_one_filed_without_the_fields() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
run(&temp, &["add", "--title", "Bare"]);
run(
&temp,
&[
"add",
"--title",
"Full",
"--description",
"A body.",
"--acceptance",
"One criterion",
"--plan",
"One step",
"--tags",
"alpha,beta",
"--due",
"2026-09-01",
"--priority",
"2",
],
);
let full = added(&worklane, "full");
let out = run(
&temp,
&[
"set",
&full.0,
"--clear",
"due",
"--clear",
"tags",
"--clear",
"priority",
"--clear",
"description",
"--clear",
"acceptance",
"--clear",
"plan",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
let cleared = comparable(&fs::read_to_string(&full.1).unwrap());
let bare = comparable(&fs::read_to_string(&added(&worklane, "bare").1).unwrap());
assert_eq!(cleared, bare);
}
/// The uuid and the file of the one ticket whose slug matches, as `add` wrote it.
fn added(worklane: &Path, slug: &str) -> (String, PathBuf) {
let entry = fs::read_dir(worklane.join("backlog"))
.unwrap()
.filter_map(|e| e.ok())
.find(|e| e.file_name().to_string_lossy().ends_with(&format!("_{slug}.md")))
.unwrap_or_else(|| panic!("no ticket slugged {slug}"));
let name = entry.file_name().into_string().unwrap();
let uuid = name.split('_').next().unwrap().to_string();
(uuid, entry.path())
}
/// A ticket without the three lines that are different by definition: its title, its
/// uuid and the moment it was filed.
fn comparable(content: &str) -> String {
content
.lines()
.filter(|line| {
!line.starts_with("# ")
&& !line.contains("**ID**:")
&& !line.contains("**Created At**:")
})
.collect::<Vec<_>>()
.join("\n")
}
/// Nothing to take away is not a rewrite, per the same whole-file comparison a
/// replacement uses.
#[test]
fn clearing_a_field_that_is_already_unset_is_no_change() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
let before = ticket(&worklane);
let out = run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
assert!(out.status.success());
assert!(
String::from_utf8_lossy(&out.stdout).contains("No changes"),
"{:?}",
String::from_utf8_lossy(&out.stdout)
);
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
}
/// Replaced and emptied are reported in those words, since a caller doing both in one
/// call cannot tell which happened to which field otherwise.
#[test]
fn clear_is_reported_apart_from_a_replacement() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["set", UUID, "--priority", "1", "--clear", "due"]);
assert!(out.status.success());
let stdout = String::from_utf8_lossy(&out.stdout);
assert!(stdout.contains("Updated priority on 'Original title'"), "{stdout:?}");
assert!(stdout.contains("Cleared due on 'Original title'"), "{stdout:?}");
}
/// Replacing and clearing one field in a single call is a contradiction, and answering
/// it by whichever was applied last would be a silent answer.
#[test]
fn clearing_and_replacing_the_same_field_is_refused() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
for (flag, value, field) in [
("--due", "2026-12-31", "due"),
("--tags", "beta", "tags"),
("--priority", "1", "priority"),
("--acceptance", "A criterion", "acceptance"),
] {
let out = run(&temp, &["set", UUID, flag, value, "--clear", field]);
assert_eq!(out.status.code(), Some(1), "{flag} with --clear {field} was accepted");
assert!(
String::from_utf8_lossy(&out.stderr).contains("contradict each other"),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
}
@@ -211,25 +454,45 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
assert_eq!(ticket(&worklane), before);
}
/// An empty value is a paragraph break for a section, so an all-blank one is a
/// clearing attempt rather than a break.
/// The fields no writer of `set` can reach are not reachable through `--clear` either,
/// and an unknown one is a usage error listing what is.
#[test]
fn set_refuses_to_clear_a_section() {
fn clear_refuses_a_field_it_does_not_own() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let before = ticket(&worklane);
let out = run(&temp, &["set", UUID, "--description", ""]);
assert_eq!(out.status.code(), Some(1));
assert!(
String::from_utf8_lossy(&out.stderr).contains("clearing is not supported"),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
for field in [
"owner",
"title",
"status",
"campaign",
"relations",
"nonsense",
] {
let out = run(&temp, &["set", UUID, "--clear", field]);
assert_eq!(out.status.code(), Some(2), "--clear {field} was accepted");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("possible values"), "{field}: {stderr:?}");
}
assert_eq!(ticket(&worklane), before);
}
/// `--clear` on its own satisfies the at-least-one-field rule, since it is a field
/// being written like any other.
#[test]
fn clear_alone_is_enough_of_a_field() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
let out = run(&temp, &["set", UUID, "--clear", "due"]);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
assert!(ticket(&worklane).contains("- **Due**: _Not set_"));
}
/// A bare `set <ticket>` would otherwise be a silent no-op.
#[test]
fn set_requires_at_least_one_field() {
@@ -248,10 +511,7 @@ fn set_keeps_a_paragraph_break_in_a_replaced_description() {
let worklane = setup_worklane(&temp);
create_ticket(&worklane);
run(
&temp,
&["set", UUID, "-d", "One.", "-d", "", "-d", "Two."],
);
run(&temp, &["set", UUID, "-d", "One.", "-d", "", "-d", "Two."]);
assert!(
ticket(&worklane).contains("## Description\nOne.\n\nTwo.\n\n## Acceptance"),
@@ -268,7 +528,14 @@ fn set_accepts_prose_that_begins_with_a_hyphen() {
let out = run(
&temp,
&["set", UUID, "-a", "--print should be supported", "-t", "-t is the title flag"],
&[
"set",
UUID,
"-a",
"--print should be supported",
"-t",
"-t is the title flag",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
@@ -296,11 +563,16 @@ fn append_adds_a_paragraph_items_and_numbered_steps() {
let out = run(
&temp,
&[
"append", UUID,
"-d", "A third paragraph.",
"-a", "Crit three",
"-a", "Crit four",
"-p", "Step three",
"append",
UUID,
"-d",
"A third paragraph.",
"-a",
"Crit three",
"-a",
"Crit four",
"-p",
"Step three",
],
);
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
@@ -315,10 +587,7 @@ fn append_adds_a_paragraph_items_and_numbered_steps() {
"{content}"
);
// Numbered on from the last step, and the steps above are untouched
assert!(
content.contains("1. Step one\n2. Step two\n3. Step three\n"),
"{content}"
);
assert!(content.contains("1. Step one\n2. Step two\n3. Step three\n"), "{content}");
}
#[test]
@@ -342,14 +611,26 @@ fn append_replaces_an_empty_section_rather_than_following_its_placeholder() {
run(
&temp,
&["append", &uuid, "-d", "A description arrives late.", "-a", "First crit", "-p", "First step"],
&[
"append",
&uuid,
"-d",
"A description arrives late.",
"-a",
"First crit",
"-p",
"First step",
],
);
let content = ticket(&worklane);
assert!(!content.contains("_No description provided._"), "{content}");
assert!(!content.contains("_No acceptance criteria provided._"), "{content}");
assert!(!content.contains("_No implementation plan provided._"), "{content}");
assert!(content.contains("## Description\nA description arrives late.\n"), "{content}");
assert!(
content.contains("## Description\nA description arrives late.\n"),
"{content}"
);
assert!(content.contains("## Implementation Plan\n1. First step\n"), "{content}");
}
+5 -6
View File
@@ -350,7 +350,10 @@ fn show_disambiguates_tickets_with_non_ascii_filenames() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
for (filename, title) in [("émigré-un.md", "Accented One"), ("日本語-二.md", "Accented Two")] {
for (filename, title) in [
("émigré-un.md", "Accented One"),
("日本語-二.md", "Accented Two"),
] {
fs::write(
worklane.join("backlog").join(filename),
format!("# {}\n\n## Metadata\n\n- **ID**: 1234\n", title),
@@ -444,11 +447,7 @@ fn show_prints_the_title_once() {
cmd.current_dir(temp.path()).arg("show").arg("Once Only");
let stdout = get_stdout(&mut cmd);
assert_eq!(
stdout.matches("Once Only").count(),
1,
"title repeated in {stdout:?}"
);
assert_eq!(stdout.matches("Once Only").count(), 1, "title repeated in {stdout:?}");
// The rule under it is still the width of the title
assert!(stdout.contains("Once Only\n─────────\n"), "{stdout:?}");
}
+3 -12
View File
@@ -44,10 +44,7 @@ fn the_tui_outside_a_worklane_directory_gives_the_usual_message() {
let stderr = String::from_utf8_lossy(&out.stderr);
assert_eq!(out.status.code(), Some(1), "{args:?}");
assert!(
stderr.contains("No .worklane directory found"),
"{args:?}: {stderr:?}"
);
assert!(stderr.contains("No .worklane directory found"), "{args:?}: {stderr:?}");
}
}
@@ -66,10 +63,7 @@ fn the_tui_without_a_terminal_says_so_and_names_an_alternative() {
assert_eq!(out.status.code(), Some(1), "{args:?}");
assert!(stderr.contains("needs a terminal"), "{args:?}: {stderr:?}");
assert!(stderr.contains("worklane ls"), "{args:?}: {stderr:?}");
assert!(
!stderr.contains("os error"),
"the raw mode error leaked: {stderr:?}"
);
assert!(!stderr.contains("os error"), "the raw mode error leaked: {stderr:?}");
}
}
@@ -105,10 +99,7 @@ fn several_path_arguments_are_accepted() {
let first = setup_project(&temp, "first");
let second = setup_project(&temp, "second");
let out = run(
&temp,
&["tui", first.to_str().unwrap(), second.to_str().unwrap()],
);
let out = run(&temp, &["tui", first.to_str().unwrap(), second.to_str().unwrap()]);
let stderr = String::from_utf8_lossy(&out.stderr);
assert_eq!(out.status.code(), Some(1), "{stderr:?}");