Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5ae9c7fe00 | ||
|
|
ce32b42ae4 | ||
|
|
ece201e3ab | ||
|
|
c437d87e9e | ||
|
|
0ce3fdb246 | ||
|
|
37dbd722e0 | ||
|
|
4502de7ee3 |
@@ -7,6 +7,7 @@
|
||||
- `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
|
||||
- `src/tui.rs` - board state, the change digest, and the ratatui draw
|
||||
- `src/clipboard.rs` - the OSC 52 write and the base64 it carries, the board's only way out to the clipboard
|
||||
- `src/install.rs` - the embedded agent assets and the compare-and-refuse install
|
||||
- `assets/SKILL.md` - the agent skill for the CLI itself, embedded with `include_str!`
|
||||
- `assets/REVIEW.md` - the agent skill for reviewing a finished ticket, shipped the same way. Assets are named after the role they teach; `SKILL.md` keeps its name because the role it teaches is the CLI
|
||||
@@ -63,6 +64,15 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **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
|
||||
|
||||
### 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` is now at the boundary the Rust Style rule names:** four filters and the directory. Two of them are adjacent `&Option<String>` parameters, which a caller can swap silently, so the next filter added here takes an `LsArgs` struct the way `add` took `AddArgs`, rather than a fifth positional
|
||||
|
||||
### 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
|
||||
@@ -135,6 +145,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- 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
|
||||
- Entering another column follows the selection rather than resetting to its top. The card index carries across columns, so a reset would open the column with the highlight below the fold whenever it was — the opposite of the detail view's reset-on-selection-move, where each ticket genuinely starts at its own top. The index is shared and clamps permanently when a shorter column pulls it down, so a column you return to follows the selection to where it now sits rather than holding your old place
|
||||
- **The footer names only keys that work.** It read `↑↓ scroll` when nothing scrolled at all, which sends the reader looking for their own mistake. A UI that misdescribes itself is worse than one that is merely incomplete
|
||||
- **`q` and `esc` are one key: close what is open, quit when there is nothing left to close.** `q` used to set `should_quit` outright, so a reader who pressed it to put a ticket away lost the board instead, which is not what `q` does anywhere else that lays a document over a list. One match arm in `main.rs`, not two: two arms carrying one rule is how a later edit changes it for one key and not the other
|
||||
- **The rule is `Board::dismiss`, not the match arm.** The dispatch in `main.rs` is not reachable from a test, so anything decided there is undecidable by the suite. The arm is the line that names the keys and nothing else. `the_dispatch_gives_q_and_esc_one_arm_and_leaves_ctrl_c_quitting` scans `main.rs` for what the arm cannot say for itself, over whitespace-collapsed source so rustfmt cannot fail it
|
||||
- **The footer's last slot always answers how to get out**, and with a ticket open the honest answer is `ctrl-c`, the only key left that quits in one press. Going on saying `q quit` there would be 1b78a24 in the other direction: a footer describing a key by what it used to do
|
||||
- **The overlay names its ticket on the border, not at the head of the paragraph.** `Board::detail` is a `Detail` carrying the title, the id and the text, because the name has to travel beside the body rather than inside it: `content_trim` drops the `# ` heading on purpose, since `cmd_show` prints it, and anything in the paragraph scrolls away
|
||||
- `detail_title` cuts the string itself instead of leaving it to ratatui, which truncates an overlong block title at whatever cell it reaches and would take the id with it. Cut against the inner width, so the id survives whole and the name ends in an ellipsis. The id goes first because that is how every other view addresses a ticket
|
||||
- The detail view renders with colour off. ratatui draws styled spans, so an escape sequence in a paragraph would be printed as literal bytes. `content_trim` and `format_comments_with` take the colour decision for that reason
|
||||
@@ -146,7 +159,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
|
||||
@@ -160,6 +173,51 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- The choice is not remembered between runs. worklane has no config file and one flag is not a reason to start one; if it should persist, that is its own ticket
|
||||
- **Assert a column heading against the top border row, not the whole screen.** The footer names done too, so `screen.contains("done (0)")` passes on the footer whether the column is drawn or not. Three tests went vacuous that way the moment done was hidden; `headings()` and `footer()` exist so the next one does not. `headings()` locates the row through `board_area()` rather than taking row zero, since the tab row sits above it when more than one board is monitored
|
||||
|
||||
### The Search Prompt
|
||||
- **`search: Option<Search>` is the whole mode**, the shape `detail` uses: "the prompt is open" and "what is in it" cannot disagree, and closing it leaves nothing to reset. `Search` also carries `missed`, set when enter found nothing and cleared by the next edit, since the message is about the query that missed
|
||||
- **The prompt swallows every key it is given.** `Board::search_key` runs ahead of the action arms in `main.rs` and reports what it took, rather than every arm below asking whether a search is open. Typing `d` into a query must not toggle done and `q` must not quit; with no prompt open it takes nothing, so the dispatch is unchanged for every other state. The rule is on `Board` for the reason `dismiss` is: the arm is not reachable from a test
|
||||
- **`ctrl-c` is the one key it declines**, because a terminal application always honours it and a prompt that ate it would leave no way off the board. Every *other* control combination is swallowed and does nothing: it must not type its letter, and it must not fall through either, since the action arms match on the code alone and `ctrl-d` would reach the one bound to `d`
|
||||
- **Esc is consumed by the search before it can mean anything else**, which is the collision e7612de left behind: `esc` and `q` close the overlay, and both have to lose to an open prompt. It falls out of the pre-branch rather than being ordered by hand
|
||||
- **`first_match` searches the *visible columns*, every card in them, not the rows on screen.** A query that answered differently on a tall terminal and a short one is not a search, and the jump scrolls the match into view anyway. Hidden columns stay out: with done hidden, a match there would put the highlight on a ticket that is not on the board. Reading order is column by column, then top to bottom
|
||||
- Id and title only, per 3b16540, both lowercased. The title has to be case insensitive to be worth typing, and giving the id the same treatment lets a pasted id match whatever case it was copied in. An empty or all-space query matches **nothing** rather than everything
|
||||
- **The jump goes through `select_at`, the tail `select_card` already used.** `follow_selection` scrolls the column the card is in, and the offsets are per column and on the `Tab`, so a jump across columns moves the right one; `refresh_detail` keeps an open overlay on the ticket the selection names. A second version of either is how a jump comes to scroll differently from the arrow keys
|
||||
- **A hit closes the prompt and a miss keeps it open**, marked, with the selection untouched. The query can then be corrected in place instead of retyped from `/`. Doing nothing visible is what makes a reader retype a query that was already right
|
||||
- **The prompt takes the whole footer row**, because the key list it replaces describes nothing that currently works while every key is going into the buffer. The typed query is drawn in the default foreground and the keys in grey: one is content, the other is chrome. `no match` is brightred beside the query it is about, since grey chrome is what a reader skips
|
||||
- **The real terminal cursor goes after the query**, not a glyph standing in for one. ratatui shows the cursor only for a frame that asked for it, so `set_cursor_position` is also what says "you are typing" while the query is still empty. Clamped to the row, so a query longer than the terminal leaves it on the last cell
|
||||
- Both closed footers name `/`, since the jump works with a ticket open as well: it moves the selection and the overlay follows
|
||||
- Out of scope on purpose, each its own ticket once the input mode exists: `n` and `N` for the next and previous match, searching the description, tags or owner, regex, and filtering the board down to matches rather than selecting one
|
||||
|
||||
### The Copy Key
|
||||
- **`y` copies the selected card's short id, over OSC 52 written by hand.** The board is where a ticket is found and the CLI is where it is acted on, and the only thing joining them was seven characters retyped off the screen. `y` reads as yank to the readers a keyboard board is for, and was the letter left: `q`, `esc`, `enter`, `space`, `hjkl`, the arrows, `pgup`, `pgdn`, `tab`, `backtab`, `d` and `/` were taken
|
||||
- **The mechanism was chosen against ssh**, which is where a board is often read. An escape sequence is the only one of the three ways that crosses the connection, since it is the terminal at the reader's end that owns the clipboard. A crate (`arboard` and its kind) wants X11 and Wayland libraries at build time, and on X11 the selection belongs to the process that set it: copy an id, quit, and the paste buffer is empty, which is precisely this flow. Shelling out to `wl-copy`, `xclip` or `pbcopy` is platform sniffing plus a process spawn, and does nothing on a machine where none of them is installed or on the far end of a connection. crossterm 0.28 is what ratatui 0.29 pins and it ships no clipboard command, and the backend types have to match whatever ratatui pins, so a newer crossterm cannot be picked up on its own
|
||||
- **The cost is paid knowingly: a terminal that ignores OSC 52 ignores it silently**, and tmux needs `set-clipboard on`. What `clipboard::copy` reports is whether the sequence was written, not whether it was honoured, and the footer message says no more than that. There is no reply to read: the query form of OSC 52 is refused by most emulators as a security matter, so nothing better is available to us
|
||||
- Base64 is twenty lines here rather than a dependency, because the only thing that goes through it is a seven-character id. Pinned on the RFC 4648 vectors, which cover both padding forms, since a wrong encoder would put plausible-looking rubbish on the clipboard
|
||||
- **`c` and not `p`**: the clipboard proper, not the X11 primary selection, since this is pasted into a command line. Terminated with BEL, which is what tmux documents and what every emulator that implements this at all accepts
|
||||
- **What is copied is `ticket.id`, the seven characters the card prints**, not the full uuid: they are what stops the retyping and what `show`, `mv` and `comment` all resolve. Decided by `Board::copy_text` rather than inside the arm that copies, so the string is a question the suite can ask without a clipboard. `None` on an empty column, since an empty string would take away whatever the reader had there and give nothing back
|
||||
- The project is left off even on the merge tab, where the id alone is not an address. This goes onto a clipboard to be pasted into a command line, and a second word in it would have to be deleted every time; running the command in the wrong project fails to resolve rather than acting on the wrong ticket
|
||||
- **The clipboard is handed to `Board::copy_selected_id` as an argument**, `clipboard::copy` from the dispatch and a closure from a test. That is what makes both answers drivable, and it keeps the terminal write out of the board state
|
||||
- **A failure is said in the footer, not returned.** There is nobody above it to handle one: the board goes on being drawn, and an error swallowed there would look exactly like a copy that worked until the paste came out wrong
|
||||
- **`Notice` is the board's one channel for saying something in words**, since a copy leaves nothing on screen to look at. `failed` means "nothing reached the clipboard" rather than "an error occurred", so an empty column and a refused write are one answer to the reader, both in brightred for the reason `no match` is
|
||||
- **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
|
||||
- **The mark says which kind of edge the row is**, not what state its target is in: `×` for blocking, `→` for a neighbour, `←` for a regression. The labels are five long words that blur when a ticket carries several, and the mark is what makes the block scannable, since the rows holding you up are the crosses. It first marked the target's *status* (a rising bar, `▁▄▆█`); that answered "is my blocker done" and read as an undifferentiated column of blocks, and the kind was judged the more useful thing to see. The status is not shown anywhere in the block now
|
||||
- **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 arrows are not from 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 mark goes ahead of the id**, where it describes the edge rather than the row. Every row carries one, 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 this one before it
|
||||
- **The mark survives a target the board cannot find**, because the kind is read from the ticket's own file rather than from the board. Only the name is gone, and `_missing_` in grey is what says so
|
||||
- **`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
|
||||
@@ -211,6 +269,7 @@ 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
|
||||
- **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
|
||||
@@ -246,6 +305,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
|
||||
- **Correcting output that shipped one version ago is a patch**, not a second minor. 0.15.1 changed the relation mark that 0.15.0 had just introduced: the minor was the arrival of a mark, and settling which glyph it is belongs to it. A second minor would say the two are separate features to anyone reading the tags
|
||||
- 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
+1
-1
@@ -1494,7 +1494,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.13.4"
|
||||
version = "0.15.1"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.13.4"
|
||||
version = "0.15.1"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -5,10 +5,10 @@ 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, `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, `/` 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` |
|
||||
| `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 |
|
||||
|
||||
+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.
|
||||
|
||||
@@ -41,11 +41,19 @@ A move is also refused while the ticket is blocked by one that is not done yet,
|
||||
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.
|
||||
|
||||
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
|
||||
|
||||
```
|
||||
@@ -133,6 +141,11 @@ 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 with the kind of edge it 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, so the rows holding
|
||||
a ticket up are readable without reading the words. The board draws the same block.
|
||||
|
||||
## Campaigns
|
||||
|
||||
A campaign groups the tickets that have to be finished together: a release, a migration,
|
||||
|
||||
+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),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
//! Putting text on the clipboard of whatever terminal is drawing the board.
|
||||
//!
|
||||
//! OSC 52, written by hand, and the reasoning is in AGENTS.md under The Copy Key. The
|
||||
//! short of it: the board is often being read over ssh, and an escape sequence is the
|
||||
//! only one of the three ways that crosses the connection. crossterm 0.28 is what
|
||||
//! ratatui 0.29 pins and it ships no clipboard command, so the sequence and the base64
|
||||
//! it carries are written here rather than pulled in.
|
||||
//!
|
||||
//! The honest limit is that a terminal which ignores OSC 52 ignores it silently: what
|
||||
//! this reports is whether the sequence was written, not whether it was honoured.
|
||||
|
||||
use std::io::Write;
|
||||
|
||||
use anyhow::{Context, Result};
|
||||
|
||||
/// Ask the terminal to put `text` on the system clipboard.
|
||||
///
|
||||
/// `52;c` is the clipboard proper rather than `p`, the X11 primary selection, because
|
||||
/// this is for pasting into a command line with ctrl-shift-v or cmd-v. Terminated with
|
||||
/// BEL rather than ST: both are accepted, and BEL is what tmux's `set-clipboard`
|
||||
/// documents and what every emulator that implements this at all takes.
|
||||
///
|
||||
/// Written straight to stdout, which is where ratatui's own frames go, and flushed
|
||||
/// before returning so a failure belongs to this call rather than to the next draw.
|
||||
pub fn copy(text: &str) -> Result<()> {
|
||||
let mut out = std::io::stdout();
|
||||
write!(out, "\x1b]52;c;{}\x07", base64(text.as_bytes()))
|
||||
.and_then(|()| out.flush())
|
||||
.context("could not write to the terminal")
|
||||
}
|
||||
|
||||
/// Standard base64, the alphabet OSC 52 requires, padding included.
|
||||
///
|
||||
/// Twenty lines against a dependency: the only thing encoded here is a seven-character
|
||||
/// id, and the crate would be carried for its own sake.
|
||||
fn base64(bytes: &[u8]) -> String {
|
||||
const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
|
||||
for chunk in bytes.chunks(3) {
|
||||
// The missing bytes of a short chunk read as zero, and the characters they
|
||||
// would have produced are the ones that become padding below.
|
||||
let triple = chunk
|
||||
.iter()
|
||||
.chain([0u8; 2].iter())
|
||||
.take(3)
|
||||
.fold(0u32, |acc, byte| (acc << 8) | u32::from(*byte));
|
||||
|
||||
for slot in 0..4 {
|
||||
match slot <= chunk.len() {
|
||||
true => out.push(char::from(ALPHABET[(triple >> (18 - 6 * slot) & 0x3f) as usize])),
|
||||
false => out.push('='),
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The vectors from RFC 4648, which is what a terminal decodes with. Every chunk
|
||||
/// length is in here, so the padding is covered in both of its forms.
|
||||
#[test]
|
||||
fn base64_encodes_the_rfc_vectors() {
|
||||
assert_eq!(base64(b""), "");
|
||||
assert_eq!(base64(b"f"), "Zg==");
|
||||
assert_eq!(base64(b"fo"), "Zm8=");
|
||||
assert_eq!(base64(b"foo"), "Zm9v");
|
||||
assert_eq!(base64(b"foob"), "Zm9vYg==");
|
||||
assert_eq!(base64(b"fooba"), "Zm9vYmE=");
|
||||
assert_eq!(base64(b"foobar"), "Zm9vYmFy");
|
||||
}
|
||||
|
||||
/// What actually goes on the wire for a short id, which is the whole use.
|
||||
#[test]
|
||||
fn base64_encodes_a_short_id() {
|
||||
assert_eq!(base64(b"0546fc5"), "MDU0NmZjNQ==");
|
||||
}
|
||||
|
||||
/// The high bits reach the end of the alphabet, which an off-by-one in the shift
|
||||
/// would miss entirely on ascii input.
|
||||
#[test]
|
||||
fn base64_reaches_the_whole_alphabet() {
|
||||
assert_eq!(base64(&[0xff, 0xff, 0xff]), "////");
|
||||
assert_eq!(base64(&[0xfb, 0xff, 0xfe]), "+//+");
|
||||
assert_eq!(base64(&[0x00, 0x00, 0x00]), "AAAA");
|
||||
}
|
||||
}
|
||||
@@ -120,6 +120,10 @@ pub enum Command {
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
priority: Option<u8>,
|
||||
|
||||
/// Only show tickets carrying this tag, matched whole
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
tag: Option<String>,
|
||||
|
||||
/// Only show the members of this campaign, by UUID or title
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
campaign: Option<String>,
|
||||
|
||||
+37
-5
@@ -40,6 +40,7 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
pub fn cmd_ls(
|
||||
status_filter: &Option<String>,
|
||||
priority_filter: Option<u8>,
|
||||
tag_filter: &Option<String>,
|
||||
campaign_filter: &Option<String>,
|
||||
worklane_dir: &Path,
|
||||
) -> Result<()> {
|
||||
@@ -50,6 +51,7 @@ pub fn cmd_ls(
|
||||
None => None,
|
||||
};
|
||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
||||
let tag = tag_filter.as_deref();
|
||||
|
||||
if let Some(campaign) = &campaign {
|
||||
println!(
|
||||
@@ -68,7 +70,7 @@ pub fn cmd_ls(
|
||||
));
|
||||
}
|
||||
|
||||
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 +88,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 +104,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() {
|
||||
@@ -119,8 +121,38 @@ pub fn cmd_ls(
|
||||
|
||||
/// 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.
|
||||
|
||||
+36
-8
@@ -2,6 +2,7 @@ use anyhow::Result;
|
||||
use clap::Parser;
|
||||
|
||||
mod campaign;
|
||||
mod clipboard;
|
||||
mod command;
|
||||
mod handlers;
|
||||
mod install;
|
||||
@@ -48,10 +49,11 @@ fn main() -> Result<()> {
|
||||
Some(Command::Ls {
|
||||
status,
|
||||
priority,
|
||||
tag,
|
||||
campaign,
|
||||
}) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_ls(&status, priority, &campaign, &worklane_dir)
|
||||
cmd_ls(&status, priority, &tag, &campaign, &worklane_dir)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
@@ -163,17 +165,34 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
continue;
|
||||
}
|
||||
|
||||
// Every keypress takes away what the last one said, so a notice never
|
||||
// outlives the moment it belongs to. Ahead of the prompt as well as the
|
||||
// arms: a key typed into a query is still a key. The rule is
|
||||
// `Board::clear_notice`, where a test can reach it, and the arm below that
|
||||
// sets one runs after this.
|
||||
board.clear_notice();
|
||||
|
||||
// Ahead of the arms, because a prompt has to swallow every key it is
|
||||
// given: typing `d` into a query must not toggle the done column and `q`
|
||||
// must not quit. It reports what it took, so the arms below stay a plain
|
||||
// match on the keys it did not, and it takes nothing when no prompt is open.
|
||||
// The rule is `Board::search_key`, where a test can reach it.
|
||||
if board.search_key(key, screen) {
|
||||
continue;
|
||||
}
|
||||
|
||||
match key.code {
|
||||
KeyCode::Char('q') => board.should_quit = true,
|
||||
// One arm, because the two keys mean one thing: close what is open, and
|
||||
// quit when there is nothing left to close. Two arms carrying one rule
|
||||
// is how a later edit changes it for one key and not the other, which is
|
||||
// what `q` quitting out from under an open ticket already was. The rule
|
||||
// itself is `Board::dismiss`, where a test can reach it.
|
||||
KeyCode::Esc | KeyCode::Char('q') => board.dismiss(),
|
||||
// The only key that leaves the board from an open ticket, which is why
|
||||
// the footer names it there.
|
||||
KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
||||
board.should_quit = true
|
||||
}
|
||||
// Esc closes the detail view, and only quits when there is nothing
|
||||
// left to dismiss.
|
||||
KeyCode::Esc => match board.detail {
|
||||
Some(_) => board.toggle_detail(),
|
||||
None => board.should_quit = true,
|
||||
},
|
||||
KeyCode::Enter | KeyCode::Char(' ') => board.toggle_detail(),
|
||||
KeyCode::Left | KeyCode::Char('h') => board.select_column(-1, screen),
|
||||
KeyCode::Right | KeyCode::Char('l') => board.select_column(1, screen),
|
||||
@@ -191,6 +210,15 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
KeyCode::BackTab => board.select_tab(-1, screen),
|
||||
// Free of the other bindings, and the footer names it in both states.
|
||||
KeyCode::Char('d') => board.toggle_done(screen),
|
||||
// An ordinary single-shot action like the rest: it opens the prompt, and
|
||||
// from the next keypress on `search_key` above has the keyboard. A `/`
|
||||
// typed into an open prompt is taken there as a character, so this arm
|
||||
// is only ever the way in.
|
||||
KeyCode::Char('/') => board.open_search(),
|
||||
// `y` as in yank, for the readers this board is for, and the only letter
|
||||
// left that a vim hand would reach for. The clipboard is handed in rather
|
||||
// than reached for inside `Board`, so the suite can drive both answers.
|
||||
KeyCode::Char('y') => board.copy_selected_id(clipboard::copy),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
+1301
-46
File diff suppressed because it is too large
Load Diff
+351
-66
@@ -539,8 +539,12 @@ pub fn format_comments_with(
|
||||
/// an edit at every call site.
|
||||
#[derive(Default)]
|
||||
pub struct Resolved {
|
||||
/// The block [`render_relations`] built, or empty for a ticket with no relations.
|
||||
pub relations: String,
|
||||
/// The relations of the ticket, both directions, from [`relations_for`]. Empty for a
|
||||
/// ticket with none at either end.
|
||||
///
|
||||
/// Rows rather than the rendered block: the CLI paints them into escapes and the
|
||||
/// board styles the same rows itself, since a paragraph is no place for an escape.
|
||||
pub relations: Vec<RelationRow>,
|
||||
/// The Campaign value as it reads, from [`reference_cell`]. Empty leaves the stored
|
||||
/// value to render as it sits, which is what a ticket in no campaign wants.
|
||||
pub campaign: String,
|
||||
@@ -555,7 +559,7 @@ pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
|
||||
/// The rule is measured on the name as displayed, in characters. It used to span the
|
||||
/// raw line, so it ran three past the heading for the `## `, and byte length over-drew
|
||||
/// anything non-ASCII.
|
||||
fn push_heading(out: &mut String, heading: &str, colored: bool) {
|
||||
fn push_heading(out: &mut Body, heading: &str, colored: bool) {
|
||||
let name = heading.strip_prefix("## ").unwrap_or(heading);
|
||||
|
||||
out.push_str(&paint(name, Color::Orange, colored));
|
||||
@@ -572,10 +576,70 @@ fn push_heading(out: &mut String, heading: &str, colored: bool) {
|
||||
///
|
||||
/// [`Resolved`] carries the parts that come from elsewhere on the board, since the
|
||||
/// body alone cannot render them.
|
||||
/// One piece of the rendered body: text as it prints, or relations still as rows.
|
||||
///
|
||||
/// The body is one string to the CLI and a run of styled lines to the board, and the
|
||||
/// only part that differs is the relations block. Splitting the body here rather than
|
||||
/// building it twice is what keeps the two views from drifting: everything outside the
|
||||
/// block is rendered once, by [`content_parts`], and the rows are handed on unpainted.
|
||||
pub enum BodyPart {
|
||||
Text(String),
|
||||
Relations(Vec<RelationRow>),
|
||||
}
|
||||
|
||||
/// The body under construction. Text accumulates into the trailing run, and a relations
|
||||
/// block closes it, so a caller pushes text and rows without tracking which it pushed
|
||||
/// last.
|
||||
#[derive(Default)]
|
||||
struct Body {
|
||||
parts: Vec<BodyPart>,
|
||||
}
|
||||
|
||||
impl Body {
|
||||
fn push_str(&mut self, text: &str) {
|
||||
match self.parts.last_mut() {
|
||||
Some(BodyPart::Text(run)) => run.push_str(text),
|
||||
_ => self.parts.push(BodyPart::Text(text.to_string())),
|
||||
}
|
||||
}
|
||||
|
||||
fn push(&mut self, c: char) {
|
||||
match self.parts.last_mut() {
|
||||
Some(BodyPart::Text(run)) => run.push(c),
|
||||
_ => self.parts.push(BodyPart::Text(c.to_string())),
|
||||
}
|
||||
}
|
||||
|
||||
fn push_relations(&mut self, rows: &[RelationRow]) {
|
||||
self.parts.push(BodyPart::Relations(rows.to_vec()));
|
||||
}
|
||||
|
||||
/// Whether the text written so far ends with `suffix`. A relations block never does,
|
||||
/// since it is not text yet.
|
||||
fn ends_with(&self, suffix: &str) -> bool {
|
||||
match self.parts.last() {
|
||||
Some(BodyPart::Text(run)) => run.ends_with(suffix),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String {
|
||||
let relations = resolved.relations.as_str();
|
||||
content_parts(content, colored, resolved)
|
||||
.iter()
|
||||
.map(|part| match part {
|
||||
BodyPart::Text(text) => text.clone(),
|
||||
BodyPart::Relations(rows) => render_relations(rows, colored),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The body rendered into its parts, with the colour decision already applied to the
|
||||
/// text and deliberately not to the relations.
|
||||
pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<BodyPart> {
|
||||
let relations = resolved.relations.as_slice();
|
||||
let lines: Vec<&str> = content.trim().lines().collect();
|
||||
let mut result = String::new();
|
||||
let mut result = Body::default();
|
||||
let mut current_section = "";
|
||||
let mut criterion = 0;
|
||||
let mut i = 0;
|
||||
@@ -598,7 +662,7 @@ pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String
|
||||
// after everything.
|
||||
if is_metadata_heading(line) && !stores_relations && !relations.is_empty() {
|
||||
push_heading(&mut result, RELATIONS.heading, colored);
|
||||
result.push_str(relations);
|
||||
result.push_relations(relations);
|
||||
result.push('\n');
|
||||
shown_relations = true;
|
||||
}
|
||||
@@ -622,7 +686,7 @@ pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String
|
||||
// holds the same edges resolved to a title, and the inverses with them.
|
||||
if line.trim_end() == RELATIONS.heading && !relations.is_empty() {
|
||||
let end = section_end(&lines, i);
|
||||
result.push_str(relations);
|
||||
result.push_relations(relations);
|
||||
// The blank line the skipped body ended with, before the next heading.
|
||||
if end < lines.len() {
|
||||
result.push('\n');
|
||||
@@ -705,10 +769,10 @@ pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String
|
||||
result.push('\n');
|
||||
}
|
||||
push_heading(&mut result, RELATIONS.heading, colored);
|
||||
result.push_str(relations);
|
||||
result.push_relations(relations);
|
||||
}
|
||||
|
||||
result
|
||||
result.parts
|
||||
}
|
||||
|
||||
/// Colour the `1.` at the head of a numbered line, leaving the rest alone.
|
||||
@@ -1640,86 +1704,214 @@ impl RelationIndex {
|
||||
/// relations block and the Campaign field, so a dangling reference is spelled one way
|
||||
/// wherever it is shown.
|
||||
pub fn reference_cell(uuid: &str, name: Option<&str>, colored: bool) -> String {
|
||||
let id = paint(short_id(uuid), Color::Red, colored);
|
||||
paint_cells(&reference_cells(uuid, name), colored)
|
||||
}
|
||||
|
||||
/// The same cross reference in cells, for a renderer that is not writing escapes.
|
||||
///
|
||||
/// The one spelling of a reference, so the relations block and the Campaign field cannot
|
||||
/// come to say a dangling one differently, and the board draws the id in the colour the
|
||||
/// guideline gives it rather than dropping every colour to stay safe.
|
||||
pub fn reference_cells(uuid: &str, name: Option<&str>) -> Vec<Cell> {
|
||||
let mut cells = vec![
|
||||
Cell::plain("("),
|
||||
Cell::colored(short_id(uuid), Color::Red),
|
||||
Cell::plain(") "),
|
||||
];
|
||||
|
||||
match name {
|
||||
Some(name) => format!("({}) {}", id, name),
|
||||
None => format!("({}) {}", id, paint("_missing_", Color::Grey, colored)),
|
||||
Some(name) => cells.push(Cell::plain(name)),
|
||||
None => cells.push(Cell::colored("_missing_", Color::Grey)),
|
||||
}
|
||||
|
||||
cells
|
||||
}
|
||||
|
||||
/// Cells as the CLI prints them: each one painted, or carried through as it stands.
|
||||
pub fn paint_cells(cells: &[Cell], colored: bool) -> String {
|
||||
cells
|
||||
.iter()
|
||||
.map(|cell| match cell.color {
|
||||
Some(color) => paint(&cell.text, color, colored),
|
||||
None => cell.text.clone(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The mark a blocking relation carries, and a card waiting on one.
|
||||
///
|
||||
/// 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.
|
||||
///
|
||||
/// One glyph for both places, since both say the same word: on a card that this ticket
|
||||
/// is held up, in the relations block that this edge is what holds one. The direction is
|
||||
/// the label's to say.
|
||||
pub const BLOCKED_MARK: &str = "\u{d7}";
|
||||
|
||||
/// The mark a `relates to` row carries: a plain pointer to somewhere else worth reading.
|
||||
pub const RELATES_MARK: &str = "\u{2192}";
|
||||
|
||||
/// The mark a regression row carries, pointing back at the fix it undid.
|
||||
pub const REGRESSION_MARK: &str = "\u{2190}";
|
||||
|
||||
/// The glyph and colour for a kind of relation.
|
||||
///
|
||||
/// The label already names the kind in words, and this is what makes the block scannable
|
||||
/// without reading them: the rows that hold you up are the red crosses, whichever
|
||||
/// direction they point. Arrows and a cross rather than shapes from the priority
|
||||
/// vocabulary, and all three are in the ramp the footer's own `\u{2190}\u{2192}\u{2191}\u{2193}` already draws.
|
||||
///
|
||||
/// The colours reuse the palette the way the priority meter does, as a small ramp inside
|
||||
/// one column rather than as new meanings: brightred is the cross a card already draws,
|
||||
/// cyan the pointer, orange the way back. Nothing here is a colour standing in for a
|
||||
/// uuid or a title, which are what sit beside it on the row.
|
||||
pub fn relation_mark(kind: RelationKind) -> (&'static str, Color) {
|
||||
match kind {
|
||||
RelationKind::BlockedBy => (BLOCKED_MARK, Color::BrightRed),
|
||||
RelationKind::RelatesTo => (RELATES_MARK, Color::Cyan),
|
||||
RelationKind::RegressionOf => (REGRESSION_MARK, Color::Orange),
|
||||
}
|
||||
}
|
||||
|
||||
/// A relation's target as it reads.
|
||||
fn target_cell(target: Option<&RelatedTicket>, uuid: &str, colored: bool) -> String {
|
||||
reference_cell(uuid, target.map(|ticket| ticket.title.as_str()), colored)
|
||||
/// One row of the Relations block: which relation, and what it points at.
|
||||
///
|
||||
/// The title is `None` for a uuid the board no longer holds, which is the one case with
|
||||
/// nothing to name.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RelationRow {
|
||||
/// Which edge this is, which decides the mark. Kept beside the label rather than
|
||||
/// derived from it: the label is the same word for both directions of `relates to`,
|
||||
/// and reading a kind back out of prose is how a mark comes to disagree with a row.
|
||||
pub kind: RelationKind,
|
||||
/// The kind as it reads from this end, which is what the row is padded against.
|
||||
pub label: &'static str,
|
||||
pub uuid: String,
|
||||
/// The title of the ticket it names, once the board has been read for it.
|
||||
pub title: Option<String>,
|
||||
}
|
||||
|
||||
/// The Relations section as it is shown, or empty when there is nothing to show.
|
||||
/// A run of text and the colour it is drawn in, or `None` for the default foreground.
|
||||
///
|
||||
/// Both directions, stored first: the relations the ticket holds, then the ones held
|
||||
/// against it, named from this end. Rendered from the index rather than from the body
|
||||
/// alone, because a bare uuid says nothing and half the relations are not in the file.
|
||||
pub fn render_relations(
|
||||
stored: &[Relation],
|
||||
index: &RelationIndex,
|
||||
uuid: &str,
|
||||
colored: bool,
|
||||
) -> String {
|
||||
let mut rows: Vec<(&'static str, String)> = stored
|
||||
/// The unit both renderers take: [`paint`] turns one into an escape sequence for the
|
||||
/// CLI, and the board turns the same one into a ratatui `Span`. A block laid out once
|
||||
/// and painted twice cannot draw two different blocks.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Cell {
|
||||
pub text: String,
|
||||
pub color: Option<Color>,
|
||||
}
|
||||
|
||||
impl Cell {
|
||||
fn plain(text: impl Into<String>) -> Self {
|
||||
Cell {
|
||||
text: text.into(),
|
||||
color: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn colored(text: impl Into<String>, color: Color) -> Self {
|
||||
Cell {
|
||||
text: text.into(),
|
||||
color: Some(color),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The relations of one ticket, both directions, in the order they are shown.
|
||||
///
|
||||
/// Stored first: the relations the ticket holds, then the ones held against it, named
|
||||
/// from this end. Read from the index rather than from the body alone, because a bare
|
||||
/// uuid says nothing and half the relations are not in the file.
|
||||
///
|
||||
/// The single builder. Everything that shows a relation goes through these rows, so the
|
||||
/// CLI and the board cannot disagree about which edges there are, what they are called
|
||||
/// or which direction comes first.
|
||||
pub fn relation_rows(stored: &[Relation], index: &RelationIndex, uuid: &str) -> Vec<RelationRow> {
|
||||
let mut rows: Vec<RelationRow> = stored
|
||||
.iter()
|
||||
.map(|relation| {
|
||||
(
|
||||
relation.kind.label(),
|
||||
target_cell(index.get(&relation.target), &relation.target, colored),
|
||||
)
|
||||
.map(|relation| RelationRow {
|
||||
kind: relation.kind,
|
||||
label: relation.kind.label(),
|
||||
uuid: relation.target.clone(),
|
||||
title: index
|
||||
.get(&relation.target)
|
||||
.map(|ticket| ticket.title.clone()),
|
||||
})
|
||||
.collect();
|
||||
|
||||
rows.extend(index.inbound(uuid).into_iter().map(|(kind, holder)| {
|
||||
(
|
||||
kind.inverse_label(),
|
||||
target_cell(Some(holder), &holder.uuid, colored),
|
||||
)
|
||||
RelationRow {
|
||||
kind,
|
||||
label: kind.inverse_label(),
|
||||
uuid: holder.uuid.clone(),
|
||||
title: Some(holder.title.clone()),
|
||||
}
|
||||
}));
|
||||
|
||||
if rows.is_empty() {
|
||||
return String::new();
|
||||
}
|
||||
rows
|
||||
}
|
||||
|
||||
// Measured on the labels, which carry no colour, and padded before the target cell
|
||||
// is joined on, for the reason the metadata table is: an escape sequence counted
|
||||
// towards a width tilts the column the moment colour is on.
|
||||
/// The Relations block laid out: one row of cells per relation, or nothing to show.
|
||||
///
|
||||
/// The layout lives here rather than in each renderer, so the mark, the padding and the
|
||||
/// gutter are decided once. The labels are measured with no colour on them and padded
|
||||
/// before the target is joined, for the reason the metadata table is: an escape sequence
|
||||
/// counted towards a width tilts the column the moment colour is on.
|
||||
pub fn relation_cells(rows: &[RelationRow]) -> Vec<Vec<Cell>> {
|
||||
let width = rows
|
||||
.iter()
|
||||
.map(|(label, _)| label.chars().count())
|
||||
.map(|row| row.label.chars().count())
|
||||
.max()
|
||||
.unwrap_or(0);
|
||||
|
||||
rows.iter()
|
||||
.map(|row| {
|
||||
let (mark, colour) = relation_mark(row.kind);
|
||||
let padding = " ".repeat(width - row.label.chars().count());
|
||||
|
||||
// The mark goes ahead of the id, where it describes the target rather than
|
||||
// the row: every row carries one, so nothing is pushed out of line the way
|
||||
// the card's blocked mark would have been.
|
||||
let mut cells = vec![
|
||||
Cell::plain(format!("{}{}{}", row.label, padding, COLUMN_GUTTER)),
|
||||
Cell::colored(mark, colour),
|
||||
Cell::plain(" "),
|
||||
];
|
||||
cells.extend(reference_cells(&row.uuid, row.title.as_deref()));
|
||||
|
||||
cells
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The Relations section as the CLI prints it, or empty when there is nothing to show.
|
||||
pub fn render_relations(rows: &[RelationRow], colored: bool) -> String {
|
||||
let mut out = String::new();
|
||||
for (label, cell) in &rows {
|
||||
out.push_str(label);
|
||||
out.push_str(&" ".repeat(width - label.chars().count()));
|
||||
out.push_str(COLUMN_GUTTER);
|
||||
out.push_str(cell);
|
||||
|
||||
for row in relation_cells(rows) {
|
||||
out.push_str(&paint_cells(&row, colored));
|
||||
out.push('\n');
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
/// The rendered Relations block for one ticket, reading the board for the rest of it.
|
||||
/// The relations of the ticket in `content`, read against the board around it.
|
||||
///
|
||||
/// The colour decision is passed in rather than asked for, like everything else the
|
||||
/// body renders: the board draws the same text with colour off.
|
||||
pub fn relations_block(content: &str, worklane_dir: &Path, colored: bool) -> Result<String> {
|
||||
/// Rows rather than a rendered block: the board styles them itself, since an escape
|
||||
/// sequence in a ratatui paragraph is drawn as literal bytes.
|
||||
pub fn relations_for(content: &str, worklane_dir: &Path) -> Result<Vec<RelationRow>> {
|
||||
let title = heading_title(content);
|
||||
let stored = parse_relations(content, &title)?;
|
||||
let index = RelationIndex::load(worklane_dir)?;
|
||||
|
||||
Ok(render_relations(
|
||||
Ok(relation_rows(
|
||||
&stored,
|
||||
&index,
|
||||
&parse_ticket_field(content, "ID"),
|
||||
colored,
|
||||
))
|
||||
}
|
||||
|
||||
@@ -3202,6 +3394,17 @@ mod tests {
|
||||
}
|
||||
// --------------------------------------------------------------- relations --
|
||||
|
||||
/// One row as the block shows it, for a test about where the block goes rather than
|
||||
/// about how it was derived.
|
||||
fn row(kind: RelationKind, label: &'static str, uuid: &str, title: &str) -> RelationRow {
|
||||
RelationRow {
|
||||
kind,
|
||||
label,
|
||||
uuid: uuid.to_string(),
|
||||
title: Some(title.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
const TARGET: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
||||
const SELF: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
|
||||
@@ -3327,30 +3530,112 @@ mod tests {
|
||||
]);
|
||||
let stored = vec![relation(RelationKind::RegressionOf, TARGET)];
|
||||
|
||||
// Each row marked for its own kind: the way back for the regression, the cross
|
||||
// for the block, the pointer for the neighbour.
|
||||
assert_eq!(
|
||||
render_relations(&stored, &index, SELF, false),
|
||||
"regression of (b1b2c3d) The blocker\n\
|
||||
blocks (ccccccc) The other one\n\
|
||||
relates to (ccccccc) The other one\n"
|
||||
render_relations(&relation_rows(&stored, &index, SELF), false),
|
||||
format!(
|
||||
"regression of {REGRESSION_MARK} (b1b2c3d) The blocker\n\
|
||||
blocks {BLOCKED_MARK} (ccccccc) The other one\n\
|
||||
relates to {RELATES_MARK} (ccccccc) The other one\n"
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/// Every kind has a mark of its own, and no two share one: the mark is what makes the
|
||||
/// block scannable without reading the labels, so two kinds drawn alike would defeat
|
||||
/// it.
|
||||
#[test]
|
||||
fn every_relation_kind_has_a_mark_of_its_own() {
|
||||
let kinds = [
|
||||
RelationKind::BlockedBy,
|
||||
RelationKind::RelatesTo,
|
||||
RelationKind::RegressionOf,
|
||||
];
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
|
||||
for kind in kinds {
|
||||
let (mark, colour) = relation_mark(kind);
|
||||
assert!(!mark.is_empty(), "{kind:?} has no mark");
|
||||
assert!(seen.insert(mark), "{kind:?} shares its mark with another kind");
|
||||
assert_ne!(
|
||||
colour,
|
||||
Color::Green,
|
||||
"{kind:?} is drawn in the colour that means a title"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(seen.len(), 3, "{seen:?}");
|
||||
}
|
||||
|
||||
/// Both directions of one kind carry the same mark, since the kind is what the mark
|
||||
/// says and the label is what says which way it points.
|
||||
#[test]
|
||||
fn both_directions_of_a_kind_carry_one_mark() {
|
||||
let index = RelationIndex::new(vec![
|
||||
related(TARGET, "The blocker", "backlog", Vec::new()),
|
||||
related(
|
||||
"cccccccc-1111-4222-8333-444444444444",
|
||||
"The held one",
|
||||
"backlog",
|
||||
vec![relation(RelationKind::BlockedBy, SELF)],
|
||||
),
|
||||
]);
|
||||
let stored = vec![relation(RelationKind::BlockedBy, TARGET)];
|
||||
|
||||
let rendered = render_relations(&relation_rows(&stored, &index, SELF), false);
|
||||
assert!(rendered.contains(&format!("blocked by {BLOCKED_MARK} (b1b2c3d)")), "{rendered}");
|
||||
assert!(rendered.contains(&format!("blocks {BLOCKED_MARK} (ccccccc)")), "{rendered}");
|
||||
}
|
||||
|
||||
/// The cards spend the circles on priority, two cells away from nothing at all, so a
|
||||
/// relation drawn as one would be read as a level.
|
||||
#[test]
|
||||
fn no_relation_mark_is_a_priority_glyph() {
|
||||
let levels = [1, 2, 3, 4, 5].map(|level| priority_mark(Priority::Level(level)).0);
|
||||
let priority: String = levels
|
||||
.iter()
|
||||
.copied()
|
||||
.chain([priority_mark(Priority::Unset).0])
|
||||
.collect();
|
||||
|
||||
for kind in [
|
||||
RelationKind::BlockedBy,
|
||||
RelationKind::RelatesTo,
|
||||
RelationKind::RegressionOf,
|
||||
] {
|
||||
let (mark, _) = relation_mark(kind);
|
||||
assert!(
|
||||
!priority.contains(mark),
|
||||
"{kind:?} is drawn with {mark:?}, which the priority meter uses"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The id is kept, since it is the only thing left to go looking for, and the title
|
||||
/// is `_missing_` rather than a bare uuid pretending to be one.
|
||||
#[test]
|
||||
fn a_target_the_board_does_not_have_renders_as_missing() {
|
||||
let stored = vec![relation(RelationKind::BlockedBy, TARGET)];
|
||||
|
||||
// The mark is the kind, which is known from the ticket's own file, so it survives
|
||||
// a target the board cannot find. `_missing_` is what says the target is gone.
|
||||
assert_eq!(
|
||||
render_relations(&stored, &RelationIndex::new(Vec::new()), SELF, false),
|
||||
"blocked by (b1b2c3d) _missing_\n"
|
||||
render_relations(
|
||||
&relation_rows(&stored, &RelationIndex::new(Vec::new()), SELF),
|
||||
false
|
||||
),
|
||||
format!("blocked by {BLOCKED_MARK} (b1b2c3d) _missing_\n")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_ticket_with_no_relations_at_either_end_renders_no_block() {
|
||||
let index = RelationIndex::new(vec![related(TARGET, "Elsewhere", "backlog", Vec::new())]);
|
||||
assert_eq!(render_relations(&[], &index, SELF, false), "");
|
||||
assert_eq!(
|
||||
render_relations(&relation_rows(&[], &index, SELF), false),
|
||||
""
|
||||
);
|
||||
}
|
||||
|
||||
/// Without the guard every ticket with no ID field relates to every other one that
|
||||
@@ -3376,10 +3661,10 @@ mod tests {
|
||||
"# T\n\n## Relations\n- blocked by {}\n\n## Metadata\n\n- **ID**: {}\n",
|
||||
TARGET, SELF
|
||||
);
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: "blocked by (b1b2c3d) The blocker\n".to_string(), ..Default::default() });
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocked by", TARGET, "The blocker")], ..Default::default() });
|
||||
|
||||
assert!(
|
||||
rendered.contains("Relations\n─────────\n\nblocked by (b1b2c3d) The blocker\n\nMetadata"),
|
||||
rendered.contains(&format!("Relations\n─────────\n\nblocked by {BLOCKED_MARK} (b1b2c3d) The blocker\n\nMetadata")),
|
||||
"{rendered:?}"
|
||||
);
|
||||
assert!(!rendered.contains(TARGET), "the bare uuid was printed: {rendered:?}");
|
||||
@@ -3391,10 +3676,10 @@ mod tests {
|
||||
#[test]
|
||||
fn the_body_injects_the_block_when_the_file_has_no_section() {
|
||||
let content = format!("# T\n\n## Description\nBody.\n\n## Metadata\n\n- **ID**: {}\n", SELF);
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: "blocks (641e3d5) The gated one\n".to_string(), ..Default::default() });
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "The gated one")], ..Default::default() });
|
||||
|
||||
assert!(
|
||||
rendered.contains("Body.\n\nRelations\n─────────\n\nblocks (641e3d5) The gated one\n\nMetadata"),
|
||||
rendered.contains(&format!("Body.\n\nRelations\n─────────\n\nblocks {BLOCKED_MARK} (641e3d5) The gated one\n\nMetadata")),
|
||||
"{rendered:?}"
|
||||
);
|
||||
}
|
||||
@@ -3403,9 +3688,9 @@ mod tests {
|
||||
/// worth more at the end than dropped.
|
||||
#[test]
|
||||
fn the_body_appends_the_block_when_there_is_no_metadata() {
|
||||
let rendered = content_trim("# T\n\n## Description\nBody.\n", false, &Resolved { relations: "blocks (641e3d5) X\n".to_string(), ..Default::default() });
|
||||
let rendered = content_trim("# T\n\n## Description\nBody.\n", false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "X")], ..Default::default() });
|
||||
|
||||
assert!(rendered.ends_with("Relations\n─────────\n\nblocks (641e3d5) X\n"), "{rendered:?}");
|
||||
assert!(rendered.ends_with(&format!("Relations\n─────────\n\nblocks {BLOCKED_MARK} (641e3d5) X\n")), "{rendered:?}");
|
||||
}
|
||||
|
||||
/// No block and a section holding only its placeholder: the section renders as it
|
||||
|
||||
+174
@@ -296,3 +296,177 @@ 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}");
|
||||
}
|
||||
|
||||
+35
-4
@@ -289,6 +289,13 @@ 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}";
|
||||
|
||||
/// 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 +306,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} (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 +324,30 @@ 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} (641e3d5) The gated one")),
|
||||
"{shown}"
|
||||
);
|
||||
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
|
||||
|
||||
// Two kinds on one ticket, each with its own mark, which is what makes the block
|
||||
// readable without reading the labels.
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(
|
||||
shown.contains(&format!("blocked by {BLOCKED_MARK} (b1b2c3d) The blocker")),
|
||||
"{shown}"
|
||||
);
|
||||
assert!(
|
||||
shown.contains(&format!("relates to {RELATES_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} (641e3d5) The gated one")),
|
||||
"{shown}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -331,7 +359,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} (b1b2c3d) _missing_")),
|
||||
"{shown}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The section is the one part of a ticket read back by machine, so a line nobody can
|
||||
|
||||
Reference in New Issue
Block a user