Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
175c1d016d | ||
|
|
139c9b012f | ||
|
|
373ba519b3 |
@@ -3,6 +3,7 @@
|
||||
## Project Structure
|
||||
- `src/main.rs` - dispatch, the SIGPIPE reset, and the TUI event loop
|
||||
- `src/command.rs` - CLI argument definitions using clap derive
|
||||
- `src/completions.rs` - the generated completion script and the fish half that asks the board
|
||||
- `src/handlers.rs` - one `cmd_*` per subcommand
|
||||
- `src/util.rs` - the ticket format, resolution, rendering and the palette
|
||||
- `src/campaign.rs` - the campaign file format, its resolution, its index and its members
|
||||
@@ -20,7 +21,8 @@
|
||||
## Ticket File Format
|
||||
- Filenames: `<uuid_v4>_<slug>.md`
|
||||
- The slug is the title through `slug()`: lowercased, alphanumerics plus `-` and `_` kept, spaces turned into dashes. `Ticket 06` lands as `<uuid>_ticket-06.md`. Derive fixture filenames through `slug()`, never by hand
|
||||
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Campaign`, `Status`. `Campaign` is the one no ticket is born with: `add` does not write it, so it is inserted on demand
|
||||
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Committed On`, `Submitted On`, `Completed On`, `Campaign`, `Status`. The last four are the ones no ticket is born with: `add` writes none of them, so they are inserted on demand, against `METADATA_ORDER`, which is also what keeps `Status` last
|
||||
- The three stamps are `mv`'s, written by `set_status_stamp` from `Status::stamp_field`, and they are mutually exclusive: entering a status writes its field, leaving removes it, re-entering restamps. So a ticket carries at most one, the one for the status it is sitting in, and a backward move under `-f` leaves no stale `Completed On` behind. They are current state, like `Status` itself; the trail of how the ticket got there is d4ce964's job and must not be grown here. `backlog` has no stamp, `Created At` already answers for it
|
||||
- Format: `**Field Name**: value`
|
||||
- Ticket structure: `# Title` → `## Description` → `## Acceptance Criteria` → `## Implementation Plan` → `## Metadata`
|
||||
- Comments stored in `.worklane/comments/<ticket_uuid>/<timestamp>.md` with `**Comment**`, `**Author**`, `**Time**` fields
|
||||
@@ -58,12 +60,22 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **The shape is checked before chrono is asked.** `%Y-%m-%d` accepts an unpadded `2026-8-9`, which would be stored exactly as typed and sort before `2026-10-01` in any string comparison. Checking the length and the two dashes first is what lets a valid date be stored unchanged instead of normalised on the way in, which is the difference between validating and rewriting
|
||||
- **Strict on the way in, tolerant on the way out.** `util::due_date` still cuts `2026-12-31T09:30:00Z` down to its date. A file written before the parser existed, or by hand, can hold one and still has to render; refusing to display what is already stored would punish the reader for the writer's mistake
|
||||
- An empty `--due` keeps `non_empty`'s message about clearing rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is that clearing is not supported yet
|
||||
- **A status is a `util::Status`, not a string.** `mv --status` and the `ls` positional take the value enum, so an unknown status is a usage error at parse time naming the four, exit 2, and no handler checks. That is the same bargain `--due` and `--priority` take, and it is what lets the shells complete the four for free. `Status::ALL` is the flow order, which `status_dirs()` and `cmd_mv` both read rather than spelling the names again, and `DONE` is defined from it
|
||||
- The ticket positionals (`show <id>`, `mv <ticket>`, `comment <ticket>`) are also left alone, so a search term starting with a hyphen is a usage error. Reachable now that a hyphen-leading title can be stored: use the UUID, or put the flags first and separate with `--`, as in `mv --status committed -- -leading-title`
|
||||
- A bare `--` is a value when it follows an option (`--title -- ` stores `--`) and clap's end-of-options marker when it sits in a positional. So a `comment` body of exactly `--` needs its own separator, `comment <ticket> -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop
|
||||
- `add` has no positionals, so anything after a bare `--` is an unexpected argument and fails
|
||||
- **A paragraph break in a description is an empty `--description` value.** `cmd_add` joins the values with a single newline, so `-d "First." -d "" -d "Second."` writes the blank line. `trim_blank_ends()` drops blank values at either end, so a break never lands against a section heading, and an all-blank description reads as no description. Interior runs are kept verbatim rather than collapsed
|
||||
- `--acceptance` and `--plan` are lists, one criterium or step per value, so a blank there is spacing rather than content and the opencode wrapper drops it. Only `--description` preserves blanks
|
||||
|
||||
### Completions
|
||||
|
||||
- **Two halves, and the split is the point.** `clap_complete` generates the structure from the clap definition, so a new flag or subcommand is completed without anyone touching `completions.rs`. Only fish gets the second half, appended by `fish_dynamic()`, and it holds exactly what clap cannot know: the tickets on the board
|
||||
- **The dynamic values come from worklane itself**, as `worklane ls --ids` in a command substitution, one run per keypress at 2.5ms in release. So the completions are only as current as the binary on PATH: an older one without `--ids` completes nothing, which is a reinstall rather than a bug
|
||||
- **What clap does and does not emit.** It emits the possible values of an *option*, which is why `mv --status <TAB>` needs nothing here, and nothing for a *positional*, which is why the `ls` status and the `completions` shell are listed in the fish half. Both lists are read off the enums with `possible_values`, never written out, so a fifth status appears in the script on its own
|
||||
- **Position is counted, not inferred.** `__worklane_first_arg_of` and `__worklane_second_arg_of` check `$tokens[2]` and the token count rather than using `__fish_seen_subcommand_from`, because `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen, and because matching against the ticket list would run worklane again inside the condition
|
||||
- **`TICKET_COMMANDS`, `TICKET_SECOND_COMMANDS` and `TICKET_FLAGS` are kept honest by tests**, which walk the clap definition and fail on a ticket-taking subcommand that is in neither list, or in the list for the wrong position. A nested subcommand is not walked: `campaign` is the only one, none of its three takes a ticket, and the token counting could not tell them apart if one did
|
||||
- **`ls --ids` is the machine-readable listing**, and the only output in the tree meant to be parsed: the short id, a tab, the title, unstyled. Two fields because fish reads what follows a tab as the description and a script reads `cut -f1`. It includes done, which the decorated listing leaves out, because a completion has to be able to name a finished ticket, and it skips a missing status directory rather than refusing, because an error printed over a shell prompt is worse than no candidates. The filters still apply, and an unknown `--campaign` is still refused
|
||||
|
||||
### Filtering the Listing
|
||||
- **The filters are one call, `filtered`,** because `ls` collects a column in three places (a named status, the counts, and the grouped listing) and three call sites are three chances to apply a different set. Every filter is an `Option` and none asked for keeps everything, which is what makes them compose in any combination without a rule per pair
|
||||
- **`--tag` matches whole values, not the field.** `parse_tags` has already split the comma-separated field, so the filter compares against those trimmed values: `--tag bug` is not answered by a ticket tagged `bugfix`, and `--tag "cli, filter"` matches nothing, because the field as written is not itself a tag. A ticket with no tags matches none
|
||||
@@ -71,11 +83,11 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **One tag per invocation.** Several would have to decide between and and or, and neither reading is obviously right for a board this size. That decision is its own ticket, along with a substring or regex match and a tag filter on the tui
|
||||
- **A tag nothing carries lists nothing rather than being refused**, which is the opposite of `--campaign`. A campaign is an object that either exists or does not, so it is resolved before anything is read and an unknown one is an error. A tag is free text with no registry: there is nothing to resolve against, and refusing an unknown one would mean maintaining a vocabulary the format deliberately does not have. `assets/PLAN.md` tells the agent to check the spelling when a listing comes back empty, since that is the failure this trades for
|
||||
- An emptied status keeps the message `ls` already gives, `No tickets in '<status>' status.`, rather than one per filter naming what excluded them. That is pre-existing behaviour for `--priority` and `--campaign`, and one message for every filter is the consistent half of it. If it should name the filter, that is a change to what the CLI prints for three flags at once and belongs in its own ticket
|
||||
- **`cmd_ls` is now at the boundary the Rust Style rule names:** four filters and the directory. Two of them are adjacent `&Option<String>` parameters, which a caller can swap silently, so the next filter added here takes an `LsArgs` struct the way `add` took `AddArgs`, rather than a fifth positional
|
||||
- **`cmd_ls` takes an `LsArgs`**, which is what the boundary in the Rust Style rule came to: four filters, an output mode and the directory, two of them adjacent `Option<String>` values a caller could swap silently. `--ids` was the argument that tipped it, the way `add` became `AddArgs`. A new filter is a field there, not a parameter
|
||||
|
||||
### Editing a Ticket
|
||||
- `set` replaces a field, `append` adds to a section. The verb carries the meaning, so no flag needs a replace-or-append prefix, and `append` only offers the sections that hold multiple lines
|
||||
- **One field, one writer.** `set` has no `--owner` (that is `chown`'s) and no `--status` (that is `mv`'s). Do not add either
|
||||
- **One field, one writer.** `set` has no `--owner` (that is `chown`'s) and no `--status` (that is `mv`'s), and neither `add`, `set`, `append` nor `chown` can reach the three status stamps, which `mv` writes as a side effect of the move. Do not add any of them
|
||||
- `chown` takes the **user first and the ticket second**, after Unix `chown`, and is the only command that does not start with the ticket. Deliberate: the name borrows the Unix association, so the order borrows it too. A swap is left to `resolve_ticket`, which refuses a bare username as a ticket. No argument is inspected to see whether it *also* names a ticket, since such a check would only fire where resolution already fails and would stay silent on the one case it cannot catch, a ticket whose title is the username
|
||||
- `cmd_chown` is `set_metadata_field` plus `save_ticket`, with the same whole-file no-op comparison `set` uses and the same `report()` output, so nothing about writing a field lives twice
|
||||
- Sections are a table in `util.rs`: `DESCRIPTION`, `ACCEPTANCE`, `PLAN`, each with a heading, a label, the placeholder `add` writes when empty, and a `SectionKind`. Adding a section later is one entry, not edits in both commands
|
||||
|
||||
Generated
+11
-1
@@ -208,6 +208,15 @@ dependencies = [
|
||||
"strsim",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_complete"
|
||||
version = "4.6.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3be2ad0423bdbbb0e25bc89add796f3559706d4a95e1bc98e4d9662a957b6a19"
|
||||
dependencies = [
|
||||
"clap",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_derive"
|
||||
version = "4.6.1"
|
||||
@@ -1494,13 +1503,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.16.1"
|
||||
version = "0.17.2"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
"assert_fs",
|
||||
"chrono",
|
||||
"clap",
|
||||
"clap_complete",
|
||||
"crossterm",
|
||||
"libc",
|
||||
"ratatui",
|
||||
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.16.1"
|
||||
version = "0.17.2"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
@@ -14,6 +14,7 @@ libc = "0.2"
|
||||
# widget until one of us changed.
|
||||
ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] }
|
||||
crossterm = "0.28"
|
||||
clap_complete = "4.6.9"
|
||||
|
||||
[dev-dependencies]
|
||||
assert_cmd = "2"
|
||||
|
||||
@@ -8,7 +8,7 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `worklane` or `worklane tui [path...]` | Opens the board: four status columns, redrawn when the tree changes. Read only. Opens on backlog, committed and reviewing; `d` shows or hides done, whose count stays in the footer either way. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, whose border carries a page indicator while there is more of it than fits, `/` to jump to the first ticket whose id or title matches, `y` to copy the selected ticket's short id to the clipboard, `q` to quit. Each path opens the first `.worklane` at or above it, the working directory by default. Several paths are monitored together, as a tab per project plus an `all` tab that merges them, with `tab` and `shift+tab` between them |
|
||||
| `worklane init` | Creates `.worklane/` with backlog, committed, reviewing, done directories |
|
||||
| `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags. `--due` takes `YYYY-MM-DD` and refuses anything else at parse time |
|
||||
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>`, `--tag <tag>` and `--campaign <campaign>`, which compose in any combination. `--tag` matches a whole value of the comma-separated Tags field, case sensitively, so `--tag bug` does not list a ticket tagged `bugfix` or one tagged `Bug` |
|
||||
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>`, `--tag <tag>` and `--campaign <campaign>`, which compose in any combination. `--tag` matches a whole value of the comma-separated Tags field, case sensitively, so `--tag bug` does not list a ticket tagged `bugfix` or one tagged `Bug`. `--ids` prints one ticket per line as its short id, a tab and its title, unstyled, done included, for a script or a completion |
|
||||
| `worklane show <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring |
|
||||
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions |
|
||||
| `worklane set <ticket>` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID |
|
||||
@@ -18,14 +18,42 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `worklane check <ticket> [criteria...]` | Ticks acceptance criteria, each by number as shown by `show` or by a substring. Several in one call, or `all` for every one of them. Prompts with the numbered list if none is given, or errors with it when there is no terminal |
|
||||
| `worklane uncheck <ticket> [criteria...]` | Unticks acceptance criteria, addressed the same way |
|
||||
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
|
||||
| `worklane completions <shell>` | Prints a completion script for `fish`, `bash`, `zsh`, `elvish` or `powershell`. See below |
|
||||
| `worklane install-skill [skill]` | Writes the embedded agent skills to `~/.claude/skills/<skill>/SKILL.md`, which Claude Code and opencode both read. Three ship: `worklane` teaches the CLI, `worklane-review` reviews a finished ticket against the code that claims to close it, `worklane-plan` grooms the board as a whole, its priorities, due dates, tags and campaigns. Every document unless one is named. Leaves a modified copy alone unless `--force`; `--print` writes one to stdout instead and needs the name |
|
||||
|
||||
## Completions
|
||||
|
||||
```sh
|
||||
worklane completions fish > ~/.config/fish/completions/worklane.fish
|
||||
```
|
||||
|
||||
Also `bash`, `zsh`, `elvish` and `powershell`, though only fish gets the dynamic half.
|
||||
|
||||
The structure comes from clap, so new flags appear without anyone remembering to add them. The four
|
||||
statuses come with it, because a status is a value enum rather than a string. On top of that, fish
|
||||
asks worklane for the one thing only the board knows:
|
||||
|
||||
```
|
||||
worklane show <TAB> every ticket, id and title, done included
|
||||
worklane mv <TAB> the same, then --status <TAB> for the four
|
||||
worklane chown alice <TAB> the ticket, which is the second argument here
|
||||
worklane relate x --blocked-by <TAB>
|
||||
```
|
||||
|
||||
The tickets come from `worklane ls --ids`, one run per keypress, 2.5ms in release on a board of
|
||||
seventy-five tickets. Since fish runs whatever `worklane` is on PATH, **completions need the
|
||||
installed binary to be current**: an older one without `--ids` completes nothing. Re-run
|
||||
`cargo install --path .` after pulling.
|
||||
|
||||
`tui` is the one command whose argument is a path, so it is the one place fish still offers
|
||||
directories.
|
||||
|
||||
## Exit codes
|
||||
| Code | Meaning |
|
||||
|------|---------|
|
||||
| 0 | Success |
|
||||
| 1 | An error, such as no matching ticket or an ambiguous search |
|
||||
| 2 | A usage mistake, such as an unknown flag |
|
||||
| 2 | A usage mistake, such as an unknown flag, an unreal `--due` date, a priority out of range or a status that is not one of the four |
|
||||
| 141 | Output was piped to a reader that stopped early, for example `worklane ls \| head -3` |
|
||||
|
||||
141 is 128 + 13, the shell's way of reporting death by `SIGPIPE`. Worklane restores
|
||||
|
||||
@@ -35,6 +35,12 @@ skipping move, for correcting a mistake.
|
||||
A move is also refused while the ticket is blocked by one that is not done yet, see
|
||||
[Relating tickets](#relating-tickets).
|
||||
|
||||
`mv` stamps the time as it goes: `Committed On`, `Submitted On` and `Completed On`, one
|
||||
field for the status the ticket is in now, shown by `show` among the rest of the
|
||||
metadata. Only the current one is kept, so the stamp says how long the ticket has been
|
||||
where it is, not how long each earlier stage took. Nothing else writes them, and moving
|
||||
a ticket back removes the stamp of the status it left.
|
||||
|
||||
## Reading the board
|
||||
|
||||
```
|
||||
@@ -47,6 +53,11 @@ worklane show 1b78a24 # one ticket, body and comments
|
||||
|
||||
`ls` prints a seven-character id per ticket. That is what you address it by.
|
||||
|
||||
`worklane ls --ids` prints the same tickets as an id, a tab and a title, one per line and
|
||||
unstyled, with done included and the filters still applying. That is the form to parse
|
||||
when you want the ids themselves: `worklane ls --ids | cut -f1`. The decorated listing is
|
||||
for reading, not for cutting up.
|
||||
|
||||
The filters compose in any combination, with each other and with the status positional:
|
||||
`worklane ls backlog --tag bug --priority 1`. `--tag` takes one tag and matches it
|
||||
against the whole values of the comma-separated `Tags` field, case sensitively, so
|
||||
@@ -214,6 +225,16 @@ existing ticket will have been written from a different angle.
|
||||
- Related but not the same: file it, and record it with `relate <new> --relates-to <old>`
|
||||
rather than only mentioning the id in prose.
|
||||
|
||||
## Shell completions
|
||||
|
||||
```
|
||||
worklane completions fish > ~/.config/fish/completions/worklane.fish
|
||||
```
|
||||
|
||||
For the person's shell, not for you, and `bash`, `zsh`, `elvish` and `powershell` are
|
||||
there too. Only fish completes ticket ids, which it does by running `worklane ls --ids`,
|
||||
so a stale binary on PATH completes nothing and the fix is to reinstall it.
|
||||
|
||||
## Addressing a ticket
|
||||
|
||||
Every command that takes a ticket accepts, in this order of precedence:
|
||||
|
||||
+41
-19
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
|
||||
|
||||
use chrono::NaiveDate;
|
||||
|
||||
use crate::util::{PRIORITY_RANGE, RelationKind, priority_legend};
|
||||
use crate::util::{PRIORITY_RANGE, RelationKind, Status, priority_legend};
|
||||
|
||||
/// clap wants a `&str` with a long enough lifetime, and the legend is built from
|
||||
/// the same ramp the listing uses rather than spelled out a second time.
|
||||
@@ -112,22 +112,7 @@ pub enum Command {
|
||||
|
||||
/// List tickets, optionally filtered by status
|
||||
#[command(after_help = PRIORITY_LEGEND.as_str())]
|
||||
Ls {
|
||||
/// Filter by status (backlog, committed, reviewing, done)
|
||||
status: Option<String>,
|
||||
|
||||
/// Only show tickets at this priority, 1 (most urgent) to 5 (least)
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
priority: Option<u8>,
|
||||
|
||||
/// Only show tickets carrying this tag, matched whole
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
tag: Option<String>,
|
||||
|
||||
/// Only show the members of this campaign, by UUID or title
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
campaign: Option<String>,
|
||||
},
|
||||
Ls(LsArgs),
|
||||
|
||||
/// Show a ticket by UUID or title
|
||||
Show {
|
||||
@@ -140,9 +125,9 @@ pub enum Command {
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
|
||||
/// Target status (backlog, committed, reviewing, done)
|
||||
/// Target status
|
||||
#[arg(short, long)]
|
||||
status: String,
|
||||
status: Status,
|
||||
|
||||
/// Force move (allows backward or non-sequential moves)
|
||||
#[arg(short, long)]
|
||||
@@ -227,6 +212,16 @@ pub enum Command {
|
||||
ticket: String,
|
||||
},
|
||||
|
||||
/// Print a shell completion script
|
||||
///
|
||||
/// The structure comes from the clap definition, so a flag added here appears
|
||||
/// without anyone remembering to. Fish gets a hand-written half appended for the
|
||||
/// values only the board knows, see `completions.rs`.
|
||||
Completions {
|
||||
/// fish, bash, zsh, elvish or powershell
|
||||
shell: clap_complete::Shell,
|
||||
},
|
||||
|
||||
/// Install the agent skills that teach an agent to use worklane
|
||||
///
|
||||
/// Every shipped document by default. The optional name narrows it to one, and
|
||||
@@ -288,6 +283,33 @@ pub struct CampaignAddArgs {
|
||||
pub owner: Option<String>,
|
||||
}
|
||||
|
||||
/// `ls` holds four filters, an output mode and nothing else, which is the boundary the
|
||||
/// Rust Style rule in AGENTS.md names: two of the filters are adjacent `Option<String>`
|
||||
/// values that a caller can swap silently, so the mode that joined them came as a
|
||||
/// struct rather than a sixth parameter, the way `add` became [`AddArgs`].
|
||||
#[derive(clap::Args)]
|
||||
pub struct LsArgs {
|
||||
/// Filter by status
|
||||
pub status: Option<Status>,
|
||||
|
||||
/// Only show tickets at this priority, 1 (most urgent) to 5 (least)
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
pub priority: Option<u8>,
|
||||
|
||||
/// Only show tickets carrying this tag, matched whole
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub tag: Option<String>,
|
||||
|
||||
/// Only show the members of this campaign, by UUID or title
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub campaign: Option<String>,
|
||||
|
||||
/// Print one ticket per line as its id and title, tab separated, for a script or a
|
||||
/// completion. Done included, and the filters still apply
|
||||
#[arg(long)]
|
||||
pub ids: bool,
|
||||
}
|
||||
|
||||
/// `add` carries every field a new ticket can hold, so it is a struct rather than an
|
||||
/// inline variant: nine parameters at the call site is what `too_many_arguments` is
|
||||
/// for, and `set`, `append` and `check` already pass their arguments this way.
|
||||
|
||||
@@ -0,0 +1,293 @@
|
||||
//! Shell completions.
|
||||
//!
|
||||
//! Two halves, because neither alone is enough.
|
||||
//!
|
||||
//! `clap_complete` generates the structure (subcommands, flags, their arguments)
|
||||
//! straight from the clap definition, so a new flag never needs remembering here. But it
|
||||
//! can only offer values it knows at compile time, and the value worth completing for
|
||||
//! worklane is the ticket, which lives in the board the command is run above.
|
||||
//!
|
||||
//! So the fish output gets a hand-written block appended that asks worklane itself. That
|
||||
//! costs one `worklane ls --ids` per keypress, which measured at 2.5ms in release on a
|
||||
//! board of seventy-five tickets, comfortably below anything a person notices.
|
||||
//!
|
||||
//! The four statuses are half clap's: `Status` is a `ValueEnum`, so it emits them for
|
||||
//! `mv --status`, but the fish generator does not emit possible values for a *positional*
|
||||
//! and `ls <status>` gets nothing. Same for `completions <shell>`. So the block below
|
||||
//! lists those two, from the enums rather than by hand.
|
||||
|
||||
use std::io;
|
||||
|
||||
use clap::{CommandFactory, ValueEnum};
|
||||
use clap_complete::Shell;
|
||||
|
||||
use crate::install::SKILLS;
|
||||
use crate::util::Status;
|
||||
|
||||
/// Subcommands whose first positional is a ticket.
|
||||
///
|
||||
/// Kept honest by a test rather than by memory: a new ticket-taking subcommand that is
|
||||
/// missing here silently loses completion, which nothing else would catch.
|
||||
pub const TICKET_COMMANDS: [&str; 8] = [
|
||||
"show", "mv", "comment", "set", "append", "relate", "check", "uncheck",
|
||||
];
|
||||
|
||||
/// Subcommands whose *second* positional is the ticket, because they name two things.
|
||||
///
|
||||
/// `chown alice <ticket>` and `assign "v1 release" <ticket>`, which put the ticket
|
||||
/// second deliberately, see AGENTS.md. The first argument of each is a user or a
|
||||
/// campaign, and neither is completed.
|
||||
pub const TICKET_SECOND_COMMANDS: [&str; 2] = ["chown", "assign"];
|
||||
|
||||
/// Options whose value is a ticket, as `relate` takes three of.
|
||||
pub const TICKET_FLAGS: [&str; 3] = ["blocked-by", "regression-of", "relates-to"];
|
||||
|
||||
pub fn generate(shell: Shell, out: &mut dyn io::Write) -> io::Result<()> {
|
||||
let mut command = crate::command::Cli::command();
|
||||
clap_complete::generate(shell, &mut command, "worklane", out);
|
||||
|
||||
if shell == Shell::Fish {
|
||||
write!(out, "{}", fish_dynamic())?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The dynamic half, appended to what clap generated.
|
||||
///
|
||||
/// Fish merges completions from every `complete` call, so these add to the generated
|
||||
/// rules rather than replacing them.
|
||||
fn fish_dynamic() -> String {
|
||||
let ticket_commands = TICKET_COMMANDS.join(" ");
|
||||
let ticket_second_commands = TICKET_SECOND_COMMANDS.join(" ");
|
||||
let ticket_flags = TICKET_FLAGS
|
||||
.iter()
|
||||
.map(|flag| format!("-l {flag}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
let statuses = possible_values(Status::value_variants());
|
||||
let shells = possible_values(Shell::value_variants());
|
||||
let skills = SKILLS
|
||||
.iter()
|
||||
.map(|skill| skill.name)
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
|
||||
format!(
|
||||
r#"
|
||||
# ---------------------------------------------------------------------------
|
||||
# Dynamic values, appended by `worklane completions fish`. Fish accumulates
|
||||
# completions, so these add to the generated rules above.
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
# Almost every argument worklane takes names something on the board rather than
|
||||
# something on disk, so stop fish falling back to the directory listing. Without this,
|
||||
# `worklane show 1b78a24 <TAB>` offers Cargo.toml and src/.
|
||||
complete -c worklane -f
|
||||
|
||||
# The exception, and the reason the line above is not the whole story: `tui` takes
|
||||
# project paths, as many as you like. Directories only, since each is resolved to the
|
||||
# first `.worklane` at or above it.
|
||||
complete -c worklane -n '__fish_seen_subcommand_from tui' \
|
||||
-a '(__fish_complete_directories)' -d project
|
||||
|
||||
# Position is counted rather than inferred from what has been typed: matching against
|
||||
# the ticket list would run worklane again inside the condition, and would also keep
|
||||
# offering tickets after one had been chosen.
|
||||
#
|
||||
# The subcommand is the second token, so its first argument is being typed once two
|
||||
# tokens are there. `$tokens[2]` rather than `__fish_seen_subcommand_from`, because
|
||||
# `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen,
|
||||
# and their arguments are not what these complete.
|
||||
function __worklane_first_arg_of
|
||||
set -l tokens (commandline -opc)
|
||||
test (count $tokens) -eq 2; and contains -- $tokens[2] $argv
|
||||
end
|
||||
|
||||
function __worklane_second_arg_of
|
||||
set -l tokens (commandline -opc)
|
||||
test (count $tokens) -eq 3; and contains -- $tokens[2] $argv
|
||||
end
|
||||
|
||||
# No `-d`: `ls --ids` prints the id and the title separated by a tab, which is fish's
|
||||
# own form for a candidate and its description, so every ticket carries its own.
|
||||
complete -c worklane \
|
||||
-n '__worklane_first_arg_of {ticket_commands}; or __worklane_second_arg_of {ticket_second_commands}' \
|
||||
-a '(worklane ls --ids)'
|
||||
|
||||
# `relate` takes its targets as option values, so they are completed by flag rather
|
||||
# than by position.
|
||||
complete -c worklane {ticket_flags} -x -a '(worklane ls --ids)'
|
||||
|
||||
# clap emits the four for `mv --status`, which is an option, but the fish generator
|
||||
# emits nothing for the possible values of a positional. So the one place a status is
|
||||
# positional needs them listed, and the same goes for the shell below.
|
||||
complete -c worklane -n '__worklane_first_arg_of ls' -a '{statuses}' -d status
|
||||
complete -c worklane -n '__worklane_first_arg_of completions' -a '{shells}' -d shell
|
||||
|
||||
# Shipped with the binary, so this list comes from `install::SKILLS` and cannot fall
|
||||
# behind it.
|
||||
complete -c worklane -n '__worklane_first_arg_of install-skill' -a '{skills}' -d skill
|
||||
"#
|
||||
)
|
||||
}
|
||||
|
||||
/// The names a `ValueEnum` accepts, for a fish `-a` list.
|
||||
///
|
||||
/// Read off the enum rather than written out, so a status or a shell added to either one
|
||||
/// is offered without anybody remembering this file. A variant marked hidden is left out,
|
||||
/// which is what `to_possible_value` returning `None` means.
|
||||
fn possible_values<T: ValueEnum>(variants: &[T]) -> String {
|
||||
variants
|
||||
.iter()
|
||||
.filter_map(|variant| variant.to_possible_value())
|
||||
.map(|value| value.get_name().to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Built, not just derived: an index is assigned when the command is built, and the
|
||||
/// positionals of an unbuilt one all report `None`.
|
||||
fn command() -> clap::Command {
|
||||
let mut cli = crate::command::Cli::command();
|
||||
cli.build();
|
||||
cli
|
||||
}
|
||||
|
||||
/// Every subcommand that takes a ticket must be listed, at the position it takes it,
|
||||
/// or it silently loses completion.
|
||||
///
|
||||
/// The nested subcommands are not walked. `campaign` is the only one, none of its
|
||||
/// three takes a ticket, and the token counting above could not tell them apart if
|
||||
/// one did. A ticket argument added under `campaign` needs the fish block reworked,
|
||||
/// not another name in a list.
|
||||
#[test]
|
||||
fn no_ticket_taking_subcommand_is_missing() {
|
||||
for subcommand in command().get_subcommands() {
|
||||
let name = subcommand.get_name();
|
||||
for positional in subcommand.get_positionals() {
|
||||
// `show` calls it `id`; everything else calls it `ticket`.
|
||||
if !matches!(positional.get_id().as_str(), "ticket" | "id") {
|
||||
continue;
|
||||
}
|
||||
match positional.get_index() {
|
||||
Some(1) => assert!(
|
||||
TICKET_COMMANDS.contains(&name),
|
||||
"`worklane {name}` takes a ticket first but is not in TICKET_COMMANDS"
|
||||
),
|
||||
Some(2) => assert!(
|
||||
TICKET_SECOND_COMMANDS.contains(&name),
|
||||
"`worklane {name}` takes a ticket second but is not in \
|
||||
TICKET_SECOND_COMMANDS"
|
||||
),
|
||||
index => panic!("`worklane {name}` takes a ticket at position {index:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_listed_command_is_a_real_subcommand() {
|
||||
let cli = command();
|
||||
let known: Vec<&str> = cli.get_subcommands().map(|c| c.get_name()).collect();
|
||||
for name in TICKET_COMMANDS.iter().chain(TICKET_SECOND_COMMANDS.iter()) {
|
||||
assert!(known.contains(name), "no such subcommand: {name}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The flags completed as tickets have to be `relate`'s actual flags, or the rule
|
||||
/// completes an option nothing accepts.
|
||||
#[test]
|
||||
fn every_ticket_flag_is_a_real_option() {
|
||||
let relate = command()
|
||||
.find_subcommand("relate")
|
||||
.expect("relate exists")
|
||||
.clone();
|
||||
let known: Vec<String> = relate
|
||||
.get_arguments()
|
||||
.filter_map(|arg| arg.get_long().map(str::to_string))
|
||||
.collect();
|
||||
for flag in TICKET_FLAGS {
|
||||
assert!(
|
||||
known.contains(&flag.to_string()),
|
||||
"`relate` has no --{flag}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_fish_script_asks_worklane_for_its_tickets() {
|
||||
let script = fish_dynamic();
|
||||
assert!(script.contains("worklane ls --ids"));
|
||||
// Both positions, in one rule.
|
||||
assert!(script.contains("__worklane_first_arg_of show"));
|
||||
assert!(script.contains("__worklane_second_arg_of chown assign"));
|
||||
// Nothing here takes a file, bar the one that does.
|
||||
assert!(script.contains("complete -c worklane -f\n"));
|
||||
assert!(script.contains("__fish_complete_directories"));
|
||||
// Generated from `install::SKILLS`, so every shipped skill is in it.
|
||||
assert!(script.contains("worklane-review"));
|
||||
}
|
||||
|
||||
/// The one status positional and the one shell positional, which clap does not emit
|
||||
/// possible values for. Read off the enums, so a fifth status would appear here on
|
||||
/// its own.
|
||||
#[test]
|
||||
fn the_fish_script_lists_the_statuses_and_the_shells() {
|
||||
let script = fish_dynamic();
|
||||
for status in Status::ALL {
|
||||
assert!(
|
||||
script.contains(status.as_str()),
|
||||
"the ls positional is never offered {}",
|
||||
status.as_str()
|
||||
);
|
||||
}
|
||||
assert!(script.contains("-a 'backlog committed reviewing done' -d status"));
|
||||
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
|
||||
assert!(script.contains(shell), "the shell positional is never offered {shell}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The four for `mv --status` are clap's, which is half of why `Status` is a
|
||||
/// `ValueEnum`. If clap ever stops emitting them, the fish half has to carry them
|
||||
/// too, and this is what says so.
|
||||
#[test]
|
||||
fn clap_emits_the_statuses_for_the_status_flag() {
|
||||
let mut out = Vec::new();
|
||||
generate(Shell::Fish, &mut out).expect("generates");
|
||||
let script = String::from_utf8(out).expect("utf8");
|
||||
let flag = script
|
||||
.lines()
|
||||
.find(|line| line.contains("using_subcommand mv") && line.contains("-l status"))
|
||||
.expect("mv --status has a rule of its own");
|
||||
assert!(flag.contains("backlog"), "{flag}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generating_fish_produces_both_halves() {
|
||||
let mut out = Vec::new();
|
||||
generate(Shell::Fish, &mut out).expect("generates");
|
||||
let script = String::from_utf8(out).expect("utf8");
|
||||
// clap's half.
|
||||
assert!(script.contains("complete -c worklane"));
|
||||
assert!(script.contains("install-skill"));
|
||||
// Ours.
|
||||
assert!(script.contains("__worklane_first_arg_of"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_shells_get_only_the_generated_half() {
|
||||
for shell in [Shell::Bash, Shell::Zsh] {
|
||||
let mut out = Vec::new();
|
||||
generate(shell, &mut out).expect("generates");
|
||||
let script = String::from_utf8(out).expect("utf8");
|
||||
assert!(
|
||||
!script.contains("__worklane_first_arg_of"),
|
||||
"fish-only helpers leaked into {shell}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
+98
-38
@@ -5,7 +5,9 @@ use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::campaign::*;
|
||||
use crate::command::{AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, RelateArgs, SetArgs};
|
||||
use crate::command::{
|
||||
AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, LsArgs, RelateArgs, SetArgs,
|
||||
};
|
||||
use crate::install;
|
||||
use crate::util::*;
|
||||
|
||||
@@ -23,8 +25,7 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
|
||||
fs::create_dir_all(&worklane_dir)?;
|
||||
|
||||
let folders = ["backlog", "committed", "reviewing", "done"];
|
||||
for folder in &folders {
|
||||
for folder in status_dirs() {
|
||||
fs::create_dir_all(worklane_dir.join(folder))?;
|
||||
}
|
||||
|
||||
@@ -37,21 +38,22 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_ls(
|
||||
status_filter: &Option<String>,
|
||||
priority_filter: Option<u8>,
|
||||
tag_filter: &Option<String>,
|
||||
campaign_filter: &Option<String>,
|
||||
worklane_dir: &Path,
|
||||
) -> Result<()> {
|
||||
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
// Resolved before anything is read, so an unknown campaign is refused rather than
|
||||
// silently listing nothing, and the name is available for the heading.
|
||||
let campaign = match campaign_filter {
|
||||
// silently listing nothing, and the name is available for the heading. Ahead of the
|
||||
// `--ids` branch too: a completion that quietly listed the whole board because the
|
||||
// campaign was misspelled would be worse than one that printed nothing.
|
||||
let campaign = match &args.campaign {
|
||||
Some(search) => Some(resolve_campaign(search, worklane_dir)?),
|
||||
None => None,
|
||||
};
|
||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
||||
let tag = tag_filter.as_deref();
|
||||
let tag = args.tag.as_deref();
|
||||
let priority_filter = args.priority;
|
||||
|
||||
if args.ids {
|
||||
return list_ids(args.status, priority_filter, uuid, tag, worklane_dir);
|
||||
}
|
||||
|
||||
if let Some(campaign) = &campaign {
|
||||
println!(
|
||||
@@ -61,12 +63,18 @@ pub fn cmd_ls(
|
||||
);
|
||||
}
|
||||
|
||||
if let Some(status) = status_filter {
|
||||
if let Some(status) = args.status {
|
||||
let status = status.as_str();
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
// The status itself is clap's to reject now, so reaching here means the
|
||||
// board is missing a directory it should have rather than that the name was
|
||||
// mistyped. `init` will not repair it: it leaves an existing `.worklane`
|
||||
// alone.
|
||||
return Err(anyhow!(
|
||||
"Status '{}' not found. Valid statuses: backlog, committed, reviewing, done",
|
||||
status
|
||||
"No '{}' directory in {}. Every board has all four; creating it is enough.",
|
||||
status,
|
||||
worklane_dir.display()
|
||||
));
|
||||
}
|
||||
|
||||
@@ -119,6 +127,47 @@ pub fn cmd_ls(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The machine-readable listing: one ticket per line, its short id then its title,
|
||||
/// separated by a tab and unstyled.
|
||||
///
|
||||
/// Two fields rather than the id alone because both readers want both. Fish takes what
|
||||
/// follows the tab as the description, which is what makes `worklane show <TAB>` a list
|
||||
/// of titles rather than of hex, and a script takes the id back out with `cut -f1`. The
|
||||
/// id is the same seven characters the listing prints, which is what a ticket is
|
||||
/// addressed by.
|
||||
///
|
||||
/// Every status, done included, where the listing above leaves done out. A completion has
|
||||
/// to be able to name a finished ticket, since `show` and `comment` are most often
|
||||
/// pointed at one, and the status positional still narrows it.
|
||||
///
|
||||
/// A missing status directory is skipped rather than refused, which is the one place this
|
||||
/// parts company with the listing. The caller is usually a shell filling in a candidate
|
||||
/// list, and an error printed over the prompt is worse there than no candidates.
|
||||
fn list_ids(
|
||||
status: Option<Status>,
|
||||
level: Option<u8>,
|
||||
campaign: Option<&str>,
|
||||
tag: Option<&str>,
|
||||
worklane_dir: &Path,
|
||||
) -> Result<()> {
|
||||
let statuses = match status {
|
||||
Some(status) => vec![status.as_str()],
|
||||
None => status_dirs(),
|
||||
};
|
||||
|
||||
for status in statuses {
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
continue;
|
||||
}
|
||||
for item in filtered(collect_ticket_items(&status_path)?, level, campaign, tag) {
|
||||
println!("{}\t{}", item.id, item.title);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The listing filters in one call, so the three places `ls` collects a column cannot
|
||||
/// end up applying a different set of them.
|
||||
///
|
||||
@@ -207,10 +256,6 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
let filename = format!("{}_{}.md", id, slug);
|
||||
let filepath = backlog_dir.join(&filename);
|
||||
|
||||
if filepath.exists() {
|
||||
return Err(anyhow!("A ticket with this title already exists."));
|
||||
}
|
||||
|
||||
// Joined with a single newline, so an empty value is how a caller spells a
|
||||
// paragraph break and an all-blank description is no description at all.
|
||||
let description = trim_blank_ends(description);
|
||||
@@ -278,7 +323,21 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
);
|
||||
body.push('\n');
|
||||
|
||||
fs::write(&filepath, body)?;
|
||||
// No existence check ahead of this. The name carries a uuid generated a few lines
|
||||
// up, so a collision is not something that happens, and the branch that used to
|
||||
// guard the write claimed the *title* was taken, which is the opposite of what the
|
||||
// format allows: duplicate titles are supported and `add_allows_duplicate_titles`
|
||||
// pins it. `cmd_campaign_add` deliberately does not carry it either. What is left is
|
||||
// the write's own failure, named with the ticket and the path the way the other
|
||||
// writes in the tree name them.
|
||||
fs::write(&filepath, body).map_err(|e| {
|
||||
anyhow!(
|
||||
"Could not write ticket '{}' at {}: {}",
|
||||
title,
|
||||
filepath.display(),
|
||||
e
|
||||
)
|
||||
})?;
|
||||
|
||||
println!("Created ticket: {}", filename);
|
||||
Ok(())
|
||||
@@ -562,29 +621,20 @@ fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()>
|
||||
))
|
||||
}
|
||||
|
||||
pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -> Result<()> {
|
||||
let valid_statuses = ["backlog", "committed", "reviewing", "done"];
|
||||
let forward_order = ["backlog", "committed", "reviewing", "done"];
|
||||
|
||||
if !valid_statuses.contains(&target_status) {
|
||||
return Err(anyhow!(
|
||||
"Invalid target status '{}'. Valid statuses: {}",
|
||||
target_status,
|
||||
valid_statuses.join(", ")
|
||||
));
|
||||
}
|
||||
/// A status is a [`Status`] rather than a string, so an unknown one is clap's to refuse
|
||||
/// and nothing here has to check. What is left is the order of the flow, which is
|
||||
/// `Status::ALL`.
|
||||
pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Result<()> {
|
||||
let target_status = target.as_str();
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (current_status, title, resolved) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
|
||||
let current_idx = forward_order
|
||||
let current_idx = Status::ALL
|
||||
.iter()
|
||||
.position(|&s| s == current_status)
|
||||
.unwrap();
|
||||
let target_idx = forward_order
|
||||
.iter()
|
||||
.position(|&s| s == target_status)
|
||||
.position(|status| status.as_str() == current_status)
|
||||
.unwrap();
|
||||
let target_idx = Status::ALL.iter().position(|status| *status == target).unwrap();
|
||||
|
||||
if !force && target_idx < current_idx {
|
||||
return Err(anyhow!(
|
||||
@@ -622,6 +672,16 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
|
||||
// refused for that reason rather than for whatever the lookup notices first.
|
||||
let content = set_status_field(&resolved, target_status, &title)?;
|
||||
|
||||
// Behind every refusal above, so a move that does not happen writes no stamp, and
|
||||
// spliced in here rather than after the rename so it travels with the same
|
||||
// crash-safe write the Status field does.
|
||||
let content = set_status_stamp(
|
||||
&content,
|
||||
target,
|
||||
&Local::now().format(TIMESTAMP_FORMAT).to_string(),
|
||||
&title,
|
||||
)?;
|
||||
|
||||
let found_filename =
|
||||
find_ticket_file(¤t_path, &parse_ticket_field(&resolved, "ID"), &title)?;
|
||||
|
||||
|
||||
+9
-8
@@ -4,6 +4,7 @@ use clap::Parser;
|
||||
mod campaign;
|
||||
mod clipboard;
|
||||
mod command;
|
||||
mod completions;
|
||||
mod handlers;
|
||||
mod install;
|
||||
mod tui;
|
||||
@@ -46,14 +47,9 @@ fn main() -> Result<()> {
|
||||
Some(Command::Tui { paths }) => run_tui(&paths, &start),
|
||||
Some(Command::Init) => cmd_init(&start),
|
||||
Some(Command::Add(args)) => cmd_add(&args, &start),
|
||||
Some(Command::Ls {
|
||||
status,
|
||||
priority,
|
||||
tag,
|
||||
campaign,
|
||||
}) => {
|
||||
Some(Command::Ls(args)) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_ls(&status, priority, &tag, &campaign, &worklane_dir)
|
||||
cmd_ls(&args, &worklane_dir)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
@@ -63,7 +59,7 @@ fn main() -> Result<()> {
|
||||
ticket,
|
||||
status,
|
||||
force,
|
||||
}) => cmd_mv(&ticket, &status, force, &start),
|
||||
}) => cmd_mv(&ticket, status, force, &start),
|
||||
Some(Command::Set(args)) => cmd_set(&args, &start),
|
||||
Some(Command::Append(args)) => cmd_append(&args, &start),
|
||||
Some(Command::Relate(args)) => cmd_relate(&args, &start),
|
||||
@@ -87,6 +83,11 @@ fn main() -> Result<()> {
|
||||
}
|
||||
},
|
||||
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
|
||||
// No board either, for the reason `install-skill` has none: a completion script
|
||||
// is generated from the clap definition and is the same wherever it is run.
|
||||
Some(Command::Completions { shell }) => {
|
||||
completions::generate(shell, &mut std::io::stdout()).map_err(Into::into)
|
||||
}
|
||||
// No board is looked for: the point of the skill is to teach an agent worklane
|
||||
// before there is a `.worklane` anywhere.
|
||||
Some(Command::InstallSkill { skill, force, print }) => {
|
||||
|
||||
+241
-6
@@ -1064,6 +1064,35 @@ fn set_metadata_line(
|
||||
if found { Some(updated) } else { None }
|
||||
}
|
||||
|
||||
/// Drop one field from the Metadata section, leaving every other line untouched.
|
||||
///
|
||||
/// Scoped to the section for the same reason as [`set_metadata_line`], and shaped like
|
||||
/// it: nothing means there was no such field, so a caller that removes a field a ticket
|
||||
/// never carried leaves the content exactly as it found it rather than rewriting it
|
||||
/// into an identical string.
|
||||
fn remove_metadata_line(content: &str, field: &str) -> Option<String> {
|
||||
let prefix = format!("**{}**:", field);
|
||||
let mut updated = String::with_capacity(content.len());
|
||||
let mut in_metadata = false;
|
||||
let mut found = false;
|
||||
|
||||
for line in content.lines() {
|
||||
if line.starts_with("## ") {
|
||||
in_metadata = is_metadata_heading(line);
|
||||
}
|
||||
|
||||
if in_metadata && !found && metadata_field_body(line).starts_with(&prefix) {
|
||||
found = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
updated.push_str(line);
|
||||
updated.push('\n');
|
||||
}
|
||||
|
||||
if found { Some(updated) } else { None }
|
||||
}
|
||||
|
||||
pub fn set_status_field(content: &str, target_status: &str, title: &str) -> Result<String> {
|
||||
set_metadata_line(content, "Status", target_status, is_status_line).ok_or_else(|| {
|
||||
anyhow!(
|
||||
@@ -1136,20 +1165,26 @@ pub fn parse_tags(content: &str) -> Vec<String> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The metadata fields in the order `add` writes them, with `Campaign` in its place
|
||||
/// among them.
|
||||
/// The metadata fields in the order `add` writes them, with the fields no ticket is
|
||||
/// born with in their places among them.
|
||||
///
|
||||
/// The anchor list for inserting a field the file does not have yet, exactly as
|
||||
/// [`SECTION_ORDER`] is for a missing section. Campaign sits beside Status because the
|
||||
/// two answer the same kind of question, where the ticket belongs rather than what it
|
||||
/// is, and Status stays last, which is where every file already keeps it.
|
||||
const METADATA_ORDER: [&str; 8] = [
|
||||
/// is, and Status stays last, which is where every file already keeps it. The three
|
||||
/// stamps follow `Created At`, since they answer the same question it does about a
|
||||
/// later moment, and they are in flow order for a reader who sees one after another
|
||||
/// across a board.
|
||||
const METADATA_ORDER: [&str; 11] = [
|
||||
"ID",
|
||||
"Priority",
|
||||
"Tags",
|
||||
"Due",
|
||||
"Owner",
|
||||
"Created At",
|
||||
COMMITTED_ON_FIELD,
|
||||
SUBMITTED_ON_FIELD,
|
||||
COMPLETED_ON_FIELD,
|
||||
CAMPAIGN_FIELD,
|
||||
"Status",
|
||||
];
|
||||
@@ -1228,6 +1263,52 @@ fn insert_metadata_field(content: &str, field: &str, value: &str, title: &str) -
|
||||
Ok(join_lines(&out))
|
||||
}
|
||||
|
||||
// The metadata fields `mv` stamps with the time a ticket entered a status. Backlog has
|
||||
// none: a ticket is filed there, and `Created At` already records when, so a fourth
|
||||
// field would say the same thing for every ticket that has never moved.
|
||||
pub const COMMITTED_ON_FIELD: &str = "Committed On";
|
||||
pub const SUBMITTED_ON_FIELD: &str = "Submitted On";
|
||||
pub const COMPLETED_ON_FIELD: &str = "Completed On";
|
||||
|
||||
/// Stamp the field of the status being entered and drop the other two.
|
||||
///
|
||||
/// A stamp is present exactly while the ticket sits in its status, so the three are
|
||||
/// mutually exclusive: entering writes one, leaving removes it, and re-entering
|
||||
/// restamps rather than keeping the first value. That is what keeps a ticket moved
|
||||
/// backward under `-f` from carrying a `Completed On` for work it has undone, and it is
|
||||
/// the line between these fields and d4ce964's history log. Metadata carries current
|
||||
/// state, which is why `Status` is a field at all; the trail of how the ticket got here
|
||||
/// belongs to the log, and a stamp left behind would be a second copy of that job.
|
||||
///
|
||||
/// The time comes in as a string rather than being read here, so the caller stamps the
|
||||
/// same moment it reports and a test can pin the value.
|
||||
pub fn set_status_stamp(content: &str, target: Status, now: &str, title: &str) -> Result<String> {
|
||||
let mut content = content.to_string();
|
||||
|
||||
// Every status but the target, so a skipping move under `-f` clears the stamps of
|
||||
// the stages it jumped over as well as the one it left.
|
||||
for status in Status::ALL {
|
||||
if status == target {
|
||||
continue;
|
||||
}
|
||||
|
||||
let Some(field) = status.stamp_field() else {
|
||||
continue;
|
||||
};
|
||||
|
||||
if let Some(updated) = remove_metadata_line(&content, field) {
|
||||
content = updated;
|
||||
}
|
||||
}
|
||||
|
||||
match target.stamp_field() {
|
||||
// Inserted on demand, the way Campaign is: every ticket written before these
|
||||
// fields existed carries none of them.
|
||||
Some(field) => set_or_insert_metadata_field(&content, field, now, title),
|
||||
None => Ok(content),
|
||||
}
|
||||
}
|
||||
|
||||
/// Rewrite the title heading, the first `# ` line in the file.
|
||||
///
|
||||
/// `## ` headings do not match: the second character has to be a space.
|
||||
@@ -2162,8 +2243,62 @@ pub fn trim_blank_ends(values: &[String]) -> &[String] {
|
||||
}
|
||||
}
|
||||
|
||||
/// A status, as clap accepts it and as the directory is named.
|
||||
///
|
||||
/// An enum rather than the string it was, so an unknown status is a usage error at parse
|
||||
/// time with the four listed, the way `priority_level` and `iso_date` refuse a bad level
|
||||
/// or date. That is the bargain the scalars already take, see AGENTS.md: nothing is
|
||||
/// written, the exit code is 2, and no handler has to check. It also gives every shell
|
||||
/// that completes possible values the four names for free.
|
||||
///
|
||||
/// The variants are in flow order, which is the order `mv` reads to decide whether a
|
||||
/// move goes forward, and the order [`status_dirs`] hands the two views.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
|
||||
pub enum Status {
|
||||
Backlog,
|
||||
Committed,
|
||||
Reviewing,
|
||||
Done,
|
||||
}
|
||||
|
||||
impl Status {
|
||||
/// Every status, in flow order. The one list, which [`status_dirs`] and `mv` both
|
||||
/// read rather than spelling the four names again.
|
||||
pub const ALL: [Status; 4] = [
|
||||
Status::Backlog,
|
||||
Status::Committed,
|
||||
Status::Reviewing,
|
||||
Status::Done,
|
||||
];
|
||||
|
||||
/// The field `mv` stamps on entering this status, for the three that have one.
|
||||
///
|
||||
/// Derived from the status rather than spelled at the call site, so the mapping is
|
||||
/// in one place and a fifth status either brings its own stamp or explicitly has
|
||||
/// none.
|
||||
pub const fn stamp_field(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Status::Backlog => None,
|
||||
Status::Committed => Some(COMMITTED_ON_FIELD),
|
||||
Status::Reviewing => Some(SUBMITTED_ON_FIELD),
|
||||
Status::Done => Some(COMPLETED_ON_FIELD),
|
||||
}
|
||||
}
|
||||
|
||||
/// The directory name, which is also what clap accepts and what the `Status` field
|
||||
/// holds. A `const fn` so [`DONE`] can be defined from it.
|
||||
pub const fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Status::Backlog => "backlog",
|
||||
Status::Committed => "committed",
|
||||
Status::Reviewing => "reviewing",
|
||||
Status::Done => "done",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn status_dirs() -> Vec<&'static str> {
|
||||
vec!["backlog", "committed", "reviewing", DONE]
|
||||
Status::ALL.iter().map(|status| status.as_str()).collect()
|
||||
}
|
||||
|
||||
/// The end of the flow, and the one status both views treat differently: `ls` counts it
|
||||
@@ -2173,7 +2308,7 @@ pub fn status_dirs() -> Vec<&'static str> {
|
||||
/// It is deliberately last in `status_dirs()`. The board leans on that: hiding done drops
|
||||
/// the final column, so the other three keep their indices and the selection only has to
|
||||
/// be handled when it is sitting on done itself.
|
||||
pub const DONE: &str = "done";
|
||||
pub const DONE: &str = Status::Done.as_str();
|
||||
|
||||
/// Lowest and highest level a ticket can carry. 1 is the most urgent, which is
|
||||
/// what the `p1` to `p3` tags this replaced already meant.
|
||||
@@ -3019,6 +3154,106 @@ mod tests {
|
||||
assert!(error.to_string().contains("Campaign"), "{error}");
|
||||
}
|
||||
|
||||
/// The one stamp the target status carries, and nothing of the others: the fields
|
||||
/// are current state, not a record of every stage the ticket has been through.
|
||||
#[test]
|
||||
fn entering_a_status_stamps_its_field_and_clears_the_rest() {
|
||||
let content = with_metadata(
|
||||
"- **ID**: abc\n- **Committed On**: 2026-08-01 09:00:00\n- **Status**: committed\n",
|
||||
);
|
||||
|
||||
let updated =
|
||||
set_status_stamp(&content, Status::Reviewing, "2026-08-22 10:11:12", "T").unwrap();
|
||||
|
||||
assert!(
|
||||
updated.contains("- **Submitted On**: 2026-08-22 10:11:12"),
|
||||
"{updated}"
|
||||
);
|
||||
assert!(!updated.contains("**Committed On**"), "{updated}");
|
||||
}
|
||||
|
||||
/// Backlog has no stamp of its own, so a backward move under `-f` leaves the ticket
|
||||
/// carrying none rather than a Completed On for work it has undone.
|
||||
#[test]
|
||||
fn moving_back_to_backlog_leaves_no_stamp_behind() {
|
||||
let content = with_metadata(
|
||||
"- **ID**: abc\n- **Completed On**: 2026-08-01 09:00:00\n- **Status**: done\n",
|
||||
);
|
||||
|
||||
let updated =
|
||||
set_status_stamp(&content, Status::Backlog, "2026-08-22 10:11:12", "T").unwrap();
|
||||
|
||||
assert!(!updated.contains("**Completed On**"), "{updated}");
|
||||
assert!(!updated.contains("2026-08-22 10:11:12"), "{updated}");
|
||||
assert!(updated.contains("- **ID**: abc\n- **Status**: done\n"), "{updated}");
|
||||
}
|
||||
|
||||
/// Re-entry is the time of the move that brought it back, not the first one.
|
||||
#[test]
|
||||
fn re_entering_a_status_restamps_rather_than_keeping_the_earlier_value() {
|
||||
let content = with_metadata(
|
||||
"- **ID**: abc\n- **Committed On**: 2026-08-01 09:00:00\n- **Status**: backlog\n",
|
||||
);
|
||||
|
||||
let updated =
|
||||
set_status_stamp(&content, Status::Committed, "2026-08-22 10:11:12", "T").unwrap();
|
||||
|
||||
assert_eq!(updated.matches("**Committed On**:").count(), 1, "{updated}");
|
||||
assert!(!updated.contains("2026-08-01 09:00:00"), "{updated}");
|
||||
}
|
||||
|
||||
/// Against METADATA_ORDER, like Campaign: after Created At, which answers the same
|
||||
/// kind of question, and never past Status, which every file keeps last.
|
||||
#[test]
|
||||
fn a_stamp_is_inserted_in_its_place_on_a_ticket_that_predates_the_field() {
|
||||
let content = with_metadata(
|
||||
"- **ID**: abc\n\
|
||||
- **Created At**: 2026-08-01 09:00:00\n\
|
||||
- **Campaign**: c-uuid\n\
|
||||
- **Status**: reviewing\n",
|
||||
);
|
||||
|
||||
let updated =
|
||||
set_status_stamp(&content, Status::Done, "2026-08-22 10:11:12", "T").unwrap();
|
||||
|
||||
assert!(
|
||||
updated.contains(
|
||||
"- **Created At**: 2026-08-01 09:00:00\n\
|
||||
- **Completed On**: 2026-08-22 10:11:12\n\
|
||||
- **Campaign**: c-uuid\n\
|
||||
- **Status**: reviewing\n"
|
||||
),
|
||||
"{updated}"
|
||||
);
|
||||
}
|
||||
|
||||
/// Removal is scoped to the section for the same reason the write is: a description
|
||||
/// quoting a field marker is prose, and rewriting it would corrupt the ticket text
|
||||
/// while leaving the real field in place.
|
||||
#[test]
|
||||
fn a_marker_in_the_description_is_not_the_field_being_removed() {
|
||||
let content = "# T\n\n## Description\n- **Committed On**: not a field\n\n\
|
||||
## Metadata\n\n- **ID**: abc\n- **Status**: backlog\n";
|
||||
|
||||
let updated =
|
||||
set_status_stamp(content, Status::Backlog, "2026-08-22 10:11:12", "T").unwrap();
|
||||
|
||||
assert!(updated.contains("- **Committed On**: not a field"), "{updated}");
|
||||
}
|
||||
|
||||
/// Nothing to remove is not a rewrite: the content comes back byte for byte, which
|
||||
/// is what keeps a move that stamps nothing from touching the file's shape.
|
||||
#[test]
|
||||
fn removing_a_field_the_ticket_does_not_carry_leaves_the_content_alone() {
|
||||
let content = with_metadata("- **ID**: abc\n- **Status**: backlog\n");
|
||||
|
||||
assert_eq!(remove_metadata_line(&content, COMPLETED_ON_FIELD), None);
|
||||
assert_eq!(
|
||||
set_status_stamp(&content, Status::Backlog, "2026-08-22 10:11:12", "T").unwrap(),
|
||||
content
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_campaign_field_that_is_unset_or_absent_reads_as_no_campaign() {
|
||||
assert_eq!(parse_campaign(&with_metadata("- **ID**: abc\n")), None);
|
||||
|
||||
@@ -561,3 +561,39 @@ fn read_only_ticket(dir: &Path) -> String {
|
||||
|
||||
fs::read_to_string(file.path()).unwrap()
|
||||
}
|
||||
|
||||
fn chmod(path: &Path, mode: u32) {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let mut perms = fs::metadata(path).unwrap().permissions();
|
||||
perms.set_mode(mode);
|
||||
fs::set_permissions(path, perms).unwrap();
|
||||
}
|
||||
|
||||
/// A duplicate title is not a failure, so the only thing left to refuse is the write
|
||||
/// itself, and it is named with the ticket and the path rather than raised as a bare io
|
||||
/// error. The branch this replaces could not fire at all: the filename carries a fresh
|
||||
/// uuid, and its message claimed the title was taken.
|
||||
#[test]
|
||||
fn add_names_the_ticket_and_the_path_when_the_write_fails() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let backlog = worklane.join("backlog");
|
||||
|
||||
chmod(&backlog, 0o555);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd
|
||||
.current_dir(temp.path())
|
||||
.args(["add", "--title", "Unwritable"])
|
||||
.assert()
|
||||
.failure();
|
||||
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("Unwritable"), "{stderr}");
|
||||
assert!(stderr.contains("unwritable.md"), "{stderr}");
|
||||
assert!(!stderr.contains("already exists"), "{stderr}");
|
||||
|
||||
chmod(&backlog, 0o755);
|
||||
assert_eq!(fs::read_dir(&backlog).unwrap().count(), 0);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
use assert_cmd::Command;
|
||||
|
||||
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||
|
||||
fn script(shell: &str) -> String {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd.arg("completions").arg(shell).assert().success();
|
||||
String::from_utf8(assert.get_output().stdout.clone()).unwrap()
|
||||
}
|
||||
|
||||
/// Every shell clap can generate for, since the README names all five.
|
||||
#[test]
|
||||
fn completions_prints_a_script_for_every_shell() {
|
||||
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
|
||||
let out = script(shell);
|
||||
assert!(
|
||||
out.contains("worklane"),
|
||||
"the {shell} script never names the command"
|
||||
);
|
||||
// Long enough to be a script rather than an empty file with a comment in it.
|
||||
assert!(out.len() > 500, "the {shell} script is {} bytes", out.len());
|
||||
}
|
||||
}
|
||||
|
||||
/// No board is looked for, the way `install-skill` looks for none: the script comes off
|
||||
/// the clap definition and is the same wherever it is run. Run from a temp directory
|
||||
/// with no `.worklane` above it, which every other command refuses.
|
||||
#[test]
|
||||
fn completions_needs_no_board() {
|
||||
let temp = assert_fs::TempDir::new().unwrap();
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.arg("completions")
|
||||
.arg("fish")
|
||||
.assert()
|
||||
.success();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fish_gets_both_halves() {
|
||||
let out = script("fish");
|
||||
// clap's, which is where the subcommands and the flags come from.
|
||||
assert!(out.contains("__fish_worklane_needs_command"));
|
||||
assert!(out.contains("install-skill"));
|
||||
// Ours, which is where the tickets come from.
|
||||
assert!(out.contains("__worklane_first_arg_of"));
|
||||
assert!(out.contains("worklane ls --ids"));
|
||||
}
|
||||
|
||||
/// The fish half is fish syntax, so it must not reach any other shell's output.
|
||||
#[test]
|
||||
fn no_other_shell_gets_the_fish_half() {
|
||||
for shell in ["bash", "zsh", "elvish", "powershell"] {
|
||||
let out = script(shell);
|
||||
assert!(
|
||||
!out.contains("__worklane_first_arg_of"),
|
||||
"fish-only helpers leaked into {shell}"
|
||||
);
|
||||
assert!(
|
||||
!out.contains("worklane ls --ids"),
|
||||
"the dynamic half leaked into {shell}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The four statuses reach fish twice over, from clap for the `mv` option and from the
|
||||
/// appended half for the `ls` positional, which clap emits nothing for.
|
||||
#[test]
|
||||
fn fish_is_offered_every_status() {
|
||||
let out = script("fish");
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
assert!(out.contains(status), "fish is never offered {status}");
|
||||
}
|
||||
assert!(out.contains("-a 'backlog committed reviewing done' -d status"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_shell_is_a_usage_error() {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd.arg("completions").arg("tcsh").assert().code(2);
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("invalid value 'tcsh'"), "{stderr}");
|
||||
}
|
||||
+223
@@ -470,3 +470,226 @@ fn ls_with_a_tag_nothing_carries_lists_nothing() {
|
||||
assert!(stdout.contains("[BACKLOG] 0 tickets"), "{stdout}");
|
||||
assert!(!stdout.contains("Tagged bug"), "{stdout}");
|
||||
}
|
||||
|
||||
/// A ticket with an id of its own, since `create_ticket` gives every fixture the same
|
||||
/// uuid and `--ids` is the one output where the id is the whole point.
|
||||
fn create_ticket_with_id(
|
||||
worklane_dir: &std::path::Path,
|
||||
status: &str,
|
||||
title: &str,
|
||||
uuid: &str,
|
||||
tags: &str,
|
||||
) {
|
||||
let ticket_body = format!(
|
||||
"# {title}\n\n## Metadata\n\n- **ID**: {uuid}\n- **Tags**: {tags}\n- **Owner**: alice\n- **Status**: {status}\n"
|
||||
);
|
||||
let filename = format!("{uuid}_{}.md", slug(title));
|
||||
fs::write(worklane_dir.join(status).join(filename), ticket_body).unwrap();
|
||||
}
|
||||
|
||||
/// The slug rule, as AGENTS.md requires: derived, never written by hand.
|
||||
fn slug(title: &str) -> String {
|
||||
title
|
||||
.to_lowercase()
|
||||
.chars()
|
||||
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
||||
.map(|c| if c == ' ' { '-' } else { c })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// One ticket per line, the seven-character id then a tab then the title, and nothing
|
||||
/// else: no heading, no counts, no owner or due column.
|
||||
#[test]
|
||||
fn ls_ids_prints_the_id_and_the_title_and_nothing_else() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Feature A",
|
||||
"1b78a24c-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||
cmd.assert().success();
|
||||
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "1b78a24\tFeature A\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
/// Every status, done included, where the decorated listing leaves done out. A
|
||||
/// completion has to be able to name a finished ticket.
|
||||
#[test]
|
||||
fn ls_ids_includes_done_and_narrows_to_a_named_status() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Still open",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"done",
|
||||
"Finished",
|
||||
"bbbbbbb2-0000-0000-0000-000000000002",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Still open"), "{stdout}");
|
||||
assert!(stdout.contains("Finished"), "a done ticket cannot be named: {stdout}");
|
||||
|
||||
// The decorated listing is unchanged: done is counted, not listed.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls");
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(!stdout.contains("Finished"), "{stdout}");
|
||||
|
||||
// The positional still narrows it.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "done", "--ids"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "bbbbbbb\tFinished\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
/// The filters apply to `--ids` exactly as they do to the listing, so a completion can
|
||||
/// be narrowed the same way.
|
||||
#[test]
|
||||
fn ls_ids_still_takes_the_filters() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Tagged bug",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Tagged cli",
|
||||
"bbbbbbb2-0000-0000-0000-000000000002",
|
||||
"cli",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
/// An unknown campaign is refused before anything is read, even here. A completion that
|
||||
/// listed the whole board because the name was misspelled would be worse than one that
|
||||
/// printed nothing.
|
||||
#[test]
|
||||
fn ls_ids_still_refuses_an_unknown_campaign() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket_with_id(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Feature A",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "--ids", "--campaign", "no such campaign"]);
|
||||
cmd.assert().failure();
|
||||
}
|
||||
|
||||
/// A status the board is missing is skipped rather than refused, unlike the listing:
|
||||
/// the caller is a shell filling in candidates, and an error printed over the prompt is
|
||||
/// worse there than no candidates.
|
||||
#[test]
|
||||
fn ls_ids_is_quiet_about_a_missing_status_directory() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
worklane.child("backlog").create_dir_all().unwrap();
|
||||
|
||||
create_ticket_with_id(
|
||||
worklane.path(),
|
||||
"backlog",
|
||||
"Feature A",
|
||||
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||
"bug",
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||
cmd.assert().success();
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "aaaaaaa\tFeature A\n", "{stdout:?}");
|
||||
|
||||
// The listing still says so, since a person reading it can act on it.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "done"]);
|
||||
let assert = cmd.assert().failure();
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("No 'done' directory"), "{stderr}");
|
||||
}
|
||||
|
||||
/// A status outside the four is clap's to refuse now, so it is a usage error naming the
|
||||
/// four rather than a runtime one.
|
||||
#[test]
|
||||
fn ls_names_the_four_statuses_when_given_another() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
setup_worklane(&temp);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd
|
||||
.current_dir(temp.path())
|
||||
.args(["ls", "nonexistent"])
|
||||
.assert()
|
||||
.code(2);
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("invalid value 'nonexistent'"), "{stderr}");
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
assert!(stderr.contains(status), "{status} is not offered: {stderr}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The listing reads the fields it prints and nothing else, so the stamps `mv` writes
|
||||
/// do not reach it. Pinned against a ticket carrying one, since a listing that started
|
||||
/// showing them would change the output every board and completion script parses.
|
||||
#[test]
|
||||
fn ls_output_is_unchanged_by_a_status_stamp() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "committed", "Stamped", "alice", "2026-06-01");
|
||||
let path = worklane
|
||||
.join("committed")
|
||||
.join("00000000-0000-0000-0000-000000000001_stamped.md");
|
||||
let before = {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
||||
get_stdout(&mut cmd)
|
||||
};
|
||||
|
||||
let stamped = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace("- **Status**:", "- **Committed On**: 2026-08-22 09:14:30\n- **Status**:");
|
||||
fs::write(&path, stamped).unwrap();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
||||
let after = get_stdout(&mut cmd);
|
||||
|
||||
assert_eq!(after, before);
|
||||
assert!(!after.contains("Committed On"), "{after}");
|
||||
}
|
||||
|
||||
+183
-3
@@ -277,13 +277,16 @@ fn mv_ignores_already_in_same_status() {
|
||||
assert!(worklane.join("reviewing").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// A status is a value enum, so an unknown one is clap's to refuse: exit 2, the four
|
||||
/// named, and the ticket untouched. The same bargain `--due` and `--priority` take, and
|
||||
/// the reason `cmd_mv` no longer checks.
|
||||
#[test]
|
||||
fn mv_rejects_invalid_status() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let id = "abc123def456789012345678901234567890";
|
||||
let _filename = create_ticket(
|
||||
let filename = create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Invalid Target",
|
||||
@@ -301,10 +304,17 @@ fn mv_rejects_invalid_status() {
|
||||
.arg("--status")
|
||||
.arg("invalid")
|
||||
.assert()
|
||||
.failure();
|
||||
.code(2);
|
||||
|
||||
let stderr = get_stderr(&mut cmd);
|
||||
assert!(stderr.contains("Invalid target status"));
|
||||
assert!(stderr.contains("invalid value 'invalid'"), "{stderr}");
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
assert!(stderr.contains(status), "{status} is not offered: {stderr}");
|
||||
}
|
||||
assert!(
|
||||
worklane.join("backlog").join(&filename).exists(),
|
||||
"the ticket moved anyway"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -878,3 +888,173 @@ fn mv_ignores_the_kinds_that_are_not_blockers() {
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// The value of a metadata field, or nothing when the ticket does not carry it.
|
||||
fn field(content: &str, name: &str) -> Option<String> {
|
||||
let prefix = format!("- **{}**: ", name);
|
||||
content
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix(prefix.as_str()))
|
||||
.map(str::to_string)
|
||||
}
|
||||
|
||||
/// `%Y-%m-%d %H:%M:%S`, checked by shape. A test cannot pin the clock, so what it can
|
||||
/// assert is that the stamp carries the same format `Created At` does.
|
||||
fn is_timestamp(value: &str) -> bool {
|
||||
value.len() == 19
|
||||
&& value.chars().enumerate().all(|(index, c)| match index {
|
||||
4 | 7 => c == '-',
|
||||
10 => c == ' ',
|
||||
13 | 16 => c == ':',
|
||||
_ => c.is_ascii_digit(),
|
||||
})
|
||||
}
|
||||
|
||||
fn stamped_ticket(worklane: &Path, status: &str) -> String {
|
||||
create_ticket(
|
||||
worklane,
|
||||
status,
|
||||
"Stamped Task",
|
||||
"Carries the stamps.",
|
||||
"cccc3333cccc3333cccc3333cccc3333cccc",
|
||||
"alice",
|
||||
"_Not set_",
|
||||
"test",
|
||||
)
|
||||
}
|
||||
|
||||
fn ticket_at(worklane: &Path, status: &str, filename: &str) -> String {
|
||||
fs::read_to_string(worklane.join(status).join(filename)).unwrap()
|
||||
}
|
||||
|
||||
/// One field per status, written with the time of the move, and only the current one:
|
||||
/// the stamps are where the ticket is now, not the trail of how it got there.
|
||||
#[test]
|
||||
fn mv_stamps_the_field_of_the_status_it_enters() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "backlog");
|
||||
|
||||
for (status, stamp, cleared) in [
|
||||
("committed", "Committed On", "Submitted On"),
|
||||
("reviewing", "Submitted On", "Committed On"),
|
||||
("done", "Completed On", "Submitted On"),
|
||||
] {
|
||||
let out = move_ticket(&temp, "cccc3333", status, false);
|
||||
assert!(out.status.success(), "{:?}", out);
|
||||
|
||||
let content = ticket_at(&worklane, status, &filename);
|
||||
let value = field(&content, stamp)
|
||||
.unwrap_or_else(|| panic!("no {stamp} after moving to {status}: {content}"));
|
||||
|
||||
assert!(is_timestamp(&value), "{stamp} reads '{value}'");
|
||||
assert_eq!(field(&content, cleared), None, "{content}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Backlog has no stamp of its own, so a ticket forced back to it carries none at all
|
||||
/// rather than a Completed On for work that has been undone.
|
||||
#[test]
|
||||
fn mv_removes_the_stamp_of_the_status_it_leaves() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "backlog");
|
||||
|
||||
move_ticket(&temp, "cccc3333", "done", true);
|
||||
let done = ticket_at(&worklane, "done", &filename);
|
||||
assert!(field(&done, "Completed On").is_some(), "{done}");
|
||||
|
||||
move_ticket(&temp, "cccc3333", "backlog", true);
|
||||
|
||||
let content = ticket_at(&worklane, "backlog", &filename);
|
||||
for stamp in ["Committed On", "Submitted On", "Completed On"] {
|
||||
assert_eq!(field(&content, stamp), None, "{content}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Re-entry is the time of the move that brought the ticket back, not the first one.
|
||||
#[test]
|
||||
fn mv_restamps_a_status_the_ticket_is_re_entering() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "committed");
|
||||
|
||||
// Hand-written so the earlier value is old enough to tell from the move's own time,
|
||||
// which two moves in the same second would not be.
|
||||
let path = worklane.join("committed").join(&filename);
|
||||
let seeded = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace("- **Status**:", "- **Committed On**: 2020-01-01 00:00:00\n- **Status**:");
|
||||
fs::write(&path, seeded).unwrap();
|
||||
|
||||
move_ticket(&temp, "cccc3333", "backlog", true);
|
||||
move_ticket(&temp, "cccc3333", "committed", false);
|
||||
|
||||
let content = ticket_at(&worklane, "committed", &filename);
|
||||
let value = field(&content, "Committed On").expect(&content);
|
||||
|
||||
assert!(is_timestamp(&value), "{value}");
|
||||
assert_ne!(value, "2020-01-01 00:00:00");
|
||||
assert_eq!(content.matches("**Committed On**:").count(), 1, "{content}");
|
||||
}
|
||||
|
||||
/// The fixture predates the fields, as every ticket on a real board does, so the line
|
||||
/// is inserted rather than rewritten. Against METADATA_ORDER, which keeps Status last.
|
||||
#[test]
|
||||
fn mv_inserts_the_stamp_before_the_status_field() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "backlog");
|
||||
|
||||
move_ticket(&temp, "cccc3333", "committed", false);
|
||||
|
||||
let content = ticket_at(&worklane, "committed", &filename);
|
||||
let value = field(&content, "Committed On").expect(&content);
|
||||
|
||||
assert!(
|
||||
content.contains(&format!(
|
||||
"- **Owner**: alice\n- **Committed On**: {}\n- **Status**: committed\n",
|
||||
value
|
||||
)),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.ends_with("- **Status**: committed\n"), "{content}");
|
||||
}
|
||||
|
||||
/// Behind the refusals, all of them: a move that does not happen leaves the file exactly
|
||||
/// as it was, stamp included.
|
||||
#[test]
|
||||
fn mv_writes_no_stamp_when_the_move_is_refused() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let backward = stamped_ticket(&worklane, "committed");
|
||||
let before = ticket_at(&worklane, "committed", &backward);
|
||||
|
||||
let out = move_ticket(&temp, "cccc3333", "backlog", false);
|
||||
assert!(!out.status.success());
|
||||
assert_eq!(ticket_at(&worklane, "committed", &backward), before);
|
||||
|
||||
// The blocked ticket takes the other refusal, which sits after the no-op return.
|
||||
let blocked = create_gated_pair(&worklane, &temp, "backlog");
|
||||
let before = ticket_at(&worklane, "backlog", &blocked);
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(!out.status.success());
|
||||
assert_eq!(ticket_at(&worklane, "backlog", &blocked), before);
|
||||
}
|
||||
|
||||
/// A move to the status the ticket is already in returns before anything is written, so
|
||||
/// it does not restamp either.
|
||||
#[test]
|
||||
fn mv_does_not_restamp_a_no_op_move() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = stamped_ticket(&worklane, "committed");
|
||||
let before = ticket_at(&worklane, "committed", &filename);
|
||||
|
||||
let out = move_ticket(&temp, "cccc3333", "committed", false);
|
||||
assert!(out.status.success());
|
||||
|
||||
assert_eq!(ticket_at(&worklane, "committed", &filename), before);
|
||||
}
|
||||
|
||||
@@ -489,6 +489,39 @@ fn show_renders_the_metadata_as_an_aligned_table() {
|
||||
assert!(content.contains("- **Owner**: alice"));
|
||||
}
|
||||
|
||||
/// The stamps `mv` writes are fields like any other: the table renders what the file
|
||||
/// holds, so nothing here knows their names, and the column widens to the longest of
|
||||
/// them the way it does for anything else.
|
||||
#[test]
|
||||
fn show_renders_a_status_stamp_in_the_metadata_table() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let filename = "abc123def456789012345678901234567890_stamped.md";
|
||||
fs::write(
|
||||
worklane.join("committed").join(filename),
|
||||
"# Stamped Ticket\n\n## Metadata\n\n\
|
||||
- **ID**: abc123def456789012345678901234567890\n\
|
||||
- **Created At**: 2026-08-20 15:51:01\n\
|
||||
- **Committed On**: 2026-08-22 09:14:30\n\
|
||||
- **Status**: committed\n",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("show").arg("Stamped");
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
|
||||
assert!(
|
||||
stdout.contains(
|
||||
"Created At 2026-08-20 15:51:01\n\
|
||||
Committed On 2026-08-22 09:14:30\n\
|
||||
Status committed\n"
|
||||
),
|
||||
"{stdout:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// Write a ticket with an exact uuid and title, since both matter to resolution.
|
||||
fn ticket_with(worklane: &std::path::Path, status: &str, uuid: &str, title: &str, slug: &str) {
|
||||
fs::write(
|
||||
|
||||
Reference in New Issue
Block a user