Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
139c9b012f | ||
|
|
373ba519b3 | ||
|
|
88918b2f8a | ||
|
|
6784d80324 | ||
|
|
ae3ee1bb9e | ||
|
|
5ae9c7fe00 | ||
|
|
ce32b42ae4 | ||
|
|
ece201e3ab | ||
|
|
c437d87e9e |
+20
-10
@@ -425,39 +425,49 @@ export const chown = tool({
|
||||
/**
|
||||
* check and uncheck differ only in the verb, so the tool is built once.
|
||||
*
|
||||
* The criterion is required here even though the CLI makes it optional: without it the
|
||||
* CLI prompts, and there is no terminal on this side of the pipe. The CLI answers a
|
||||
* The criteria are required here even though the CLI makes them optional: without any
|
||||
* the CLI prompts, and there is no terminal on this side of the pipe. The CLI answers a
|
||||
* missing criterion with the numbered list on stderr, which run() relays, so the model
|
||||
* sees the options and can retry with a number.
|
||||
*
|
||||
* One value per line, like the other list arguments, and every value goes in one call.
|
||||
* The CLI resolves them all before it writes, so a bad term costs nothing, and finishing
|
||||
* a ticket is one tool call rather than one per box.
|
||||
*/
|
||||
function checkboxTool(verb: "check" | "uncheck") {
|
||||
const past = verb === "check" ? "Checked" : "Unchecked";
|
||||
|
||||
return tool({
|
||||
description:
|
||||
`${past === "Checked" ? "Tick" : "Untick"} one acceptance criterion on a worklane ticket. ` +
|
||||
"Every other criterion keeps its state. Identify the criterion by its number as shown by show, " +
|
||||
"or by a substring of its text; a substring matching more than one is an error listing them.",
|
||||
`${past === "Checked" ? "Tick" : "Untick"} acceptance criteria on a worklane ticket. ` +
|
||||
"Every criterion not named keeps its state. Identify each one by its number as shown by show, " +
|
||||
"or by a substring of its text; a substring matching more than one is an error listing them. " +
|
||||
`Pass several, one per line, to ${verb} them in a single call, or the single word all for every ` +
|
||||
"criterion on the ticket. If any value cannot be resolved the whole call is refused and nothing " +
|
||||
"is written, so a partly wrong list never leaves the ticket half-marked.",
|
||||
args: {
|
||||
ticket: tool.schema
|
||||
.string()
|
||||
.describe("Ticket UUID prefix (4+ chars) or title substring (required)"),
|
||||
criterion: tool.schema
|
||||
criteria: tool.schema
|
||||
.string()
|
||||
.describe(
|
||||
"Criterion number as shown by show, or a substring of its text (required)",
|
||||
"Criterion numbers as shown by show, or substrings of their text, one per line. " +
|
||||
"Or the single word all for every criterion (required)",
|
||||
),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.ticket) {
|
||||
return `Error running ${verb}: ticket is required`;
|
||||
}
|
||||
if (!args.criterion) {
|
||||
return `Error running ${verb}: criterion is required, give the number or a substring`;
|
||||
|
||||
const terms = args.criteria ? itemLines(String(args.criteria)) : [];
|
||||
if (terms.length === 0) {
|
||||
return `Error running ${verb}: criteria is required, give the numbers, substrings, or all`;
|
||||
}
|
||||
|
||||
try {
|
||||
return await run([verb, args.ticket, String(args.criterion)], context);
|
||||
return await run([verb, args.ticket, ...terms], context);
|
||||
} catch (err: any) {
|
||||
return `Error running ${verb}: ${err.message}`;
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
## Project Structure
|
||||
- `src/main.rs` - dispatch, the SIGPIPE reset, and the TUI event loop
|
||||
- `src/command.rs` - CLI argument definitions using clap derive
|
||||
- `src/completions.rs` - the generated completion script and the fish half that asks the board
|
||||
- `src/handlers.rs` - one `cmd_*` per subcommand
|
||||
- `src/util.rs` - the ticket format, resolution, rendering and the palette
|
||||
- `src/campaign.rs` - the campaign file format, its resolution, its index and its members
|
||||
@@ -20,7 +21,8 @@
|
||||
## Ticket File Format
|
||||
- Filenames: `<uuid_v4>_<slug>.md`
|
||||
- The slug is the title through `slug()`: lowercased, alphanumerics plus `-` and `_` kept, spaces turned into dashes. `Ticket 06` lands as `<uuid>_ticket-06.md`. Derive fixture filenames through `slug()`, never by hand
|
||||
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Campaign`, `Status`. `Campaign` is the one no ticket is born with: `add` does not write it, so it is inserted on demand
|
||||
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Committed On`, `Submitted On`, `Completed On`, `Campaign`, `Status`. The last four are the ones no ticket is born with: `add` writes none of them, so they are inserted on demand, against `METADATA_ORDER`, which is also what keeps `Status` last
|
||||
- The three stamps are `mv`'s, written by `set_status_stamp` from `Status::stamp_field`, and they are mutually exclusive: entering a status writes its field, leaving removes it, re-entering restamps. So a ticket carries at most one, the one for the status it is sitting in, and a backward move under `-f` leaves no stale `Completed On` behind. They are current state, like `Status` itself; the trail of how the ticket got there is d4ce964's job and must not be grown here. `backlog` has no stamp, `Created At` already answers for it
|
||||
- Format: `**Field Name**: value`
|
||||
- Ticket structure: `# Title` → `## Description` → `## Acceptance Criteria` → `## Implementation Plan` → `## Metadata`
|
||||
- Comments stored in `.worklane/comments/<ticket_uuid>/<timestamp>.md` with `**Comment**`, `**Author**`, `**Time**` fields
|
||||
@@ -58,15 +60,34 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **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
|
||||
- **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
|
||||
- `add` has no positionals, so anything after a bare `--` is an unexpected argument and fails
|
||||
- **A paragraph break in a description is an empty `--description` value.** `cmd_add` joins the values with a single newline, so `-d "First." -d "" -d "Second."` writes the blank line. `trim_blank_ends()` drops blank values at either end, so a break never lands against a section heading, and an all-blank description reads as no description. Interior runs are kept verbatim rather than collapsed
|
||||
- `--acceptance` and `--plan` are lists, one criterium or step per value, so a blank there is spacing rather than content and the opencode wrapper drops it. Only `--description` preserves blanks
|
||||
|
||||
### Completions
|
||||
|
||||
- **Two halves, and the split is the point.** `clap_complete` generates the structure from the clap definition, so a new flag or subcommand is completed without anyone touching `completions.rs`. Only fish gets the second half, appended by `fish_dynamic()`, and it holds exactly what clap cannot know: the tickets on the board
|
||||
- **The dynamic values come from worklane itself**, as `worklane ls --ids` in a command substitution, one run per keypress at 2.5ms in release. So the completions are only as current as the binary on PATH: an older one without `--ids` completes nothing, which is a reinstall rather than a bug
|
||||
- **What clap does and does not emit.** It emits the possible values of an *option*, which is why `mv --status <TAB>` needs nothing here, and nothing for a *positional*, which is why the `ls` status and the `completions` shell are listed in the fish half. Both lists are read off the enums with `possible_values`, never written out, so a fifth status appears in the script on its own
|
||||
- **Position is counted, not inferred.** `__worklane_first_arg_of` and `__worklane_second_arg_of` check `$tokens[2]` and the token count rather than using `__fish_seen_subcommand_from`, because `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen, and because matching against the ticket list would run worklane again inside the condition
|
||||
- **`TICKET_COMMANDS`, `TICKET_SECOND_COMMANDS` and `TICKET_FLAGS` are kept honest by tests**, which walk the clap definition and fail on a ticket-taking subcommand that is in neither list, or in the list for the wrong position. A nested subcommand is not walked: `campaign` is the only one, none of its three takes a ticket, and the token counting could not tell them apart if one did
|
||||
- **`ls --ids` is the machine-readable listing**, and the only output in the tree meant to be parsed: the short id, a tab, the title, unstyled. Two fields because fish reads what follows a tab as the description and a script reads `cut -f1`. It includes done, which the decorated listing leaves out, because a completion has to be able to name a finished ticket, and it skips a missing status directory rather than refusing, because an error printed over a shell prompt is worse than no candidates. The filters still apply, and an unknown `--campaign` is still refused
|
||||
|
||||
### Filtering the Listing
|
||||
- **The filters are one call, `filtered`,** because `ls` collects a column in three places (a named status, the counts, and the grouped listing) and three call sites are three chances to apply a different set. Every filter is an `Option` and none asked for keeps everything, which is what makes them compose in any combination without a rule per pair
|
||||
- **`--tag` matches whole values, not the field.** `parse_tags` has already split the comma-separated field, so the filter compares against those trimmed values: `--tag bug` is not answered by a ticket tagged `bugfix`, and `--tag "cli, filter"` matches nothing, because the field as written is not itself a tag. A ticket with no tags matches none
|
||||
- **Case sensitive**, the opinion the field already takes: `tag_color` draws `Bug` and `bug` in two colours because they are two tags. A filter that folded them would list tickets carrying a tag nobody asked for, and would hide exactly the split a grooming sweep is looking for
|
||||
- **One tag per invocation.** Several would have to decide between and and or, and neither reading is obviously right for a board this size. That decision is its own ticket, along with a substring or regex match and a tag filter on the tui
|
||||
- **A tag nothing carries lists nothing rather than being refused**, which is the opposite of `--campaign`. A campaign is an object that either exists or does not, so it is resolved before anything is read and an unknown one is an error. A tag is free text with no registry: there is nothing to resolve against, and refusing an unknown one would mean maintaining a vocabulary the format deliberately does not have. `assets/PLAN.md` tells the agent to check the spelling when a listing comes back empty, since that is the failure this trades for
|
||||
- An emptied status keeps the message `ls` already gives, `No tickets in '<status>' status.`, rather than one per filter naming what excluded them. That is pre-existing behaviour for `--priority` and `--campaign`, and one message for every filter is the consistent half of it. If it should name the filter, that is a change to what the CLI prints for three flags at once and belongs in its own ticket
|
||||
- **`cmd_ls` takes an `LsArgs`**, which is what the boundary in the Rust Style rule came to: four filters, an output mode and the directory, two of them adjacent `Option<String>` values a caller could swap silently. `--ids` was the argument that tipped it, the way `add` became `AddArgs`. A new filter is a field there, not a parameter
|
||||
|
||||
### Editing a Ticket
|
||||
- `set` replaces a field, `append` adds to a section. The verb carries the meaning, so no flag needs a replace-or-append prefix, and `append` only offers the sections that hold multiple lines
|
||||
- **One field, one writer.** `set` has no `--owner` (that is `chown`'s) and no `--status` (that is `mv`'s). Do not add either
|
||||
- **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
|
||||
@@ -81,11 +102,16 @@ and this file is for what someone changing worklane's own code needs.
|
||||
### Checking Off a Criterion
|
||||
- `check` and `uncheck` are separate commands, not one verb with a flag. They share `CheckArgs` and `cmd_check(args, checked)`
|
||||
- `criteria()` is scoped to the Acceptance Criteria section and counts only checkbox lines, so a checkbox written into a description is not a criterion and a handwritten line inside the section takes no number
|
||||
- `set_criterion()` splices only the character between the brackets. Rebuilding the line would normalise its indentation and whatever spacing followed the checkbox
|
||||
- The criterion argument is an index first, a substring second, so a criterion whose text is literally `2` is reachable only by substring
|
||||
- `set_criteria()` splices only the character between the brackets, and takes every line in one pass. Rebuilding the line would normalise its indentation and whatever spacing followed the checkbox
|
||||
- Each criterion term is the keyword `all` first, an index second, a substring third. So a criterion whose text is literally `2` is reachable only by substring, and one whose text merely contains "all" only by its number or a longer substring. `is_all_criteria()` and `is_index()` sit beside each other in `util.rs` for that reason
|
||||
- **The keyword wins over the text on purpose.** Ticking every box is the reason the word is typed, and a board where `all` sometimes means one criterion and sometimes means the lot would be worse than one that can be addressed another way. `all_is_the_keyword_and_not_a_substring_of_the_text` pins it against its own fixture, so the shared one keeps its three criteria and its numbering
|
||||
- **A number out of range is a bad index, not a failed substring search**, and says so. `is_index()` makes that distinction
|
||||
- Any listing of a subset must keep the real numbers, via `numbered_criteria()`. Renumbering the matches from one contradicts the advice to use the number and points at the wrong criterion
|
||||
- With the criterion omitted: prompt when stdin is a terminal, otherwise return the numbered list as an error. Never prompt unconditionally, the opencode wrapper has no tty and would block on a stdin that never closes. This is the same choice `resolve_ticket` makes for an ambiguous match, and for the same reason
|
||||
- **The criterion positional is variadic**, so `check <ticket> 1 3 "the footer"` is one call and one write. Variadic rather than a repeated flag: the terms address criteria that are already there, the way the ticket positional does, instead of carrying content the way `--acceptance` does. The prompt path is unchanged and fires on an empty list
|
||||
- **`resolve_criteria()` resolves every term before a byte is written, and one bad term refuses the whole batch.** A call that ticked the terms it understood and then failed would leave the ticket half-marked with nothing in the file to say which half was meant. It names the offending term alone rather than every failure at once, since each message carries the criteria listing and a batch of them would repeat the list per bad term
|
||||
- The chosen offsets are sorted and deduped, so the report reads in `show`'s order whatever order the terms arrived in, and a criterion named twice, or by both `all` and its own number, is marked and reported once
|
||||
- **Every named criterion gets a line, in `show`'s order, printed after the write.** A criterion already in the target state reads `Already checked 2: text` and does not count towards the write, so a batch where every box is already ticked writes nothing, which is the whole-file no-op rule the editing commands keep. The number is on the unchanged line too: without it a batch cannot be read back against `show`
|
||||
- `show` numbers the criteria as `1. [x] text`, so the index is visible where the ticket is read. The number replaces the list marker rather than joining it
|
||||
|
||||
### Relating Tickets
|
||||
@@ -131,6 +157,12 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- The scroll offset is clamped against the *wrapped* line count, from `Paragraph::line_count`, which is why `ratatui` carries the `unstable-rendered-line-info` feature. The paragraph wraps on words, so a clamp on the raw lines would stop short of the end or scroll past it into blank space. Counting the wrapping by hand would only agree with the widget until one of the two changed
|
||||
- The clamp runs on the keypress and again in the draw. The terminal can be resized between the two, and a tick can shorten the ticket under a reader who is already at the end
|
||||
- The offset resets when the selection moves and when the modal is closed, so a ticket opens at its top. It deliberately does *not* reset on a tick: an edit elsewhere in the tree must not throw the reader back to the top of what they are reading
|
||||
- **The overlay carries a page indicator on the bottom right of its border**, `pg 2/8`, so a long ticket does not open looking exactly like a short one. `Block::title_bottom` with a right-aligned `Line`, which spends no text row, the trade the title already makes on the top border. The two cannot crowd each other: they are on opposite borders
|
||||
- **`wrapped_height` is the one measurement.** `last_offset` is it less the viewport and `page_indicator` takes the same two numbers, so the clamp and the indicator cannot disagree. A second `line_count` call, or a count of the raw lines, is a number free to drift, and an indicator that says there is more to read where the scroll refuses to move is worse than none
|
||||
- **The furthest offset is the last page by definition, not by division.** The clamp stops at the wrapped height less the viewport, which is not a page boundary, so the final screenful is partial: `offset / step + 1` reads `pg 2/3` at the bottom of a 25 row ticket in a 10 row viewport and claims there is more below
|
||||
- **The pages are counted in `scroll_step`, a screenful less the overlap line, not in whole screenfuls.** The step is what the keys take, so counting in it names only pages `pgdn` can land on. Counting by screenfuls puts a 30 row ticket in a 10 row viewport at `pg 3/3` two rows short of its end, since three presses are what it takes to get there
|
||||
- The indicator is dropped whole on an overlay too narrow for it, the rule a corner and the tags row already follow, and absent entirely when nothing scrolls, the way an untagged card spends no row on tags
|
||||
- `page_indicator` takes four numbers and returns an `Option<String>`, so every case above is pinned without a terminal. The drawn tests exist for the two things arithmetic cannot answer: which border it landed on and what colour it reached the screen in
|
||||
- **Columns scroll to keep the selected card in view.** `Board::offsets` holds one offset per column, parallel to `columns` and resized in step by `reload`, so a column you leave stays where it was. The keypress aligns the focused column via `follow_selection(screen)`, taking the screen size for the same reason `scroll_detail` does: the visible height belongs to the terminal, which only the caller measures between draws
|
||||
- Card heights are measured on `card_lines`, never assumed, on both the keypress and the draw side (`card_height`, and the `starts` vec as the cards are built). An alignment that trusted a fixed card height would drift from the renderer the first time the card changed shape
|
||||
- The draw aligns the focused column again on its own geometry, so a resize between keypress and frame cannot hide the selection, and caps every column against blank space past its last card. The stored value may go stale after a tick shrinks the column; that is fine, because what is drawn is corrected immediately and the next navigation writes the correction back
|
||||
@@ -150,7 +182,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- The criteria count is a field on `TicketItem`, filled in `collect_ticket_items` where the file is already being read, and counted through `criteria()` so a checkbox in a description is not counted here or numbered by `show`. Do not count per card: that re-reads every ticket body on every draw instead of on the tick that changed something. `None` rather than `[0/0]` for a ticket with no criteria
|
||||
- **The tags go under the title, dimmed, each prefixed with `#`.** The field was invisible on the board: nothing said a ticket was tagged `bug` without opening it. The marker is what stops the row reading as a third line of the title, since a tag is an ordinary word and the title sits directly above it. The row is dropped whole when the column will not hold it, the rule a corner follows, and an untagged ticket spends no row at all, the way a short title spends no second one
|
||||
- `tags` is a field on `TicketItem`, filled in `collect_ticket_items` through `parse_tags`, for the reason the criteria count is. `parse_tags` splits the comma-separated field into whole trimmed values, so a caller asking for `bug` is not answered by `bugfix`, and reads absent, `_None_` and empty as the same answer
|
||||
- **A held-up card carries `×` after its id, in brightred.** A ticket waiting on an open blocker looked exactly like one that is ready, and the board is where the next thing to pick up is chosen. Not a fourth circle from Geometric Shapes: those belong to the priority meter two cells away and would read as part of that ramp. The multiplication sign is Latin-1, like the middle dot the unset priority draws, so it renders wherever the meter does
|
||||
- **A held-up card carries `BLOCKED_MARK`, `×`, after its id, in brightred.** The constant lives in `util.rs` and the relations block draws the same one, since both say the same word. A ticket waiting on an open blocker looked exactly like one that is ready, and the board is where the next thing to pick up is chosen. Not a fourth circle from Geometric Shapes: those belong to the priority meter two cells away and would read as part of that ramp. The multiplication sign is Latin-1, like the middle dot the unset priority draws, so it renders wherever the meter does
|
||||
- **The mark goes after the id, not before it.** Ahead of the id it would push every id in the column out of line whenever one card was blocked, which costs more than one card's state is worth. It is measured before the project label and the due date, so both give way to it: those are context for a ticket somebody can start, and this is the one thing on a card that says not to. Dropped whole when the row cannot hold the identity and the mark together, the rule a corner follows
|
||||
- **`blocked` is on `Card`, not on `TicketItem`.** The answer lives on two tickets at once, so no card can reach it alone, and it is settled at reload the way `project` is. What `collect_ticket_items` fills is the ticket's own `uuid` and its `blockers`, both read off the file it is already holding; `mark_blocked` then walks the four columns once for a uuid-to-status map and once to answer every card. No file is read twice and nothing is asked per draw
|
||||
- **A blocker the board does not hold marks nothing**, the answer `mv` already gives a dangling uuid. A Relations section that cannot be parsed reads as no blockers, the exception `detail_of` makes for the same reason: `show` and `mv` are where a hand-edited file is reported, and a board that will not draw because one ticket is malformed is the worse failure
|
||||
@@ -192,6 +224,27 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **It takes the whole footer row**, on a weaker reason than the prompt's: every key still works while a notice is up. It is that a message squeezed in beside the key list would move every key in it, and the row is the only part of the board that is not a ticket. Drawn after the prompt, which is an input and cannot be covered
|
||||
- **The notice is cleared by the next keypress, not by a timer.** No clock on the board and no wakeup in the loop, and the moment the reader does anything else the message has been read or was never going to be. Doing nothing leaves it up, which is the one state where it is still worth reading. `Board::clear_notice` runs ahead of `search_key` as well as the arms, since a key typed into a query is still a key, and it must never move into `tick`: the board redraws four times a second and a notice cleared there would never be read
|
||||
|
||||
### The Relations Block
|
||||
- **One builder, two painters.** `relation_rows` decides which edges there are, what they are called and which direction comes first; `relation_cells` decides the layout, the mark and the colours; `paint_cells` turns cells into escapes for the CLI and `span_of` turns the same cells into ratatui spans for the board. Two builders producing one block in two shapes is a pair free to disagree about ordering or padding, which is what this shape exists to prevent
|
||||
- **`Cell` is the unit both renderers take**: a run of text and the colour it is drawn in, `None` for the default foreground. The same trick as the palette itself, where `Color::ansi()` and `From<Color> for ratatui::style::Color` keep one colour from existing for one renderer and not the other
|
||||
- **`reference_cells` is the one spelling of a cross reference**, and `reference_cell` is it painted. The relations block and the Campaign field both go through it, so a dangling reference reads the same way wherever it is shown
|
||||
- **A row carries two marks, kind then status**: what sort of edge this is, then how far the ticket at the other end has got. `blocked by × ◐ (6ce2c47) Title`. Two questions are asked of this block and one glyph could not answer both: which rows hold this ticket up, and whether the ones that do are finished
|
||||
- The status went through one bad shape first. It was a rising bar, `▁▄▆█`, as the only mark, which read as an undifferentiated column of blocks and left the kind to five long words that blur when a ticket carries several. Then the kind took the column alone and the status was lost. Both, in that order, is the answer
|
||||
- **Both directions of a kind carry one mark.** `blocked by` and `blocks` are the same edge read from two ends, and the label is what says which end you are on. `both_directions_of_a_kind_carry_one_mark` pins it
|
||||
- **`×` is `BLOCKED_MARK`, the same constant a held-up card draws**, in the same brightred. On a card it says this ticket is held up and in the block it says this edge is what holds one, which is one word, so one glyph and one definition. It lives in `util.rs` for that reason, not in `tui.rs` where the card is
|
||||
- **The kind marks stay out of the priority vocabulary**, which owns `●◐○·`, and `no_relation_mark_is_a_priority_glyph` pins that against every level. They are the arrows the footer already draws, so they render wherever it does
|
||||
- **The status marks are those very circles, and what keeps them from reading as a level is width**: the meter is always two cells and a status mark is one. `the_status_mark_is_one_cell_where_the_meter_is_two` pins both halves. A card carries the meter and never a status mark, and the block carries the status mark and never a meter, so the two never sit in one column
|
||||
- **Both marks go ahead of the id**, where they describe the target rather than the row. Every row carries both, so nothing is pushed out of line the way the card's blocked mark would have been, which is why that one sits after the id and these before it
|
||||
- **The kind mark survives a target the board cannot find and the status mark cannot**, since a kind is read from the ticket's own file and a status from the board. `?` holds the column so the id does not move, and `_missing_` in grey is what says the target is gone
|
||||
- **Committed and reviewing are told apart by colour alone**, both being `◐`, so a pipe cannot tell them apart: `should_use_colors` is false and both read as under way. Accepted, because `●` and `○` are the two answers usually wanted and `show` on the target settles the rest, and `assets/SKILL.md` says so outright rather than leaving an agent to infer it. Do not fix this by giving one of them a colour that means something else
|
||||
- `RelationTarget` carries the title and the status in one `Option`, because they come from the same lookup and are absent together. It was taken out when the mark keyed on the kind alone and put back one commit later, which is the cost of a field nothing reads: correct at the time, and churn either way
|
||||
- **`show` and the board carry the same mark**, decided rather than left to be discovered: the rows are one builder, so giving the CLI the mark cost nothing, and two views disagreeing about what a relation shows would be the kind of difference nobody can explain later. That makes it a change to what the CLI prints, so it is a minor
|
||||
- **`Resolved.relations` is rows, not a rendered block.** That is what lets the board style them: an escape sequence in a ratatui paragraph is drawn as literal bytes (6d327df), so the block cannot arrive pre-painted. `content_parts` hands the text through already painted and the rows through untouched, which is the asymmetry the two renderers need
|
||||
- **`BodyPart` splits the body rather than building it twice.** Everything outside the relations block is rendered once, by `content_parts`; `content_trim` is that with the rows painted, and the board is that with the rows styled. `Body` is the accumulator, so a caller pushes text and rows without tracking which it pushed last
|
||||
- **`Detail.body` is a `Text`, and it is the only thing measured.** `last_offset` and the `Paragraph` both take it, so the clamp cannot wrap the body differently from the draw. `Detail::plain()` flattens it for the suite and is `#[cfg(test)]`: a second representation carried alongside the spans is a second thing to disagree
|
||||
- `detail_body` closes a line only where the text says, so a part that does not end on a newline runs on into the next one. The seam between text and rows is wherever the body put it rather than wherever a part happened to end
|
||||
- **The relations block is the only coloured part of the overlay body, and that is a decision, not an oversight.** The headings, the plan numbers, the criteria marks, the bold runs and the grey unset values are all painted by `show` and all flat on the board. The block earned its colour because it is where a reader compares several references at once, and because it was already data rather than prose: it arrives as rows for the status mark, so styling it cost nothing extra. Colouring the rest means giving every painted run in `content_parts` the `Cell` treatment, which is a much larger change with no reader's question behind it, and it is its own ticket. Do not paint one more section here without taking that on: two coloured sections and five plain ones reads as a bug, where one clearly does not
|
||||
|
||||
### Monitoring Several Boards
|
||||
- `worklane tui <path>...` takes any number of paths, each resolved through `find_worklane_dir` the way the working directory is: the first `.worklane` at or above it. No path is the working directory, so a bare `worklane` and `worklane tui` are unchanged
|
||||
- The failure **names the path** that had no board, since with several arguments "No .worklane directory found" does not say which one was wrong. Only when a path was given: a bare `worklane` has no path to name and keeps the message every other command gives, which is what its integration test asserts
|
||||
@@ -243,6 +296,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- Title → green (32)
|
||||
- Unknown values (`_None_`, `_Not set_`) → grey (38;5;8)
|
||||
- Priority ramp → brightred (1), red (2), orange (3), cyan (4), grey (5). Green is deliberately absent: it means title
|
||||
- Relation kind mark → brightred `×` blocked by and blocks, cyan `→` relates to, orange `←` regression of and regressed by. A small ramp inside one column, the way the priority meter is: the mark says which kind of edge the row is, so none of these three is a colour standing in for the uuid or the title beside it. Brightred on the cross rather than red, because the id one cell to its right is red and the two would blend. It is the colour and the glyph a held-up card already carries, which is the point: one vocabulary for blocking
|
||||
- Relation status mark → grey `○` backlog, orange `◐` committed, cyan `◐` reviewing, green `●` done, grey `?` for a target the board does not hold. The second ramp in that column: the shape says how far the target has got and the colour tells the two middle stages apart, since both are half circles. **Green is here and deliberately absent from the priority ramp**, where it would sit on a whole line and read as a title; on a one-cell mark with no title behind it, it is the obvious colour for finished and nothing else wants it. Orange keeps the meaning it already has, Status, and grey keeps unset for the one row with no status to show
|
||||
- Chrome → grey. The footer's key names, a rendered `[ ]`, and the overlay's page indicator. Not a new slot: grey already means "what a reader skips", which is the other half of the unset-value meaning, and none of these is a value. The indicator in orange would read as the title it faces across the overlay, in cyan as a timestamp, and in the priority ramp's colours as a level
|
||||
- **The palette splits in two: seven colours that each mean one thing, and `TAG_COLORS`, the eight a tag may be drawn in.** A tag in red would read as a uuid, in green as a title, in grey as an unset value, so the tag slots are reserved as a list rather than picked at the call site. Do not assign a new meaning to a colour in `TAG_COLORS`, and do not draw a tag in one outside it
|
||||
- `tag_color()` is a pure function of the tag string, so the same tag is the same colour on every card, in every view and on every board, with nothing stored. Case sensitive, because `Bug` and `bug` are two different tags to the field and to every search
|
||||
- **The hash is FNV-1a written out here, not `DefaultHasher`.** std does not promise its output is stable across releases, and a board that repaints itself on a toolchain upgrade has lost the only property the mapping is for. `the_tag_mapping_is_pinned` fails on any change to it, so a repaint is a decision rather than a surprise
|
||||
@@ -278,6 +334,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- Always ask the user to confirm the bump and its kind before making it — never bump silently, and never skip the question because the answer looks obvious
|
||||
- Pre-1.0, so: patch for fixes and internal changes, minor for a new command, flag or changed output, major only for a deliberate 1.0
|
||||
- **Changed output means the CLI's output.** That is the surface scripts and agents read, so a changed listing, message or exit code is a minor. A change to what the board draws is a patch however visible it is, since nothing consumes the frame. See The Board View
|
||||
- **Settling output that shipped one version ago is a patch**, not a second minor. 0.15.1 changed the relation mark 0.15.0 had just introduced, and 0.15.2 added the status mark beside it: the minor was the arrival of a marked relations block, and settling what it marks belongs to that. Three minors in an hour would tell anyone reading the tags that there were three features
|
||||
- No bump for docs-only, tests-only or `--fixup` commits
|
||||
- When one body of work spans several commits, bump once on the final commit rather than on each
|
||||
- Bump `Cargo.toml` and the `worklane` entry in `Cargo.lock` together, in the commit that carries the bump
|
||||
|
||||
Generated
+11
-1
@@ -208,6 +208,15 @@ dependencies = [
|
||||
"strsim",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_complete"
|
||||
version = "4.6.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3be2ad0423bdbbb0e25bc89add796f3559706d4a95e1bc98e4d9662a957b6a19"
|
||||
dependencies = [
|
||||
"clap",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_derive"
|
||||
version = "4.6.1"
|
||||
@@ -1494,13 +1503,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.13.7"
|
||||
version = "0.17.1"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
"assert_fs",
|
||||
"chrono",
|
||||
"clap",
|
||||
"clap_complete",
|
||||
"crossterm",
|
||||
"libc",
|
||||
"ratatui",
|
||||
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.13.7"
|
||||
version = "0.17.1"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
@@ -14,6 +14,7 @@ libc = "0.2"
|
||||
# widget until one of us changed.
|
||||
ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] }
|
||||
crossterm = "0.28"
|
||||
clap_complete = "4.6.9"
|
||||
|
||||
[dev-dependencies]
|
||||
assert_cmd = "2"
|
||||
|
||||
@@ -5,27 +5,55 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
## Commands
|
||||
| Command | Description |
|
||||
|---------|-------------|
|
||||
| `worklane` or `worklane tui [path...]` | Opens the board: four status columns, redrawn when the tree changes. Read only. Opens on backlog, committed and reviewing; `d` shows or hides done, whose count stays in the footer either way. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, `/` to jump to the first ticket whose id or title matches, `y` to copy the selected ticket's short id to the clipboard, `q` to quit. Each path opens the first `.worklane` at or above it, the working directory by default. Several paths are monitored together, as a tab per project plus an `all` tab that merges them, with `tab` and `shift+tab` between them |
|
||||
| `worklane` or `worklane tui [path...]` | Opens the board: four status columns, redrawn when the tree changes. Read only. Opens on backlog, committed and reviewing; `d` shows or hides done, whose count stays in the footer either way. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, whose border carries a page indicator while there is more of it than fits, `/` to jump to the first ticket whose id or title matches, `y` to copy the selected ticket's short id to the clipboard, `q` to quit. Each path opens the first `.worklane` at or above it, the working directory by default. Several paths are monitored together, as a tab per project plus an `all` tab that merges them, with `tab` and `shift+tab` between them |
|
||||
| `worklane init` | Creates `.worklane/` with backlog, committed, reviewing, done directories |
|
||||
| `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags. `--due` takes `YYYY-MM-DD` and refuses anything else at parse time |
|
||||
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>` |
|
||||
| `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 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 check <ticket> [criterion]` | Ticks one acceptance criterion, by number as shown by `show` or by a substring. Prompts with the numbered list if omitted, or errors with it when there is no terminal |
|
||||
| `worklane uncheck <ticket> [criterion]` | Unticks one acceptance criterion, addressed the same way |
|
||||
| `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 |
|
||||
| `worklane completions <shell>` | Prints a completion script for `fish`, `bash`, `zsh`, `elvish` or `powershell`. See below |
|
||||
| `worklane install-skill [skill]` | Writes the embedded agent skills to `~/.claude/skills/<skill>/SKILL.md`, which Claude Code and opencode both read. Three ship: `worklane` teaches the CLI, `worklane-review` reviews a finished ticket against the code that claims to close it, `worklane-plan` grooms the board as a whole, its priorities, due dates, tags and campaigns. Every document unless one is named. Leaves a modified copy alone unless `--force`; `--print` writes one to stdout instead and needs the name |
|
||||
|
||||
## Completions
|
||||
|
||||
```sh
|
||||
worklane completions fish > ~/.config/fish/completions/worklane.fish
|
||||
```
|
||||
|
||||
Also `bash`, `zsh`, `elvish` and `powershell`, though only fish gets the dynamic half.
|
||||
|
||||
The structure comes from clap, so new flags appear without anyone remembering to add them. The four
|
||||
statuses come with it, because a status is a value enum rather than a string. On top of that, fish
|
||||
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 relate x --blocked-by <TAB>
|
||||
```
|
||||
|
||||
The tickets come from `worklane ls --ids`, one run per keypress, 2.5ms in release on a board of
|
||||
seventy-five tickets. Since fish runs whatever `worklane` is on PATH, **completions need the
|
||||
installed binary to be current**: an older one without `--ids` completes nothing. Re-run
|
||||
`cargo install --path .` after pulling.
|
||||
|
||||
`tui` is the one command whose argument is a path, so it is the one place fish still offers
|
||||
directories.
|
||||
|
||||
## Exit codes
|
||||
| Code | Meaning |
|
||||
|------|---------|
|
||||
| 0 | Success |
|
||||
| 1 | An error, such as no matching ticket or an ambiguous search |
|
||||
| 2 | A usage mistake, such as an unknown flag |
|
||||
| 2 | A usage mistake, such as an unknown flag, an unreal `--due` date, a priority out of range or a status that is not one of the four |
|
||||
| 141 | Output was piped to a reader that stopped early, for example `worklane ls \| head -3` |
|
||||
|
||||
141 is 128 + 13, the shell's way of reporting death by `SIGPIPE`. Worklane restores
|
||||
|
||||
+7
-4
@@ -56,14 +56,17 @@ The last two rows are in the table to be recognised, not used. See the closing s
|
||||
worklane ls # every status, counts then tickets
|
||||
worklane ls backlog # one status
|
||||
worklane ls --priority 1 # the top of the pile
|
||||
worklane ls --tag bug # one tag's worth of the board
|
||||
worklane show 1b78a24 # one ticket, with its relations and comments
|
||||
worklane campaign ls # the goals that already exist
|
||||
```
|
||||
|
||||
`ls` prints the mark, the id, the title, the owner and the due date. It does **not**
|
||||
print tags, and there is no tag filter yet, so any judgement about tags means reading the
|
||||
tickets themselves. On a board of a few dozen that is a `show` per ticket and is worth
|
||||
doing rather than guessing from titles.
|
||||
print tags, so the vocabulary itself still has to be read off the tickets: `--tag` answers
|
||||
"what is tagged `bug`" and cannot answer "what tags exist", which is the question a
|
||||
grooming sweep starts from. Count the vocabulary with a `show` per ticket, then use
|
||||
`--tag` to check each candidate, and remember that `--tag` matches whole values case
|
||||
sensitively: `bug` and `Bug` are two answers, which is exactly the split worth reporting.
|
||||
|
||||
Read `done` too when the question is about what to do next. What was finished last is the
|
||||
best evidence of what this board actually moves at, and a plan that ignores it is a wish.
|
||||
@@ -137,7 +140,7 @@ what is actually used, and show the count before proposing anything. What to rep
|
||||
that will disagree with it. This board already made that mistake once with priority and
|
||||
undid it deliberately.
|
||||
- **An untagged ticket** in a board where everything else is tagged. It is invisible to
|
||||
every question asked by tag.
|
||||
every question asked by tag, `worklane ls --tag` included.
|
||||
|
||||
Tags are for kind, not for state and not for goal. State is the status directory and the
|
||||
fields; a goal is a campaign.
|
||||
|
||||
+4
-2
@@ -117,12 +117,14 @@ quote `--force` literally. A body of exactly `--` needs its own separator.
|
||||
## 5. Write the verdict back to the ticket
|
||||
|
||||
```
|
||||
worklane uncheck 1b78a24 2
|
||||
worklane uncheck 1b78a24 2 5
|
||||
worklane append 1b78a24 --acceptance "The footer lists only the keys that are bound"
|
||||
```
|
||||
|
||||
Untick every criterion you found unmet, one call each, by the number `show` printed. Do
|
||||
Untick every criterion you found unmet, by the numbers `show` printed, in one call. Do
|
||||
it after the comment so there is a written reason on the board before the mark changes.
|
||||
Do not reach for `all`: a review unticks what it found unmet, and unticking the lot would
|
||||
erase the implementer's claim on the criteria you agreed with.
|
||||
|
||||
**Never tick a criterion.** A tick is the implementer's claim that something is done, and
|
||||
unticking is the review disagreeing with that claim. A reviewer that also ticks makes
|
||||
|
||||
+57
-2
@@ -35,32 +35,64 @@ skipping move, for correcting a mistake.
|
||||
A move is also refused while the ticket is blocked by one that is not done yet, see
|
||||
[Relating tickets](#relating-tickets).
|
||||
|
||||
`mv` stamps the time as it goes: `Committed On`, `Submitted On` and `Completed On`, one
|
||||
field for the status the ticket is in now, shown by `show` among the rest of the
|
||||
metadata. Only the current one is kept, so the stamp says how long the ticket has been
|
||||
where it is, not how long each earlier stage took. Nothing else writes them, and moving
|
||||
a ticket back removes the stamp of the status it left.
|
||||
|
||||
## Reading the board
|
||||
|
||||
```
|
||||
worklane ls # every status, counts then tickets
|
||||
worklane ls backlog # one status
|
||||
worklane ls --priority 1 # only the most urgent
|
||||
worklane ls --tag bug # only the tickets carrying that tag
|
||||
worklane show 1b78a24 # one ticket, body and comments
|
||||
```
|
||||
|
||||
`ls` prints a seven-character id per ticket. That is what you address it by.
|
||||
|
||||
`worklane ls --ids` prints the same tickets as an id, a tab and a title, one per line and
|
||||
unstyled, with done included and the filters still applying. That is the form to parse
|
||||
when you want the ids themselves: `worklane ls --ids | cut -f1`. The decorated listing is
|
||||
for reading, not for cutting up.
|
||||
|
||||
The filters compose in any combination, with each other and with the status positional:
|
||||
`worklane ls backlog --tag bug --priority 1`. `--tag` takes one tag and matches it
|
||||
against the whole values of the comma-separated `Tags` field, case sensitively, so
|
||||
`--tag bug` finds neither a ticket tagged `bugfix` nor one tagged `Bug`. A ticket with no
|
||||
tags matches none. A tag nothing carries lists nothing rather than failing, so when a
|
||||
listing comes back empty check the spelling against a ticket you know is tagged.
|
||||
|
||||
## Working a ticket
|
||||
|
||||
```
|
||||
worklane mv 1b78a24 --status committed
|
||||
worklane check 1b78a24 3 # tick acceptance criterion 3
|
||||
worklane check 1b78a24 "the footer describes" # or a substring of it
|
||||
worklane check 1b78a24 1 3 "the footer" # several in one call
|
||||
worklane check 1b78a24 all # every criterion on the ticket
|
||||
worklane uncheck 1b78a24 3
|
||||
worklane comment 1b78a24 "Found the cause: the offset was never passed to the widget."
|
||||
worklane mv 1b78a24 --status reviewing
|
||||
```
|
||||
|
||||
Criteria are numbered by `show`. With the criterion omitted, `check` prompts when there
|
||||
is a terminal and otherwise fails with the numbered list, so **always pass the criterion
|
||||
Criteria are numbered by `show`. With no criterion given, `check` prompts when there
|
||||
is a terminal and otherwise fails with the numbered list, so **always pass the criteria
|
||||
when you are not sitting at a prompt**.
|
||||
|
||||
One call takes as many terms as you like, mixing numbers and substrings, and `all` stands
|
||||
for every criterion on the ticket. Use it when the work is done: it is one write instead
|
||||
of one per box. `all` is a keyword, checked before the text, so a criterion whose own
|
||||
words include "all" is reached by its number or by a longer substring.
|
||||
|
||||
**Every term is resolved before anything is written.** One term that matches nothing, or
|
||||
matches more than one criterion, refuses the whole call and names that term, so the ticket
|
||||
is never left half-marked. A criterion already in the state you asked for is reported
|
||||
unchanged rather than refused, and a call that would change nothing writes nothing. Both
|
||||
apply to `uncheck` exactly as they do to `check`.
|
||||
|
||||
## Filing a ticket
|
||||
|
||||
```
|
||||
@@ -133,6 +165,19 @@ Recording a relation the ticket already holds reports no change. A ticket cannot
|
||||
to itself, and a target that later disappears shows as `_missing_` rather than silently
|
||||
going away.
|
||||
|
||||
`show` marks each row twice, kind then status. The kind is `×` for `blocked by` and
|
||||
`blocks`, `→` for `relates to`, `←` for `regression of` and `regressed by`; both
|
||||
directions of one kind carry one mark, and the label is what says which end you are on.
|
||||
The status is the target's own: `○` backlog, `◐` committed or reviewing, `●` done, and
|
||||
`?` for a target the board no longer holds. So `blocked by × ● (1b78a24)` is a blocker
|
||||
that is finished and `blocked by × ○ (1b78a24)` is one nobody has started. The board
|
||||
draws the same block.
|
||||
|
||||
Colour is what tells committed from reviewing, since both are `◐`, and **your output is a
|
||||
pipe, so you do not get the colour**. Read `◐` as under way, and if it matters which
|
||||
stage, `worklane show` on that target says so in its Status field. `●` and `○` are
|
||||
unambiguous without it, which are the two answers usually being asked for.
|
||||
|
||||
## Campaigns
|
||||
|
||||
A campaign groups the tickets that have to be finished together: a release, a migration,
|
||||
@@ -180,6 +225,16 @@ existing ticket will have been written from a different angle.
|
||||
- Related but not the same: file it, and record it with `relate <new> --relates-to <old>`
|
||||
rather than only mentioning the id in prose.
|
||||
|
||||
## Shell completions
|
||||
|
||||
```
|
||||
worklane completions fish > ~/.config/fish/completions/worklane.fish
|
||||
```
|
||||
|
||||
For the person's shell, not for you, and `bash`, `zsh`, `elvish` and `powershell` are
|
||||
there too. Only fish completes ticket ids, which it does by running `worklane ls --ids`,
|
||||
so a stale binary on PATH completes nothing and the fix is to reinstall it.
|
||||
|
||||
## Addressing a ticket
|
||||
|
||||
Every command that takes a ticket accepts, in this order of precedence:
|
||||
|
||||
+1
-1
@@ -179,7 +179,7 @@ pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> Str
|
||||
/// rather than at each call site.
|
||||
pub fn resolved_for(content: &str, worklane_dir: &Path, colored: bool) -> Result<Resolved> {
|
||||
Ok(Resolved {
|
||||
relations: relations_block(content, worklane_dir, colored)?,
|
||||
relations: relations_for(content, worklane_dir)?,
|
||||
campaign: campaign_cell(content, &CampaignIndex::load(worklane_dir)?, colored),
|
||||
})
|
||||
}
|
||||
|
||||
+52
-20
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
|
||||
|
||||
use chrono::NaiveDate;
|
||||
|
||||
use crate::util::{PRIORITY_RANGE, RelationKind, priority_legend};
|
||||
use crate::util::{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.
|
||||
@@ -112,18 +112,7 @@ pub enum Command {
|
||||
|
||||
/// List tickets, optionally filtered by status
|
||||
#[command(after_help = PRIORITY_LEGEND.as_str())]
|
||||
Ls {
|
||||
/// Filter by status (backlog, committed, reviewing, done)
|
||||
status: Option<String>,
|
||||
|
||||
/// Only show tickets at this priority, 1 (most urgent) to 5 (least)
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
priority: Option<u8>,
|
||||
|
||||
/// Only show the members of this campaign, by UUID or title
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
campaign: Option<String>,
|
||||
},
|
||||
Ls(LsArgs),
|
||||
|
||||
/// Show a ticket by UUID or title
|
||||
Show {
|
||||
@@ -136,9 +125,9 @@ pub enum Command {
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
|
||||
/// Target status (backlog, committed, reviewing, done)
|
||||
/// Target status
|
||||
#[arg(short, long)]
|
||||
status: String,
|
||||
status: Status,
|
||||
|
||||
/// Force move (allows backward or non-sequential moves)
|
||||
#[arg(short, long)]
|
||||
@@ -181,10 +170,10 @@ pub enum Command {
|
||||
paths: Vec<std::path::PathBuf>,
|
||||
},
|
||||
|
||||
/// Tick an acceptance criterion
|
||||
/// Tick acceptance criteria
|
||||
Check(CheckArgs),
|
||||
|
||||
/// Untick an acceptance criterion
|
||||
/// Untick acceptance criteria
|
||||
Uncheck(CheckArgs),
|
||||
|
||||
/// Add a comment to a ticket
|
||||
@@ -223,6 +212,16 @@ pub enum Command {
|
||||
ticket: String,
|
||||
},
|
||||
|
||||
/// Print a shell completion script
|
||||
///
|
||||
/// The structure comes from the clap definition, so a flag added here appears
|
||||
/// without anyone remembering to. Fish gets a hand-written half appended for the
|
||||
/// values only the board knows, see `completions.rs`.
|
||||
Completions {
|
||||
/// fish, bash, zsh, elvish or powershell
|
||||
shell: clap_complete::Shell,
|
||||
},
|
||||
|
||||
/// Install the agent skills that teach an agent to use worklane
|
||||
///
|
||||
/// Every shipped document by default. The optional name narrows it to one, and
|
||||
@@ -284,6 +283,33 @@ pub struct CampaignAddArgs {
|
||||
pub owner: Option<String>,
|
||||
}
|
||||
|
||||
/// `ls` holds four filters, an output mode and nothing else, which is the boundary the
|
||||
/// Rust Style rule in AGENTS.md names: two of the filters are adjacent `Option<String>`
|
||||
/// values that a caller can swap silently, so the mode that joined them came as a
|
||||
/// struct rather than a sixth parameter, the way `add` became [`AddArgs`].
|
||||
#[derive(clap::Args)]
|
||||
pub struct LsArgs {
|
||||
/// Filter by status
|
||||
pub status: Option<Status>,
|
||||
|
||||
/// Only show tickets at this priority, 1 (most urgent) to 5 (least)
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
pub priority: Option<u8>,
|
||||
|
||||
/// Only show tickets carrying this tag, matched whole
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub tag: Option<String>,
|
||||
|
||||
/// Only show the members of this campaign, by UUID or title
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub campaign: Option<String>,
|
||||
|
||||
/// Print one ticket per line as its id and title, tab separated, for a script or a
|
||||
/// completion. Done included, and the filters still apply
|
||||
#[arg(long)]
|
||||
pub ids: bool,
|
||||
}
|
||||
|
||||
/// `add` carries every field a new ticket can hold, so it is a struct rather than an
|
||||
/// inline variant: nine parameters at the call site is what `too_many_arguments` is
|
||||
/// for, and `set`, `append` and `check` already pass their arguments this way.
|
||||
@@ -448,14 +474,20 @@ impl RelateArgs {
|
||||
/// because the two read as opposites at the call site and neither needs the other's
|
||||
/// name to make sense.
|
||||
///
|
||||
/// The criterion is optional: without it the criteria are listed and the index asked
|
||||
/// The criteria are optional: without any the criteria are listed and the index asked
|
||||
/// for, or, where there is no terminal to ask at, returned as an error carrying the
|
||||
/// same list.
|
||||
///
|
||||
/// Several terms in one call because finishing a ticket means ticking every box, and
|
||||
/// one invocation per box resolved the ticket and rewrote the file each time. The
|
||||
/// terms are variadic rather than a repeated flag: they address something that is
|
||||
/// already there, the way the ticket positional does, instead of carrying content the
|
||||
/// way `--acceptance` does.
|
||||
#[derive(clap::Args)]
|
||||
pub struct CheckArgs {
|
||||
/// Ticket UUID or title
|
||||
pub ticket: String,
|
||||
|
||||
/// Criterion index as shown by `show`, or a substring of its text. Prompts if omitted
|
||||
pub criterion: Option<String>,
|
||||
/// Criterion indexes as shown by `show`, substrings of their text, or `all`. Prompts if omitted
|
||||
pub criteria: Vec<String>,
|
||||
}
|
||||
|
||||
@@ -0,0 +1,293 @@
|
||||
//! Shell completions.
|
||||
//!
|
||||
//! Two halves, because neither alone is enough.
|
||||
//!
|
||||
//! `clap_complete` generates the structure (subcommands, flags, their arguments)
|
||||
//! straight from the clap definition, so a new flag never needs remembering here. But it
|
||||
//! can only offer values it knows at compile time, and the value worth completing for
|
||||
//! worklane is the ticket, which lives in the board the command is run above.
|
||||
//!
|
||||
//! So the fish output gets a hand-written block appended that asks worklane itself. That
|
||||
//! costs one `worklane ls --ids` per keypress, which measured at 2.5ms in release on a
|
||||
//! board of seventy-five tickets, comfortably below anything a person notices.
|
||||
//!
|
||||
//! The four statuses are half clap's: `Status` is a `ValueEnum`, so it emits them for
|
||||
//! `mv --status`, but the fish generator does not emit possible values for a *positional*
|
||||
//! and `ls <status>` gets nothing. Same for `completions <shell>`. So the block below
|
||||
//! lists those two, from the enums rather than by hand.
|
||||
|
||||
use std::io;
|
||||
|
||||
use clap::{CommandFactory, ValueEnum};
|
||||
use clap_complete::Shell;
|
||||
|
||||
use crate::install::SKILLS;
|
||||
use crate::util::Status;
|
||||
|
||||
/// Subcommands whose first positional is a ticket.
|
||||
///
|
||||
/// Kept honest by a test rather than by memory: a new ticket-taking subcommand that is
|
||||
/// missing here silently loses completion, which nothing else would catch.
|
||||
pub const TICKET_COMMANDS: [&str; 8] = [
|
||||
"show", "mv", "comment", "set", "append", "relate", "check", "uncheck",
|
||||
];
|
||||
|
||||
/// Subcommands whose *second* positional is the ticket, because they name two things.
|
||||
///
|
||||
/// `chown alice <ticket>` and `assign "v1 release" <ticket>`, which put the ticket
|
||||
/// second deliberately, see AGENTS.md. The first argument of each is a user or a
|
||||
/// campaign, and neither is completed.
|
||||
pub const TICKET_SECOND_COMMANDS: [&str; 2] = ["chown", "assign"];
|
||||
|
||||
/// Options whose value is a ticket, as `relate` takes three of.
|
||||
pub const TICKET_FLAGS: [&str; 3] = ["blocked-by", "regression-of", "relates-to"];
|
||||
|
||||
pub fn generate(shell: Shell, out: &mut dyn io::Write) -> io::Result<()> {
|
||||
let mut command = crate::command::Cli::command();
|
||||
clap_complete::generate(shell, &mut command, "worklane", out);
|
||||
|
||||
if shell == Shell::Fish {
|
||||
write!(out, "{}", fish_dynamic())?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The dynamic half, appended to what clap generated.
|
||||
///
|
||||
/// Fish merges completions from every `complete` call, so these add to the generated
|
||||
/// rules rather than replacing them.
|
||||
fn fish_dynamic() -> String {
|
||||
let ticket_commands = TICKET_COMMANDS.join(" ");
|
||||
let ticket_second_commands = TICKET_SECOND_COMMANDS.join(" ");
|
||||
let ticket_flags = TICKET_FLAGS
|
||||
.iter()
|
||||
.map(|flag| format!("-l {flag}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
let statuses = possible_values(Status::value_variants());
|
||||
let shells = possible_values(Shell::value_variants());
|
||||
let skills = SKILLS
|
||||
.iter()
|
||||
.map(|skill| skill.name)
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
|
||||
format!(
|
||||
r#"
|
||||
# ---------------------------------------------------------------------------
|
||||
# Dynamic values, appended by `worklane completions fish`. Fish accumulates
|
||||
# completions, so these add to the generated rules above.
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
# Almost every argument worklane takes names something on the board rather than
|
||||
# something on disk, so stop fish falling back to the directory listing. Without this,
|
||||
# `worklane show 1b78a24 <TAB>` offers Cargo.toml and src/.
|
||||
complete -c worklane -f
|
||||
|
||||
# The exception, and the reason the line above is not the whole story: `tui` takes
|
||||
# project paths, as many as you like. Directories only, since each is resolved to the
|
||||
# first `.worklane` at or above it.
|
||||
complete -c worklane -n '__fish_seen_subcommand_from tui' \
|
||||
-a '(__fish_complete_directories)' -d project
|
||||
|
||||
# Position is counted rather than inferred from what has been typed: matching against
|
||||
# the ticket list would run worklane again inside the condition, and would also keep
|
||||
# offering tickets after one had been chosen.
|
||||
#
|
||||
# The subcommand is the second token, so its first argument is being typed once two
|
||||
# tokens are there. `$tokens[2]` rather than `__fish_seen_subcommand_from`, because
|
||||
# `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen,
|
||||
# and their arguments are not what these complete.
|
||||
function __worklane_first_arg_of
|
||||
set -l tokens (commandline -opc)
|
||||
test (count $tokens) -eq 2; and contains -- $tokens[2] $argv
|
||||
end
|
||||
|
||||
function __worklane_second_arg_of
|
||||
set -l tokens (commandline -opc)
|
||||
test (count $tokens) -eq 3; and contains -- $tokens[2] $argv
|
||||
end
|
||||
|
||||
# No `-d`: `ls --ids` prints the id and the title separated by a tab, which is fish's
|
||||
# own form for a candidate and its description, so every ticket carries its own.
|
||||
complete -c worklane \
|
||||
-n '__worklane_first_arg_of {ticket_commands}; or __worklane_second_arg_of {ticket_second_commands}' \
|
||||
-a '(worklane ls --ids)'
|
||||
|
||||
# `relate` takes its targets as option values, so they are completed by flag rather
|
||||
# than by position.
|
||||
complete -c worklane {ticket_flags} -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.
|
||||
complete -c worklane -n '__worklane_first_arg_of ls' -a '{statuses}' -d status
|
||||
complete -c worklane -n '__worklane_first_arg_of completions' -a '{shells}' -d shell
|
||||
|
||||
# Shipped with the binary, so this list comes from `install::SKILLS` and cannot fall
|
||||
# behind it.
|
||||
complete -c worklane -n '__worklane_first_arg_of install-skill' -a '{skills}' -d skill
|
||||
"#
|
||||
)
|
||||
}
|
||||
|
||||
/// The names a `ValueEnum` accepts, for a fish `-a` list.
|
||||
///
|
||||
/// Read off the enum rather than written out, so a status or a shell added to either one
|
||||
/// is offered without anybody remembering this file. A variant marked hidden is left out,
|
||||
/// which is what `to_possible_value` returning `None` means.
|
||||
fn possible_values<T: ValueEnum>(variants: &[T]) -> String {
|
||||
variants
|
||||
.iter()
|
||||
.filter_map(|variant| variant.to_possible_value())
|
||||
.map(|value| value.get_name().to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Built, not just derived: an index is assigned when the command is built, and the
|
||||
/// positionals of an unbuilt one all report `None`.
|
||||
fn command() -> clap::Command {
|
||||
let mut cli = crate::command::Cli::command();
|
||||
cli.build();
|
||||
cli
|
||||
}
|
||||
|
||||
/// Every subcommand that takes a ticket must be listed, at the position it takes it,
|
||||
/// or it silently loses completion.
|
||||
///
|
||||
/// The nested subcommands are not walked. `campaign` is the only one, none of its
|
||||
/// three takes a ticket, and the token counting above could not tell them apart if
|
||||
/// one did. A ticket argument added under `campaign` needs the fish block reworked,
|
||||
/// not another name in a list.
|
||||
#[test]
|
||||
fn no_ticket_taking_subcommand_is_missing() {
|
||||
for subcommand in command().get_subcommands() {
|
||||
let name = subcommand.get_name();
|
||||
for positional in subcommand.get_positionals() {
|
||||
// `show` calls it `id`; everything else calls it `ticket`.
|
||||
if !matches!(positional.get_id().as_str(), "ticket" | "id") {
|
||||
continue;
|
||||
}
|
||||
match positional.get_index() {
|
||||
Some(1) => assert!(
|
||||
TICKET_COMMANDS.contains(&name),
|
||||
"`worklane {name}` takes a ticket first but is not in TICKET_COMMANDS"
|
||||
),
|
||||
Some(2) => assert!(
|
||||
TICKET_SECOND_COMMANDS.contains(&name),
|
||||
"`worklane {name}` takes a ticket second but is not in \
|
||||
TICKET_SECOND_COMMANDS"
|
||||
),
|
||||
index => panic!("`worklane {name}` takes a ticket at position {index:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_listed_command_is_a_real_subcommand() {
|
||||
let cli = command();
|
||||
let known: Vec<&str> = cli.get_subcommands().map(|c| c.get_name()).collect();
|
||||
for name in TICKET_COMMANDS.iter().chain(TICKET_SECOND_COMMANDS.iter()) {
|
||||
assert!(known.contains(name), "no such subcommand: {name}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The flags completed as tickets have to be `relate`'s actual flags, or the rule
|
||||
/// completes an option nothing accepts.
|
||||
#[test]
|
||||
fn every_ticket_flag_is_a_real_option() {
|
||||
let relate = command()
|
||||
.find_subcommand("relate")
|
||||
.expect("relate exists")
|
||||
.clone();
|
||||
let known: Vec<String> = relate
|
||||
.get_arguments()
|
||||
.filter_map(|arg| arg.get_long().map(str::to_string))
|
||||
.collect();
|
||||
for flag in TICKET_FLAGS {
|
||||
assert!(
|
||||
known.contains(&flag.to_string()),
|
||||
"`relate` has no --{flag}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_fish_script_asks_worklane_for_its_tickets() {
|
||||
let script = fish_dynamic();
|
||||
assert!(script.contains("worklane ls --ids"));
|
||||
// Both positions, in one rule.
|
||||
assert!(script.contains("__worklane_first_arg_of show"));
|
||||
assert!(script.contains("__worklane_second_arg_of chown assign"));
|
||||
// Nothing here takes a file, bar the one that does.
|
||||
assert!(script.contains("complete -c worklane -f\n"));
|
||||
assert!(script.contains("__fish_complete_directories"));
|
||||
// Generated from `install::SKILLS`, so every shipped skill is in it.
|
||||
assert!(script.contains("worklane-review"));
|
||||
}
|
||||
|
||||
/// The one status positional and the one shell positional, which clap does not emit
|
||||
/// possible values for. Read off the enums, so a fifth status would appear here on
|
||||
/// its own.
|
||||
#[test]
|
||||
fn the_fish_script_lists_the_statuses_and_the_shells() {
|
||||
let script = fish_dynamic();
|
||||
for status in Status::ALL {
|
||||
assert!(
|
||||
script.contains(status.as_str()),
|
||||
"the ls positional is never offered {}",
|
||||
status.as_str()
|
||||
);
|
||||
}
|
||||
assert!(script.contains("-a 'backlog committed reviewing done' -d status"));
|
||||
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
|
||||
assert!(script.contains(shell), "the shell positional is never offered {shell}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The four for `mv --status` are clap's, which is half of why `Status` is a
|
||||
/// `ValueEnum`. If clap ever stops emitting them, the fish half has to carry them
|
||||
/// too, and this is what says so.
|
||||
#[test]
|
||||
fn clap_emits_the_statuses_for_the_status_flag() {
|
||||
let mut out = Vec::new();
|
||||
generate(Shell::Fish, &mut out).expect("generates");
|
||||
let script = String::from_utf8(out).expect("utf8");
|
||||
let flag = script
|
||||
.lines()
|
||||
.find(|line| line.contains("using_subcommand mv") && line.contains("-l status"))
|
||||
.expect("mv --status has a rule of its own");
|
||||
assert!(flag.contains("backlog"), "{flag}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generating_fish_produces_both_halves() {
|
||||
let mut out = Vec::new();
|
||||
generate(Shell::Fish, &mut out).expect("generates");
|
||||
let script = String::from_utf8(out).expect("utf8");
|
||||
// clap's half.
|
||||
assert!(script.contains("complete -c worklane"));
|
||||
assert!(script.contains("install-skill"));
|
||||
// Ours.
|
||||
assert!(script.contains("__worklane_first_arg_of"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_shells_get_only_the_generated_half() {
|
||||
for shell in [Shell::Bash, Shell::Zsh] {
|
||||
let mut out = Vec::new();
|
||||
generate(shell, &mut out).expect("generates");
|
||||
let script = String::from_utf8(out).expect("utf8");
|
||||
assert!(
|
||||
!script.contains("__worklane_first_arg_of"),
|
||||
"fish-only helpers leaked into {shell}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
+216
-88
@@ -5,7 +5,9 @@ use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::campaign::*;
|
||||
use crate::command::{AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, RelateArgs, SetArgs};
|
||||
use crate::command::{
|
||||
AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, LsArgs, RelateArgs, SetArgs,
|
||||
};
|
||||
use crate::install;
|
||||
use crate::util::*;
|
||||
|
||||
@@ -23,8 +25,7 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
|
||||
fs::create_dir_all(&worklane_dir)?;
|
||||
|
||||
let folders = ["backlog", "committed", "reviewing", "done"];
|
||||
for folder in &folders {
|
||||
for folder in status_dirs() {
|
||||
fs::create_dir_all(worklane_dir.join(folder))?;
|
||||
}
|
||||
|
||||
@@ -37,19 +38,22 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_ls(
|
||||
status_filter: &Option<String>,
|
||||
priority_filter: Option<u8>,
|
||||
campaign_filter: &Option<String>,
|
||||
worklane_dir: &Path,
|
||||
) -> Result<()> {
|
||||
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
// Resolved before anything is read, so an unknown campaign is refused rather than
|
||||
// silently listing nothing, and the name is available for the heading.
|
||||
let campaign = match campaign_filter {
|
||||
// silently listing nothing, and the name is available for the heading. Ahead of the
|
||||
// `--ids` branch too: a completion that quietly listed the whole board because the
|
||||
// campaign was misspelled would be worse than one that printed nothing.
|
||||
let campaign = match &args.campaign {
|
||||
Some(search) => Some(resolve_campaign(search, worklane_dir)?),
|
||||
None => None,
|
||||
};
|
||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
||||
let tag = args.tag.as_deref();
|
||||
let priority_filter = args.priority;
|
||||
|
||||
if args.ids {
|
||||
return list_ids(args.status, priority_filter, uuid, tag, worklane_dir);
|
||||
}
|
||||
|
||||
if let Some(campaign) = &campaign {
|
||||
println!(
|
||||
@@ -59,16 +63,22 @@ pub fn cmd_ls(
|
||||
);
|
||||
}
|
||||
|
||||
if let Some(status) = status_filter {
|
||||
if let Some(status) = args.status {
|
||||
let status = status.as_str();
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
// The status itself is clap's to reject now, so reaching here means the
|
||||
// board is missing a directory it should have rather than that the name was
|
||||
// mistyped. `init` will not repair it: it leaves an existing `.worklane`
|
||||
// alone.
|
||||
return Err(anyhow!(
|
||||
"Status '{}' not found. Valid statuses: backlog, committed, reviewing, done",
|
||||
status
|
||||
"No '{}' directory in {}. Every board has all four; creating it is enough.",
|
||||
status,
|
||||
worklane_dir.display()
|
||||
));
|
||||
}
|
||||
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid);
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid, tag);
|
||||
|
||||
if items.is_empty() {
|
||||
println!("No tickets in '{}' status.", status);
|
||||
@@ -86,7 +96,7 @@ pub fn cmd_ls(
|
||||
if !status_path.exists() {
|
||||
continue;
|
||||
}
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid);
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid, tag);
|
||||
let count = items.len();
|
||||
let label = if count == 1 { "ticket" } else { "tickets" };
|
||||
println!(" [{}] {} {}", status.to_uppercase(), count, label);
|
||||
@@ -102,7 +112,7 @@ pub fn cmd_ls(
|
||||
continue;
|
||||
}
|
||||
let items = match collect_ticket_items(&status_path) {
|
||||
Ok(items) => filtered(items, priority_filter, uuid),
|
||||
Ok(items) => filtered(items, priority_filter, uuid, tag),
|
||||
Err(_) => continue,
|
||||
};
|
||||
if items.is_empty() {
|
||||
@@ -117,10 +127,81 @@ pub fn cmd_ls(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The machine-readable listing: one ticket per line, its short id then its title,
|
||||
/// separated by a tab and unstyled.
|
||||
///
|
||||
/// Two fields rather than the id alone because both readers want both. Fish takes what
|
||||
/// follows the tab as the description, which is what makes `worklane show <TAB>` a list
|
||||
/// of titles rather than of hex, and a script takes the id back out with `cut -f1`. The
|
||||
/// id is the same seven characters the listing prints, which is what a ticket is
|
||||
/// addressed by.
|
||||
///
|
||||
/// Every status, done included, where the listing above leaves done out. A completion has
|
||||
/// to be able to name a finished ticket, since `show` and `comment` are most often
|
||||
/// pointed at one, and the status positional still narrows it.
|
||||
///
|
||||
/// A missing status directory is skipped rather than refused, which is the one place this
|
||||
/// parts company with the listing. The caller is usually a shell filling in a candidate
|
||||
/// list, and an error printed over the prompt is worse there than no candidates.
|
||||
fn list_ids(
|
||||
status: Option<Status>,
|
||||
level: Option<u8>,
|
||||
campaign: Option<&str>,
|
||||
tag: Option<&str>,
|
||||
worklane_dir: &Path,
|
||||
) -> Result<()> {
|
||||
let statuses = match status {
|
||||
Some(status) => vec![status.as_str()],
|
||||
None => status_dirs(),
|
||||
};
|
||||
|
||||
for status in statuses {
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
continue;
|
||||
}
|
||||
for item in filtered(collect_ticket_items(&status_path)?, level, campaign, tag) {
|
||||
println!("{}\t{}", item.id, item.title);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The listing filters in one call, so the three places `ls` collects a column cannot
|
||||
/// end up applying a different set of them.
|
||||
fn filtered(items: Vec<TicketItem>, level: Option<u8>, campaign: Option<&str>) -> Vec<TicketItem> {
|
||||
filter_by_campaign(filter_by_priority(items, level), campaign)
|
||||
///
|
||||
/// Every filter is `Option`, and none asked for is everything kept, which is what makes
|
||||
/// them compose in any combination without a rule per pair.
|
||||
fn filtered(
|
||||
items: Vec<TicketItem>,
|
||||
level: Option<u8>,
|
||||
campaign: Option<&str>,
|
||||
tag: Option<&str>,
|
||||
) -> Vec<TicketItem> {
|
||||
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.
|
||||
///
|
||||
/// Matched against the whole values `parse_tags` split out of the field rather than as a
|
||||
/// substring of it, so `--tag bug` is not answered by a ticket tagged `bugfix`, and a
|
||||
/// ticket with no tags matches nothing at all.
|
||||
///
|
||||
/// Case sensitive, the opinion the field already takes everywhere else: `tag_color`
|
||||
/// draws `Bug` and `bug` in two colours because they are two tags, and a filter that
|
||||
/// folded them would list tickets carrying a tag nobody asked for.
|
||||
fn filter_by_tag(items: Vec<TicketItem>, tag: Option<&str>) -> Vec<TicketItem> {
|
||||
match tag {
|
||||
Some(tag) => items
|
||||
.into_iter()
|
||||
.filter(|item| item.tags.iter().any(|carried| carried == tag))
|
||||
.collect(),
|
||||
None => items,
|
||||
}
|
||||
}
|
||||
|
||||
/// Keep only the members of `campaign`, or everything when none was asked for.
|
||||
@@ -530,29 +611,20 @@ fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()>
|
||||
))
|
||||
}
|
||||
|
||||
pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -> Result<()> {
|
||||
let valid_statuses = ["backlog", "committed", "reviewing", "done"];
|
||||
let forward_order = ["backlog", "committed", "reviewing", "done"];
|
||||
|
||||
if !valid_statuses.contains(&target_status) {
|
||||
return Err(anyhow!(
|
||||
"Invalid target status '{}'. Valid statuses: {}",
|
||||
target_status,
|
||||
valid_statuses.join(", ")
|
||||
));
|
||||
}
|
||||
/// A status is a [`Status`] rather than a string, so an unknown one is clap's to refuse
|
||||
/// and nothing here has to check. What is left is the order of the flow, which is
|
||||
/// `Status::ALL`.
|
||||
pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Result<()> {
|
||||
let target_status = target.as_str();
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (current_status, title, resolved) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
|
||||
let current_idx = forward_order
|
||||
let current_idx = Status::ALL
|
||||
.iter()
|
||||
.position(|&s| s == current_status)
|
||||
.unwrap();
|
||||
let target_idx = forward_order
|
||||
.iter()
|
||||
.position(|&s| s == target_status)
|
||||
.position(|status| status.as_str() == current_status)
|
||||
.unwrap();
|
||||
let target_idx = Status::ALL.iter().position(|status| *status == target).unwrap();
|
||||
|
||||
if !force && target_idx < current_idx {
|
||||
return Err(anyhow!(
|
||||
@@ -590,6 +662,16 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
|
||||
// refused for that reason rather than for whatever the lookup notices first.
|
||||
let content = set_status_field(&resolved, target_status, &title)?;
|
||||
|
||||
// Behind every refusal above, so a move that does not happen writes no stamp, and
|
||||
// spliced in here rather than after the rename so it travels with the same
|
||||
// crash-safe write the Status field does.
|
||||
let content = set_status_stamp(
|
||||
&content,
|
||||
target,
|
||||
&Local::now().format(TIMESTAMP_FORMAT).to_string(),
|
||||
&title,
|
||||
)?;
|
||||
|
||||
let found_filename =
|
||||
find_ticket_file(¤t_path, &parse_ticket_field(&resolved, "ID"), &title)?;
|
||||
|
||||
@@ -1121,6 +1203,66 @@ fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Every criterion the terms name, in the order `show` numbers them and without
|
||||
/// repeats.
|
||||
///
|
||||
/// Resolved before a byte is written, and one bad term refuses the whole batch. A call
|
||||
/// that ticked the terms it understood and then failed would leave the ticket
|
||||
/// half-marked, with nothing in the file to say which half the caller meant, and the
|
||||
/// obvious retry would be reading the ticket back to find out.
|
||||
///
|
||||
/// The offending term is named on its own rather than every failure at once: each
|
||||
/// message carries the criteria listing, so a batch of them would repeat the list per
|
||||
/// bad term and bury the first one.
|
||||
fn resolve_criteria(criteria: &[Criterion], terms: &[String], title: &str) -> Result<Vec<usize>> {
|
||||
let mut chosen: Vec<usize> = Vec::new();
|
||||
|
||||
for term in terms {
|
||||
if is_all_criteria(term) {
|
||||
chosen.extend(0..criteria.len());
|
||||
continue;
|
||||
}
|
||||
|
||||
let found = find_criteria(criteria, term);
|
||||
match found.len() {
|
||||
1 => chosen.push(found[0]),
|
||||
0 if is_index(term) => {
|
||||
return Err(anyhow!(
|
||||
"'{}' is not one of the {} criteria of '{}':\n{}",
|
||||
term.trim(),
|
||||
criteria.len(),
|
||||
title,
|
||||
criteria_list(criteria)
|
||||
));
|
||||
}
|
||||
0 => {
|
||||
return Err(anyhow!(
|
||||
"No criterion of '{}' matches '{}'. Its criteria are:\n{}",
|
||||
title,
|
||||
term,
|
||||
criteria_list(criteria)
|
||||
));
|
||||
}
|
||||
_ => {
|
||||
return Err(anyhow!(
|
||||
"'{}' matches {} criteria of '{}':\n{}\n\nUse the number instead.",
|
||||
term,
|
||||
found.len(),
|
||||
title,
|
||||
numbered_criteria(criteria, &found)
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sorted so the report reads in the order `show` numbers the criteria whatever
|
||||
// order the terms arrived in, and deduped so a criterion named twice, or by both
|
||||
// `all` and its own number, is reported once.
|
||||
chosen.sort_unstable();
|
||||
chosen.dedup();
|
||||
Ok(chosen)
|
||||
}
|
||||
|
||||
pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, content) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
@@ -1130,64 +1272,50 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
return Err(anyhow!("Ticket '{}' has no acceptance criteria", title));
|
||||
}
|
||||
|
||||
let chosen = match &args.criterion {
|
||||
None => ask_which_criterion(&criteria, &title)?,
|
||||
Some(search) => {
|
||||
let found = find_criteria(&criteria, search);
|
||||
match found.len() {
|
||||
1 => found[0],
|
||||
0 if is_index(search) => {
|
||||
return Err(anyhow!(
|
||||
"'{}' is not one of the {} criteria of '{}':\n{}",
|
||||
search.trim(),
|
||||
criteria.len(),
|
||||
title,
|
||||
criteria_list(&criteria)
|
||||
));
|
||||
}
|
||||
0 => {
|
||||
return Err(anyhow!(
|
||||
"No criterion of '{}' matches '{}'. Its criteria are:\n{}",
|
||||
title,
|
||||
search,
|
||||
criteria_list(&criteria)
|
||||
));
|
||||
}
|
||||
_ => {
|
||||
return Err(anyhow!(
|
||||
"'{}' matches {} criteria of '{}':\n{}\n\nUse the number instead.",
|
||||
search,
|
||||
found.len(),
|
||||
title,
|
||||
numbered_criteria(&criteria, &found)
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
let chosen = match args.criteria.as_slice() {
|
||||
[] => vec![ask_which_criterion(&criteria, &title)?],
|
||||
terms => resolve_criteria(&criteria, terms, &title)?,
|
||||
};
|
||||
|
||||
let criterion = &criteria[chosen];
|
||||
let verb = if checked { "checked" } else { "unchecked" };
|
||||
// Only the criteria that are not already in the target state, so a batch where
|
||||
// every box is already ticked writes nothing, the way a single one always has.
|
||||
let changing: Vec<usize> = chosen
|
||||
.iter()
|
||||
.copied()
|
||||
.filter(|offset| criteria[*offset].checked != checked)
|
||||
.collect();
|
||||
|
||||
if criterion.checked == checked {
|
||||
println!(
|
||||
"Already {}: {}",
|
||||
verb,
|
||||
color_text(&criterion.text, Color::Green)
|
||||
);
|
||||
return Ok(());
|
||||
if !changing.is_empty() {
|
||||
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)?;
|
||||
}
|
||||
|
||||
let updated = set_criterion(&content, criterion.line, checked);
|
||||
let uuid = parse_ticket_field(&content, "ID");
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
|
||||
// Reported after the write, one line per criterion the call named, so nothing
|
||||
// claims a mark the file does not carry.
|
||||
let verb = if checked { "checked" } else { "unchecked" };
|
||||
let past = if checked { "Checked" } else { "Unchecked" };
|
||||
|
||||
for offset in chosen {
|
||||
let criterion = &criteria[offset];
|
||||
let state = if criterion.checked == checked {
|
||||
format!("Already {}", verb)
|
||||
} else {
|
||||
past.to_string()
|
||||
};
|
||||
|
||||
println!(
|
||||
"{} {}: {}",
|
||||
state,
|
||||
offset + 1,
|
||||
color_text(&criterion.text, Color::Green)
|
||||
);
|
||||
}
|
||||
|
||||
println!(
|
||||
"{} {}: {}",
|
||||
if checked { "Checked" } else { "Unchecked" },
|
||||
chosen + 1,
|
||||
color_text(&criterion.text, Color::Green)
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
+9
-7
@@ -4,6 +4,7 @@ use clap::Parser;
|
||||
mod campaign;
|
||||
mod clipboard;
|
||||
mod command;
|
||||
mod completions;
|
||||
mod handlers;
|
||||
mod install;
|
||||
mod tui;
|
||||
@@ -46,13 +47,9 @@ fn main() -> Result<()> {
|
||||
Some(Command::Tui { paths }) => run_tui(&paths, &start),
|
||||
Some(Command::Init) => cmd_init(&start),
|
||||
Some(Command::Add(args)) => cmd_add(&args, &start),
|
||||
Some(Command::Ls {
|
||||
status,
|
||||
priority,
|
||||
campaign,
|
||||
}) => {
|
||||
Some(Command::Ls(args)) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_ls(&status, priority, &campaign, &worklane_dir)
|
||||
cmd_ls(&args, &worklane_dir)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
@@ -62,7 +59,7 @@ fn main() -> Result<()> {
|
||||
ticket,
|
||||
status,
|
||||
force,
|
||||
}) => cmd_mv(&ticket, &status, force, &start),
|
||||
}) => 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),
|
||||
@@ -86,6 +83,11 @@ fn main() -> Result<()> {
|
||||
}
|
||||
},
|
||||
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
|
||||
// No board either, for the reason `install-skill` has none: a completion script
|
||||
// is generated from the clap definition and is the same wherever it is run.
|
||||
Some(Command::Completions { shell }) => {
|
||||
completions::generate(shell, &mut std::io::stdout()).map_err(Into::into)
|
||||
}
|
||||
// No board is looked for: the point of the skill is to teach an agent worklane
|
||||
// before there is a `.worklane` anywhere.
|
||||
Some(Command::InstallSkill { skill, force, print }) => {
|
||||
|
||||
+684
-54
@@ -16,7 +16,7 @@ use anyhow::{Context, Result};
|
||||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||||
use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect, Size};
|
||||
use ratatui::style::{Modifier, Style};
|
||||
use ratatui::text::{Line, Span};
|
||||
use ratatui::text::{Line, Span, Text};
|
||||
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs, Wrap};
|
||||
use ratatui::Frame;
|
||||
|
||||
@@ -202,7 +202,35 @@ pub struct Detail {
|
||||
/// card that said so, and the id alone is not an address across several boards:
|
||||
/// acting on the ticket means knowing which project to run the command in.
|
||||
pub project: Option<String>,
|
||||
pub text: String,
|
||||
/// The body as the overlay draws it: lines of styled spans, not a string.
|
||||
///
|
||||
/// Styled here rather than painted into the text, because ratatui draws an escape
|
||||
/// sequence in a paragraph as literal bytes, which is 6d327df. It is also the one
|
||||
/// value the clamp and the draw both measure, so neither can wrap it differently
|
||||
/// from the other.
|
||||
pub body: Text<'static>,
|
||||
}
|
||||
|
||||
impl Detail {
|
||||
/// The body as plain text, one line per drawn line.
|
||||
///
|
||||
/// Only the suite asks: it is what an assertion about the body reads, and what shows
|
||||
/// that no escape sequence reached it. Nothing in the draw path needs it, so it is
|
||||
/// not carried alongside the spans where the two could disagree.
|
||||
#[cfg(test)]
|
||||
pub fn plain(&self) -> String {
|
||||
self.body
|
||||
.lines
|
||||
.iter()
|
||||
.map(|line| {
|
||||
line.spans
|
||||
.iter()
|
||||
.map(|span| span.content.as_ref())
|
||||
.collect::<String>()
|
||||
})
|
||||
.collect::<Vec<String>>()
|
||||
.join("\n")
|
||||
}
|
||||
}
|
||||
|
||||
/// The open search prompt: what has been typed, and whether the last enter missed.
|
||||
@@ -702,7 +730,7 @@ impl Board {
|
||||
let text = detail_text_area(Rect::new(0, 0, screen.width, screen.height));
|
||||
// A screenful less a line, so the eye has something to land on after the jump.
|
||||
let step = text.height.saturating_sub(1).max(1) as isize;
|
||||
let last = last_offset(&detail.text, text) as isize;
|
||||
let last = last_offset(&detail.body, text) as isize;
|
||||
|
||||
self.offset = (self.offset as isize + pages.saturating_mul(step)).clamp(0, last) as u16;
|
||||
}
|
||||
@@ -744,15 +772,73 @@ fn detail_of(card: &Card) -> Detail {
|
||||
None => Vec::new(),
|
||||
};
|
||||
|
||||
let mut out = content_trim(&content, false, &resolved);
|
||||
// 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)
|
||||
)));
|
||||
|
||||
out.push('\n');
|
||||
out.push_str(&format_comments_with(&comments, false));
|
||||
Detail {
|
||||
title: ticket.title.clone(),
|
||||
id: ticket.id.clone(),
|
||||
project: card.project.clone(),
|
||||
text: out,
|
||||
body: detail_body(&parts),
|
||||
}
|
||||
}
|
||||
|
||||
/// The rendered body as lines of spans: the text split where it says, and each relation
|
||||
/// row styled from the cells the CLI paints.
|
||||
///
|
||||
/// A part that does not end on a newline runs on into the next one rather than closing a
|
||||
/// line, so the seam between text and relations is wherever the body actually put it and
|
||||
/// not wherever a part happened to end.
|
||||
fn detail_body(parts: &[BodyPart]) -> Text<'static> {
|
||||
let mut lines: Vec<Line<'static>> = Vec::new();
|
||||
let mut open: Vec<Span<'static>> = Vec::new();
|
||||
|
||||
for part in parts {
|
||||
match part {
|
||||
BodyPart::Text(text) => {
|
||||
let mut rest = text.as_str();
|
||||
while let Some((line, tail)) = rest.split_once('\n') {
|
||||
if !line.is_empty() {
|
||||
open.push(Span::raw(line.to_string()));
|
||||
}
|
||||
lines.push(Line::from(std::mem::take(&mut open)));
|
||||
rest = tail;
|
||||
}
|
||||
if !rest.is_empty() {
|
||||
open.push(Span::raw(rest.to_string()));
|
||||
}
|
||||
}
|
||||
// One line each, from the same cells `render_relations` paints, so the block
|
||||
// cannot read differently here than it does in `show`.
|
||||
BodyPart::Relations(rows) => {
|
||||
for row in relation_cells(rows) {
|
||||
open.extend(row.into_iter().map(span_of));
|
||||
lines.push(Line::from(std::mem::take(&mut open)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !open.is_empty() {
|
||||
lines.push(Line::from(open));
|
||||
}
|
||||
|
||||
Text::from(lines)
|
||||
}
|
||||
|
||||
/// A cell as the board draws it: the same text in the same colour, as a span.
|
||||
///
|
||||
/// The other half of `paint_cells`, which is the CLI's. `From<Color>` is what makes the
|
||||
/// two agree about what the colour is.
|
||||
fn span_of(cell: Cell) -> Span<'static> {
|
||||
match cell.color {
|
||||
Some(color) => Span::styled(cell.text, Style::default().fg(color.into())),
|
||||
None => Span::raw(cell.text),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1123,15 +1209,6 @@ fn aligned_offset(offset: u16, start: u16, end: u16, inner: u16, total: u16) ->
|
||||
offset.min(total.saturating_sub(inner))
|
||||
}
|
||||
|
||||
/// The mark a card carries while it waits on a ticket that is not done.
|
||||
///
|
||||
/// Not a fourth circle. The Geometric Shapes glyphs belong to the priority meter, and
|
||||
/// another one two cells away from it would read as part of that ramp rather than as a
|
||||
/// different fact. A multiplication sign is Latin-1, like the middle dot the unset
|
||||
/// priority draws, so it renders wherever the meter already does. That is the same
|
||||
/// safe-glyph rule that took the quadrant circles out of the ramp.
|
||||
const BLOCKED_MARK: &str = "\u{d7}";
|
||||
|
||||
/// One card as four corners with the title between them:
|
||||
///
|
||||
/// ```text
|
||||
@@ -1566,29 +1643,87 @@ fn detail_text_area(area: Rect) -> Rect {
|
||||
detail_overlay(area).inner(Margin::new(1, 1))
|
||||
}
|
||||
|
||||
/// The furthest the detail view can scroll: the last screenful, and no further.
|
||||
/// How tall the detail body is once wrapped to `width`.
|
||||
///
|
||||
/// Measured by the widget rather than counted by hand, since it wraps on words. A clamp
|
||||
/// on the raw lines would stop short of the end on a wrapped ticket, and one that
|
||||
/// ignored the wrapping the other way would scroll past it into blank space.
|
||||
fn last_offset(detail: &str, text: Rect) -> u16 {
|
||||
let wrapped = Paragraph::new(detail)
|
||||
/// Measured by the widget rather than counted by hand, since it wraps on words. A count
|
||||
/// of the raw lines would stop short of the end on a wrapped ticket, and one that
|
||||
/// ignored the wrapping the other way would run past it into blank space.
|
||||
///
|
||||
/// The one place the number comes from. The scroll clamp and the page indicator are both
|
||||
/// derived from it, and two measurements are two numbers free to disagree: an indicator
|
||||
/// saying there is more to read where the scroll refuses to move is worse than no
|
||||
/// indicator at all.
|
||||
fn wrapped_height(detail: &Text<'static>, width: u16) -> u16 {
|
||||
let wrapped = Paragraph::new(detail.clone())
|
||||
.wrap(Wrap { trim: false })
|
||||
.line_count(text.width);
|
||||
.line_count(width);
|
||||
|
||||
u16::try_from(wrapped)
|
||||
.unwrap_or(u16::MAX)
|
||||
.saturating_sub(text.height)
|
||||
u16::try_from(wrapped).unwrap_or(u16::MAX)
|
||||
}
|
||||
|
||||
/// The furthest the detail view can scroll: the last screenful, and no further.
|
||||
fn last_offset(detail: &Text<'static>, text: Rect) -> u16 {
|
||||
wrapped_height(detail, text.width).saturating_sub(text.height)
|
||||
}
|
||||
|
||||
/// The step `scroll_detail` takes, a screenful less the line kept for overlap.
|
||||
///
|
||||
/// The page numbers are counted in it rather than in whole screenfuls, so the pages the
|
||||
/// indicator names are the ones the keys can actually land on. Counting by screenfuls
|
||||
/// would put a 30 line ticket in a 10 line viewport at `pg 3/3` two rows short of its
|
||||
/// end, since three presses are what it takes to get there.
|
||||
fn scroll_step(height: u16) -> u16 {
|
||||
height.saturating_sub(1).max(1)
|
||||
}
|
||||
|
||||
/// Where the reader is, as `pg 2/5`, or `None` when there is nothing to say or no room
|
||||
/// to say it in.
|
||||
///
|
||||
/// `offset` has to be clamped already and `last` is what it was clamped against, so this
|
||||
/// is arithmetic on the one wrapped measurement rather than a second look at the text.
|
||||
///
|
||||
/// **The furthest offset is the last page by definition, not by division.** The clamp
|
||||
/// stops at `last`, which is the wrapped height less the viewport and not a page
|
||||
/// boundary, so the final screenful is partial: dividing there reads `pg 2/3` at the
|
||||
/// bottom of the ticket and claims there is more to read.
|
||||
fn page_indicator(offset: u16, last: u16, height: u16, overlay_width: u16) -> Option<String> {
|
||||
// Nothing scrolls, so there are no pages to be on. A ticket that fits spends no
|
||||
// indicator, the way an untagged card spends no row on tags.
|
||||
if last == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let step = scroll_step(height);
|
||||
let total = last.div_ceil(step).saturating_add(1);
|
||||
let page = match offset >= last {
|
||||
true => total,
|
||||
false => offset / step + 1,
|
||||
};
|
||||
|
||||
let indicator = format!(" pg {page}/{total} ");
|
||||
|
||||
// Dropped whole rather than cut, the rule a card's corner follows: half a page number
|
||||
// reads as a different one. Measured against the inner width, since the two border
|
||||
// columns are not the indicator's to write on. The title cannot be crowded by this
|
||||
// however narrow the overlay gets, because the two sit on opposite borders.
|
||||
match indicator.chars().count() <= overlay_width.saturating_sub(2) as usize {
|
||||
true => Some(indicator),
|
||||
false => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn draw_detail(frame: &mut Frame, detail: &Detail, offset: u16, area: Rect) {
|
||||
let overlay = detail_overlay(area);
|
||||
let text = detail_text_area(area);
|
||||
|
||||
// Clamped here as well as on the keypress: the terminal may have been resized since,
|
||||
// and a ticket read to its end can grow shorter under a tick.
|
||||
let offset = offset.min(last_offset(&detail.text, detail_text_area(area)));
|
||||
// One measurement, two derivations. Clamped here as well as on the keypress: the
|
||||
// terminal may have been resized since, and a ticket read to its end can grow
|
||||
// shorter under a tick. Which is also what repages the indicator, since the wrapped
|
||||
// count and the viewport both move with the width.
|
||||
let last = wrapped_height(&detail.body, text.width).saturating_sub(text.height);
|
||||
let offset = offset.min(last);
|
||||
|
||||
let block = Block::default()
|
||||
let mut block = Block::default()
|
||||
.borders(Borders::ALL)
|
||||
.border_style(Style::default().fg(Color::Cyan.into()))
|
||||
.title(Span::styled(
|
||||
@@ -1596,9 +1731,23 @@ fn draw_detail(frame: &mut Frame, detail: &Detail, offset: u16, area: Rect) {
|
||||
Style::default().fg(Color::Orange.into()),
|
||||
));
|
||||
|
||||
// On the bottom border, so it costs no text row, which is the trade the title already
|
||||
// makes on the top one. Grey because it is chrome: it says where you are in the
|
||||
// ticket rather than anything about the ticket, so it takes the colour the footer
|
||||
// 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(),
|
||||
);
|
||||
}
|
||||
|
||||
frame.render_widget(Clear, overlay);
|
||||
frame.render_widget(
|
||||
Paragraph::new(detail.text.to_string())
|
||||
Paragraph::new(detail.body.clone())
|
||||
.block(block)
|
||||
.wrap(Wrap { trim: false })
|
||||
.scroll((offset, 0)),
|
||||
@@ -1769,6 +1918,31 @@ mod tests {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The overlay's bottom border row, where the page indicator sits.
|
||||
fn overlay_bottom_row(lines: &[String], width: u16, height: u16) -> String {
|
||||
let overlay = detail_overlay(Rect::new(0, 0, width, height));
|
||||
lines[(overlay.y + overlay.height - 1) as usize]
|
||||
.chars()
|
||||
.skip(overlay.x as usize)
|
||||
.take(overlay.width as usize)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A board with one ticket long enough to scroll, opened on it.
|
||||
fn scrolling_board(dir: &Path, lines: usize) -> Board {
|
||||
write_ticket(
|
||||
dir,
|
||||
"backlog",
|
||||
"11111111-0000-4000-8000-000000000000",
|
||||
"A long one",
|
||||
&long_section(lines),
|
||||
);
|
||||
|
||||
let mut board = one_board(dir);
|
||||
board.toggle_detail();
|
||||
board
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_board_draws_the_four_statuses_as_columns_once_done_is_shown() {
|
||||
let dir = board_dir();
|
||||
@@ -2571,16 +2745,16 @@ mod tests {
|
||||
board.toggle_detail();
|
||||
let detail = board.detail.as_ref().expect("no detail");
|
||||
|
||||
assert!(detail.text.contains("A description."), "{}", detail.text);
|
||||
assert!(detail.text.contains("Crit one"), "{}", detail.text);
|
||||
assert!(detail.text.contains("A note from elsewhere."), "{}", detail.text);
|
||||
assert!(detail.text.contains("bob"), "{}", detail.text);
|
||||
assert!(detail.plain().contains("A description."), "{}", detail.plain());
|
||||
assert!(detail.plain().contains("Crit one"), "{}", detail.plain());
|
||||
assert!(detail.plain().contains("A note from elsewhere."), "{}", detail.plain());
|
||||
assert!(detail.plain().contains("bob"), "{}", detail.plain());
|
||||
|
||||
// Plain text, since ratatui would print an escape as literal bytes
|
||||
assert!(
|
||||
!detail.text.contains('\x1b'),
|
||||
!detail.plain().contains('\x1b'),
|
||||
"escapes reached the detail view: {:?}",
|
||||
detail.text
|
||||
detail.plain()
|
||||
);
|
||||
|
||||
board.toggle_detail();
|
||||
@@ -2605,7 +2779,7 @@ mod tests {
|
||||
// The heading stays out of the text: `show` prints it and here the border
|
||||
// carries it, so it is on screen once rather than twice.
|
||||
assert!(
|
||||
!board.detail.as_ref().unwrap().text.contains("First one"),
|
||||
!board.detail.as_ref().unwrap().plain().contains("First one"),
|
||||
"{:?}",
|
||||
board.detail
|
||||
);
|
||||
@@ -2670,7 +2844,7 @@ mod tests {
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
assert!(!board.detail.as_ref().unwrap().text.contains("A late note."));
|
||||
assert!(!board.detail.as_ref().unwrap().plain().contains("A late note."));
|
||||
|
||||
let comments = dir.join("comments").join(uuid);
|
||||
std::fs::create_dir_all(&comments).unwrap();
|
||||
@@ -2682,7 +2856,7 @@ mod tests {
|
||||
|
||||
assert!(board.tick().unwrap(), "the tick saw no change");
|
||||
assert!(
|
||||
board.detail.as_ref().unwrap().text.contains("A late note."),
|
||||
board.detail.as_ref().unwrap().plain().contains("A late note."),
|
||||
"{:?}",
|
||||
board.detail
|
||||
);
|
||||
@@ -2809,7 +2983,7 @@ mod tests {
|
||||
// By id in the text: the heading is stripped from the body, and the title
|
||||
// travels beside it for the block title instead.
|
||||
assert!(
|
||||
board.detail.as_ref().unwrap().text.contains("11111111"),
|
||||
board.detail.as_ref().unwrap().plain().contains("11111111"),
|
||||
"{:?}",
|
||||
board.detail
|
||||
);
|
||||
@@ -2817,7 +2991,7 @@ mod tests {
|
||||
board.select_card(1, SCREEN);
|
||||
assert_eq!(selected_title(&board), Some("Beta".to_string()));
|
||||
assert!(
|
||||
board.detail.as_ref().unwrap().text.contains("22222222"),
|
||||
board.detail.as_ref().unwrap().plain().contains("22222222"),
|
||||
"{:?}",
|
||||
board.detail
|
||||
);
|
||||
@@ -3299,7 +3473,7 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
assert!(
|
||||
board.detail.as_ref().unwrap().text.contains("11111111"),
|
||||
board.detail.as_ref().unwrap().plain().contains("11111111"),
|
||||
"{:?}",
|
||||
board.detail
|
||||
);
|
||||
@@ -3310,7 +3484,7 @@ mod tests {
|
||||
|
||||
let detail = board.detail.as_ref().expect("the overlay closed on a jump");
|
||||
assert_eq!(detail.title, "Gamma third");
|
||||
assert!(detail.text.contains("33333333"), "{detail:?}");
|
||||
assert!(detail.plain().contains("33333333"), "{detail:?}");
|
||||
}
|
||||
|
||||
/// With no prompt open the keyboard belongs to the action arms, so `search_key` has
|
||||
@@ -4007,9 +4181,9 @@ mod tests {
|
||||
_ => "22222222",
|
||||
};
|
||||
assert!(
|
||||
detail.text.contains(uuid),
|
||||
detail.plain().contains(uuid),
|
||||
"the overlay opened another project's ticket: {project} {:?}",
|
||||
detail.text
|
||||
detail.plain()
|
||||
);
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
@@ -4020,7 +4194,7 @@ mod tests {
|
||||
board.select_card(1, SCREEN);
|
||||
let moved = board.detail.as_ref().expect("no detail");
|
||||
assert_ne!(moved.project, Some(project), "the modal stayed on one project");
|
||||
assert!(!moved.text.contains(uuid), "{:?}", moved.text);
|
||||
assert!(!moved.plain().contains(uuid), "{:?}", moved.plain());
|
||||
}
|
||||
|
||||
/// The board and the listing draw from the same palette, so a colour cannot exist
|
||||
@@ -4037,6 +4211,238 @@ 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.
|
||||
fn drawn_color(
|
||||
board: &Board,
|
||||
width: u16,
|
||||
height: u16,
|
||||
symbol: &str,
|
||||
) -> 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();
|
||||
|
||||
(0..buffer.area.height)
|
||||
.flat_map(|y| (0..buffer.area.width).map(move |x| (x, y)))
|
||||
.find(|(x, y)| buffer[(*x, *y)].symbol() == symbol)
|
||||
.map(|(x, y)| buffer[(x, y)].fg)
|
||||
}
|
||||
|
||||
/// A board holding one relation, so the tests below have a block to look at.
|
||||
///
|
||||
/// The section goes where `relate` writes it, ahead of the metadata, rather than in
|
||||
/// `write_ticket`'s trailer: the block has to be on screen for a test to read the
|
||||
/// colour off the drawn buffer.
|
||||
fn related_board() -> PathBuf {
|
||||
let dir = board_dir();
|
||||
let holder = "11111111-0000-4000-8000-000000000000";
|
||||
let target = "22222222-0000-4000-8000-000000000000";
|
||||
|
||||
std::fs::write(
|
||||
dir.join("backlog").join(format!("{holder}_a-holder.md")),
|
||||
format!(
|
||||
"# A holder\n\n## Description\nA description.\n\n## Relations\n\
|
||||
- blocked by {target}\n\n## Metadata\n\n- **ID**: {holder}\n\
|
||||
- **Priority**: 2\n- **Status**: backlog\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
write_ticket(&dir, "reviewing", target, "The target", "");
|
||||
dir
|
||||
}
|
||||
|
||||
/// The mark is a ratatui style, not an escape sequence in the body. Passing `true`
|
||||
/// to the body renderers would put `\x1b[33m` in the paragraph and draw it as literal
|
||||
/// bytes, which is 6d327df; this asserts the colour arrived and the escape did not.
|
||||
#[test]
|
||||
fn the_relation_mark_is_drawn_as_a_style_and_not_as_an_escape() {
|
||||
let dir = related_board();
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let (mark, colour) = relation_mark(RelationKind::BlockedBy);
|
||||
let detail = board.detail.as_ref().expect("no detail");
|
||||
assert!(
|
||||
detail.plain().contains(mark),
|
||||
"the target's mark is not in the body: {:?}",
|
||||
detail.plain()
|
||||
);
|
||||
assert!(
|
||||
!detail.plain().contains('\x1b'),
|
||||
"an escape reached the body: {:?}",
|
||||
detail.plain()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
drawn_color(&board, SCREEN.width, SCREEN.height, mark),
|
||||
Some(colour.into()),
|
||||
"the mark was drawn without its colour"
|
||||
);
|
||||
}
|
||||
|
||||
/// One layout, two painters. The overlay draws the block from the same cells the CLI
|
||||
/// paints, so the two views cannot come to list different edges in a different order
|
||||
/// or pad them differently.
|
||||
#[test]
|
||||
fn the_overlay_and_the_listing_draw_the_same_block() {
|
||||
let dir = related_board();
|
||||
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 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()),
|
||||
"the overlay drew a different block than the listing prints: {printed:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The body is no longer one string, so the clamp and the draw could measure two
|
||||
/// different things. They take the same `Text`, and this is what says so: a ticket
|
||||
/// whose relations run past the overlay scrolls to its last row.
|
||||
#[test]
|
||||
fn the_scroll_measures_the_relations_block_with_the_rest_of_the_body() {
|
||||
let dir = board_dir();
|
||||
let holder = "11111111-0000-4000-8000-000000000000";
|
||||
let mut relations = String::from("\n## Relations\n");
|
||||
for n in 0..20 {
|
||||
let target = format!("2222222{n:x}-0000-4000-8000-000000000000");
|
||||
relations.push_str(&format!("- blocked by {target}\n"));
|
||||
write_ticket(&dir, "done", &target, &format!("Target {n:02}"), "");
|
||||
}
|
||||
write_ticket(&dir, "backlog", holder, "A holder", &relations);
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let area = detail_text_area(Rect::new(0, 0, SCREEN.width, SCREEN.height));
|
||||
let last = last_offset(&board.detail.as_ref().unwrap().body, area);
|
||||
assert!(last > 0, "the fixture fits on one screen, so nothing is measured");
|
||||
|
||||
// Far past the end, so the clamp is what stops it.
|
||||
for _ in 0..20 {
|
||||
board.scroll_detail(1, SCREEN);
|
||||
}
|
||||
assert_eq!(board.offset, last, "the clamp and the body disagree");
|
||||
|
||||
// The relations sit at the end of this fixture, so the last row and the comments
|
||||
// line are what the last screenful has to hold.
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height).join("\n");
|
||||
assert!(
|
||||
screen.contains("Target 19"),
|
||||
"the last relation is not on screen:\n{screen}"
|
||||
);
|
||||
assert!(
|
||||
screen.contains("No comments yet."),
|
||||
"the body ends past the last screenful:\n{screen}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The line of the body carrying `needle`, so a test can ask what colour a run of it
|
||||
/// is drawn in rather than reading the flattened text.
|
||||
fn body_line(detail: &Detail, needle: &str) -> Line<'static> {
|
||||
detail
|
||||
.body
|
||||
.lines
|
||||
.iter()
|
||||
.find(|line| {
|
||||
line.spans
|
||||
.iter()
|
||||
.map(|span| span.content.as_ref())
|
||||
.collect::<String>()
|
||||
.contains(needle)
|
||||
})
|
||||
.cloned()
|
||||
.unwrap_or_else(|| panic!("no line holding {needle:?} in:\n{}", detail.plain()))
|
||||
}
|
||||
|
||||
/// The colour of the span whose whole content is `text`, on that line.
|
||||
fn span_color(line: &Line<'static>, text: &str) -> Option<ratatui::style::Color> {
|
||||
line.spans
|
||||
.iter()
|
||||
.find(|span| span.content.as_ref() == text)
|
||||
.map(|span| span.style.fg)
|
||||
.unwrap_or_else(|| panic!("no span {text:?} in {line:?}"))
|
||||
}
|
||||
|
||||
/// A short id is red everywhere the CLI prints one, and the overlay was the one place
|
||||
/// it was not: the body arrived as flat text because a paragraph is no place for an
|
||||
/// escape. It is styled now, so the guideline holds in both views.
|
||||
///
|
||||
/// Paired the way the guideline demands. The absence, no escape byte in the body,
|
||||
/// cannot pass on its own: a version that dropped every colour to stay safe would
|
||||
/// satisfy it, so the presence is asserted beside it. And the one character version
|
||||
/// of this, passing `true` to the body renderers, fails the absence.
|
||||
#[test]
|
||||
fn the_relation_id_is_red_in_the_overlay_and_no_escape_reached_the_body() {
|
||||
let dir = related_board();
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
let detail = board.detail.as_ref().expect("no detail");
|
||||
|
||||
let row = body_line(detail, "blocked by");
|
||||
assert_eq!(
|
||||
span_color(&row, "2222222"),
|
||||
Some(Color::Red.into()),
|
||||
"the target's id is not red: {row:?}"
|
||||
);
|
||||
|
||||
// The pair: colour arrived, and it arrived as a style rather than as bytes.
|
||||
assert!(
|
||||
row.spans.iter().any(|span| span.style.fg.is_some()),
|
||||
"nothing on the row is coloured at all, so the guard below is vacuous"
|
||||
);
|
||||
assert!(
|
||||
!detail.plain().contains('\x1b'),
|
||||
"escapes reached the body: {:?}",
|
||||
detail.plain()
|
||||
);
|
||||
}
|
||||
|
||||
/// A target the board no longer holds keeps the id, which is the only thing left to
|
||||
/// go looking for, and says `_missing_` in the grey that means an unset value. The
|
||||
/// colour must not turn a gap into something that reads like a real target.
|
||||
#[test]
|
||||
fn a_missing_target_still_reads_as_missing_in_the_overlay() {
|
||||
let dir = board_dir();
|
||||
let holder = "11111111-0000-4000-8000-000000000000";
|
||||
std::fs::write(
|
||||
dir.join("backlog").join(format!("{holder}_a-holder.md")),
|
||||
format!(
|
||||
"# A holder\n\n## Relations\n- blocked by 99999999-0000-4000-8000-000000000000\n\
|
||||
\n## Metadata\n\n- **ID**: {holder}\n- **Status**: backlog\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
let detail = board.detail.as_ref().expect("no detail");
|
||||
|
||||
let row = body_line(detail, "blocked by");
|
||||
assert_eq!(span_color(&row, "_missing_"), Some(Color::Grey.into()));
|
||||
assert_eq!(
|
||||
span_color(&row, "9999999"),
|
||||
Some(Color::Red.into()),
|
||||
"the id went with the title it could not find"
|
||||
);
|
||||
// The mark is the kind, read off this ticket's own file, so it survives a target
|
||||
// the board cannot find: only the name is gone.
|
||||
assert_eq!(
|
||||
span_color(&row, BLOCKED_MARK),
|
||||
Some(Color::BrightRed.into()),
|
||||
"the mark went with the title it could not find"
|
||||
);
|
||||
}
|
||||
|
||||
/// The detail view is the second renderer of a ticket body, so it resolves a
|
||||
/// relation the way `show` does rather than printing the uuid the file stores.
|
||||
///
|
||||
@@ -4058,8 +4464,12 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
assert!(text.contains("blocked by (2222222) The target"), "{text:?}");
|
||||
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:?}"
|
||||
);
|
||||
assert!(!text.contains(target), "the bare uuid was drawn: {text:?}");
|
||||
}
|
||||
|
||||
@@ -4082,8 +4492,11 @@ mod tests {
|
||||
board.select_card(1, SCREEN);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
assert!(text.contains("blocks (1111111) A holder"), "{text:?}");
|
||||
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:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The detail view resolves the Campaign field the way `show` does. The field stores
|
||||
@@ -4109,7 +4522,7 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
assert!(text.contains("(ccccccc) v1 release"), "{text:?}");
|
||||
assert!(!text.contains(campaign), "the bare uuid reached the screen: {text:?}");
|
||||
}
|
||||
@@ -4130,7 +4543,7 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
assert!(text.contains("A description."), "the body was lost: {text:?}");
|
||||
// No campaigns to resolve against, so the reference reads as gone.
|
||||
assert!(text.contains("_missing_"), "{text:?}");
|
||||
@@ -4152,7 +4565,224 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
assert!(text.contains("A description."), "the body was lost: {text:?}");
|
||||
}
|
||||
|
||||
/// The overlay scrolls and nothing said where you were: a long ticket opened looking
|
||||
/// exactly like a short one.
|
||||
#[test]
|
||||
fn a_scrollable_ticket_shows_a_page_indicator_on_the_bottom_border() {
|
||||
let dir = board_dir();
|
||||
let board = scrolling_board(&dir, 60);
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
let row = overlay_bottom_row(&screen, SCREEN.width, SCREEN.height);
|
||||
|
||||
assert!(row.contains("pg 1/"), "no indicator on the bottom border:\n{row}");
|
||||
|
||||
// On the border, not on a text row: the row it is drawn on is the one carrying
|
||||
// the corners, so no line of the ticket was spent on it.
|
||||
assert!(row.starts_with('└'), "not the bottom border row:\n{row}");
|
||||
assert!(row.ends_with('┘'), "not the bottom border row:\n{row}");
|
||||
|
||||
// Bottom right, so it is in the corner the eye goes to for a number and not
|
||||
// adrift in the middle of the border.
|
||||
let at = row.chars().position(|c| c == 'p').expect("no indicator");
|
||||
let width = row.chars().count();
|
||||
assert!(
|
||||
at > width - 12,
|
||||
"the indicator is not in the right-hand corner of a {width} cell border:\n{row}"
|
||||
);
|
||||
|
||||
// And the top border still carries the title alone.
|
||||
let title = overlay_title_row(&screen, SCREEN.width, SCREEN.height);
|
||||
assert!(title.contains("A long one"), "{title}");
|
||||
assert!(!title.contains("pg "), "the indicator landed on the title row:\n{title}");
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// At the top of a scrollable ticket, page one.
|
||||
#[test]
|
||||
fn the_indicator_opens_on_page_one() {
|
||||
let dir = board_dir();
|
||||
let board = scrolling_board(&dir, 60);
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
let row = overlay_bottom_row(&screen, SCREEN.width, SCREEN.height);
|
||||
|
||||
assert!(row.contains("pg 1/"), "{row}");
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// The one the arithmetic is for: the clamp stops at the wrapped height less the
|
||||
/// viewport, not on a page boundary, so the last screenful is partial and dividing
|
||||
/// would claim there is more to read.
|
||||
#[test]
|
||||
fn the_furthest_scroll_reads_the_last_page() {
|
||||
let dir = board_dir();
|
||||
let mut board = scrolling_board(&dir, 60);
|
||||
|
||||
// Far past the end, so the clamp is what stops it.
|
||||
for _ in 0..40 {
|
||||
board.scroll_detail(1, SCREEN);
|
||||
}
|
||||
|
||||
let text = detail_text_area(Rect::new(0, 0, SCREEN.width, SCREEN.height));
|
||||
let last = last_offset(&board.detail.as_ref().unwrap().body, text);
|
||||
assert_eq!(board.offset, last, "the fixture did not reach the end");
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
let row = overlay_bottom_row(&screen, SCREEN.width, SCREEN.height);
|
||||
|
||||
let indicator = row
|
||||
.split_whitespace()
|
||||
.find(|word| word.contains('/'))
|
||||
.unwrap_or_else(|| panic!("no indicator on:\n{row}"))
|
||||
.to_string();
|
||||
let (page, total) = indicator.split_once('/').expect("no separator");
|
||||
assert_eq!(page, total, "the last page reads as the second to last: {indicator}");
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// A ticket that fits spends no indicator, the way an untagged card spends no row on
|
||||
/// tags.
|
||||
///
|
||||
/// On a taller screen than the other overlay tests use: `write_ticket`'s own body is
|
||||
/// twenty-odd rows and scrolls in a twenty row terminal, so the fixture has to be
|
||||
/// given a terminal it fits in for the absence to mean anything.
|
||||
#[test]
|
||||
fn a_ticket_that_fits_shows_no_indicator() {
|
||||
let (width, height) = (120, 60);
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "A short one", "");
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = detail_text_area(Rect::new(0, 0, width, height));
|
||||
assert_eq!(
|
||||
last_offset(&board.detail.as_ref().unwrap().body, text),
|
||||
0,
|
||||
"the fixture scrolls, so it proves nothing"
|
||||
);
|
||||
|
||||
let screen = render(&board, width, height);
|
||||
assert!(
|
||||
!screen.join("\n").contains("pg "),
|
||||
"a ticket that fits drew an indicator:\n{}",
|
||||
screen.join("\n")
|
||||
);
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// The wrapped count and the viewport both move with the terminal, so the total has
|
||||
/// to move with them. Narrower and shorter means more pages of the same ticket.
|
||||
#[test]
|
||||
fn a_resize_repages_the_indicator() {
|
||||
let dir = board_dir();
|
||||
let board = scrolling_board(&dir, 60);
|
||||
|
||||
let total = |width: u16, height: u16| -> String {
|
||||
let screen = render(&board, width, height);
|
||||
let row = overlay_bottom_row(&screen, width, height);
|
||||
row.split_whitespace()
|
||||
.find(|word| word.contains('/'))
|
||||
.unwrap_or_else(|| panic!("no indicator at {width}x{height} on:\n{row}"))
|
||||
.split_once('/')
|
||||
.expect("no separator")
|
||||
.1
|
||||
.to_string()
|
||||
};
|
||||
|
||||
let wide = total(120, 40);
|
||||
let narrow = total(60, 20);
|
||||
assert_ne!(wide, narrow, "the same total on two terminal sizes");
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// An overlay too narrow for the indicator drops it whole rather than cutting it, the
|
||||
/// rule a card's corner follows: half a page number reads as a different one.
|
||||
#[test]
|
||||
fn an_overlay_too_narrow_for_the_indicator_drops_it_whole() {
|
||||
// Six pages in a two cell overlay, so there is plenty to say and no room for it.
|
||||
assert_eq!(page_indicator(0, 50, 10, 2), None);
|
||||
assert_eq!(page_indicator(0, 50, 10, 8), None);
|
||||
|
||||
// ` pg 1/7 ` is eight characters, so it needs ten cells of overlay.
|
||||
assert_eq!(page_indicator(0, 50, 10, 10).as_deref(), Some(" pg 1/7 "));
|
||||
}
|
||||
|
||||
/// The arithmetic on its own, so the cases that need no terminal are pinned where
|
||||
/// they can be read.
|
||||
#[test]
|
||||
fn the_page_numbers_count_in_the_step_the_keys_take() {
|
||||
// A 25 line ticket in a 10 line viewport: the step is nine, so the offsets the
|
||||
// keys reach are 0, 9 and 15, the last of them clamped.
|
||||
let (last, height) = (15, 10);
|
||||
assert_eq!(page_indicator(0, last, height, 40).as_deref(), Some(" pg 1/3 "));
|
||||
assert_eq!(page_indicator(9, last, height, 40).as_deref(), Some(" pg 2/3 "));
|
||||
assert_eq!(page_indicator(15, last, height, 40).as_deref(), Some(" pg 3/3 "));
|
||||
|
||||
// Nothing to scroll, nothing to say.
|
||||
assert_eq!(page_indicator(0, 0, height, 40), None);
|
||||
|
||||
// One line over the viewport is two pages, and the second of them is one row.
|
||||
assert_eq!(page_indicator(0, 1, height, 40).as_deref(), Some(" pg 1/2 "));
|
||||
assert_eq!(page_indicator(1, 1, height, 40).as_deref(), Some(" pg 2/2 "));
|
||||
}
|
||||
|
||||
/// The colour the indicator actually reached the screen in.
|
||||
///
|
||||
/// 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> {
|
||||
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
|
||||
terminal.draw(|frame| draw(frame, board)).unwrap();
|
||||
let buffer = terminal.backend().buffer().clone();
|
||||
|
||||
let overlay = detail_overlay(Rect::new(0, 0, width, height));
|
||||
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"
|
||||
})
|
||||
.map(|x| buffer[(x, row)].fg)
|
||||
}
|
||||
|
||||
/// Chrome, not a value: the guideline gives grey to what a reader skips, and the
|
||||
/// title on the opposite border keeps orange.
|
||||
#[test]
|
||||
fn the_indicator_is_drawn_as_chrome() {
|
||||
let dir = board_dir();
|
||||
let board = scrolling_board(&dir, 60);
|
||||
|
||||
assert_eq!(
|
||||
indicator_color(&board, SCREEN.width, SCREEN.height),
|
||||
Some(Color::Grey.into()),
|
||||
"the indicator was drawn in something other than the chrome colour"
|
||||
);
|
||||
|
||||
// Not the same colour as the title on the opposite border, or it would read as
|
||||
// part of the ticket's identity rather than as chrome.
|
||||
assert_ne!(
|
||||
indicator_color(&board, SCREEN.width, SCREEN.height),
|
||||
Some(Color::Orange.into()),
|
||||
"the indicator took the title's colour"
|
||||
);
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
+788
-75
File diff suppressed because it is too large
Load Diff
@@ -53,6 +53,43 @@ fn create_ticket(worklane: &Path) {
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// A second ticket whose criteria carry the word `all`, so the keyword's precedence
|
||||
/// can be pinned without renumbering the shared fixture.
|
||||
const ALL_UUID: &str = "6b1f9c22-0d4e-4a1b-9f37-2c85ab4d1e70";
|
||||
|
||||
fn create_all_in_text_ticket(worklane: &Path) {
|
||||
let lines = [
|
||||
"# All in the text",
|
||||
"",
|
||||
"## Acceptance Criteria",
|
||||
"- [ ] all the boxes are listed",
|
||||
"- [ ] the footer is drawn",
|
||||
"",
|
||||
"## Metadata",
|
||||
"",
|
||||
&format!("- **ID**: {}", ALL_UUID),
|
||||
"- **Status**: backlog",
|
||||
"",
|
||||
];
|
||||
|
||||
fs::write(
|
||||
worklane
|
||||
.join("backlog")
|
||||
.join(format!("{}_all-in-the-text.md", ALL_UUID)),
|
||||
lines.join("\n"),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn all_in_text_ticket(worklane: &Path) -> String {
|
||||
fs::read_to_string(
|
||||
worklane
|
||||
.join("backlog")
|
||||
.join(format!("{}_all-in-the-text.md", ALL_UUID)),
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(args);
|
||||
@@ -285,3 +322,239 @@ fn check_leaves_nothing_behind() {
|
||||
.collect();
|
||||
assert_eq!(strays, Vec::<String>::new());
|
||||
}
|
||||
|
||||
/// The common case the batch exists for: the work is done, every box is true.
|
||||
#[test]
|
||||
fn all_ticks_every_criterion() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "all"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- [x] alpha shared\n"), "{content}");
|
||||
assert!(content.contains("- [x] beta alone\n"), "{content}");
|
||||
assert!(content.contains("- [x] gamma shared\n"), "{content}");
|
||||
|
||||
// beta was already ticked, so it is reported unchanged rather than as a new mark
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert!(stdout.contains("Checked 1: alpha shared"), "{stdout:?}");
|
||||
assert!(stdout.contains("Already checked 2: beta alone"), "{stdout:?}");
|
||||
assert!(stdout.contains("Checked 3: gamma shared"), "{stdout:?}");
|
||||
|
||||
// And nothing outside the section was touched
|
||||
assert!(
|
||||
content.contains("- [ ] A checkbox in the description, which is not a criterion.\n"),
|
||||
"the description checkbox was ticked: {content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains(" A handwritten line inside the section.\n"),
|
||||
"the handwritten line was lost: {content}"
|
||||
);
|
||||
}
|
||||
|
||||
/// An index and a substring in one call, each addressed by the existing rules.
|
||||
#[test]
|
||||
fn one_call_takes_several_mixed_terms() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "3", "ALPHA"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- [x] alpha shared\n"), "{content}");
|
||||
assert!(content.contains("- [x] gamma shared\n"), "{content}");
|
||||
|
||||
// Reported in show's order whatever order the terms arrived in
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
let alpha = stdout.find("Checked 1: alpha");
|
||||
let gamma = stdout.find("Checked 3: gamma");
|
||||
assert!(
|
||||
matches!((alpha, gamma), (Some(alpha), Some(gamma)) if alpha < gamma),
|
||||
"reported out of order, or one of them is missing: {stdout:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The same criterion named twice, once by number and once by text, is one mark and
|
||||
/// one line of output.
|
||||
#[test]
|
||||
fn a_criterion_named_twice_is_reported_once() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "1", "alpha", "all"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert_eq!(
|
||||
stdout.matches("alpha shared").count(),
|
||||
1,
|
||||
"alpha was reported more than once: {stdout:?}"
|
||||
);
|
||||
assert_eq!(
|
||||
stdout.lines().count(),
|
||||
3,
|
||||
"one line per criterion, not per term: {stdout:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// Nothing to change, so nothing is written, the way a single already-ticked
|
||||
/// criterion already behaves.
|
||||
#[test]
|
||||
fn a_batch_that_would_change_nothing_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["check", UUID, "all"]);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "all"]);
|
||||
assert!(out.status.success());
|
||||
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert_eq!(
|
||||
stdout.matches("Already checked").count(),
|
||||
3,
|
||||
"{stdout:?}"
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
/// One term that matches nothing refuses the whole call, so the ticket is never left
|
||||
/// half-marked.
|
||||
#[test]
|
||||
fn a_term_matching_nothing_leaves_the_batch_unwritten() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "1", "nowhere", "3"]);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(stderr.contains("nowhere"), "the term was not named: {stderr:?}");
|
||||
assert_eq!(ticket(&worklane), before, "alpha was ticked anyway");
|
||||
}
|
||||
|
||||
/// An ambiguous term in a batch is refused the same way a lone one is, and names
|
||||
/// itself rather than whichever term happened to come first.
|
||||
#[test]
|
||||
fn an_ambiguous_term_in_a_batch_names_itself_and_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "1", "shared"]);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(stderr.contains("'shared' matches 2 criteria"), "{stderr:?}");
|
||||
assert!(stderr.contains("1. [ ] alpha shared"), "{stderr:?}");
|
||||
assert!(stderr.contains("3. [ ] gamma shared"), "{stderr:?}");
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An index out of range in a batch is still a bad index, not a failed text search.
|
||||
#[test]
|
||||
fn an_index_out_of_range_in_a_batch_leaves_the_file_untouched() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["check", UUID, "1", "9"]);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(stderr.contains("is not one of the 3 criteria"), "{stderr:?}");
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// The decision this pins: `all` is the keyword, checked before the substring the way
|
||||
/// the index is, so it ticks every criterion and not the one whose text says "all".
|
||||
#[test]
|
||||
fn all_is_the_keyword_and_not_a_substring_of_the_text() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_all_in_text_ticket(&worklane);
|
||||
|
||||
run(&temp, &["check", ALL_UUID, "all"]);
|
||||
|
||||
let content = all_in_text_ticket(&worklane);
|
||||
assert!(content.contains("- [x] all the boxes are listed\n"), "{content}");
|
||||
assert!(
|
||||
content.contains("- [x] the footer is drawn\n"),
|
||||
"all matched its own text instead of every criterion: {content}"
|
||||
);
|
||||
}
|
||||
|
||||
/// And the criterion whose text carries the word is still reachable, by its number or
|
||||
/// by a longer substring.
|
||||
#[test]
|
||||
fn a_criterion_whose_text_contains_all_is_still_reachable() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_all_in_text_ticket(&worklane);
|
||||
|
||||
run(&temp, &["check", ALL_UUID, "all the boxes"]);
|
||||
|
||||
let content = all_in_text_ticket(&worklane);
|
||||
assert!(content.contains("- [x] all the boxes are listed\n"), "{content}");
|
||||
assert!(content.contains("- [ ] the footer is drawn\n"), "{content}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uncheck_takes_all() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["uncheck", UUID, "all"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- [ ] alpha shared\n"), "{content}");
|
||||
assert!(content.contains("- [ ] beta alone\n"), "{content}");
|
||||
assert!(content.contains("- [ ] gamma shared\n"), "{content}");
|
||||
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert!(stdout.contains("Unchecked 2: beta alone"), "{stdout:?}");
|
||||
assert!(stdout.contains("Already unchecked 1: alpha shared"), "{stdout:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uncheck_takes_several_mixed_terms() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["check", UUID, "all"]);
|
||||
let out = run(&temp, &["uncheck", UUID, "2", "gamma"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- [x] alpha shared\n"), "{content}");
|
||||
assert!(content.contains("- [ ] beta alone\n"), "{content}");
|
||||
assert!(content.contains("- [ ] gamma shared\n"), "{content}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failing_term_refuses_an_uncheck_batch_too() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["uncheck", UUID, "2", "nowhere"]);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert_eq!(ticket(&worklane), before, "beta was unticked anyway");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
use assert_cmd::Command;
|
||||
|
||||
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||
|
||||
fn script(shell: &str) -> String {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd.arg("completions").arg(shell).assert().success();
|
||||
String::from_utf8(assert.get_output().stdout.clone()).unwrap()
|
||||
}
|
||||
|
||||
/// Every shell clap can generate for, since the README names all five.
|
||||
#[test]
|
||||
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"
|
||||
);
|
||||
// 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());
|
||||
}
|
||||
}
|
||||
|
||||
/// No board is looked for, the way `install-skill` looks for none: the script comes off
|
||||
/// the clap definition and is the same wherever it is run. Run from a temp directory
|
||||
/// with no `.worklane` above it, which every other command refuses.
|
||||
#[test]
|
||||
fn completions_needs_no_board() {
|
||||
let temp = assert_fs::TempDir::new().unwrap();
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.arg("completions")
|
||||
.arg("fish")
|
||||
.assert()
|
||||
.success();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fish_gets_both_halves() {
|
||||
let out = script("fish");
|
||||
// clap's, which is where the subcommands and the flags come from.
|
||||
assert!(out.contains("__fish_worklane_needs_command"));
|
||||
assert!(out.contains("install-skill"));
|
||||
// Ours, which is where the tickets come from.
|
||||
assert!(out.contains("__worklane_first_arg_of"));
|
||||
assert!(out.contains("worklane ls --ids"));
|
||||
}
|
||||
|
||||
/// The fish half is fish syntax, so it must not reach any other shell's output.
|
||||
#[test]
|
||||
fn no_other_shell_gets_the_fish_half() {
|
||||
for shell in ["bash", "zsh", "elvish", "powershell"] {
|
||||
let out = script(shell);
|
||||
assert!(
|
||||
!out.contains("__worklane_first_arg_of"),
|
||||
"fish-only helpers leaked into {shell}"
|
||||
);
|
||||
assert!(
|
||||
!out.contains("worklane ls --ids"),
|
||||
"the dynamic half leaked into {shell}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The four statuses reach fish twice over, from clap for the `mv` option and from the
|
||||
/// appended half for the `ls` positional, which clap emits nothing for.
|
||||
#[test]
|
||||
fn fish_is_offered_every_status() {
|
||||
let out = script("fish");
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
assert!(out.contains(status), "fish is never offered {status}");
|
||||
}
|
||||
assert!(out.contains("-a 'backlog committed reviewing done' -d status"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_shell_is_a_usage_error() {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd.arg("completions").arg("tcsh").assert().code(2);
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("invalid value 'tcsh'"), "{stderr}");
|
||||
}
|
||||
+397
@@ -296,3 +296,400 @@ fn ls_shows_a_mark_for_the_level() {
|
||||
// The raw number is not what the listing shows
|
||||
assert!(!stdout.contains(" 1 "), "the digit leaked into the row");
|
||||
}
|
||||
|
||||
/// A ticket whose Tags field is whatever the test needs it to be, written verbatim so a
|
||||
/// missing field, an unset one and a real list are all reachable.
|
||||
fn create_ticket_with_tags(
|
||||
worklane_dir: &std::path::Path,
|
||||
status: &str,
|
||||
title: &str,
|
||||
tags: &str,
|
||||
priority: &str,
|
||||
) {
|
||||
let slug: String = title.to_lowercase().replace(' ', "-");
|
||||
let body = format!(
|
||||
"# {title}\n\n## Metadata\n\n - **ID**: 00000000-0000-0000-0000-000000000001\n - **Priority**: {priority}\n{tags} - **Due**: _Not set_\n- **Owner**: alice\n- **Status**: {status}\n"
|
||||
);
|
||||
fs::write(
|
||||
worklane_dir
|
||||
.join(status)
|
||||
.join(format!("00000000-0000-0000-0000-000000000001_{slug}.md")),
|
||||
body,
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// The Tags line as a ticket carries it, for the common case of a real list.
|
||||
fn tags(list: &str) -> String {
|
||||
format!("- **Tags**: {list}\n")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ls_filters_by_tag_and_composes_with_status_and_priority() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_tags(&worklane, "backlog", "Tagged bug", &tags("bug,cli"), "1");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Tagged feature", &tags("feature"), "1");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Lower bug", &tags("bug"), "3");
|
||||
create_ticket_with_tags(&worklane, "committed", "Started bug", &tags("bug"), "1");
|
||||
|
||||
// Alone, through the grouped listing: every status, only the tagged tickets.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--tag", "bug"]);
|
||||
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("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}");
|
||||
assert!(stdout.contains("[COMMITTED] 1 ticket"), "{stdout}");
|
||||
|
||||
// With the status positional.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "bug"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Tagged bug"));
|
||||
assert!(stdout.contains("Lower bug"));
|
||||
assert!(!stdout.contains("Started bug"), "the status was ignored");
|
||||
|
||||
// With --priority, and with both: none asked for is everything kept, so the three
|
||||
// compose without a rule per pair.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "--tag", "bug", "--priority", "1"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Tagged bug"));
|
||||
assert!(stdout.contains("Started bug"));
|
||||
assert!(!stdout.contains("Lower bug"), "the priority was ignored");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "bug", "--priority", "1"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Tagged bug"));
|
||||
assert!(!stdout.contains("Lower bug"), "the priority was ignored");
|
||||
assert!(!stdout.contains("Started bug"), "the status was ignored");
|
||||
assert!(!stdout.contains("Tagged feature"), "the tag was ignored");
|
||||
}
|
||||
|
||||
/// The field is a list of whole values, not a string to search: a ticket tagged `bugfix`
|
||||
/// is not a ticket tagged `bug`, and neither is one tagged `Bug`. Case sensitive is the
|
||||
/// opinion the field already takes, since `tag_color` draws those two differently.
|
||||
#[test]
|
||||
fn ls_matches_a_whole_tag_value_and_not_a_substring_or_another_case() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_tags(&worklane, "backlog", "Real bug", &tags("bug"), "2");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Only bugfix", &tags("bugfix"), "2");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Capital Bug", &tags("Bug"), "2");
|
||||
// A value that only appears with its neighbours around it, so a match on the raw
|
||||
// field would find it and a match on the split values cannot.
|
||||
create_ticket_with_tags(&worklane, "backlog", "Spaced list", &tags("cli, filter"), "2");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "bug"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Real bug"), "{stdout}");
|
||||
assert!(!stdout.contains("Only bugfix"), "bug matched bugfix");
|
||||
assert!(!stdout.contains("Capital Bug"), "bug matched Bug");
|
||||
|
||||
// Trimmed on the way in, so the space after the comma is not part of the tag.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "filter"]);
|
||||
assert!(get_stdout(&mut cmd).contains("Spaced list"));
|
||||
|
||||
// And the field as written is not itself a tag.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "cli, filter"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(!stdout.contains("Spaced list"), "the whole field matched as one tag");
|
||||
}
|
||||
|
||||
/// No tags is no match, however the ticket spells it: the field absent, unset, or empty.
|
||||
#[test]
|
||||
fn ls_never_matches_a_ticket_carrying_no_tags() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_tags(&worklane, "backlog", "Has one", &tags("bug"), "2");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Field unset", &tags("_None_"), "2");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Field empty", "- **Tags**:\n", "2");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Field missing", "", "2");
|
||||
create_ticket_with_tags(&worklane, "backlog", "Only commas", &tags(", ,"), "2");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "bug"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Has one"), "{stdout}");
|
||||
for absent in ["Field unset", "Field empty", "Field missing", "Only commas"] {
|
||||
assert!(!stdout.contains(absent), "{absent} matched a tag it does not carry");
|
||||
}
|
||||
|
||||
// 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.assert().failure().code(2);
|
||||
}
|
||||
|
||||
/// A tag nothing carries lists nothing and still succeeds. The message is the one `ls`
|
||||
/// already gives for a filter that empties a status, rather than a second one invented
|
||||
/// here for tags alone.
|
||||
#[test]
|
||||
fn ls_with_a_tag_nothing_carries_lists_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_tags(&worklane, "backlog", "Tagged bug", &tags("bug"), "2");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "frontend"]);
|
||||
cmd.assert().success();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", "frontend"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(!stdout.contains("Tagged bug"), "{stdout}");
|
||||
assert!(stdout.contains("No tickets in 'backlog' status."), "{stdout}");
|
||||
|
||||
// Through the grouped listing the counts go to zero and no section is drawn.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--tag", "frontend"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("[BACKLOG] 0 tickets"), "{stdout}");
|
||||
assert!(!stdout.contains("Tagged bug"), "{stdout}");
|
||||
}
|
||||
|
||||
/// A ticket with an id of its own, since `create_ticket` gives every fixture the same
|
||||
/// uuid and `--ids` is the one output where the id is the whole point.
|
||||
fn create_ticket_with_id(
|
||||
worklane_dir: &std::path::Path,
|
||||
status: &str,
|
||||
title: &str,
|
||||
uuid: &str,
|
||||
tags: &str,
|
||||
) {
|
||||
let ticket_body = format!(
|
||||
"# {title}\n\n## Metadata\n\n- **ID**: {uuid}\n- **Tags**: {tags}\n- **Owner**: alice\n- **Status**: {status}\n"
|
||||
);
|
||||
let filename = format!("{uuid}_{}.md", slug(title));
|
||||
fs::write(worklane_dir.join(status).join(filename), ticket_body).unwrap();
|
||||
}
|
||||
|
||||
/// The slug rule, as AGENTS.md requires: derived, never written by hand.
|
||||
fn slug(title: &str) -> String {
|
||||
title
|
||||
.to_lowercase()
|
||||
.chars()
|
||||
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
||||
.map(|c| if c == ' ' { '-' } else { c })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// One ticket per line, the seven-character id then a tab then the title, and nothing
|
||||
/// else: no heading, no counts, no owner or due column.
|
||||
#[test]
|
||||
fn ls_ids_prints_the_id_and_the_title_and_nothing_else() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Feature A",
|
||||
"1b78a24c-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||
cmd.assert().success();
|
||||
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "1b78a24\tFeature A\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
/// Every status, done included, where the decorated listing leaves done out. A
|
||||
/// completion has to be able to name a finished ticket.
|
||||
#[test]
|
||||
fn ls_ids_includes_done_and_narrows_to_a_named_status() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Still open",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"done",
|
||||
"Finished",
|
||||
"bbbbbbb2-0000-0000-0000-000000000002",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Still open"), "{stdout}");
|
||||
assert!(stdout.contains("Finished"), "a done ticket cannot be named: {stdout}");
|
||||
|
||||
// The decorated listing is unchanged: done is counted, not listed.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls");
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(!stdout.contains("Finished"), "{stdout}");
|
||||
|
||||
// The positional still narrows it.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "done", "--ids"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "bbbbbbb\tFinished\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
/// The filters apply to `--ids` exactly as they do to the listing, so a completion can
|
||||
/// be narrowed the same way.
|
||||
#[test]
|
||||
fn ls_ids_still_takes_the_filters() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Tagged bug",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Tagged cli",
|
||||
"bbbbbbb2-0000-0000-0000-000000000002",
|
||||
"cli",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
/// An unknown campaign is refused before anything is read, even here. A completion that
|
||||
/// listed the whole board because the name was misspelled would be worse than one that
|
||||
/// printed nothing.
|
||||
#[test]
|
||||
fn ls_ids_still_refuses_an_unknown_campaign() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Feature A",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "--ids", "--campaign", "no such campaign"]);
|
||||
cmd.assert().failure();
|
||||
}
|
||||
|
||||
/// A status the board is missing is skipped rather than refused, unlike the listing:
|
||||
/// the caller is a shell filling in candidates, and an error printed over the prompt is
|
||||
/// worse there than no candidates.
|
||||
#[test]
|
||||
fn ls_ids_is_quiet_about_a_missing_status_directory() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
worklane.child("backlog").create_dir_all().unwrap();
|
||||
|
||||
create_ticket_with_id(
|
||||
worklane.path(),
|
||||
"backlog",
|
||||
"Feature A",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||
cmd.assert().success();
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "aaaaaaa\tFeature A\n", "{stdout:?}");
|
||||
|
||||
// The listing still says so, since a person reading it can act on it.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "done"]);
|
||||
let assert = cmd.assert().failure();
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("No 'done' directory"), "{stderr}");
|
||||
}
|
||||
|
||||
/// A status outside the four is clap's to refuse now, so it is a usage error naming the
|
||||
/// four rather than a runtime one.
|
||||
#[test]
|
||||
fn ls_names_the_four_statuses_when_given_another() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
setup_worklane(&temp);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd
|
||||
.current_dir(temp.path())
|
||||
.args(["ls", "nonexistent"])
|
||||
.assert()
|
||||
.code(2);
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("invalid value 'nonexistent'"), "{stderr}");
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
assert!(stderr.contains(status), "{status} is not offered: {stderr}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The listing reads the fields it prints and nothing else, so the stamps `mv` writes
|
||||
/// do not reach it. Pinned against a ticket carrying one, since a listing that started
|
||||
/// showing them would change the output every board and completion script parses.
|
||||
#[test]
|
||||
fn ls_output_is_unchanged_by_a_status_stamp() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "committed", "Stamped", "alice", "2026-06-01");
|
||||
let path = worklane
|
||||
.join("committed")
|
||||
.join("00000000-0000-0000-0000-000000000001_stamped.md");
|
||||
let before = {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
||||
get_stdout(&mut cmd)
|
||||
};
|
||||
|
||||
let stamped = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace("- **Status**:", "- **Committed On**: 2026-08-22 09:14:30\n- **Status**:");
|
||||
fs::write(&path, stamped).unwrap();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
||||
let after = get_stdout(&mut cmd);
|
||||
|
||||
assert_eq!(after, before);
|
||||
assert!(!after.contains("Committed On"), "{after}");
|
||||
}
|
||||
|
||||
+183
-3
@@ -277,13 +277,16 @@ fn mv_ignores_already_in_same_status() {
|
||||
assert!(worklane.join("reviewing").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// A status is a value enum, so an unknown one is clap's to refuse: exit 2, the four
|
||||
/// named, and the ticket untouched. The same bargain `--due` and `--priority` take, and
|
||||
/// the reason `cmd_mv` no longer checks.
|
||||
#[test]
|
||||
fn mv_rejects_invalid_status() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let id = "abc123def456789012345678901234567890";
|
||||
let _filename = create_ticket(
|
||||
let filename = create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Invalid Target",
|
||||
@@ -301,10 +304,17 @@ fn mv_rejects_invalid_status() {
|
||||
.arg("--status")
|
||||
.arg("invalid")
|
||||
.assert()
|
||||
.failure();
|
||||
.code(2);
|
||||
|
||||
let stderr = get_stderr(&mut cmd);
|
||||
assert!(stderr.contains("Invalid target status"));
|
||||
assert!(stderr.contains("invalid value 'invalid'"), "{stderr}");
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
assert!(stderr.contains(status), "{status} is not offered: {stderr}");
|
||||
}
|
||||
assert!(
|
||||
worklane.join("backlog").join(&filename).exists(),
|
||||
"the ticket moved anyway"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -878,3 +888,173 @@ fn mv_ignores_the_kinds_that_are_not_blockers() {
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// The value of a metadata field, or nothing when the ticket does not carry it.
|
||||
fn field(content: &str, name: &str) -> Option<String> {
|
||||
let prefix = format!("- **{}**: ", name);
|
||||
content
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix(prefix.as_str()))
|
||||
.map(str::to_string)
|
||||
}
|
||||
|
||||
/// `%Y-%m-%d %H:%M:%S`, checked by shape. A test cannot pin the clock, so what it can
|
||||
/// assert is that the stamp carries the same format `Created At` does.
|
||||
fn is_timestamp(value: &str) -> bool {
|
||||
value.len() == 19
|
||||
&& value.chars().enumerate().all(|(index, c)| match index {
|
||||
4 | 7 => c == '-',
|
||||
10 => c == ' ',
|
||||
13 | 16 => c == ':',
|
||||
_ => c.is_ascii_digit(),
|
||||
})
|
||||
}
|
||||
|
||||
fn stamped_ticket(worklane: &Path, status: &str) -> String {
|
||||
create_ticket(
|
||||
worklane,
|
||||
status,
|
||||
"Stamped Task",
|
||||
"Carries the stamps.",
|
||||
"cccc3333cccc3333cccc3333cccc3333cccc",
|
||||
"alice",
|
||||
"_Not set_",
|
||||
"test",
|
||||
)
|
||||
}
|
||||
|
||||
fn ticket_at(worklane: &Path, status: &str, filename: &str) -> String {
|
||||
fs::read_to_string(worklane.join(status).join(filename)).unwrap()
|
||||
}
|
||||
|
||||
/// One field per status, written with the time of the move, and only the current one:
|
||||
/// the stamps are where the ticket is now, not the trail of how it got there.
|
||||
#[test]
|
||||
fn mv_stamps_the_field_of_the_status_it_enters() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "backlog");
|
||||
|
||||
for (status, stamp, cleared) in [
|
||||
("committed", "Committed On", "Submitted On"),
|
||||
("reviewing", "Submitted On", "Committed On"),
|
||||
("done", "Completed On", "Submitted On"),
|
||||
] {
|
||||
let out = move_ticket(&temp, "cccc3333", status, false);
|
||||
assert!(out.status.success(), "{:?}", out);
|
||||
|
||||
let content = ticket_at(&worklane, status, &filename);
|
||||
let value = field(&content, stamp)
|
||||
.unwrap_or_else(|| panic!("no {stamp} after moving to {status}: {content}"));
|
||||
|
||||
assert!(is_timestamp(&value), "{stamp} reads '{value}'");
|
||||
assert_eq!(field(&content, cleared), None, "{content}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Backlog has no stamp of its own, so a ticket forced back to it carries none at all
|
||||
/// rather than a Completed On for work that has been undone.
|
||||
#[test]
|
||||
fn mv_removes_the_stamp_of_the_status_it_leaves() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "backlog");
|
||||
|
||||
move_ticket(&temp, "cccc3333", "done", true);
|
||||
let done = ticket_at(&worklane, "done", &filename);
|
||||
assert!(field(&done, "Completed On").is_some(), "{done}");
|
||||
|
||||
move_ticket(&temp, "cccc3333", "backlog", true);
|
||||
|
||||
let content = ticket_at(&worklane, "backlog", &filename);
|
||||
for stamp in ["Committed On", "Submitted On", "Completed On"] {
|
||||
assert_eq!(field(&content, stamp), None, "{content}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Re-entry is the time of the move that brought the ticket back, not the first one.
|
||||
#[test]
|
||||
fn mv_restamps_a_status_the_ticket_is_re_entering() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "committed");
|
||||
|
||||
// Hand-written so the earlier value is old enough to tell from the move's own time,
|
||||
// which two moves in the same second would not be.
|
||||
let path = worklane.join("committed").join(&filename);
|
||||
let seeded = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace("- **Status**:", "- **Committed On**: 2020-01-01 00:00:00\n- **Status**:");
|
||||
fs::write(&path, seeded).unwrap();
|
||||
|
||||
move_ticket(&temp, "cccc3333", "backlog", true);
|
||||
move_ticket(&temp, "cccc3333", "committed", false);
|
||||
|
||||
let content = ticket_at(&worklane, "committed", &filename);
|
||||
let value = field(&content, "Committed On").expect(&content);
|
||||
|
||||
assert!(is_timestamp(&value), "{value}");
|
||||
assert_ne!(value, "2020-01-01 00:00:00");
|
||||
assert_eq!(content.matches("**Committed On**:").count(), 1, "{content}");
|
||||
}
|
||||
|
||||
/// The fixture predates the fields, as every ticket on a real board does, so the line
|
||||
/// is inserted rather than rewritten. Against METADATA_ORDER, which keeps Status last.
|
||||
#[test]
|
||||
fn mv_inserts_the_stamp_before_the_status_field() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "backlog");
|
||||
|
||||
move_ticket(&temp, "cccc3333", "committed", false);
|
||||
|
||||
let content = ticket_at(&worklane, "committed", &filename);
|
||||
let value = field(&content, "Committed On").expect(&content);
|
||||
|
||||
assert!(
|
||||
content.contains(&format!(
|
||||
"- **Owner**: alice\n- **Committed On**: {}\n- **Status**: committed\n",
|
||||
value
|
||||
)),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.ends_with("- **Status**: committed\n"), "{content}");
|
||||
}
|
||||
|
||||
/// Behind the refusals, all of them: a move that does not happen leaves the file exactly
|
||||
/// as it was, stamp included.
|
||||
#[test]
|
||||
fn mv_writes_no_stamp_when_the_move_is_refused() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let backward = stamped_ticket(&worklane, "committed");
|
||||
let before = ticket_at(&worklane, "committed", &backward);
|
||||
|
||||
let out = move_ticket(&temp, "cccc3333", "backlog", false);
|
||||
assert!(!out.status.success());
|
||||
assert_eq!(ticket_at(&worklane, "committed", &backward), before);
|
||||
|
||||
// The blocked ticket takes the other refusal, which sits after the no-op return.
|
||||
let blocked = create_gated_pair(&worklane, &temp, "backlog");
|
||||
let before = ticket_at(&worklane, "backlog", &blocked);
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(!out.status.success());
|
||||
assert_eq!(ticket_at(&worklane, "backlog", &blocked), before);
|
||||
}
|
||||
|
||||
/// A move to the status the ticket is already in returns before anything is written, so
|
||||
/// it does not restamp either.
|
||||
#[test]
|
||||
fn mv_does_not_restamp_a_no_op_move() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "committed");
|
||||
let before = ticket_at(&worklane, "committed", &filename);
|
||||
|
||||
let out = move_ticket(&temp, "cccc3333", "committed", false);
|
||||
assert!(out.status.success());
|
||||
|
||||
assert_eq!(ticket_at(&worklane, "committed", &filename), before);
|
||||
}
|
||||
|
||||
+44
-4
@@ -289,6 +289,21 @@ fn relate_leaves_everything_it_was_not_asked_about_alone() {
|
||||
assert!(content.contains("- **Owner**: alice"), "{content}");
|
||||
}
|
||||
|
||||
/// The mark each kind prints before the id. Written out rather than imported: these
|
||||
/// tests drive the binary, so they see only its output.
|
||||
///
|
||||
/// The cross is the one a held-up card already carries, since both say the same word.
|
||||
const BLOCKED_MARK: &str = "\u{d7}";
|
||||
const RELATES_MARK: &str = "\u{2192}";
|
||||
|
||||
/// And the mark for the status of the ticket the row names, which follows the kind: a
|
||||
/// circle filling up as the target moves through the flow.
|
||||
const BACKLOG_MARK: &str = "\u{25cb}";
|
||||
const DONE_MARK: &str = "\u{25cf}";
|
||||
/// A target the board no longer holds has no status, and `?` holds the column so the id
|
||||
/// does not move.
|
||||
const NO_STATUS_MARK: &str = "?";
|
||||
|
||||
/// The kind, the short id and the title, so the section reads without a second lookup.
|
||||
#[test]
|
||||
fn show_renders_the_kind_the_short_id_and_the_title() {
|
||||
@@ -299,7 +314,10 @@ fn show_renders_the_kind_the_short_id_and_the_title() {
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("Relations"), "{shown}");
|
||||
assert!(shown.contains("blocked by (b1b2c3d) The blocker"), "{shown}");
|
||||
assert!(
|
||||
shown.contains(&format!("blocked by {BLOCKED_MARK} {BACKLOG_MARK} (b1b2c3d) The blocker")),
|
||||
"{shown}"
|
||||
);
|
||||
// Never the stored line: a bare uuid says nothing about what it points at.
|
||||
assert!(!shown.contains(BLOCKER), "{shown}");
|
||||
}
|
||||
@@ -314,12 +332,31 @@ fn show_lists_the_relation_the_other_ticket_holds() {
|
||||
run(&temp, &["relate", GATED, "--relates-to", FIXED]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", BLOCKER]));
|
||||
assert!(shown.contains("blocks (641e3d5) The gated one"), "{shown}");
|
||||
assert!(
|
||||
shown.contains(&format!("blocks {BLOCKED_MARK} {BACKLOG_MARK} (641e3d5) The gated one")),
|
||||
"{shown}"
|
||||
);
|
||||
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
|
||||
|
||||
// Two kinds on one ticket, each with its own mark, and the second mark is the state
|
||||
// of the ticket at the far end: the old fix is in done and the blocker is not. That
|
||||
// is the pair the block is for, which kind of edge and whether it is finished.
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(
|
||||
shown.contains(&format!("blocked by {BLOCKED_MARK} {BACKLOG_MARK} (b1b2c3d) The blocker")),
|
||||
"{shown}"
|
||||
);
|
||||
assert!(
|
||||
shown.contains(&format!("relates to {RELATES_MARK} {DONE_MARK} (f1f2f3f) The old fix")),
|
||||
"{shown}"
|
||||
);
|
||||
|
||||
// `relates to` is symmetric, so it reads the same way from either end.
|
||||
let shown = stdout(&run(&temp, &["show", FIXED]));
|
||||
assert!(shown.contains("relates to (641e3d5) The gated one"), "{shown}");
|
||||
assert!(
|
||||
shown.contains(&format!("relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one")),
|
||||
"{shown}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -331,7 +368,10 @@ fn a_target_that_no_longer_exists_renders_as_missing() {
|
||||
fs::remove_file(find(&worklane, BLOCKER)).unwrap();
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("blocked by (b1b2c3d) _missing_"), "{shown}");
|
||||
assert!(
|
||||
shown.contains(&format!("blocked by {BLOCKED_MARK} {NO_STATUS_MARK} (b1b2c3d) _missing_")),
|
||||
"{shown}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The section is the one part of a ticket read back by machine, so a line nobody can
|
||||
|
||||
@@ -489,6 +489,39 @@ fn show_renders_the_metadata_as_an_aligned_table() {
|
||||
assert!(content.contains("- **Owner**: alice"));
|
||||
}
|
||||
|
||||
/// The stamps `mv` writes are fields like any other: the table renders what the file
|
||||
/// holds, so nothing here knows their names, and the column widens to the longest of
|
||||
/// them the way it does for anything else.
|
||||
#[test]
|
||||
fn show_renders_a_status_stamp_in_the_metadata_table() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let filename = "abc123def456789012345678901234567890_stamped.md";
|
||||
fs::write(
|
||||
worklane.join("committed").join(filename),
|
||||
"# Stamped Ticket\n\n## Metadata\n\n\
|
||||
- **ID**: abc123def456789012345678901234567890\n\
|
||||
- **Created At**: 2026-08-20 15:51:01\n\
|
||||
- **Committed On**: 2026-08-22 09:14:30\n\
|
||||
- **Status**: committed\n",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("show").arg("Stamped");
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
|
||||
assert!(
|
||||
stdout.contains(
|
||||
"Created At 2026-08-20 15:51:01\n\
|
||||
Committed On 2026-08-22 09:14:30\n\
|
||||
Status committed\n"
|
||||
),
|
||||
"{stdout:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// Write a ticket with an exact uuid and title, since both matter to resolution.
|
||||
fn ticket_with(worklane: &std::path::Path, status: &str, uuid: &str, title: &str, slug: &str) {
|
||||
fs::write(
|
||||
|
||||
Reference in New Issue
Block a user