Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5b0bac9c2d | ||
|
|
41a65f95b2 | ||
|
|
3085b0226f | ||
|
|
b56b31d2d9 |
@@ -112,8 +112,8 @@ criteria and handwritten sections are left alone. At least one field is required
|
||||
**Options:** `--title`, `--description` (or `-d`), `--acceptance` (or `-a`), `--plan`
|
||||
(or `-p`), `--tags` (or `-g`), `--due`, `--priority`
|
||||
|
||||
Owner is not settable here, and neither is status: `mv` owns status. Changing the
|
||||
title renames the file, keeping the UUID.
|
||||
Owner is not settable here, and neither is status: `chown` owns owner and `mv` owns
|
||||
status. Changing the title renames the file, keeping the UUID.
|
||||
|
||||
```bash
|
||||
worklane set a1b2c3d4 --priority 1
|
||||
@@ -138,6 +138,25 @@ worklane append a1b2c3d4 -a "One more criterium"
|
||||
worklane append a1b2c3d4 -p "A later step"
|
||||
```
|
||||
|
||||
### `worklane chown`
|
||||
|
||||
Set the owner of a ticket. The only command that writes the Owner field: `set` does
|
||||
not offer it.
|
||||
|
||||
**Positional arguments:**
|
||||
- `<user>`: The new owner. Free text, checked against nothing
|
||||
- `<ticket>`: Ticket UUID prefix (4+ characters) or title
|
||||
|
||||
The user comes first and the ticket second, after Unix `chown`. That is the one
|
||||
command here that does not start with the ticket, so mind the order: swap the two and
|
||||
the call fails, because the username has to resolve as a ticket. An owner set to the
|
||||
value it already holds is reported unchanged and nothing is written.
|
||||
|
||||
```bash
|
||||
worklane chown alice a1b2c3d4
|
||||
worklane chown "Ansho Rei" "A clearer title"
|
||||
```
|
||||
|
||||
### `worklane check` and `worklane uncheck`
|
||||
|
||||
Tick or untick a single acceptance criterion. Every other criterion keeps its state,
|
||||
|
||||
@@ -395,6 +395,33 @@ export const append = tool({
|
||||
},
|
||||
});
|
||||
|
||||
export const chown = tool({
|
||||
description:
|
||||
"Change the owner of a worklane ticket. This is the only writer of the Owner field: set does not offer it. The user is free text and is checked against nothing. Note the argument order, user first and ticket second, after Unix chown.",
|
||||
args: {
|
||||
user: tool.schema
|
||||
.string()
|
||||
.describe("New owner (required). Free text, checked against nothing."),
|
||||
ticket: tool.schema
|
||||
.string()
|
||||
.describe("Ticket UUID prefix (4+ chars) or title substring (required)"),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.user) {
|
||||
return "Error changing owner: user is required";
|
||||
}
|
||||
if (!args.ticket) {
|
||||
return "Error changing owner: ticket is required";
|
||||
}
|
||||
|
||||
try {
|
||||
return await run(["chown", args.user, args.ticket], context);
|
||||
} catch (err: any) {
|
||||
return `Error changing owner: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* check and uncheck differ only in the verb, so the tool is built once.
|
||||
*
|
||||
|
||||
@@ -5,17 +5,19 @@
|
||||
- `src/command.rs` - CLI argument definitions using clap derive
|
||||
- `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
|
||||
- `src/tui.rs` - board state, the change digest, and the ratatui draw
|
||||
- `src/install.rs` - the embedded agent assets and the compare-and-refuse install
|
||||
- `assets/SKILL.md` - the agent skill `install-skill` ships, embedded with `include_str!`
|
||||
- `tests/` - Integration tests using `assert_cmd` and `assert_fs`, one file per command
|
||||
- Unit tests live beside the code in `#[cfg(test)] mod tests`, in `util.rs`, `handlers.rs` and `tui.rs`
|
||||
- Ticket files stored as `.md` in `.worklane/<status>/` directories
|
||||
- Campaign files stored as `.md` in `.worklane/campaigns/`, which is beside the status directories and deliberately not in `status_dirs()`
|
||||
|
||||
## 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`, `Status`
|
||||
- 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
|
||||
- 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
|
||||
@@ -32,7 +34,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
## Testing
|
||||
- Run: `cargo test`
|
||||
- Tests use `assert_cmd` and `assert_fs` for CLI testing
|
||||
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created
|
||||
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created, plus `campaigns/` in `cmd_campaign.rs`, which is also where the on-demand creation is tested from a board without it
|
||||
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
|
||||
- **`cargo clippy --all-targets` is clean. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
|
||||
|
||||
@@ -57,7 +59,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
|
||||
### 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, once it exists) 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). Do not add either
|
||||
- `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
|
||||
- Everything is targeted line surgery, never a regenerated file. That is what keeps a ticked criterion ticked and a handwritten `## Notes` section intact when an unrelated field changes. `section_body()` finds the lines to touch, `set_metadata_line()` does the metadata, and every other byte is copied through
|
||||
- Appending to a numbered section continues from the count of steps already there and does not renumber what is above it, so a handwritten line in the section survives exactly as written
|
||||
@@ -77,6 +81,36 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- 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
|
||||
- `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
|
||||
|
||||
- **The Relations section is `relate`'s alone.** `RELATIONS` is in the section table but deliberately out of `section_args`, so `set` and `append` cannot reach it: a relation names a target that has to be resolved to a uuid first, and a prose flag would let an unresolvable line into the one section that is read back by machine. Same rule as Owner and Status, one field one writer
|
||||
- **`add` does not write the section.** The plan on 4179958 asked for it in the ticket writer; it is out on purpose. A `_No relations._` block in every new ticket is noise in every `show`, and the insertion path has to exist regardless for every ticket written before the section did, so leaving it out means one path that is always exercised rather than two
|
||||
- **The full uuid is stored, not the seven characters `ls` prints.** It resolves without a scan and cannot turn ambiguous as the board grows. `show` renders the short id and the target's title instead: the file is the machine's copy, the output is the reader's
|
||||
- **One direction is stored and the inverse is derived.** `blocked by` goes on the gated ticket rather than `blocks` on the blocker, because the gated ticket is the one whose move is refused and whose author knows about the dependency. `relates to` is symmetric and is written once, on whichever end the caller ran it from. `RelationIndex::inbound` finds the far end by scanning, which is what keeps `relate` a single-file write
|
||||
- **A line in the section that is not a relation is an error naming the ticket**, not a line quietly dropped. Nothing but `relate` writes there, so a bad line means a hand-edited file. The TUI is the deliberate exception: `detail_of` falls back to no block, since one corrupt ticket must not take the whole board down
|
||||
- **The block is built outside `content_trim` and passed in.** Half of it comes from other tickets and `content_trim` has only the body. It is spliced over the stored lines where the file has the section, and injected ahead of the metadata where it does not, because a ticket that is only pointed at has no section of its own and still has relations to show
|
||||
- `ensure_section` inserts against `SECTION_ORDER`, before the first following section that is actually in the file, and adds no blank line that was not already there. A handwritten `## Notes` between the plan and the metadata therefore keeps its place, and Metadata is in that list as an anchor rather than as something anything appends to
|
||||
- **The blocker check runs on every move**, after the already-in-that-status return and behind `force`. An open blocker is a reason not to start and a reason not to finish, and one rule is easier to hold than a table of which transitions care. A move to the status the ticket is already in is not a move, so it is not refused. `-f` now bypasses three rules, which is the right home for it: each one is a deliberate override of something the board would otherwise keep true
|
||||
- **A blocker that is not on the board warns and allows the move.** Refusing would wedge the ticket with no way out but `-f`, and a uuid nothing carries is a bookkeeping fault rather than a dependency. The refusal names **every** open blocker, since clearing the one that happened to be printed would leave the ticket blocked
|
||||
- Left out on purpose: removing a relation, which 4179958 assigns to 74904dc, and a blocked marker on the TUI card, which is its own ticket. Nothing on a card is worth a scan of the board per tick until the card is designed for it
|
||||
|
||||
### Campaigns
|
||||
|
||||
- **A campaign's state is derived, never stored.** Open until every member is done, computed by `Standing` from the members. A `Status` field on the campaign would be the same state in two places, and the two would disagree the moment a member moved. It is also why there is no `campaign mv` and no forward-only ruleset beside `mv`'s
|
||||
- **A campaign with no members is neither open nor done.** `Standing::state()` returns `None` there, and both callers print `no members`. Calling it done would make a container nothing has been filed against the most complete thing on the board; calling it open would claim work that does not exist
|
||||
- **Membership is one field on the member**, `Campaign` in the ticket Metadata, written only by `assign`. The member list is deliberately *not* on the campaign: that would put membership in two places, and would make one file that every assignment edits, which is contended the moment two agents share a board. So `add` has no `--campaign` and `set` has no `--campaign`, the same rule as Owner and Status
|
||||
- **The full uuid is stored and the title is resolved for display**, as the Relations section already does. `reference_cell` is shared between the two, so a dangling campaign and a dangling relation target are both spelled `_missing_` rather than each inventing a spelling
|
||||
- **`add` does not write the field.** Every ticket written before campaigns existed has none, so the insertion path has to exist regardless; leaving it out of `add` means one path that is always exercised rather than two. Same reasoning as the Relations section
|
||||
- `set_or_insert_metadata_field()` is the upsert, and `METADATA_ORDER` is its anchor list, the way `SECTION_ORDER` is `ensure_section`'s. Campaign is placed before Status, so Status stays last where every file already keeps it. A file with no `## Metadata` heading is an **error, not an insertion**: per 641e3d5 such a file has no fields at all, and writing one above the prose would invent a shape nothing reads
|
||||
- **The three tiers are `resolve_in()`, shared by tickets and campaigns.** A campaign is addressed exactly the way a ticket is, and a second resolver would be a second copy of the precedence rules to keep in step. `Found.dir` is the status for a ticket and empty for a campaign, which is what makes the ambiguity listing drop the bracket for one
|
||||
- **`resolve_ticket` explains a search that names a campaign**, rather than each command doing it. One place, so `mv`, `show`, `chown` and everything else that takes a ticket give the same reason instead of a bare "no ticket found". Checked only on the zero-match path, so it costs nothing normally, and only when exactly one campaign matches: an ambiguous ticket error must not be replaced by a complaint about a directory the caller never mentioned
|
||||
- **`Resolved` carries what `content_trim` cannot render from the file.** The relations block and the campaign cell both come from elsewhere on the board. A struct rather than two more parameters, so the next such field is one entry here instead of an edit at every call site
|
||||
- `campaign show` lists **done** members, unlike `ls`, which leaves the done column out of its listing. What is finished against what is left is the whole question a campaign asks, so hiding half the answer is not an option. `ls --campaign` is the other way round: it is the ordinary board filtered, and keeps every rule `ls` already has
|
||||
- `campaign ls` scans the status directories **once per campaign** to count members. That is a scan per row rather than one walk reused, and it is deliberate: the map-from-uuid version is worth writing when a board has enough campaigns to notice
|
||||
- **The TUI gets neither a campaign tab nor a card marker**, for now. The detail view resolves the field because it renders the body, and that is all. A marker on a card would want a campaigns read per reload and the four corners are already spent; same reasoning as the blocked marker, which is also its own ticket
|
||||
- `campaign_body()` builds the file from `DESCRIPTION` and `METADATA_HEADING` rather than its own string literals, so the two file formats cannot drift apart on the spelling of a heading. A campaign has no acceptance criteria (its definition of done is derived), no implementation plan and no Status
|
||||
- The campaigns directory is created by `init` and **on demand** by `campaign add`, since every board made before campaigns existed has none and a `worklane init` over a live board to get one would be a strange thing to have to do
|
||||
|
||||
### The Board View
|
||||
- `worklane` with no subcommand and `worklane tui` both open it, the way a bare `frig` does. `Cli::command` is therefore an `Option`
|
||||
- The worklane directory is looked for **before** the terminal, so running outside one gives the usual "No .worklane directory found" rather than a complaint about the tty. Both errors stay reachable and both are testable without a pty
|
||||
|
||||
Generated
+1
-1
@@ -1494,7 +1494,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.9.0"
|
||||
version = "0.12.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.9.0"
|
||||
version = "0.12.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -13,6 +13,8 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `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 comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
|
||||
|
||||
+73
-8
@@ -32,6 +32,9 @@ go straight to `reviewing` and has to be walked through `committed` anyway. Doin
|
||||
front is the same two commands in a more useful order. `-f` allows a backward or
|
||||
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).
|
||||
|
||||
## Reading the board
|
||||
|
||||
```
|
||||
@@ -90,14 +93,75 @@ worklane set 1b78a24 --priority 1 # replace a field
|
||||
worklane set 1b78a24 --title "A better title" # renames the file, keeps the uuid
|
||||
worklane append 1b78a24 --acceptance "One more criterion"
|
||||
worklane append 1b78a24 --description "What was learned since."
|
||||
worklane chown alice 1b78a24 # hand the ticket to someone
|
||||
```
|
||||
|
||||
`set` replaces, `append` adds. Neither has `--owner` or `--status`: owner is its own
|
||||
command's, and status is `mv`'s. A field set to the value it already holds is reported
|
||||
unchanged and nothing is written.
|
||||
`set` replaces, `append` adds. Neither has `--owner` or `--status`: owner is `chown`'s
|
||||
and status is `mv`'s, so each field has exactly one writer. A field set to the value it
|
||||
already holds is reported unchanged and nothing is written.
|
||||
|
||||
`worklane init` creates `.worklane/` with the four status directories, for a repo that
|
||||
has no board yet.
|
||||
`chown` takes the **user first and the ticket second**, after Unix `chown`, which is the
|
||||
one command here that does not start with the ticket. The user is free text and is
|
||||
checked against nothing. Swap the two and the call fails, because the username has to
|
||||
resolve as a ticket.
|
||||
|
||||
`worklane init` creates `.worklane/` with the four status directories and the campaigns
|
||||
directory beside them, for a repo that has no board yet.
|
||||
|
||||
## Relating tickets
|
||||
|
||||
```
|
||||
worklane relate 1b78a24 --blocked-by 4179958 # this one waits on that one
|
||||
worklane relate 1b78a24 --regression-of 6d327df # this one broke that one's fix
|
||||
worklane relate 1b78a24 --relates-to 7bfb9fc # neighbours, no dependency
|
||||
```
|
||||
|
||||
One flag per kind, and each repeats. The ticket comes first and the flag says what it is
|
||||
to the target, so read the call as a sentence: `relate A --blocked-by B` means A waits
|
||||
on B. **Only one side is stored**, on the ticket you name, and `show` derives the other
|
||||
end for the ticket at the far side, so never record both directions.
|
||||
|
||||
`--blocked-by` is enforced: `mv` refuses to move a ticket while a ticket it is blocked by
|
||||
is not in `done`, whichever move it is, and names every open blocker. `-f` moves it
|
||||
anyway, beside the backward and skipping moves it already allows. The other two kinds are
|
||||
reference data and never refuse anything.
|
||||
|
||||
Recording a relation the ticket already holds reports no change. A ticket cannot relate
|
||||
to itself, and a target that later disappears shows as `_missing_` rather than silently
|
||||
going away.
|
||||
|
||||
## Campaigns
|
||||
|
||||
A campaign groups the tickets that have to be finished together: a release, a migration,
|
||||
anything whose parts are separate tickets but whose goal is one thing. It is a file of
|
||||
its own under `.worklane/campaigns/`, with a title and a description, and it sits in no
|
||||
status directory. Its state is derived instead, open until every member is done, so
|
||||
there is no such thing as a done campaign holding an open ticket.
|
||||
|
||||
```
|
||||
worklane campaign add --title "v1 release" \
|
||||
--description "Everything that has to ship before the tag."
|
||||
worklane campaign ls # every campaign and how far it has got
|
||||
worklane campaign show "v1 release" # its body, then its members by status
|
||||
worklane assign "v1 release" 1b78a24 # put a ticket in it
|
||||
worklane ls --campaign "v1 release" # only that campaign's tickets
|
||||
```
|
||||
|
||||
`assign` takes the **campaign first and the ticket second**, like `chown`, and is the
|
||||
only writer of the field. `add` has no `--campaign` and neither has `set`, so membership
|
||||
has one writer the way owner and status do.
|
||||
|
||||
A ticket is in at most one campaign, so assigning one that already belongs somewhere
|
||||
moves it rather than adding a second. Assigning it to the campaign it already names
|
||||
reports no change and writes nothing.
|
||||
|
||||
`campaign show` lists done members too, unlike `ls`, which leaves the done column out of
|
||||
its listing: a campaign is precisely the question of what is finished against what is
|
||||
left.
|
||||
|
||||
A campaign is addressed the way a ticket is, by uuid prefix, title or filename, but it
|
||||
is not a ticket. Passing one where a ticket is expected is refused with a message saying
|
||||
so, and there is no way to move a campaign, because it has no status to move.
|
||||
|
||||
## Search the backlog before filing
|
||||
|
||||
@@ -108,9 +172,10 @@ existing ticket will have been written from a different angle.
|
||||
|
||||
- Already there and still open: add what you learned as a comment, not a second ticket.
|
||||
- Already there and closed, but the issue is back: file a **new** ticket naming the old
|
||||
id, and say it is a regression. There is no way to reopen one, and moving a done
|
||||
ticket back would destroy the record of the original fix.
|
||||
- Related but not the same: file it and reference the neighbour by id.
|
||||
id, and record it with `relate <new> --regression-of <old>`. There is no way to reopen
|
||||
one, and moving a done ticket back would destroy the record of the original fix.
|
||||
- Related but not the same: file it, and record it with `relate <new> --relates-to <old>`
|
||||
rather than only mentioning the id in prose.
|
||||
|
||||
## Addressing a ticket
|
||||
|
||||
|
||||
+294
@@ -0,0 +1,294 @@
|
||||
//! Campaigns: the container for tickets that have to be finished together.
|
||||
//!
|
||||
//! A campaign is a file of its own under `.worklane/campaigns/`, holding a title, a
|
||||
//! description and metadata. It has no status directory and never sits in one. Its
|
||||
//! state is derived instead: open until every member is done. Deriving it means there
|
||||
//! is no such thing as a done campaign holding an open ticket, and no second
|
||||
//! forward-only ruleset to reason about beside `mv`'s.
|
||||
//!
|
||||
//! Membership is one field on the *member*, `Campaign` in the ticket Metadata, written
|
||||
//! only by `assign`. The member list is deliberately not stored on the campaign: that
|
||||
//! would put membership in two places, and would make one file that every assignment
|
||||
//! edits, which is contended the moment two agents share a board.
|
||||
|
||||
use anyhow::{Result, anyhow};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::util::*;
|
||||
|
||||
/// Where campaigns live, beside the status directories rather than among them.
|
||||
pub const CAMPAIGNS_DIR: &str = "campaigns";
|
||||
|
||||
pub fn campaigns_dir(worklane_dir: &Path) -> PathBuf {
|
||||
worklane_dir.join(CAMPAIGNS_DIR)
|
||||
}
|
||||
|
||||
/// The campaigns directory, created if the board predates it.
|
||||
///
|
||||
/// `init` writes it for a new board, but every board made before campaigns existed has
|
||||
/// none, and refusing to file a campaign there would mean a `worklane init` over a live
|
||||
/// board just to get a directory.
|
||||
pub fn ensure_campaigns_dir(worklane_dir: &Path) -> Result<PathBuf> {
|
||||
let dir = campaigns_dir(worklane_dir);
|
||||
|
||||
fs::create_dir_all(&dir)
|
||||
.map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
|
||||
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
/// A campaign as it comes off disk.
|
||||
pub struct Campaign {
|
||||
pub uuid: String,
|
||||
pub title: String,
|
||||
pub content: String,
|
||||
}
|
||||
|
||||
/// The campaigns directory as [`resolve_in`] takes it.
|
||||
///
|
||||
/// The name is empty because a campaign has no status: it is what makes the ambiguity
|
||||
/// listing print an id and a title with no bracket after it.
|
||||
fn campaign_paths(worklane_dir: &Path) -> Vec<(String, PathBuf)> {
|
||||
vec![(String::new(), campaigns_dir(worklane_dir))]
|
||||
}
|
||||
|
||||
/// A campaign by the same three tiers a ticket resolves by, scoped to its own
|
||||
/// directory.
|
||||
///
|
||||
/// The tiers are [`resolve_in`]'s, not a second copy: a campaign is addressed the way
|
||||
/// everything else here is, and two resolvers would be two sets of precedence rules to
|
||||
/// keep in step.
|
||||
pub fn resolve_campaign(search: &str, worklane_dir: &Path) -> Result<Campaign> {
|
||||
let mut matches = resolve_in(search, &campaign_paths(worklane_dir))?;
|
||||
|
||||
if matches.is_empty() {
|
||||
return Err(anyhow!("No campaign found matching '{}'", search));
|
||||
}
|
||||
|
||||
if matches.len() > 1 {
|
||||
return Err(ambiguous("campaign", search, &matches));
|
||||
}
|
||||
|
||||
let found = matches.remove(0);
|
||||
let uuid = parse_ticket_field(&found.content, "ID");
|
||||
|
||||
if uuid.trim().is_empty() || is_unknown_value(&uuid) {
|
||||
return Err(anyhow!(
|
||||
"Campaign '{}' has no ID field, so nothing can be assigned to it",
|
||||
found.title
|
||||
));
|
||||
}
|
||||
|
||||
Ok(Campaign {
|
||||
uuid,
|
||||
title: found.title,
|
||||
content: found.content,
|
||||
})
|
||||
}
|
||||
|
||||
/// The title of the campaign a search names, for a caller that only needs to say so.
|
||||
///
|
||||
/// Used by `resolve_ticket` to explain a search that names a campaign rather than a
|
||||
/// ticket. Deliberately swallows both failures: nothing matched and too much matched
|
||||
/// both mean "this is not the explanation", and an error here would replace a clear
|
||||
/// "no ticket found" with a complaint about a directory the caller never mentioned.
|
||||
pub fn campaign_named(search: &str, worklane_dir: &Path) -> Option<String> {
|
||||
resolve_campaign(search, worklane_dir)
|
||||
.ok()
|
||||
.map(|campaign| campaign.title)
|
||||
}
|
||||
|
||||
/// Every campaign on the board, read in one pass.
|
||||
///
|
||||
/// One pass for the same reason [`RelationIndex`] takes one: rendering a ticket's
|
||||
/// Campaign field or listing the campaigns both need every one of them, and a lookup
|
||||
/// per ticket would read the directory once per row.
|
||||
pub struct CampaignIndex {
|
||||
campaigns: Vec<Campaign>,
|
||||
}
|
||||
|
||||
impl CampaignIndex {
|
||||
pub fn load(worklane_dir: &Path) -> Result<Self> {
|
||||
let dir = campaigns_dir(worklane_dir);
|
||||
let mut campaigns = Vec::new();
|
||||
|
||||
// A board with no campaigns directory has no campaigns, which is not an error:
|
||||
// every board made before campaigns existed is in that state.
|
||||
if !dir.exists() {
|
||||
return Ok(Self { campaigns });
|
||||
}
|
||||
|
||||
for entry in fs::read_dir(&dir)?.filter_map(|e| e.ok()) {
|
||||
let path = entry.path();
|
||||
if !path.extension().is_some_and(|e| e == "md") {
|
||||
continue;
|
||||
}
|
||||
let Ok(content) = fs::read_to_string(&path) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
campaigns.push(Campaign {
|
||||
uuid: parse_ticket_field(&content, "ID"),
|
||||
title: heading_title(&content),
|
||||
content,
|
||||
});
|
||||
}
|
||||
|
||||
// By title, so a listing does not depend on the order the directory hands its
|
||||
// entries back in.
|
||||
campaigns.sort_by_key(|campaign| campaign.title.to_lowercase());
|
||||
Ok(Self { campaigns })
|
||||
}
|
||||
|
||||
/// The campaign carrying `uuid`, or nothing when the board no longer has it.
|
||||
pub fn get(&self, uuid: &str) -> Option<&Campaign> {
|
||||
self.campaigns.iter().find(|campaign| campaign.uuid == uuid)
|
||||
}
|
||||
|
||||
pub fn iter(&self) -> impl Iterator<Item = &Campaign> {
|
||||
self.campaigns.iter()
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.campaigns.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
/// The Campaign field as it reads, or empty for a ticket in no campaign.
|
||||
///
|
||||
/// A uuid no campaign carries renders as `_missing_`, the way a dangling relation
|
||||
/// target does, rather than as the bare value the file stores: the value is a full
|
||||
/// uuid, so showing it raw is thirty-six characters that say nothing about what is
|
||||
/// gone.
|
||||
pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> String {
|
||||
let Some(uuid) = parse_campaign(content) else {
|
||||
return String::new();
|
||||
};
|
||||
|
||||
reference_cell(
|
||||
&uuid,
|
||||
index.get(&uuid).map(|campaign| campaign.title.as_str()),
|
||||
colored,
|
||||
)
|
||||
}
|
||||
|
||||
/// The parts [`content_trim`] cannot render from the ticket file alone.
|
||||
///
|
||||
/// Both halves read the tree beside the ticket, so they are gathered in one place
|
||||
/// 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)?,
|
||||
campaign: campaign_cell(content, &CampaignIndex::load(worklane_dir)?, colored),
|
||||
})
|
||||
}
|
||||
|
||||
/// The members of a campaign, grouped by status in flow order.
|
||||
///
|
||||
/// Read through `collect_ticket_items`, the source `ls` and the board already use, so
|
||||
/// there is no second parser and the rows print the way every other listing does.
|
||||
/// Empty groups are kept: a campaign's shape is the four statuses, and a caller that
|
||||
/// wants only the filled ones can say so.
|
||||
pub fn members(worklane_dir: &Path, uuid: &str) -> Result<Vec<(&'static str, Vec<TicketItem>)>> {
|
||||
let mut grouped = Vec::new();
|
||||
|
||||
for status in status_dirs() {
|
||||
let status_path = worklane_dir.join(status);
|
||||
let items = match status_path.exists() {
|
||||
true => collect_ticket_items(&status_path)?,
|
||||
false => Vec::new(),
|
||||
};
|
||||
|
||||
grouped.push((
|
||||
status,
|
||||
items
|
||||
.into_iter()
|
||||
.filter(|item| item.campaign.as_deref() == Some(uuid))
|
||||
.collect(),
|
||||
));
|
||||
}
|
||||
|
||||
Ok(grouped)
|
||||
}
|
||||
|
||||
/// How far a campaign has got: members done against members held.
|
||||
pub struct Standing {
|
||||
pub done: usize,
|
||||
pub total: usize,
|
||||
}
|
||||
|
||||
impl Standing {
|
||||
pub fn of(grouped: &[(&'static str, Vec<TicketItem>)]) -> Self {
|
||||
Self {
|
||||
done: grouped
|
||||
.iter()
|
||||
.filter(|(status, _)| *status == DONE)
|
||||
.map(|(_, items)| items.len())
|
||||
.sum(),
|
||||
total: grouped.iter().map(|(_, items)| items.len()).sum(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The count as it reads, or `no members` for a campaign nothing has been filed
|
||||
/// against.
|
||||
pub fn label(&self) -> String {
|
||||
match self.total {
|
||||
0 => "no members".to_string(),
|
||||
total => format!("{}/{} done", self.done, total),
|
||||
}
|
||||
}
|
||||
|
||||
/// A campaign is done when it holds members and every one of them is done.
|
||||
///
|
||||
/// An empty campaign is neither, hence the `None`: calling it done would make a
|
||||
/// container nothing has been filed against the most complete thing on the board,
|
||||
/// and calling it open would claim work that does not exist.
|
||||
pub fn state(&self) -> Option<&'static str> {
|
||||
match (self.total, self.done == self.total) {
|
||||
(0, _) => None,
|
||||
(_, true) => Some(DONE),
|
||||
(_, false) => Some("open"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The campaign file as it is written.
|
||||
///
|
||||
/// The same shape a ticket has, minus what a campaign has no use for: no acceptance
|
||||
/// criteria, because its definition of done is derived from its members rather than
|
||||
/// written down, no implementation plan, and no Status, because it sits in no status
|
||||
/// directory. The headings and the placeholder come from the section table in
|
||||
/// `util.rs`, so the two file formats cannot drift apart on the spelling of a heading.
|
||||
pub fn campaign_body(
|
||||
title: &str,
|
||||
description: &[String],
|
||||
id: &uuid::Uuid,
|
||||
owner: Option<&str>,
|
||||
created_at: &str,
|
||||
) -> String {
|
||||
// Joined with a single newline, so an empty value is how a caller spells a
|
||||
// paragraph break, exactly as it is for a ticket.
|
||||
let description = trim_blank_ends(description);
|
||||
let description_text = match description.is_empty() {
|
||||
true => DESCRIPTION.placeholder.to_string(),
|
||||
false => description.join("\n"),
|
||||
};
|
||||
|
||||
format!(
|
||||
"# {title}\n\
|
||||
\n\
|
||||
{description_heading}\n\
|
||||
{description_text}\n\
|
||||
\n\
|
||||
{metadata_heading}\n\
|
||||
\n\
|
||||
- **ID**: {id}\n\
|
||||
- **Owner**: {owner}\n\
|
||||
- **Created At**: {created_at}\n\
|
||||
",
|
||||
description_heading = DESCRIPTION.heading,
|
||||
metadata_heading = METADATA_HEADING,
|
||||
owner = owner.unwrap_or("_Not set_"),
|
||||
)
|
||||
}
|
||||
+136
-1
@@ -2,7 +2,7 @@ use clap::Parser;
|
||||
|
||||
use std::sync::LazyLock;
|
||||
|
||||
use crate::util::{PRIORITY_RANGE, priority_legend};
|
||||
use crate::util::{PRIORITY_RANGE, RelationKind, 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.
|
||||
@@ -81,6 +81,10 @@ pub enum Command {
|
||||
/// 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>,
|
||||
},
|
||||
|
||||
/// Show a ticket by UUID or title
|
||||
@@ -109,6 +113,29 @@ pub enum Command {
|
||||
/// Add to a section of an existing ticket
|
||||
Append(AppendArgs),
|
||||
|
||||
/// Record a relation from one ticket to another
|
||||
Relate(RelateArgs),
|
||||
|
||||
/// Change the owner of a ticket
|
||||
///
|
||||
/// User first, ticket second, after Unix `chown`. That reverses the ticket-first
|
||||
/// order `mv`, `comment` and `show` use, deliberately: the name borrows the Unix
|
||||
/// association, so the argument order borrows it too.
|
||||
///
|
||||
/// A swap is caught by resolution rather than by a check of its own. Given
|
||||
/// `chown 641e3d5 alice` the second argument has to resolve as a ticket, and a bare
|
||||
/// username usually will not, so the call fails on its own. It is silently wrong
|
||||
/// only when both arguments resolve, which needs a ticket whose title matches the
|
||||
/// username.
|
||||
Chown {
|
||||
/// New owner. Free text, like `add --owner`, checked against nothing
|
||||
#[arg(value_parser = non_empty)]
|
||||
user: String,
|
||||
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
},
|
||||
|
||||
/// Open the board view
|
||||
Tui {
|
||||
/// Projects to monitor, each resolved to the first `.worklane` at or above it.
|
||||
@@ -136,6 +163,28 @@ pub enum Command {
|
||||
owner: Option<String>,
|
||||
},
|
||||
|
||||
/// Group tickets that have to be finished together
|
||||
Campaign {
|
||||
#[command(subcommand)]
|
||||
command: CampaignCommand,
|
||||
},
|
||||
|
||||
/// Put a ticket in a campaign
|
||||
///
|
||||
/// Campaign first, ticket second, after `chown` and for the same reason: the
|
||||
/// container is what the call is about, and the order is worth being consistent
|
||||
/// about across the two commands that name two things.
|
||||
///
|
||||
/// The only writer of the Campaign field. `add` has no `--campaign` and `set` has
|
||||
/// no `--campaign`, so the field keeps one writer the way Owner and Status do.
|
||||
Assign {
|
||||
/// Campaign UUID or title
|
||||
campaign: String,
|
||||
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
},
|
||||
|
||||
/// Install the agent skill that teaches an agent to use worklane
|
||||
InstallSkill {
|
||||
/// Overwrite an existing copy that has been modified
|
||||
@@ -148,6 +197,48 @@ pub enum Command {
|
||||
},
|
||||
}
|
||||
|
||||
/// What a campaign can be asked for.
|
||||
///
|
||||
/// No `mv`: a campaign has no status to move it to, its state is derived from its
|
||||
/// members. No `set` or `append` either, which is a gap rather than a decision, since
|
||||
/// nothing yet edits a campaign after it is filed.
|
||||
#[derive(clap::Subcommand)]
|
||||
pub enum CampaignCommand {
|
||||
/// File a new campaign
|
||||
Add(CampaignAddArgs),
|
||||
|
||||
/// List campaigns with their member counts
|
||||
Ls,
|
||||
|
||||
/// Show a campaign and its members grouped by status
|
||||
Show {
|
||||
/// Campaign UUID or title
|
||||
campaign: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// What a campaign holds: a title, a description and an owner.
|
||||
///
|
||||
/// Deliberately narrower than [`AddArgs`]. There are no acceptance criteria, because a
|
||||
/// campaign's definition of done is derived from its members rather than written down,
|
||||
/// and no implementation plan. Priority, tags and a due date are left out because
|
||||
/// nothing reads them yet, and a field written but never shown is a field that goes
|
||||
/// stale unnoticed.
|
||||
#[derive(clap::Args)]
|
||||
pub struct CampaignAddArgs {
|
||||
/// Campaign title
|
||||
#[arg(short, long, allow_hyphen_values = PROSE)]
|
||||
pub title: String,
|
||||
|
||||
/// What the campaign is for. Use multiple flags for multiline descriptions
|
||||
#[arg(short, long, allow_hyphen_values = PROSE)]
|
||||
pub description: Vec<String>,
|
||||
|
||||
/// Owner. Defaults to the git user
|
||||
#[arg(short, long)]
|
||||
pub owner: Option<String>,
|
||||
}
|
||||
|
||||
/// `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.
|
||||
@@ -260,6 +351,50 @@ pub struct AppendArgs {
|
||||
pub plan: Vec<String>,
|
||||
}
|
||||
|
||||
/// `relate` is the only writer of the Relations section, the way `chown` is the only
|
||||
/// writer of Owner. One flag per kind rather than a `--kind` value: the accepted kinds
|
||||
/// are then clap's business, an unknown one is a usage error, and a call reads as a
|
||||
/// sentence about the ticket it names.
|
||||
///
|
||||
/// Each flag repeats, so several relations of one kind land in a single call. The
|
||||
/// targets are ticket searches, resolved by the same three tiers every other ticket
|
||||
/// argument is, and stored as the target's uuid.
|
||||
#[derive(clap::Args)]
|
||||
#[command(group(
|
||||
clap::ArgGroup::new("relation_kinds")
|
||||
.required(true)
|
||||
.multiple(true)
|
||||
.args(["blocked_by", "regression_of", "relates_to"])
|
||||
))]
|
||||
pub struct RelateArgs {
|
||||
/// Ticket UUID or title
|
||||
pub ticket: String,
|
||||
|
||||
/// Ticket this one waits on. Its own moves are refused until the target is done
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub blocked_by: Vec<String>,
|
||||
|
||||
/// Ticket whose fix this one broke
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub regression_of: Vec<String>,
|
||||
|
||||
/// Ticket this one is merely related to. Symmetric, so it is recorded once
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub relates_to: Vec<String>,
|
||||
}
|
||||
|
||||
impl RelateArgs {
|
||||
/// The relations asked for, one entry per kind, so the handler walks a table
|
||||
/// instead of repeating itself three times.
|
||||
pub fn requested(&self) -> [(RelationKind, &[String]); 3] {
|
||||
[
|
||||
(RelationKind::BlockedBy, &self.blocked_by),
|
||||
(RelationKind::RegressionOf, &self.regression_of),
|
||||
(RelationKind::RelatesTo, &self.relates_to),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
/// `check` and `uncheck` are separate commands rather than one verb with a flag,
|
||||
/// because the two read as opposites at the call site and neither needs the other's
|
||||
/// name to make sense.
|
||||
|
||||
+356
-5
@@ -4,7 +4,8 @@ use std::fs;
|
||||
use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::command::{AddArgs, AppendArgs, CheckArgs, SetArgs};
|
||||
use crate::campaign::*;
|
||||
use crate::command::{AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, RelateArgs, SetArgs};
|
||||
use crate::install;
|
||||
use crate::util::*;
|
||||
|
||||
@@ -27,6 +28,11 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
fs::create_dir_all(worklane_dir.join(folder))?;
|
||||
}
|
||||
|
||||
// Beside the status directories, not among them: a campaign has no status. Created
|
||||
// here for a new board, and on demand by `campaign add` for a board that predates
|
||||
// campaigns, which is why `status_dirs()` is untouched.
|
||||
fs::create_dir_all(campaigns_dir(&worklane_dir))?;
|
||||
|
||||
println!("Initialized worklane in: {}", worklane_dir.display());
|
||||
Ok(())
|
||||
}
|
||||
@@ -34,8 +40,25 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
pub fn cmd_ls(
|
||||
status_filter: &Option<String>,
|
||||
priority_filter: Option<u8>,
|
||||
campaign_filter: &Option<String>,
|
||||
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 {
|
||||
Some(search) => Some(resolve_campaign(search, worklane_dir)?),
|
||||
None => None,
|
||||
};
|
||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
||||
|
||||
if let Some(campaign) = &campaign {
|
||||
println!(
|
||||
"Members of campaign ({}) {}\n",
|
||||
color_text(short_id(&campaign.uuid), Color::Red),
|
||||
color_text(&campaign.title, Color::Green),
|
||||
);
|
||||
}
|
||||
|
||||
if let Some(status) = status_filter {
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
@@ -45,7 +68,7 @@ pub fn cmd_ls(
|
||||
));
|
||||
}
|
||||
|
||||
let items = filter_by_priority(collect_ticket_items(&status_path)?, priority_filter);
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid);
|
||||
|
||||
if items.is_empty() {
|
||||
println!("No tickets in '{}' status.", status);
|
||||
@@ -63,7 +86,7 @@ pub fn cmd_ls(
|
||||
if !status_path.exists() {
|
||||
continue;
|
||||
}
|
||||
let items = filter_by_priority(collect_ticket_items(&status_path)?, priority_filter);
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid);
|
||||
let count = items.len();
|
||||
let label = if count == 1 { "ticket" } else { "tickets" };
|
||||
println!(" [{}] {} {}", status.to_uppercase(), count, label);
|
||||
@@ -79,7 +102,7 @@ pub fn cmd_ls(
|
||||
continue;
|
||||
}
|
||||
let items = match collect_ticket_items(&status_path) {
|
||||
Ok(items) => filter_by_priority(items, priority_filter),
|
||||
Ok(items) => filtered(items, priority_filter, uuid),
|
||||
Err(_) => continue,
|
||||
};
|
||||
if items.is_empty() {
|
||||
@@ -94,6 +117,23 @@ pub fn cmd_ls(
|
||||
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)
|
||||
}
|
||||
|
||||
/// Keep only the members of `campaign`, or everything when none was asked for.
|
||||
fn filter_by_campaign(items: Vec<TicketItem>, campaign: Option<&str>) -> Vec<TicketItem> {
|
||||
match campaign {
|
||||
Some(uuid) => items
|
||||
.into_iter()
|
||||
.filter(|item| item.campaign.as_deref() == Some(uuid))
|
||||
.collect(),
|
||||
None => items,
|
||||
}
|
||||
}
|
||||
|
||||
/// Keep only the tickets at `level`, or everything when no level was asked for.
|
||||
fn filter_by_priority(items: Vec<TicketItem>, level: Option<u8>) -> Vec<TicketItem> {
|
||||
match level {
|
||||
@@ -302,13 +342,16 @@ fn write_new_comment(comments_dir: &Path, stem: &str, content: &str) -> Result<S
|
||||
pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
let (_status, title, content) = resolve_ticket(search, worklane_dir)?;
|
||||
let ticket_uuid = parse_ticket_field(&content, "ID");
|
||||
// Read before anything is printed, so a board that cannot be read fails instead of
|
||||
// half printing a ticket.
|
||||
let resolved = resolved_for(&content, worklane_dir, should_use_colors())?;
|
||||
|
||||
// The only title in the output: content_trim_colored used to print it a second
|
||||
// time from the file content. Green per the colour guideline, and the rule is
|
||||
// measured in characters so a non-ASCII title is not over-drawn.
|
||||
println!("{}", color_text(&title, Color::Green));
|
||||
println!("{}", "─".repeat(title.chars().count()));
|
||||
println!("\n{}", content_trim_colored(&content));
|
||||
println!("\n{}", content_trim_colored(&content, &resolved));
|
||||
|
||||
if ticket_uuid != "_Not set_" {
|
||||
let comments_dir = worklane_dir.join("comments").join(&ticket_uuid);
|
||||
@@ -434,6 +477,59 @@ fn move_ticket_file(
|
||||
})
|
||||
}
|
||||
|
||||
/// Refuse a move while a ticket it is `blocked by` is not done.
|
||||
///
|
||||
/// Every move, not only the one into committed: an open blocker is a reason not to
|
||||
/// start and a reason not to finish, and one rule is easier to hold than a table of
|
||||
/// which transitions care. Called before anything is written, so a refusal leaves no
|
||||
/// rename, no rewritten field and no half moved ticket.
|
||||
///
|
||||
/// A target the board does not have warns and allows the move. Refusing there would
|
||||
/// wedge the ticket behind a bookkeeping fault with no way out but `--force`, and a
|
||||
/// dangling uuid is not a dependency.
|
||||
fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()> {
|
||||
let blockers: Vec<Relation> = parse_relations(content, title)?
|
||||
.into_iter()
|
||||
.filter(|relation| relation.kind == RelationKind::BlockedBy)
|
||||
.collect();
|
||||
|
||||
if blockers.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let index = RelationIndex::load(worklane_dir)?;
|
||||
let mut open: Vec<String> = Vec::new();
|
||||
|
||||
for blocker in &blockers {
|
||||
match index.get(&blocker.target) {
|
||||
Some(target) if target.status == DONE => {}
|
||||
Some(target) => open.push(format!(
|
||||
" ({}) {} [{}]",
|
||||
color_text(short_id(&target.uuid), Color::Red),
|
||||
target.title,
|
||||
color_text(&target.status, Color::Orange),
|
||||
)),
|
||||
None => eprintln!(
|
||||
"Warning: ticket '{}' is blocked by {}, which is not on the board.",
|
||||
title,
|
||||
short_id(&blocker.target),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
if open.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Every open blocker, not the first: a ticket waiting on three of them is not
|
||||
// unblocked by clearing the one the message happened to name.
|
||||
Err(anyhow!(
|
||||
"Cannot move '{}' while it is blocked by:\n{}\nUse --force (-f) to move it anyway.",
|
||||
color_text(title, Color::Green),
|
||||
open.join("\n"),
|
||||
))
|
||||
}
|
||||
|
||||
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"];
|
||||
@@ -480,6 +576,13 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// After the no-op above, so a ticket is never refused for a move it is not making,
|
||||
// and behind `force`, which is where the other two overrides of a rule the board
|
||||
// keeps true already live.
|
||||
if !force {
|
||||
check_blockers(&worklane_dir, &resolved, &title)?;
|
||||
}
|
||||
|
||||
let current_path = worklane_dir.join(¤t_status);
|
||||
let target_path = worklane_dir.join(target_status);
|
||||
|
||||
@@ -691,6 +794,34 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Rewrite the Owner field, the only writer of it.
|
||||
///
|
||||
/// The user comes first at the call site, after Unix `chown`, and the reasoning for
|
||||
/// reversing the ticket-first order is on the `Chown` variant. A swapped call is left
|
||||
/// to resolution: nothing here inspects `user` to see whether it also names a ticket,
|
||||
/// since the check would only fire on the case resolution already refuses and would
|
||||
/// stay silent on the one it cannot, a ticket whose title is the username.
|
||||
///
|
||||
/// No-op detection compares the whole file, the way `set` does, so an owner set to the
|
||||
/// value it already holds is reported unchanged and nothing is written.
|
||||
pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let content = set_metadata_field(&original, "Owner", user, &title)?;
|
||||
|
||||
if content == original {
|
||||
report(&[], &title, "Updated");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
report(&["owner"], &title, "Updated");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
@@ -722,6 +853,226 @@ pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Record a relation from one ticket to another.
|
||||
///
|
||||
/// One side is written and the inverse is derived wherever it is shown. `blocked by`
|
||||
/// goes on the gated ticket rather than `blocks` on the blocker: the gated ticket is the
|
||||
/// one whose move is refused and whose author knows about the dependency. `relates to`
|
||||
/// is symmetric, so it is written once, on whichever end the caller ran it from.
|
||||
///
|
||||
/// The kinds are a flag each rather than a `--kind` value, so an unknown kind is a
|
||||
/// usage error at the door instead of a line written into the file and refused on the
|
||||
/// way back out.
|
||||
pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
let existing = parse_relations(&original, &title)?;
|
||||
|
||||
// Every target resolved and every refusal raised before a byte is written, so a
|
||||
// call naming one good ticket and one bad one records neither.
|
||||
let mut items: Vec<String> = Vec::new();
|
||||
let mut changed: Vec<&str> = Vec::new();
|
||||
|
||||
for (kind, targets) in args.requested() {
|
||||
for search in targets {
|
||||
let (_target_status, target_title, target) = resolve_ticket(search, &worklane_dir)?;
|
||||
let target_uuid = parse_ticket_field(&target, "ID");
|
||||
|
||||
if target_uuid.trim().is_empty() || is_unknown_value(&target_uuid) {
|
||||
return Err(anyhow!(
|
||||
"Ticket '{}' has no ID field, so nothing can point at it",
|
||||
target_title
|
||||
));
|
||||
}
|
||||
|
||||
if target_uuid == uuid {
|
||||
return Err(anyhow!(
|
||||
"A ticket cannot relate to itself, and '{}' is the ticket being edited",
|
||||
title
|
||||
));
|
||||
}
|
||||
|
||||
let relation = Relation {
|
||||
kind,
|
||||
target: target_uuid,
|
||||
};
|
||||
|
||||
// Already held, either in the file or earlier in this call. Recording it
|
||||
// twice would read as two dependencies on one ticket.
|
||||
if existing.contains(&relation) || items.contains(&relation.item()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
items.push(relation.item());
|
||||
if !changed.contains(&kind.label()) {
|
||||
changed.push(kind.label());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if items.is_empty() {
|
||||
report(&[], &title, "Recorded");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let content = append_section_body(&ensure_section(&original, &RELATIONS), &RELATIONS, &items)?;
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
report(&changed, &title, "Recorded");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------- campaigns --
|
||||
|
||||
/// File a new campaign.
|
||||
///
|
||||
/// Written through `write_then_replace` rather than `fs::write`, so a failure leaves no
|
||||
/// half-written campaign behind. `cmd_add` predates that primitive and still uses the
|
||||
/// plain write; the difference is noted on the ticket rather than fixed here.
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
let CampaignAddArgs {
|
||||
title,
|
||||
description,
|
||||
owner,
|
||||
} = args;
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let dir = ensure_campaigns_dir(&worklane_dir)?;
|
||||
|
||||
let owner = match owner {
|
||||
Some(owner) => Some(owner.clone()),
|
||||
None => get_git_user(),
|
||||
};
|
||||
|
||||
let id = uuid::Uuid::new_v4();
|
||||
let filename = format!("{}_{}.md", id, slug(title));
|
||||
let path = dir.join(&filename);
|
||||
|
||||
let body = campaign_body(
|
||||
title,
|
||||
description,
|
||||
&id,
|
||||
owner.as_deref(),
|
||||
&Local::now().format(TIMESTAMP_FORMAT).to_string(),
|
||||
);
|
||||
|
||||
write_then_replace(&worklane_dir, &path, &filename, &body, title)?;
|
||||
|
||||
println!("Created campaign: {}", filename);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// List the campaigns with how far each has got.
|
||||
///
|
||||
/// The counts come from one pass over the status directories per campaign. That is a
|
||||
/// scan per row rather than one scan reused, and it is deliberate: the alternative is a
|
||||
/// map from campaign uuid to counts built in a single walk, which is worth writing when
|
||||
/// a board has enough campaigns to notice and is premature now.
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path) -> Result<()> {
|
||||
let index = CampaignIndex::load(worklane_dir)?;
|
||||
|
||||
if index.is_empty() {
|
||||
println!("No campaigns yet. `worklane campaign add --title` files one.");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let colored = should_use_colors();
|
||||
println!("Campaigns:\n");
|
||||
|
||||
for campaign in index.iter() {
|
||||
let standing = Standing::of(&members(worklane_dir, &campaign.uuid)?);
|
||||
let state = match standing.state() {
|
||||
Some(state) => format!(" [{}]", paint(state, Color::Orange, colored)),
|
||||
None => String::new(),
|
||||
};
|
||||
|
||||
println!(
|
||||
" ({}) {} | {}{}",
|
||||
paint(short_id(&campaign.uuid), Color::Red, colored),
|
||||
campaign.title,
|
||||
standing.label(),
|
||||
state,
|
||||
);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Show a campaign, then its members grouped by status.
|
||||
///
|
||||
/// Every status is shown, done included, unlike `ls`, which leaves done out of its
|
||||
/// listing. A campaign's whole point is what is finished against what is left, so
|
||||
/// hiding the finished half would hide the answer.
|
||||
pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
let campaign = resolve_campaign(search, worklane_dir)?;
|
||||
|
||||
println!("{}", color_text(&campaign.title, Color::Green));
|
||||
println!("{}", "─".repeat(campaign.title.chars().count()));
|
||||
// No relations and no campaign of its own: a campaign is not a ticket, and neither
|
||||
// belongs to one.
|
||||
println!(
|
||||
"\n{}",
|
||||
content_trim_colored(&campaign.content, &Resolved::default())
|
||||
);
|
||||
|
||||
let grouped = members(worklane_dir, &campaign.uuid)?;
|
||||
let standing = Standing::of(&grouped);
|
||||
|
||||
println!("{}", color_text("Members", Color::Orange));
|
||||
println!("{}", "─".repeat("Members".chars().count()));
|
||||
println!("\n{}", standing.label());
|
||||
|
||||
for (status, items) in &grouped {
|
||||
if items.is_empty() {
|
||||
continue;
|
||||
}
|
||||
println!(
|
||||
"\n{}",
|
||||
color_text(&format!("[{}]", status.to_uppercase()), Color::Orange)
|
||||
);
|
||||
display_ticket_items(items);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Put a ticket in a campaign, the only writer of the Campaign field.
|
||||
///
|
||||
/// The campaign is resolved first, so a call naming a good ticket and a bad campaign
|
||||
/// writes nothing. A ticket names at most one campaign because the field is rewritten
|
||||
/// rather than added to, so assigning a ticket that is already in one moves it.
|
||||
///
|
||||
/// No-op detection compares the whole file, the way `set` and `chown` do, so assigning
|
||||
/// a ticket to the campaign it already names writes nothing.
|
||||
pub fn cmd_assign(campaign_search: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(campaign_search, &worklane_dir)?;
|
||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let content =
|
||||
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
|
||||
|
||||
if content == original {
|
||||
println!(
|
||||
"Ticket '{}' is already in campaign '{}'",
|
||||
color_text(&title, Color::Green),
|
||||
campaign.title,
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
println!(
|
||||
"Assigned '{}' to campaign '{}'",
|
||||
color_text(&title, Color::Green),
|
||||
campaign.title,
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Which criterion to act on, asked for when the caller did not say.
|
||||
///
|
||||
/// A terminal gets the list and a prompt. Anything else gets the same list as an
|
||||
|
||||
+21
-2
@@ -1,6 +1,7 @@
|
||||
use anyhow::Result;
|
||||
use clap::Parser;
|
||||
|
||||
mod campaign;
|
||||
mod command;
|
||||
mod handlers;
|
||||
mod install;
|
||||
@@ -44,9 +45,13 @@ 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 }) => {
|
||||
Some(Command::Ls {
|
||||
status,
|
||||
priority,
|
||||
campaign,
|
||||
}) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_ls(&status, priority, &worklane_dir)
|
||||
cmd_ls(&status, priority, &campaign, &worklane_dir)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
@@ -59,6 +64,8 @@ fn main() -> Result<()> {
|
||||
}) => cmd_mv(&ticket, &status, force, &start),
|
||||
Some(Command::Set(args)) => cmd_set(&args, &start),
|
||||
Some(Command::Append(args)) => cmd_append(&args, &start),
|
||||
Some(Command::Relate(args)) => cmd_relate(&args, &start),
|
||||
Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start),
|
||||
Some(Command::Check(args)) => cmd_check(&args, true, &start),
|
||||
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
||||
Some(Command::Comment {
|
||||
@@ -66,6 +73,18 @@ fn main() -> Result<()> {
|
||||
body,
|
||||
owner,
|
||||
}) => cmd_comment(&ticket, &body, &owner, &start),
|
||||
Some(Command::Campaign { command }) => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
||||
CampaignCommand::Ls => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_campaign_ls(&worklane_dir)
|
||||
}
|
||||
CampaignCommand::Show { campaign } => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_campaign_show(&campaign, &worklane_dir)
|
||||
}
|
||||
},
|
||||
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
|
||||
// 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 { force, print }) => cmd_install_skill(force, print),
|
||||
|
||||
+133
-3
@@ -501,16 +501,27 @@ impl Board {
|
||||
fn detail_of(card: &Card) -> Detail {
|
||||
let ticket = &card.ticket;
|
||||
let content = std::fs::read_to_string(&ticket.path).unwrap_or_default();
|
||||
let mut out = content_trim(&content, false);
|
||||
|
||||
let uuid = parse_ticket_field(&content, "ID");
|
||||
let comments = match ticket.path.parent().and_then(|status| status.parent()) {
|
||||
let worklane_dir = ticket.path.parent().and_then(|status| status.parent());
|
||||
|
||||
// All of these read the tree beside the ticket, and all fall back to nothing: one
|
||||
// unreadable file must not take the board down with it. The relations cost a scan of
|
||||
// the board, paid only while a ticket is open and only on a tick that changed
|
||||
// something, which is what already reloads every card. The campaign title costs a
|
||||
// read of one small directory beside it, for the same reason `show` pays it: the
|
||||
// field stores a uuid, and a card that displayed one raw would say nothing.
|
||||
let resolved = worklane_dir
|
||||
.and_then(|dir| crate::campaign::resolved_for(&content, dir, false).ok())
|
||||
.unwrap_or_default();
|
||||
let comments = match worklane_dir {
|
||||
Some(worklane_dir) => {
|
||||
read_comments(&worklane_dir.join("comments").join(&uuid)).unwrap_or_default()
|
||||
}
|
||||
None => Vec::new(),
|
||||
};
|
||||
|
||||
let mut out = content_trim(&content, false, &resolved);
|
||||
|
||||
out.push('\n');
|
||||
out.push_str(&format_comments_with(&comments, false));
|
||||
Detail {
|
||||
@@ -2666,4 +2677,123 @@ mod tests {
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// The section goes in `extra`, after the metadata, which is not where `relate`
|
||||
/// writes it. Position is the CLI's test to make; this one is about the lookup.
|
||||
#[test]
|
||||
fn the_detail_view_resolves_a_relation_to_a_title() {
|
||||
let dir = board_dir();
|
||||
let target = "22222222-0000-4000-8000-000000000000";
|
||||
write_ticket(&dir, "backlog", target, "The target", "");
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
"11111111-0000-4000-8000-000000000000",
|
||||
"A holder",
|
||||
&format!("\n## Relations\n- blocked by {target}\n"),
|
||||
);
|
||||
|
||||
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:?}");
|
||||
assert!(!text.contains(target), "the bare uuid was drawn: {text:?}");
|
||||
}
|
||||
|
||||
/// The far end of a relation stores nothing, so the board derives it too.
|
||||
#[test]
|
||||
fn the_detail_view_derives_the_other_end() {
|
||||
let dir = board_dir();
|
||||
let holder = "11111111-0000-4000-8000-000000000000";
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
holder,
|
||||
"A holder",
|
||||
"\n## Relations\n- blocked by 22222222-0000-4000-8000-000000000000\n",
|
||||
);
|
||||
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "The target", "");
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
// The holder sorts first by title, so the target is the card below it.
|
||||
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:?}");
|
||||
}
|
||||
|
||||
/// The detail view resolves the Campaign field the way `show` does. The field stores
|
||||
/// a uuid, so an unresolved one would put thirty-six characters of hex on screen.
|
||||
#[test]
|
||||
fn the_detail_view_shows_the_campaign_title() {
|
||||
let dir = board_dir();
|
||||
let campaign = "cccccccc-0000-4000-8000-000000000000";
|
||||
std::fs::create_dir_all(dir.join("campaigns")).unwrap();
|
||||
std::fs::write(
|
||||
dir.join("campaigns").join(format!("{campaign}_v1-release.md")),
|
||||
format!("# v1 release\n\n## Metadata\n\n- **ID**: {campaign}\n"),
|
||||
)
|
||||
.unwrap();
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
"11111111-0000-4000-8000-000000000000",
|
||||
"A member",
|
||||
&format!("- **Campaign**: {campaign}\n"),
|
||||
);
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
assert!(text.contains("(ccccccc) v1 release"), "{text:?}");
|
||||
assert!(!text.contains(campaign), "the bare uuid reached the screen: {text:?}");
|
||||
}
|
||||
|
||||
/// A board with no campaigns directory is every board made before campaigns existed.
|
||||
/// The detail view still has to draw.
|
||||
#[test]
|
||||
fn a_board_with_no_campaigns_directory_still_draws_a_ticket() {
|
||||
let dir = board_dir();
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
"11111111-0000-4000-8000-000000000000",
|
||||
"A ticket",
|
||||
"- **Campaign**: cccccccc-0000-4000-8000-000000000000\n",
|
||||
);
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
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:?}");
|
||||
}
|
||||
|
||||
/// The CLI refuses a relations line it cannot read, naming the ticket. The board
|
||||
/// cannot: one hand-edited file must not take every other card down with it.
|
||||
#[test]
|
||||
fn a_relations_line_that_cannot_be_read_still_draws_the_ticket() {
|
||||
let dir = board_dir();
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
"11111111-0000-4000-8000-000000000000",
|
||||
"A holder",
|
||||
"\n## Relations\n- depends on 22222222-0000-4000-8000-000000000000\n",
|
||||
);
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").text;
|
||||
assert!(text.contains("A description."), "the body was lost: {text:?}");
|
||||
}
|
||||
}
|
||||
|
||||
+1068
-83
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,602 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||
|
||||
/// Two campaigns, so a filter has something to exclude, and three tickets: one in each
|
||||
/// campaign and one in neither.
|
||||
const CAMP_A: &str = "aa11bb22-33cc-4dd4-8ee5-ff6677889900";
|
||||
const CAMP_B: &str = "bb22cc33-44dd-4ee5-8ff6-001122334455";
|
||||
const MEMBER: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
const OTHER: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
||||
const LONER: &str = "f1f2f3f4-5a6b-4c7d-8e9f-0a1b2c3d4e5f";
|
||||
|
||||
fn setup_worklane(temp: &TempDir) -> PathBuf {
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done", "campaigns"] {
|
||||
worklane.child(dir).create_dir_all().unwrap();
|
||||
}
|
||||
|
||||
worklane.path().to_path_buf()
|
||||
}
|
||||
|
||||
fn slug(title: &str) -> String {
|
||||
title
|
||||
.to_lowercase()
|
||||
.chars()
|
||||
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
||||
.map(|c| if c == ' ' { '-' } else { c })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A ticket with a ticked criterion, a section the tool knows nothing about and a
|
||||
/// metadata field it has never heard of, so every test can check that an assignment
|
||||
/// leaves all three exactly as they were.
|
||||
///
|
||||
/// Deliberately carries no Campaign field: no ticket written before campaigns existed
|
||||
/// has one, and `add` still does not write one, so the insertion path is what every
|
||||
/// assignment goes through.
|
||||
fn create_ticket(worklane: &Path, status: &str, title: &str, uuid: &str) -> PathBuf {
|
||||
let path = worklane
|
||||
.join(status)
|
||||
.join(format!("{}_{}.md", uuid, slug(title)));
|
||||
|
||||
fs::write(
|
||||
&path,
|
||||
format!(
|
||||
"# {title}\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
Prose that mentions **Campaign**: not a field, in the body.\n\
|
||||
\n\
|
||||
## Acceptance Criteria\n\
|
||||
- [x] Crit one\n\
|
||||
\n\
|
||||
## Implementation Plan\n\
|
||||
1. Step one\n\
|
||||
\n\
|
||||
## Notes\n\
|
||||
A handwritten note the tool knows nothing about.\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {uuid}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: alpha\n\
|
||||
- **Due**: _Not set_\n\
|
||||
- **Handled By Team**: ops\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: {status}\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
path
|
||||
}
|
||||
|
||||
fn create_campaign(worklane: &Path, title: &str, uuid: &str) -> PathBuf {
|
||||
let path = worklane
|
||||
.join("campaigns")
|
||||
.join(format!("{}_{}.md", uuid, slug(title)));
|
||||
|
||||
fs::write(
|
||||
&path,
|
||||
format!(
|
||||
"# {title}\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
What has to ship together.\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {uuid}\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
path
|
||||
}
|
||||
|
||||
fn board(temp: &TempDir) -> PathBuf {
|
||||
let worklane = setup_worklane(temp);
|
||||
create_campaign(&worklane, "v1 release", CAMP_A);
|
||||
create_campaign(&worklane, "v2 release", CAMP_B);
|
||||
create_ticket(&worklane, "backlog", "The member", MEMBER);
|
||||
create_ticket(&worklane, "done", "The other member", OTHER);
|
||||
create_ticket(&worklane, "backlog", "The loner", LONER);
|
||||
worklane
|
||||
}
|
||||
|
||||
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);
|
||||
cmd.assert().get_output().clone()
|
||||
}
|
||||
|
||||
fn stdout(out: &std::process::Output) -> String {
|
||||
String::from_utf8_lossy(&out.stdout).to_string()
|
||||
}
|
||||
|
||||
fn stderr(out: &std::process::Output) -> String {
|
||||
String::from_utf8_lossy(&out.stderr).to_string()
|
||||
}
|
||||
|
||||
fn find(worklane: &Path, uuid: &str) -> PathBuf {
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
for entry in fs::read_dir(worklane.join(status))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
{
|
||||
if entry.file_name().to_string_lossy().starts_with(uuid) {
|
||||
return entry.path();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
panic!("no file for ticket {uuid}");
|
||||
}
|
||||
|
||||
fn ticket(worklane: &Path, uuid: &str) -> String {
|
||||
fs::read_to_string(find(worklane, uuid)).unwrap()
|
||||
}
|
||||
|
||||
fn campaigns(worklane: &Path) -> Vec<String> {
|
||||
let mut names: Vec<String> = fs::read_dir(worklane.join("campaigns"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().to_string_lossy().to_string())
|
||||
.collect();
|
||||
names.sort();
|
||||
names
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ filing one --
|
||||
|
||||
#[test]
|
||||
fn campaign_add_writes_a_uuid_title_description_and_metadata() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"campaign",
|
||||
"add",
|
||||
"--title",
|
||||
"v1 release",
|
||||
"--description",
|
||||
"Everything that ships together.",
|
||||
"--owner",
|
||||
"alice",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let names = campaigns(&worklane);
|
||||
assert_eq!(names.len(), 1, "{names:?}");
|
||||
let name = &names[0];
|
||||
assert!(name.ends_with("_v1-release.md"), "{name}");
|
||||
|
||||
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
||||
assert!(content.starts_with("# v1 release\n"), "{content}");
|
||||
assert!(content.contains("Everything that ships together."), "{content}");
|
||||
assert!(content.contains("- **Owner**: alice"), "{content}");
|
||||
assert!(content.contains("- **Created At**: 20"), "{content}");
|
||||
|
||||
// The uuid in the file is the one in the filename, since that is what `assign`
|
||||
// stores and what every lookup compares against.
|
||||
let uuid = name.split('_').next().unwrap();
|
||||
assert!(content.contains(&format!("- **ID**: {uuid}")), "{content}");
|
||||
}
|
||||
|
||||
/// A campaign has no status, so its file carries none. A Status field would be a second
|
||||
/// place for a state that is derived, and the two would disagree the moment a member
|
||||
/// moved.
|
||||
#[test]
|
||||
fn a_campaign_carries_no_status_and_no_criteria() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
run(&temp, &["campaign", "add", "--title", "v1 release"]);
|
||||
|
||||
let name = campaigns(&worklane).remove(0);
|
||||
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
||||
|
||||
assert!(!content.contains("**Status**"), "{content}");
|
||||
assert!(!content.contains("Acceptance Criteria"), "{content}");
|
||||
assert!(!content.contains("Implementation Plan"), "{content}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_is_created_without_a_title() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let out = run(&temp, &["campaign", "add", "--description", "No title here."]);
|
||||
|
||||
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
||||
assert!(campaigns(&worklane).is_empty(), "{:?}", campaigns(&worklane));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn init_creates_the_campaigns_directory() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
|
||||
let out = run(&temp, &["init"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
assert!(temp.child(".worklane").child("campaigns").path().is_dir());
|
||||
}
|
||||
|
||||
/// A board made before campaigns existed has no such directory, and a `worklane init`
|
||||
/// over a live board to get one would be a strange thing to have to do.
|
||||
#[test]
|
||||
fn the_campaigns_directory_is_created_for_a_board_that_predates_it() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
worklane.child(dir).create_dir_all().unwrap();
|
||||
}
|
||||
assert!(!worklane.child("campaigns").path().exists());
|
||||
|
||||
let out = run(&temp, &["campaign", "add", "--title", "v1 release"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
assert_eq!(campaigns(worklane.path()).len(), 1);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------- assigning --
|
||||
|
||||
#[test]
|
||||
fn assign_writes_the_campaign_field_in_the_metadata_section() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let content = ticket(&worklane, MEMBER);
|
||||
assert!(content.contains(&format!("- **Campaign**: {CAMP_A}")), "{content}");
|
||||
|
||||
// Scoped to the section: the description quotes the marker, and the field has to
|
||||
// land under the heading rather than over the prose.
|
||||
let metadata = content.split("## Metadata").nth(1).unwrap();
|
||||
assert!(metadata.contains(&format!("- **Campaign**: {CAMP_A}")), "{content}");
|
||||
assert!(
|
||||
content.contains("Prose that mentions **Campaign**: not a field, in the body."),
|
||||
"the description was rewritten: {content}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The field goes in its place among the others rather than at the end, so Status stays
|
||||
/// last, which is where every file already keeps it.
|
||||
#[test]
|
||||
fn the_field_is_inserted_before_status() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
|
||||
let content = ticket(&worklane, MEMBER);
|
||||
let campaign_at = content.find("- **Campaign**:").unwrap();
|
||||
let status_at = content.find("- **Status**:").unwrap();
|
||||
assert!(campaign_at < status_at, "{content}");
|
||||
}
|
||||
|
||||
/// All three tiers, since a campaign is addressed the way a ticket is: a uuid prefix, a
|
||||
/// title substring, and a substring reaching the middle of the filename.
|
||||
#[test]
|
||||
fn a_campaign_resolves_by_uuid_prefix_title_or_filename() {
|
||||
for search in ["aa11", "v1 release", "4dd4"] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["assign", search, MEMBER]);
|
||||
assert!(out.status.success(), "{search}: {}", stderr(&out));
|
||||
assert!(
|
||||
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
|
||||
"{search}: {}",
|
||||
ticket(&worklane, MEMBER)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_ticket_names_at_most_one_campaign() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
let out = run(&temp, &["assign", "v2 release", MEMBER]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let content = ticket(&worklane, MEMBER);
|
||||
assert_eq!(
|
||||
content.matches("- **Campaign**:").count(),
|
||||
1,
|
||||
"reassigning added a second field: {content}"
|
||||
);
|
||||
assert!(content.contains(&format!("- **Campaign**: {CAMP_B}")), "{content}");
|
||||
assert!(!content.contains(CAMP_A), "{content}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn assigning_the_campaign_already_named_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
let before = ticket(&worklane, MEMBER);
|
||||
|
||||
let out = run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert!(stdout(&out).contains("already in campaign"), "{}", stdout(&out));
|
||||
assert_eq!(ticket(&worklane, MEMBER), before);
|
||||
}
|
||||
|
||||
/// The campaign is resolved before the ticket is touched, so a call naming a good
|
||||
/// ticket and a campaign that does not exist writes nothing at all.
|
||||
#[test]
|
||||
fn an_unknown_campaign_leaves_the_ticket_alone() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, MEMBER);
|
||||
|
||||
let out = run(&temp, &["assign", "v9 release", MEMBER]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
assert!(stderr(&out).contains("No campaign found matching"), "{}", stderr(&out));
|
||||
assert_eq!(ticket(&worklane, MEMBER), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn content_the_tool_does_not_know_survives_an_assignment() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
|
||||
let content = ticket(&worklane, MEMBER);
|
||||
assert!(content.contains("## Notes"), "{content}");
|
||||
assert!(
|
||||
content.contains("A handwritten note the tool knows nothing about."),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.contains("- **Handled By Team**: ops"), "{content}");
|
||||
// And the ticked criterion is still ticked.
|
||||
assert!(content.contains("- [x] Crit one"), "{content}");
|
||||
}
|
||||
|
||||
/// One field, one writer. `assign` owns Campaign the way `chown` owns Owner.
|
||||
#[test]
|
||||
fn neither_add_nor_set_offers_a_campaign_flag() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let added = run(&temp, &["add", "--title", "New one", "--campaign", "v1 release"]);
|
||||
assert_eq!(added.status.code(), Some(2), "{}", stderr(&added));
|
||||
|
||||
let set = run(&temp, &["set", MEMBER, "--campaign", "v1 release"]);
|
||||
assert_eq!(set.status.code(), Some(2), "{}", stderr(&set));
|
||||
|
||||
// The stored shape, not the bare marker: the fixture description quotes the marker
|
||||
// on purpose, so an unscoped match here would pass whatever the commands did.
|
||||
assert!(!ticket(&worklane, MEMBER).contains("- **Campaign**:"));
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------- reading --
|
||||
|
||||
#[test]
|
||||
fn campaign_ls_lists_campaigns_with_their_member_counts() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
run(&temp, &["assign", "v1 release", OTHER]);
|
||||
|
||||
let out = run(&temp, &["campaign", "ls"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let listing = stdout(&out);
|
||||
// One of the two members is in done, so the campaign is open and half finished.
|
||||
assert!(listing.contains("v1 release | 1/2 done [open]"), "{listing}");
|
||||
// Nothing has been filed against the other one.
|
||||
assert!(listing.contains("v2 release | no members"), "{listing}");
|
||||
}
|
||||
|
||||
/// A campaign is done when it holds members and every one of them is done. An empty one
|
||||
/// is neither, which is why it reads `no members` rather than `0/0 done`.
|
||||
#[test]
|
||||
fn a_campaign_whose_every_member_is_done_reads_done() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", OTHER]);
|
||||
|
||||
let listing = stdout(&run(&temp, &["campaign", "ls"]));
|
||||
assert!(listing.contains("v1 release | 1/1 done [done]"), "{listing}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn campaign_show_prints_the_body_and_the_members_grouped_by_status() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
run(&temp, &["assign", "v1 release", OTHER]);
|
||||
|
||||
let out = run(&temp, &["campaign", "show", "aa11"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let shown = stdout(&out);
|
||||
assert!(shown.contains("v1 release"), "{shown}");
|
||||
assert!(shown.contains("What has to ship together."), "{shown}");
|
||||
assert!(shown.contains("1/2 done"), "{shown}");
|
||||
assert!(shown.contains("[BACKLOG]"), "{shown}");
|
||||
assert!(shown.contains("The member"), "{shown}");
|
||||
// Done members are shown here, unlike in `ls`: what is finished against what is
|
||||
// left is the whole question a campaign asks.
|
||||
assert!(shown.contains("[DONE]"), "{shown}");
|
||||
assert!(shown.contains("The other member"), "{shown}");
|
||||
// And a ticket in no campaign is not a member of this one.
|
||||
assert!(!shown.contains("The loner"), "{shown}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ls_campaign_lists_only_that_campaigns_members() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
run(&temp, &["assign", "v2 release", LONER]);
|
||||
|
||||
let out = run(&temp, &["ls", "--campaign", "v1 release"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let listing = stdout(&out);
|
||||
assert!(listing.contains("The member"), "{listing}");
|
||||
assert!(!listing.contains("The loner"), "{listing}");
|
||||
assert!(listing.contains("[BACKLOG] 1 ticket"), "{listing}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ls_campaign_refuses_a_campaign_that_does_not_exist() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["ls", "--campaign", "v9 release"]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
assert!(stderr(&out).contains("No campaign found matching"), "{}", stderr(&out));
|
||||
}
|
||||
|
||||
/// The stored value is a full uuid, so a campaign that has been deleted has to be
|
||||
/// reported as gone rather than shown raw, the way a dangling relation target is.
|
||||
#[test]
|
||||
fn a_campaign_that_no_longer_exists_reads_as_missing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
fs::remove_file(worklane.join("campaigns").join(format!("{CAMP_A}_v1-release.md"))).unwrap();
|
||||
|
||||
let out = run(&temp, &["show", MEMBER]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let shown = stdout(&out);
|
||||
assert!(shown.contains("_missing_"), "{shown}");
|
||||
// The short id survives, since it is the only thing left to go looking for.
|
||||
assert!(shown.contains("(aa11bb2)"), "{shown}");
|
||||
assert!(!shown.contains(CAMP_A), "the bare uuid was shown: {shown}");
|
||||
}
|
||||
|
||||
/// The title is shown rather than the uuid the file stores: thirty-six characters of
|
||||
/// hex in a metadata table say nothing about which campaign it is.
|
||||
#[test]
|
||||
fn a_ticket_shows_the_campaign_title_not_its_uuid() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", MEMBER]));
|
||||
assert!(shown.contains("(aa11bb2) v1 release"), "{shown}");
|
||||
assert!(!shown.contains(CAMP_A), "{shown}");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------- not a ticket --
|
||||
|
||||
/// A campaign is in no status directory, so `mv` has nothing to move. It says so rather
|
||||
/// than reporting a ticket it could not find, which would send the caller hunting for a
|
||||
/// typo in a name that is perfectly correct.
|
||||
#[test]
|
||||
fn mv_refuses_a_campaign() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["mv", "v1 release", "--status", "committed"]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
let message = stderr(&out);
|
||||
assert!(message.contains("is a campaign, not a ticket"), "{message}");
|
||||
assert!(message.contains("no status directory"), "{message}");
|
||||
|
||||
// And it stayed where it was: nothing was moved into a status directory.
|
||||
assert!(
|
||||
worklane
|
||||
.join("campaigns")
|
||||
.join(format!("{CAMP_A}_v1-release.md"))
|
||||
.exists()
|
||||
);
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
let moved = fs::read_dir(worklane.join(status))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.any(|e| e.file_name().to_string_lossy().starts_with(CAMP_A));
|
||||
assert!(!moved, "a campaign reached the {status} directory");
|
||||
}
|
||||
}
|
||||
|
||||
/// Every command that takes a ticket gives the same explanation, because the refusal is
|
||||
/// in resolution rather than in `mv`.
|
||||
#[test]
|
||||
fn a_campaign_is_refused_wherever_a_ticket_is_expected() {
|
||||
for args in [
|
||||
vec!["show", "v1 release"],
|
||||
vec!["comment", "v1 release", "A note."],
|
||||
vec!["chown", "bob", "v1 release"],
|
||||
] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &args);
|
||||
assert!(!out.status.success(), "{args:?}");
|
||||
assert!(
|
||||
stderr(&out).contains("is a campaign, not a ticket"),
|
||||
"{args:?}: {}",
|
||||
stderr(&out)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// A search that names neither still says nothing was found, rather than complaining
|
||||
/// about a directory the caller never mentioned.
|
||||
#[test]
|
||||
fn a_search_that_names_nothing_still_reports_no_ticket() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["show", "nothing at all"]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
assert!(
|
||||
stderr(&out).contains("No ticket found matching"),
|
||||
"{}",
|
||||
stderr(&out)
|
||||
);
|
||||
}
|
||||
|
||||
/// A campaign resolves by the same tiers a ticket does, so it can be ambiguous the same
|
||||
/// way, and the listing has to name campaigns rather than tickets.
|
||||
#[test]
|
||||
fn an_ambiguous_campaign_lists_the_candidates() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["campaign", "show", "release"]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
let message = stderr(&out);
|
||||
assert!(message.contains("Multiple campaigns found matching"), "{message}");
|
||||
assert!(message.contains("v1 release"), "{message}");
|
||||
assert!(message.contains("v2 release"), "{message}");
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||
const UUID: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
|
||||
fn setup_worklane(temp: &TempDir) -> PathBuf {
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
worklane.child(dir).create_dir_all().unwrap();
|
||||
}
|
||||
|
||||
worklane.path().to_path_buf()
|
||||
}
|
||||
|
||||
/// A fully populated ticket, with one criterion already ticked and a section the tool
|
||||
/// knows nothing about, so every test can check both survive.
|
||||
fn create_ticket(worklane: &Path) {
|
||||
fs::write(
|
||||
worklane
|
||||
.join("backlog")
|
||||
.join(format!("{}_original-title.md", UUID)),
|
||||
format!(
|
||||
"# Original title\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
The **Owner**: line quoted here is prose, not metadata.\n\
|
||||
\n\
|
||||
## Acceptance Criteria\n\
|
||||
- [x] Crit one\n\
|
||||
- [ ] Crit two\n\
|
||||
\n\
|
||||
## Implementation Plan\n\
|
||||
1. Step one\n\
|
||||
\n\
|
||||
## Notes\n\
|
||||
A handwritten note the tool knows nothing about.\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: alpha\n\
|
||||
- **Due**: 2026-09-01\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: backlog\n",
|
||||
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);
|
||||
cmd.assert().get_output().clone()
|
||||
}
|
||||
|
||||
fn ticket(worklane: &Path) -> String {
|
||||
let entry = fs::read_dir(worklane.join("backlog"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.find(|e| e.file_name().to_string_lossy().ends_with(".md"))
|
||||
.expect("no ticket file");
|
||||
fs::read_to_string(entry.path()).unwrap()
|
||||
}
|
||||
|
||||
fn stray_files(worklane: &Path) -> Vec<String> {
|
||||
fs::read_dir(worklane)
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| {
|
||||
!["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chown_sets_the_owner() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "bob", UUID]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("owner"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Owner**: bob"), "{content}");
|
||||
|
||||
// Every other field is left as it was
|
||||
assert!(content.contains("- **Priority**: 3"), "{content}");
|
||||
assert!(content.contains("- **Tags**: alpha"), "{content}");
|
||||
assert!(content.contains("- **Due**: 2026-09-01"), "{content}");
|
||||
assert!(content.contains("- **Status**: backlog"), "{content}");
|
||||
}
|
||||
|
||||
/// The value is free text, matching `add --owner`, and is checked against nothing:
|
||||
/// not git, not a list of users.
|
||||
#[test]
|
||||
fn chown_accepts_any_user_without_validating_it() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["chown", "Nobody At All", UUID]);
|
||||
|
||||
assert!(
|
||||
ticket(&worklane).contains("- **Owner**: Nobody At All"),
|
||||
"{}",
|
||||
ticket(&worklane)
|
||||
);
|
||||
}
|
||||
|
||||
/// The tick and the unknown section are what a regenerated file would lose, and the
|
||||
/// quoted `**Owner**:` line in the description is what an unscoped rewrite would take
|
||||
/// instead of the real field.
|
||||
#[test]
|
||||
fn chown_leaves_everything_it_was_not_asked_about_alone() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["chown", "bob", UUID]);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(
|
||||
content.contains("- [x] Crit one"),
|
||||
"the tick was lost: {content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
||||
"the unknown section was lost: {content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains("The **Owner**: line quoted here is prose, not metadata.\n"),
|
||||
"the prose was rewritten as metadata: {content}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chown_reports_no_change_and_leaves_the_file_alone() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "alice", UUID]);
|
||||
assert!(out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
/// Resolution is `resolve_ticket`, the same as `mv` and `comment`, so all three tiers
|
||||
/// reach the ticket. The filename search reaches the middle of the uuid, which the
|
||||
/// prefix tier cannot.
|
||||
#[test]
|
||||
fn chown_resolves_a_uuid_prefix_a_title_or_a_filename() {
|
||||
for search in ["641e", "Original", "4d2f"] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "bob", search]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{search} did not resolve: {:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(
|
||||
ticket(&worklane).contains("- **Owner**: bob"),
|
||||
"{search}: {}",
|
||||
ticket(&worklane)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The swap is left to resolution rather than checked for: the username has to resolve
|
||||
/// as a ticket, and a bare one does not.
|
||||
#[test]
|
||||
fn chown_refuses_a_swapped_call() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", UUID, "bob"]);
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("No ticket found matching 'bob'"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty user looks like a way to clear the field, and clearing is not supported.
|
||||
#[test]
|
||||
fn chown_refuses_an_empty_user_as_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "", UUID]);
|
||||
assert_eq!(out.status.code(), Some(2));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// A hand-made ticket without the field is refused rather than guessed at, the same
|
||||
/// as every other metadata field.
|
||||
#[test]
|
||||
fn chown_refuses_a_ticket_with_no_owner_field() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
fs::write(
|
||||
worklane.join("backlog").join(format!("{}_bare.md", UUID)),
|
||||
format!("# Bare\n\n## Metadata\n\n- **ID**: {}\n", UUID),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let out = run(&temp, &["chown", "bob", UUID]);
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("has no Owner field"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
|
||||
/// The staged temp file is renamed into place, so a completed write leaves nothing to
|
||||
/// be read as a stray ticket.
|
||||
#[test]
|
||||
fn chown_leaves_nothing_behind() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["chown", "bob", UUID]);
|
||||
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
||||
}
|
||||
|
||||
/// The file keeps its name: the slug follows the title, and the owner is not in it.
|
||||
#[test]
|
||||
fn chown_does_not_rename_the_file() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["chown", "bob", UUID]);
|
||||
|
||||
let names: Vec<String> = fs::read_dir(worklane.join("backlog"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.collect();
|
||||
assert_eq!(names, vec![format!("{}_original-title.md", UUID)]);
|
||||
}
|
||||
+233
@@ -645,3 +645,236 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
|
||||
vec!["11111111-aaaa-bbbb-cccc-dddddddddddd_foo.md".to_string()]
|
||||
);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------- blocked by --
|
||||
|
||||
/// A ticket waiting on another, and a second one for it to wait on. Returns the
|
||||
/// filename of the gated ticket, whose relations the moves are then checked against.
|
||||
fn create_gated_pair(worklane: &std::path::Path, temp: &TempDir, status: &str) -> String {
|
||||
let filename = create_ticket(
|
||||
worklane,
|
||||
status,
|
||||
"Gated Task",
|
||||
"Waits on the blocker.",
|
||||
"aaaa1111aaaa1111aaaa1111aaaa1111aaaa",
|
||||
"alice",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
create_ticket(
|
||||
worklane,
|
||||
"backlog",
|
||||
"The Blocker",
|
||||
"Nothing waits on this.",
|
||||
"bbbb2222bbbb2222bbbb2222bbbb2222bbbb",
|
||||
"bob",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
|
||||
// Through the command, so the fixture cannot store a relation in a shape the tool
|
||||
// does not actually write.
|
||||
Command::cargo_bin(BIN_NAME)
|
||||
.unwrap()
|
||||
.current_dir(temp.path())
|
||||
.args(["relate", "aaaa1111", "--blocked-by", "bbbb2222"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
filename
|
||||
}
|
||||
|
||||
fn move_ticket(temp: &TempDir, ticket: &str, status: &str, force: bool) -> std::process::Output {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["mv", ticket, "--status", status]);
|
||||
if force {
|
||||
cmd.arg("-f");
|
||||
}
|
||||
|
||||
cmd.assert().get_output().clone()
|
||||
}
|
||||
|
||||
/// Refused, and nothing written: not the rename, not the Status field, not a stray
|
||||
/// temp file. The blocker is named with its status, since that is what has to change.
|
||||
#[test]
|
||||
fn mv_refuses_a_move_while_a_blocker_is_open() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
let before = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(!out.status.success());
|
||||
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("blocked by"), "{stderr}");
|
||||
assert!(stderr.contains("The Blocker"), "{stderr}");
|
||||
assert!(stderr.contains("backlog"), "{stderr}");
|
||||
assert!(stderr.contains("--force"), "{stderr}");
|
||||
|
||||
assert!(worklane.join("backlog").join(&filename).exists());
|
||||
assert_eq!(md_files(&worklane.join("committed")).len(), 0);
|
||||
assert_eq!(
|
||||
fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap(),
|
||||
before,
|
||||
"a refused move rewrote the ticket"
|
||||
);
|
||||
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
||||
}
|
||||
|
||||
/// Every open blocker, not the first: clearing the one the message happened to name
|
||||
/// would leave the ticket blocked and the reader surprised.
|
||||
#[test]
|
||||
fn mv_names_every_open_blocker() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_gated_pair(&worklane, &temp, "backlog");
|
||||
create_ticket(
|
||||
&worklane,
|
||||
"reviewing",
|
||||
"The Second Blocker",
|
||||
"Also not done.",
|
||||
"cccc3333cccc3333cccc3333cccc3333cccc",
|
||||
"bob",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
|
||||
Command::cargo_bin(BIN_NAME)
|
||||
.unwrap()
|
||||
.current_dir(temp.path())
|
||||
.args(["relate", "aaaa1111", "--blocked-by", "cccc3333"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("The Blocker"), "{stderr}");
|
||||
assert!(stderr.contains("The Second Blocker"), "{stderr}");
|
||||
}
|
||||
|
||||
/// `-f` is where the deliberate overrides live, beside the backward and skipping moves.
|
||||
#[test]
|
||||
fn mv_moves_a_blocked_ticket_with_force() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", true);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mv_allows_the_move_once_the_blocker_is_done() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
|
||||
for status in ["committed", "reviewing", "done"] {
|
||||
assert!(
|
||||
move_ticket(&temp, "bbbb2222", status, false).status.success(),
|
||||
"the blocker itself could not be moved to {status}"
|
||||
);
|
||||
}
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// Every move, not only the one into committed. An open blocker is a reason not to
|
||||
/// finish as much as a reason not to start.
|
||||
#[test]
|
||||
fn mv_checks_the_blockers_on_every_move() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "reviewing");
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "done", false);
|
||||
assert!(!out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("reviewing").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// A move to the status the ticket is already in is not a move, so it is reported the
|
||||
/// way it always was rather than refused.
|
||||
#[test]
|
||||
fn mv_does_not_check_the_blockers_on_a_no_op() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_gated_pair(&worklane, &temp, "backlog");
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "backlog", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(String::from_utf8_lossy(&out.stdout).contains("already in"));
|
||||
}
|
||||
|
||||
/// A dangling target is a bookkeeping fault, not a dependency. Refusing there would
|
||||
/// wedge the ticket with no way out but `--force`.
|
||||
#[test]
|
||||
fn mv_warns_and_allows_when_a_blocker_is_not_on_the_board() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
fs::remove_file(
|
||||
worklane
|
||||
.join("backlog")
|
||||
.join("bbbb2222bbbb2222bbbb2222bbbb2222bbbb_the-blocker.md"),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("not on the board"),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// Only `blocked by` gates a move. The other two kinds are reference data.
|
||||
#[test]
|
||||
fn mv_ignores_the_kinds_that_are_not_blockers() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Related Task",
|
||||
"Points at an open ticket.",
|
||||
"aaaa1111aaaa1111aaaa1111aaaa1111aaaa",
|
||||
"alice",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"The Other",
|
||||
"Still open.",
|
||||
"bbbb2222bbbb2222bbbb2222bbbb2222bbbb",
|
||||
"bob",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
|
||||
Command::cargo_bin(BIN_NAME)
|
||||
.unwrap()
|
||||
.current_dir(temp.path())
|
||||
.args([
|
||||
"relate",
|
||||
"aaaa1111",
|
||||
"--regression-of",
|
||||
"bbbb2222",
|
||||
"--relates-to",
|
||||
"bbbb2222",
|
||||
])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
@@ -0,0 +1,358 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||
|
||||
/// The ticket under edit, the one it points at, and one that is already done.
|
||||
const GATED: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
const BLOCKER: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
||||
const FIXED: &str = "f1f2f3f4-5a6b-4c7d-8e9f-0a1b2c3d4e5f";
|
||||
|
||||
fn setup_worklane(temp: &TempDir) -> PathBuf {
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
worklane.child(dir).create_dir_all().unwrap();
|
||||
}
|
||||
|
||||
worklane.path().to_path_buf()
|
||||
}
|
||||
|
||||
fn slug(title: &str) -> String {
|
||||
title
|
||||
.to_lowercase()
|
||||
.chars()
|
||||
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
||||
.map(|c| if c == ' ' { '-' } else { c })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A ticket with a ticked criterion and a section the tool knows nothing about, so
|
||||
/// every test can check that recording a relation leaves both exactly as they were.
|
||||
fn create_ticket(worklane: &Path, status: &str, title: &str, uuid: &str) -> PathBuf {
|
||||
let path = worklane
|
||||
.join(status)
|
||||
.join(format!("{}_{}.md", uuid, slug(title)));
|
||||
|
||||
fs::write(
|
||||
&path,
|
||||
format!(
|
||||
"# {}\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
Prose.\n\
|
||||
\n\
|
||||
## Acceptance Criteria\n\
|
||||
- [x] Crit one\n\
|
||||
\n\
|
||||
## Implementation Plan\n\
|
||||
1. Step one\n\
|
||||
\n\
|
||||
## Notes\n\
|
||||
A handwritten note the tool knows nothing about.\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: alpha\n\
|
||||
- **Due**: _Not set_\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: {}\n",
|
||||
title, uuid, status
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
path
|
||||
}
|
||||
|
||||
/// The three tickets every test starts from: the one being edited, one it can wait on,
|
||||
/// and one in done.
|
||||
fn board(temp: &TempDir) -> PathBuf {
|
||||
let worklane = setup_worklane(temp);
|
||||
create_ticket(&worklane, "backlog", "The gated one", GATED);
|
||||
create_ticket(&worklane, "backlog", "The blocker", BLOCKER);
|
||||
create_ticket(&worklane, "done", "The old fix", FIXED);
|
||||
worklane
|
||||
}
|
||||
|
||||
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);
|
||||
cmd.assert().get_output().clone()
|
||||
}
|
||||
|
||||
fn stdout(out: &std::process::Output) -> String {
|
||||
String::from_utf8_lossy(&out.stdout).to_string()
|
||||
}
|
||||
|
||||
fn find(worklane: &Path, uuid: &str) -> PathBuf {
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
let dir = worklane.join(status);
|
||||
for entry in fs::read_dir(&dir).unwrap().filter_map(|e| e.ok()) {
|
||||
if entry.file_name().to_string_lossy().starts_with(uuid) {
|
||||
return entry.path();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
panic!("no file for ticket {uuid}");
|
||||
}
|
||||
|
||||
fn ticket(worklane: &Path, uuid: &str) -> String {
|
||||
fs::read_to_string(find(worklane, uuid)).unwrap()
|
||||
}
|
||||
|
||||
/// All three tiers, since the target is a ticket argument like any other: a uuid
|
||||
/// prefix, a title substring, and a substring reaching the middle of the filename.
|
||||
#[test]
|
||||
fn a_target_resolves_by_uuid_prefix_title_or_filename() {
|
||||
for search in ["b1b2", "blocker", "4a7b"] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", search]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{search}: {}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(
|
||||
ticket(&worklane, GATED).contains(&format!("- blocked by {}", BLOCKER)),
|
||||
"{search}: {}",
|
||||
ticket(&worklane, GATED)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_kind_is_recorded_under_its_own_label() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"relate",
|
||||
GATED,
|
||||
"--blocked-by",
|
||||
BLOCKER,
|
||||
"--regression-of",
|
||||
FIXED,
|
||||
"--relates-to",
|
||||
"old fix",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success());
|
||||
|
||||
let content = ticket(&worklane, GATED);
|
||||
assert!(content.contains(&format!("- blocked by {}", BLOCKER)), "{content}");
|
||||
assert!(content.contains(&format!("- regression of {}", FIXED)), "{content}");
|
||||
assert!(content.contains(&format!("- relates to {}", FIXED)), "{content}");
|
||||
|
||||
// Each kind named once in the report, whatever the order of the flags.
|
||||
let reported = stdout(&out);
|
||||
for kind in ["blocked by", "regression of", "relates to"] {
|
||||
assert!(reported.contains(kind), "{reported}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The kinds are flags, so anything else never reaches the file: clap refuses it with
|
||||
/// a usage error, exit code 2, and nothing is written.
|
||||
#[test]
|
||||
fn an_unknown_kind_is_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, GATED);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--depends-on", BLOCKER]);
|
||||
assert_eq!(out.status.code(), Some(2), "{}", stdout(&out));
|
||||
assert_eq!(ticket(&worklane, GATED), before);
|
||||
}
|
||||
|
||||
/// A bare `relate <ticket>` is a usage error too, not a silent no-op, the same way a
|
||||
/// bare `set` and a bare `append` are.
|
||||
#[test]
|
||||
fn a_relate_with_no_kind_is_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
board(&temp);
|
||||
|
||||
assert_eq!(run(&temp, &["relate", GATED]).status.code(), Some(2));
|
||||
}
|
||||
|
||||
/// Between the plan and the metadata, created for a ticket written before the section
|
||||
/// existed, and behind a handwritten section rather than in front of it.
|
||||
#[test]
|
||||
fn the_section_is_created_in_its_place() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
let content = ticket(&worklane, GATED);
|
||||
let at = |heading: &str| content.find(heading).unwrap_or_else(|| panic!("{heading}"));
|
||||
assert!(at("## Implementation Plan") < at("## Relations"), "{content}");
|
||||
assert!(at("## Notes") < at("## Relations"), "{content}");
|
||||
assert!(at("## Relations") < at("## Metadata"), "{content}");
|
||||
}
|
||||
|
||||
/// The full uuid, not the seven characters `ls` prints, which is what makes the link
|
||||
/// survive a rename of the target and stay unambiguous as the board grows.
|
||||
#[test]
|
||||
fn the_stored_target_is_the_full_uuid() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
assert!(
|
||||
ticket(&worklane, GATED).contains(&format!("- blocked by {}\n", BLOCKER)),
|
||||
"{}",
|
||||
ticket(&worklane, GATED)
|
||||
);
|
||||
|
||||
run(&temp, &["set", BLOCKER, "--title", "Renamed entirely"]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("Renamed entirely"), "{shown}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_ticket_cannot_relate_to_itself() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, GATED);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--relates-to", "gated"]);
|
||||
assert!(!out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("cannot relate to itself"),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert_eq!(ticket(&worklane, GATED), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_relation_already_held_reports_no_change_and_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
let before = ticket(&worklane, GATED);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
assert!(out.status.success());
|
||||
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
||||
assert_eq!(
|
||||
ticket(&worklane, GATED),
|
||||
before,
|
||||
"the relation was recorded twice"
|
||||
);
|
||||
}
|
||||
|
||||
/// One direction is stored. The inverse is derived by a scan, so the ticket at the
|
||||
/// other end is not touched at all.
|
||||
#[test]
|
||||
fn only_the_ticket_named_is_written() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, BLOCKER);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
assert_eq!(ticket(&worklane, BLOCKER), before);
|
||||
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
|
||||
}
|
||||
|
||||
/// The tick, the handwritten section and the prose are what a regenerated file would
|
||||
/// lose, and the section is spliced in rather than rewritten around them.
|
||||
#[test]
|
||||
fn relate_leaves_everything_it_was_not_asked_about_alone() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
let content = ticket(&worklane, GATED);
|
||||
assert!(content.contains("- [x] Crit one"), "the tick was lost: {content}");
|
||||
assert!(
|
||||
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
||||
"the unknown section was lost: {content}"
|
||||
);
|
||||
assert!(content.contains("1. Step one"), "{content}");
|
||||
assert!(content.contains("- **Owner**: alice"), "{content}");
|
||||
}
|
||||
|
||||
/// 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() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("Relations"), "{shown}");
|
||||
assert!(shown.contains("blocked by (b1b2c3d) The blocker"), "{shown}");
|
||||
// Never the stored line: a bare uuid says nothing about what it points at.
|
||||
assert!(!shown.contains(BLOCKER), "{shown}");
|
||||
}
|
||||
|
||||
/// Derived by scanning, since the file at this end holds nothing at all.
|
||||
#[test]
|
||||
fn show_lists_the_relation_the_other_ticket_holds() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
run(&temp, &["relate", GATED, "--relates-to", FIXED]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", BLOCKER]));
|
||||
assert!(shown.contains("blocks (641e3d5) The gated one"), "{shown}");
|
||||
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
|
||||
|
||||
// `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}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_target_that_no_longer_exists_renders_as_missing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
fs::remove_file(find(&worklane, BLOCKER)).unwrap();
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("blocked by (b1b2c3d) _missing_"), "{shown}");
|
||||
}
|
||||
|
||||
/// The section is the one part of a ticket read back by machine, so a line nobody can
|
||||
/// parse is an error naming the ticket rather than a line quietly skipped.
|
||||
#[test]
|
||||
fn a_line_that_is_not_a_relation_is_an_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let path = find(&worklane, GATED);
|
||||
let content = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace(
|
||||
"## Metadata",
|
||||
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
|
||||
);
|
||||
fs::write(&path, content).unwrap();
|
||||
|
||||
let out = run(&temp, &["show", GATED]);
|
||||
assert!(!out.status.success());
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("is not a relation"), "{stderr}");
|
||||
assert!(stderr.contains("The gated one"), "{stderr}");
|
||||
}
|
||||
Reference in New Issue
Block a user