Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
6a800fb385 | ||
|
|
4ae7ef03ff | ||
|
|
73ffcad733 | ||
|
|
964ca342d8 | ||
|
|
cc5f9b8a46 | ||
|
|
175c1d016d | ||
|
|
139c9b012f | ||
|
|
373ba519b3 |
@@ -0,0 +1,8 @@
|
||||
# Revisions that changed layout and nothing else. Teach git to look through them:
|
||||
#
|
||||
# git config blame.ignoreRevsFile .git-blame-ignore-revs
|
||||
#
|
||||
# Only a commit whose diff is pure formatting belongs here.
|
||||
|
||||
# Reformat with cargo fmt, and nothing else
|
||||
73ffcad73314621e299dc06ee688db9b4c4d6b29
|
||||
@@ -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
|
||||
@@ -40,6 +42,20 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created, plus `campaigns/` in `cmd_campaign.rs`, which is also where the on-demand creation is tested from a board without it
|
||||
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
|
||||
- **`cargo clippy --all-targets` is clean. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
|
||||
- **`cargo fmt --check` is clean too, and `rustfmt.toml` is what makes that affordable.** rustfmt is the formatter here, run it. The config is four stable width settings and nothing else:
|
||||
|
||||
| setting | value | why |
|
||||
|---|---|---|
|
||||
| `max_width` | 100 | The tree's own habit, and the measured optimum: 90 costs 268 hunks and 120 costs 194, against 161 at 100 |
|
||||
| `fn_call_width` | 75 | A call stays whole if it fits in three quarters of the line. rustfmt's default of 60 is what expanded 276 of the 305 hunks the default config wanted |
|
||||
| `chain_width` | 65 | The same for a method chain |
|
||||
| `struct_lit_width` | 30 | A small struct literal stays whole, so `Size { width: 120, height: 20 }` is not six lines |
|
||||
|
||||
**The numbers were measured, not chosen.** Default rustfmt wanted 305 hunks and would have added 1418 lines of pure layout, because its sub-widths sit far below the 100 columns this tree is written to. `use_small_heuristics = "Max"` went the other way, 308 hunks and 796 lines *removed*, one-lining `if`/`else` and collapsing struct literals that were split on purpose. Coordinate descent over the stable width knobs landed here, at 161 hunks, and 98 of those are rustfmt *joining* calls that fit rather than breaking them. Sweeping any one of these four in either direction makes the diff bigger, so do not adjust one by eye; measure it the same way, with `cargo fmt --check | grep -c '^Diff in'`
|
||||
- What this does not buy: rustfmt has no rule for "keep parallel arms parallel", so a match whose arms are one line and four lines depending on the length of their contents is what it produces, and that is accepted. Reach for `#[rustfmt::skip]` only where the layout carries meaning a reader needs, not to win an argument about density
|
||||
- Do not add an unstable option. `cargo fmt` on stable ignores them with a warning, so the tree would format differently for whoever ran nightly
|
||||
- **Sixteen lines still run past 100 columns and every one of them is a single string literal**, a test fixture or an error message rustfmt cannot break. `format_strings` is deliberately left at its default: turning it on would let the formatter rewrite message text, and a message is prose. So `max_width` is where rustfmt breaks lines, not a limit the tree keeps
|
||||
- The reformat is `73ffcad`, and `.git-blame-ignore-revs` names it so `git blame` looks through it. Turn that on once per clone with `git config blame.ignoreRevsFile .git-blame-ignore-revs`. A commit belongs in that file only if its diff is pure layout
|
||||
|
||||
## Coding Guidelines
|
||||
|
||||
@@ -57,13 +73,24 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **`--due` is validated at parse time by `iso_date`, the way `--priority` is by `priority_level`.** A date that is not real is a usage error, exit 2, with nothing written, which is the whole point of leaving the scalars without `PROSE`. One parser serves `add` and `set`: the field has one definition of what it accepts, and validating only `add` would leave `set` open, which is the command a grooming sweep actually uses
|
||||
- **The shape is checked before chrono is asked.** `%Y-%m-%d` accepts an unpadded `2026-8-9`, which would be stored exactly as typed and sort before `2026-10-01` in any string comparison. Checking the length and the two dashes first is what lets a valid date be stored unchanged instead of normalised on the way in, which is the difference between validating and rewriting
|
||||
- **Strict on the way in, tolerant on the way out.** `util::due_date` still cuts `2026-12-31T09:30:00Z` down to its date. A file written before the parser existed, or by hand, can hold one and still has to render; refusing to display what is already stored would punish the reader for the writer's mistake
|
||||
- An empty `--due` keeps `non_empty`'s message about clearing rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is that clearing is not supported yet
|
||||
- An empty `--due` keeps the clearing message rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is the flag that does it
|
||||
- **There are two empty-value parsers, and which one an argument takes is the point.** `non_empty` says only that the value cannot be empty, for the arguments with no empty form: the `ls` filters, `relate`'s targets, and `set --title`, which addresses the ticket and names its file. `clearable` names `--clear`, for the arguments whose field does have one: `set --tags`, `--due` through `iso_date`, and the `chown` user. One message for both would either lie about `ls --tag` or leave the useful half unsaid. `add --due` takes the second one because `iso_date` is shared, and the answer it points at is a command later rather than the omission that would do it now, which is close enough to be worth the shared parser
|
||||
- **A status is a `util::Status`, not a string.** `mv --status` and the `ls` positional take the value enum, so an unknown status is a usage error at parse time naming the four, exit 2, and no handler checks. That is the same bargain `--due` and `--priority` take, and it is what lets the shells complete the four for free. `Status::ALL` is the flow order, which `status_dirs()` and `cmd_mv` both read rather than spelling the names again, and `DONE` is defined from it
|
||||
- The ticket positionals (`show <id>`, `mv <ticket>`, `comment <ticket>`) are also left alone, so a search term starting with a hyphen is a usage error. Reachable now that a hyphen-leading title can be stored: use the UUID, or put the flags first and separate with `--`, as in `mv --status committed -- -leading-title`
|
||||
- A bare `--` is a value when it follows an option (`--title -- ` stores `--`) and clap's end-of-options marker when it sits in a positional. So a `comment` body of exactly `--` needs its own separator, `comment <ticket> -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop
|
||||
- `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,18 +98,31 @@ 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
|
||||
- `apply()` is the one place an edit is taken or dropped, shared by `set`'s replaced list and its cleared one. It was a closure over the single list until there were two, and two closures carrying one rule is how a later edit changes it for one and not the other
|
||||
- Sections are a table in `util.rs`: `DESCRIPTION`, `ACCEPTANCE`, `PLAN`, each with a heading, a label, the placeholder `add` writes when empty, a `SectionKind` and the `--clear` value that empties it. Adding a section later is one entry, not edits in both commands
|
||||
- Everything is targeted line surgery, never a regenerated file. That is what keeps a ticked criterion ticked and a handwritten `## Notes` section intact when an unrelated field changes. `section_body()` finds the lines to touch, `set_metadata_line()` does the metadata, and every other byte is copied through
|
||||
- Appending to a numbered section continues from the count of steps already there and does not renumber what is above it, so a handwritten line in the section survives exactly as written
|
||||
- Appending to an empty section replaces the placeholder rather than following it, or the ticket would read `_No description provided._` above its description
|
||||
- An empty value is a paragraph break for the three sections and a usage error for the scalars, via `non_empty` in `command.rs`. Clearing a field is not supported yet, and the error says so rather than guessing
|
||||
- An empty value is a paragraph break for the three sections and a usage error for the scalars, via `non_empty` and `clearable` in `command.rs`. Neither spells clearing, and both errors name the flag that does
|
||||
|
||||
### Clearing a Field
|
||||
- **`set --clear <field>` is the one way to take a value away, and it is a flag with the field as its value.** Not a per-field `--clear-due`, which is a flag per field to keep in step with the field it undoes, and not an empty value, which is already a paragraph break for a section and would make an accidentally empty variable a silent delete. Repeatable, so one call empties as many fields as it likes
|
||||
- **`Clearable` is a `ValueEnum` in `util.rs`**, so an unknown field is a usage error at the door listing the six that are not, and the shells complete them for free. It is also the whole table of what can be cleared: `Due`, `Tags` and `Priority` clear to a sentinel, `Description`, `Acceptance` and `Plan` to their section's placeholder. `Title` is absent because it addresses the ticket and names its file, so there is no state to go back to; `Owner`, `Status`, `Campaign` and the stamps because clearing them through `set` is exactly the second writer the missing `set --owner` exists to prevent
|
||||
- **What is written is `NOT_SET` and `NONE`, the constants `add` writes.** A cleared ticket and one that was never given the field have to read the same, or clearing would be a third state that every parser then has to know about. `a_cleared_ticket_reads_like_one_filed_without_the_fields` compares the two files byte for byte, which is what keeps a new field honest
|
||||
- **The placeholder goes into a section bare, via `clear_section_body`.** `set_section_body` runs its items through `Section::render`, which would write `- [ ] _No acceptance criteria provided._`. Both are `replace_section_body` underneath, so the line surgery and the trailing blank line live once
|
||||
- **The pairing between a section and its `--clear` value is stored on both**, `Clearable::unset` one way and `Section::clear` the other, because the error for an empty value has to name the flag for *that* section and the section's label ("acceptance criteria") is not the flag's value ("acceptance"). `every_clearable_section_points_back_at_the_field_that_clears_it` keeps the two directions from drifting. `RELATIONS.clear` is `None`, the same rule that keeps it out of `section_args`
|
||||
- **Cleared fields are reported apart from replaced ones**, as `Cleared due on '...'` beside `Updated priority on '...'`. One list would say `Updated` of a field that was emptied, which is the opposite of what a caller needs to read back. The labels are the ones `set` already prints when it *writes* the field, so the two lines name a field the same way
|
||||
- **Replacing and clearing one field in a single call is refused**, by `SetArgs::contested`. clap cannot express it, because the field arrives as `--clear`'s value rather than in its name, and answering by whichever was applied last is a silent answer to a contradictory call
|
||||
- **Clearing the owner is `chown --clear <ticket>`, and `--clear` carries the ticket.** Owner has one writer and clearing it cannot introduce a second, so it lives on `chown`; but the ticket is `chown`'s *second* positional, and a bare flag would land it in the user's slot for the handler to read back out, which is hand-parsing what clap can state. The typed call is identical either way. `ChownArgs::target` returns the one shape the constraints allow, and an error rather than a panic for the combination they already refuse
|
||||
- **Clearing the owner writes `NOT_SET`, not the git user.** `add` falls back to the git user because it is filing something new; an owner taken away says nobody owns this, and putting the person running the command there instead hands them a ticket they were giving up
|
||||
- Clearing a field that is already unset writes the sentinel that is already there, so the whole-file comparison below reports no change and nothing is written. That is not a special case, and must not become one
|
||||
- No-op detection compares the whole file before and after each edit, so a field set to the value it already holds is reported unchanged and nothing is written
|
||||
- `find_ticket_file()` matches on the uuid, never the title. Duplicate titles are allowed, so a title scan can land on a different ticket than the one resolved: `mv <uuid-of-second>` used to move the first ticket sharing its title
|
||||
- `write_then_replace()` is the only way a ticket file is written. Content first, rename second, so a failure leaves a correct ticket under a stale name rather than a half-written one
|
||||
@@ -310,7 +350,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- The UUID tier applies from `MIN_ID_SEARCH` (4) characters up. Not 8: `ls` prints `SHORT_ID_WIDTH` (7) characters, so a longer minimum would drop the printed id out of the UUID tier and let any title quoting it win instead. Below the minimum the search is text, so `show 641` is a title search
|
||||
- The filename tier earns its place by reaching the middle of a UUID, which the prefix tier cannot. It is also why a short UUID search still resolves under a longer minimum, just at the wrong precedence, so a test for the minimum needs a decoy title to be meaningful
|
||||
- Ambiguous matches (multiple results) print options and exit(1)
|
||||
- Never return empty strings for required fields — use `_Not set_` or `_None_` as defaults
|
||||
- Never return empty strings for required fields — use the `NOT_SET` and `NONE` constants in `util.rs`, which are what `add` writes and what `--clear` puts back. `is_unknown_value` reads those two and nothing else
|
||||
- **`-None-` and `-Not set-` are not unset, and re-adding them would be a mistake with a plausible story behind it.** They were accepted by `is_unknown_value` from the day it was written, by analogy with the `**-Status**` field name the `mv` splicing bug really did produce, c230d2c. But no version of this tool ever wrote a hyphenated *value*: `git log -S` finds both spellings in exactly one commit, the one that added them to the check. Dead from birth, and dropped by bdddc09. `a_hyphenated_marker_is_not_unset` is what stops the analogy being drawn a second time
|
||||
- **The `**-Status**` repair in `is_status_line` is the opposite case and stays.** That corruption was real, `mv` wrote it, and the repair is what fixes a damaged ticket as it moves. Do not tidy the two away together on the grounds that they look alike
|
||||
|
||||
### Git Workflow
|
||||
- Commit format: `([ticketID]) [short description]`
|
||||
|
||||
Generated
+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.18.1"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
"assert_fs",
|
||||
"chrono",
|
||||
"clap",
|
||||
"clap_complete",
|
||||
"crossterm",
|
||||
"libc",
|
||||
"ratatui",
|
||||
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.16.1"
|
||||
version = "0.18.1"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
@@ -14,6 +14,7 @@ libc = "0.2"
|
||||
# widget until one of us changed.
|
||||
ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] }
|
||||
crossterm = "0.28"
|
||||
clap_complete = "4.6.9"
|
||||
|
||||
[dev-dependencies]
|
||||
assert_cmd = "2"
|
||||
|
||||
@@ -8,24 +8,53 @@ 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 |
|
||||
| `worklane set <ticket>` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID. `--clear <field>` returns a field to unset instead, repeatable, taking `due`, `tags`, `priority`, `description`, `acceptance` or `plan`, and writing back exactly what `add` writes for a field it was never given. No `title`, which addresses the ticket, and no `owner`, which is `chown`'s. Replacing and clearing the same field in one call is refused |
|
||||
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last |
|
||||
| `worklane relate <ticket>` | Records an edge to another ticket with `--blocked-by`, `--regression-of` or `--relates-to`, each repeatable. At least one required. Only the ticket named is written; `show` derives the other end by scanning. `mv` refuses to move a ticket blocked by one that is not done, unless `-f` |
|
||||
| `worklane chown <user> <ticket>` | Sets the Owner field, the only command that writes it. Free text, checked against nothing. User first and ticket second, after Unix `chown` |
|
||||
| `worklane chown <user> <ticket>` | Sets the Owner field, the only command that writes it. Free text, checked against nothing. User first and ticket second, after Unix `chown`. `worklane chown --clear <ticket>` returns the field to unset, taking the ticket in the flag since there is no user to give, and not to the git user `add` falls back to |
|
||||
| `worklane check <ticket> [criteria...]` | Ticks acceptance criteria, each by number as shown by `show` or by a substring. Several in one call, or `all` for every one of them. Prompts with the numbered list if none is given, or errors with it when there is no terminal |
|
||||
| `worklane uncheck <ticket> [criteria...]` | Unticks acceptance criteria, addressed the same way |
|
||||
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
|
||||
| `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 chown --clear <TAB> the ticket, which the flag carries 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
|
||||
|
||||
+15
-11
@@ -16,11 +16,12 @@ which command owns which field. Read it too. This document is the judgement.
|
||||
|
||||
**Propose the whole set of edits, wait, then apply exactly what was approved.**
|
||||
|
||||
Every job here writes to many tickets at once, and no field can be cleared back to unset
|
||||
yet, so a date written onto the wrong ticket can only be overwritten, never taken off. A wrong
|
||||
edit to one ticket is a mistake; a wrong sweep is thirty of them with no undo. So a
|
||||
proposal is a list, one line per intended edit, each naming the ticket and the command
|
||||
that would make it:
|
||||
Every job here writes to many tickets at once, and nothing on the board records what a
|
||||
field held before you wrote to it. `--clear` puts a field back to unset, which is **not
|
||||
back to what it held**, so a date written over another date is gone. A wrong edit to one
|
||||
ticket is a mistake; a wrong sweep is thirty of them with no undo. So a proposal is a
|
||||
list, one line per intended edit, each naming the ticket and the command that would make
|
||||
it:
|
||||
|
||||
```
|
||||
(1b78a24) priority 3 -> 1 worklane set 1b78a24 --priority 1
|
||||
@@ -37,10 +38,10 @@ other way is editing the file by hand:
|
||||
|
||||
| Field | Writer |
|
||||
|-------|--------|
|
||||
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags` |
|
||||
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags`, and `--clear <field>` to empty one |
|
||||
| Relations | `worklane relate <ticket> --blocked-by` / `--regression-of` / `--relates-to` |
|
||||
| Campaign membership | `worklane assign <campaign> <ticket>` |
|
||||
| Owner | `worklane chown <user> <ticket>` |
|
||||
| Owner | `worklane chown <user> <ticket>`, and `worklane chown --clear <ticket>` to empty it |
|
||||
| Status | `worklane mv <ticket> --status <target>` |
|
||||
|
||||
**Never edit a ticket file directly.** The filename, the `Status` field and the directory
|
||||
@@ -101,8 +102,9 @@ What to look for:
|
||||
|
||||
A value that is not a real calendar date in that exact form is refused before anything
|
||||
is written, so a typo costs nothing. `2026-8-9` is refused too: the padding is part of
|
||||
the format. What is still true is that a date, once written, **cannot be cleared**, only
|
||||
replaced by another date, so a plan applied to the wrong ticket has no undo.
|
||||
the format. A date can be taken off again with `worklane set <ticket> --clear due`. What
|
||||
that cannot do is recover the date that was there before it, so a plan applied over
|
||||
existing dates still has no undo.
|
||||
|
||||
Ask the system what today is rather than assuming it. A plan built on a guessed date is
|
||||
wrong by however much the guess was wrong.
|
||||
@@ -119,13 +121,15 @@ The rules a dating plan has to keep:
|
||||
whole backlog produces a board where every ticket is late, which is the same as no
|
||||
dates at all.
|
||||
- **Do not date `done`.** It is finished; a date on it is noise in every listing.
|
||||
- Leave the rest unset. An unset due date is honest about what has not been planned.
|
||||
- Leave the rest unset. An unset due date is honest about what has not been planned, and
|
||||
a date that turned out to be wrong is better cleared than left to read as a plan.
|
||||
|
||||
## Tags
|
||||
|
||||
`worklane set <ticket> --tags bug,cli` is the writer, and it **replaces the whole
|
||||
field**. Restate every tag the ticket should keep, or the ones you left out are gone.
|
||||
This is the single most destructive thing in this document.
|
||||
This is the single most destructive thing in this document. `--clear tags` empties the
|
||||
field on purpose, which is a different thing from emptying it by forgetting a tag.
|
||||
|
||||
Derive the vocabulary from the board rather than inventing one. Read the tickets, count
|
||||
what is actually used, and show the count before proposing anything. What to report:
|
||||
|
||||
+42
-7
@@ -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
|
||||
@@ -113,21 +124,34 @@ worklane add \
|
||||
Editing afterwards, on a ticket in any status:
|
||||
|
||||
```
|
||||
worklane set 1b78a24 --priority 1 # replace a field
|
||||
worklane set 1b78a24 --priority 1 # replace a field
|
||||
worklane set 1b78a24 --title "A better title" # renames the file, keeps the uuid
|
||||
worklane set 1b78a24 --clear due # take a value away again
|
||||
worklane set 1b78a24 --clear tags --clear plan # as many fields as you like
|
||||
worklane append 1b78a24 --acceptance "One more criterion"
|
||||
worklane append 1b78a24 --description "What was learned since."
|
||||
worklane chown alice 1b78a24 # hand the ticket to someone
|
||||
worklane chown --clear 1b78a24 # hand it back to nobody
|
||||
```
|
||||
|
||||
`set` replaces, `append` adds. Neither has `--owner` or `--status`: owner is `chown`'s
|
||||
and status is `mv`'s, so each field has exactly one writer. A field set to the value it
|
||||
already holds is reported unchanged and nothing is written.
|
||||
`set` replaces, `append` adds, `--clear` empties. Neither `set` nor `append` has
|
||||
`--owner` or `--status`: owner is `chown`'s and status is `mv`'s, so each field has
|
||||
exactly one writer. A field set to the value it already holds is reported unchanged and
|
||||
nothing is written, and so is a field cleared that was already unset.
|
||||
|
||||
**`--clear` takes the field as its value**, one of `due`, `tags`, `priority`,
|
||||
`description`, `acceptance` or `plan`, and repeats. It writes back exactly what `add`
|
||||
writes for a field it was never given: `_Not set_`, `_None_` for tags, and the section
|
||||
placeholder. There is no `--clear title`, because a title addresses the ticket and names
|
||||
its file. There is no `--clear owner` either: that is `chown --clear <ticket>`, which
|
||||
takes the ticket in the flag since there is no user to give, and returns the field to
|
||||
unset rather than to the git user. Replacing and clearing the same field in one call is
|
||||
refused rather than resolved.
|
||||
|
||||
`chown` takes the **user first and the ticket second**, after Unix `chown`, which is the
|
||||
one command here that does not start with the ticket. The user is free text and is
|
||||
checked against nothing. Swap the two and the call fails, because the username has to
|
||||
resolve as a ticket.
|
||||
resolve as a ticket. `--clear` replaces both arguments with the ticket alone.
|
||||
|
||||
`worklane init` creates `.worklane/` with the four status directories and the campaigns
|
||||
directory beside them, for a repo that has no board yet.
|
||||
@@ -214,6 +238,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:
|
||||
@@ -240,6 +274,7 @@ the candidates and exits 1 rather than guessing.
|
||||
`worklane mv --status committed -- -leading-title`.
|
||||
- A comment body of exactly `--` needs its own separator:
|
||||
`worklane comment 1b78a24 -- --`.
|
||||
- An empty value for a scalar is a usage error. Clearing a field back to unset is not
|
||||
supported yet.
|
||||
- An empty value for a scalar is a usage error, not a way to clear the field: use
|
||||
`--clear`. For a section an empty value is a paragraph break, so it cannot mean empty
|
||||
the section either, and an all-blank one is refused with the `--clear` for it named.
|
||||
- Piping is safe: `worklane ls | head -3` exits on the closed pipe instead of panicking.
|
||||
|
||||
@@ -24,9 +24,9 @@ fn git_sha() -> String {
|
||||
.output();
|
||||
|
||||
let sha = match output {
|
||||
Ok(output) if output.status.success() => String::from_utf8_lossy(&output.stdout)
|
||||
.trim()
|
||||
.to_string(),
|
||||
Ok(output) if output.status.success() => {
|
||||
String::from_utf8_lossy(&output.stdout).trim().to_string()
|
||||
}
|
||||
_ => String::new(),
|
||||
};
|
||||
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
# rustfmt is the formatter for this tree, and these four widths are what make it agree
|
||||
# with how the tree is already written. Measured, not chosen: the default config wanted
|
||||
# 305 hunks and +1418 lines of layout, `use_small_heuristics = "Max"` wanted 308 the
|
||||
# other way, and this lands at 161. The reasoning is in AGENTS.md beside the clippy rule.
|
||||
#
|
||||
# Sweeping any one of these in either direction makes the diff bigger. Measure before
|
||||
# changing one: `cargo fmt --check | grep -c '^Diff in'`.
|
||||
|
||||
# The habit the tree is written to, and the measured optimum: 90 costs 268 hunks, 120
|
||||
# costs 194.
|
||||
max_width = 100
|
||||
|
||||
# A call stays whole if it fits in three quarters of the line. rustfmt's default of 60
|
||||
# is what expands 276 of the 305 hunks the default config wants.
|
||||
fn_call_width = 75
|
||||
|
||||
# The same for a method chain.
|
||||
chain_width = 65
|
||||
|
||||
# A small struct literal stays whole, so `Size { width: 120, height: 20 }` is not six
|
||||
# lines. Above the default of 18, which is what explodes it.
|
||||
struct_lit_width = 30
|
||||
+2
-7
@@ -32,8 +32,7 @@ pub fn campaigns_dir(worklane_dir: &Path) -> PathBuf {
|
||||
pub fn ensure_campaigns_dir(worklane_dir: &Path) -> Result<PathBuf> {
|
||||
let dir = campaigns_dir(worklane_dir);
|
||||
|
||||
fs::create_dir_all(&dir)
|
||||
.map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
|
||||
fs::create_dir_all(&dir).map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
|
||||
|
||||
Ok(dir)
|
||||
}
|
||||
@@ -166,11 +165,7 @@ pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> Str
|
||||
return String::new();
|
||||
};
|
||||
|
||||
reference_cell(
|
||||
&uuid,
|
||||
index.get(&uuid).map(|campaign| campaign.title.as_str()),
|
||||
colored,
|
||||
)
|
||||
reference_cell(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()), colored)
|
||||
}
|
||||
|
||||
/// The parts [`content_trim`] cannot render from the ticket file alone.
|
||||
|
||||
+141
-36
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
|
||||
|
||||
use chrono::NaiveDate;
|
||||
|
||||
use crate::util::{PRIORITY_RANGE, RelationKind, priority_legend};
|
||||
use crate::util::{Clearable, PRIORITY_RANGE, RelationKind, Status, priority_legend};
|
||||
|
||||
/// clap wants a `&str` with a long enough lifetime, and the legend is built from
|
||||
/// the same ramp the listing uses rather than spelled out a second time.
|
||||
@@ -43,13 +43,31 @@ pub struct Cli {
|
||||
/// Reject an empty value at parse time, so it lands as a usage error rather than a
|
||||
/// runtime one.
|
||||
///
|
||||
/// An empty value looks like a way to clear a field, and clearing is not supported
|
||||
/// yet. Refusing it keeps the gap visible and stops an accidentally empty variable
|
||||
/// from silently blanking a field. Only the scalars use this: for the multi-line
|
||||
/// sections an empty value is a paragraph break.
|
||||
/// Two messages rather than one, because the arguments that use this fall into two
|
||||
/// kinds. A search term or a title has no empty form at all, and that is all this says.
|
||||
/// A field that *can* be emptied says so and names `--clear`, which is [`clearable`]
|
||||
/// below: an accidentally empty variable must not blank a field silently, and somebody
|
||||
/// typing an empty value on purpose is reaching for exactly the flag that does it.
|
||||
///
|
||||
/// Only the scalars use either one. For the multi-line sections an empty value is a
|
||||
/// paragraph break.
|
||||
fn non_empty(raw: &str) -> Result<String, String> {
|
||||
if raw.trim().is_empty() {
|
||||
return Err("value cannot be empty, and clearing a field is not supported yet".to_string());
|
||||
return Err("value cannot be empty".to_string());
|
||||
}
|
||||
|
||||
Ok(raw.to_string())
|
||||
}
|
||||
|
||||
/// Reject an empty value on an argument whose field can be cleared, and say how.
|
||||
///
|
||||
/// The message names no command, because the arguments that use this belong to three:
|
||||
/// `set --tags`, `set --due`, `add --due` and the `chown` user. `set` and `chown` both
|
||||
/// take a `--clear`; `add` does not, and there a field is left unset by omitting the
|
||||
/// flag, which is what the caller was reaching for anyway.
|
||||
fn clearable(raw: &str) -> Result<String, String> {
|
||||
if raw.trim().is_empty() {
|
||||
return Err("value cannot be empty, use --clear to return a field to unset".to_string());
|
||||
}
|
||||
|
||||
Ok(raw.to_string())
|
||||
@@ -73,7 +91,7 @@ fn non_empty(raw: &str) -> Result<String, String> {
|
||||
fn iso_date(raw: &str) -> Result<String, String> {
|
||||
// An empty value keeps the message that explains why it is refused, since somebody
|
||||
// typing it is reaching for a way to clear the field rather than mistyping a date.
|
||||
non_empty(raw)?;
|
||||
clearable(raw)?;
|
||||
|
||||
let bytes = raw.as_bytes();
|
||||
let shaped = raw.len() == 10 && bytes[4] == b'-' && bytes[7] == b'-';
|
||||
@@ -112,22 +130,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 +143,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)]
|
||||
@@ -158,7 +161,7 @@ pub enum Command {
|
||||
/// Record a relation from one ticket to another
|
||||
Relate(RelateArgs),
|
||||
|
||||
/// Change the owner of a ticket
|
||||
/// Change the owner of a ticket, or return it to unset
|
||||
///
|
||||
/// User first, ticket second, after Unix `chown`. That reverses the ticket-first
|
||||
/// order `mv`, `comment` and `show` use, deliberately: the name borrows the Unix
|
||||
@@ -169,14 +172,7 @@ pub enum Command {
|
||||
/// username usually will not, so the call fails on its own. It is silently wrong
|
||||
/// only when both arguments resolve, which needs a ticket whose title matches the
|
||||
/// username.
|
||||
Chown {
|
||||
/// New owner. Free text, like `add --owner`, checked against nothing
|
||||
#[arg(value_parser = non_empty)]
|
||||
user: String,
|
||||
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
},
|
||||
Chown(ChownArgs),
|
||||
|
||||
/// Open the board view
|
||||
Tui {
|
||||
@@ -227,6 +223,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 +294,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.
|
||||
@@ -339,7 +372,7 @@ pub struct AddArgs {
|
||||
clap::ArgGroup::new("set_fields")
|
||||
.required(true)
|
||||
.multiple(true)
|
||||
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority"])
|
||||
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority", "clear"])
|
||||
))]
|
||||
pub struct SetArgs {
|
||||
/// Ticket UUID or title
|
||||
@@ -362,7 +395,7 @@ pub struct SetArgs {
|
||||
pub plan: Vec<String>,
|
||||
|
||||
/// Replace the tags
|
||||
#[arg(short = 'g', long, value_parser = non_empty)]
|
||||
#[arg(short = 'g', long, value_parser = clearable)]
|
||||
pub tags: Vec<String>,
|
||||
|
||||
/// Replace the due date (YYYY-MM-DD)
|
||||
@@ -376,6 +409,78 @@ pub struct SetArgs {
|
||||
/// Replace the priority, 1 (most urgent) to 5 (least)
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
pub priority: Option<u8>,
|
||||
|
||||
/// Return a field to unset. Repeat the flag for more than one
|
||||
///
|
||||
/// The counterpart to the flag it names, and the only way to take a value away: an
|
||||
/// empty value is a paragraph break for a section and a usage error for a scalar, so
|
||||
/// neither can spell this. What goes back is what `add` writes for a field it was
|
||||
/// never given.
|
||||
///
|
||||
/// No `title`, which addresses the ticket and names its file, and no `owner`, which
|
||||
/// is `chown --clear`'s. The reasoning for each is on `util::Clearable`.
|
||||
#[arg(long, value_name = "FIELD")]
|
||||
pub clear: Vec<Clearable>,
|
||||
}
|
||||
|
||||
impl SetArgs {
|
||||
/// A field this call both replaces and clears, if there is one.
|
||||
///
|
||||
/// clap cannot express the conflict, because `--clear` carries the field as a value
|
||||
/// rather than in the flag's own name. So it is checked once here and refused, rather
|
||||
/// than resolved by whichever of the two happens to be applied last, which is a
|
||||
/// silent answer to a contradictory call.
|
||||
pub fn contested(&self) -> Option<Clearable> {
|
||||
self.clear.iter().copied().find(|field| match field {
|
||||
Clearable::Due => self.due.is_some(),
|
||||
Clearable::Tags => !self.tags.is_empty(),
|
||||
Clearable::Priority => self.priority.is_some(),
|
||||
Clearable::Description => !self.description.is_empty(),
|
||||
Clearable::Acceptance => !self.acceptance.is_empty(),
|
||||
Clearable::Plan => !self.plan.is_empty(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `chown` is the only writer of Owner, so clearing the field has to live here too, and
|
||||
/// that is what shapes the arguments.
|
||||
///
|
||||
/// **`--clear` carries the ticket rather than being a bare flag.** The ticket is the
|
||||
/// *second* positional, so `chown --clear 1b78a24` with a plain flag would land the
|
||||
/// ticket in the user's slot, and reading it back out of there is hand-parsing what clap
|
||||
/// can state outright. The typed call is the same either way; only who checks it differs.
|
||||
///
|
||||
/// The two forms are mutually exclusive, and each argument says so, so a call carrying
|
||||
/// both is a usage error from clap rather than a decision made here.
|
||||
#[derive(clap::Args)]
|
||||
pub struct ChownArgs {
|
||||
/// New owner. Free text, like `add --owner`, checked against nothing
|
||||
#[arg(value_parser = clearable, required_unless_present = "clear", conflicts_with = "clear")]
|
||||
pub user: Option<String>,
|
||||
|
||||
/// Ticket UUID or title
|
||||
#[arg(required_unless_present = "clear", conflicts_with = "clear")]
|
||||
pub ticket: Option<String>,
|
||||
|
||||
/// Return the owner to unset on this ticket, which is named here since there is no
|
||||
/// user to name
|
||||
#[arg(long, value_name = "TICKET", value_parser = non_empty)]
|
||||
pub clear: Option<String>,
|
||||
}
|
||||
|
||||
impl ChownArgs {
|
||||
/// The ticket the call names, and the owner to write on it, `None` being unset.
|
||||
///
|
||||
/// `None` for the pair is unreachable while the constraints above hold, and is an
|
||||
/// error at the call site rather than a panic, so loosening one of them costs a
|
||||
/// message instead of a crash.
|
||||
pub fn target(&self) -> Option<(&str, Option<&str>)> {
|
||||
match (self.clear.as_deref(), self.user.as_deref(), self.ticket.as_deref()) {
|
||||
(Some(ticket), None, None) => Some((ticket, None)),
|
||||
(None, Some(user), Some(ticket)) => Some((ticket, Some(user))),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `append` only offers the sections that hold multiple lines, since appending to a
|
||||
|
||||
@@ -0,0 +1,317 @@
|
||||
//! 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)'
|
||||
|
||||
# `chown --clear` names the ticket in the flag too, since with no user to give there is
|
||||
# no second positional to put it in. Scoped to `chown`, unlike the rule above: `set`
|
||||
# has a `--clear` of its own that takes a field name, and clap already offers those.
|
||||
complete -c worklane -n '__fish_seen_subcommand_from chown' -l clear -x -a '(worklane ls --ids)'
|
||||
|
||||
# clap emits the four for `mv --status`, which is an option, but the fish generator
|
||||
# emits nothing for the possible values of a positional. So the one place a status is
|
||||
# positional needs them listed, and the same goes for the shell below.
|
||||
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}");
|
||||
}
|
||||
}
|
||||
|
||||
/// `chown --clear` takes a ticket, so it is completed like one, and only under
|
||||
/// `chown`: `set --clear` is the same flag name carrying a field.
|
||||
#[test]
|
||||
fn chowns_clear_is_completed_with_tickets_and_sets_is_not() {
|
||||
let script = fish_dynamic();
|
||||
let rule = script
|
||||
.lines()
|
||||
.find(|line| line.starts_with("complete") && line.contains("-l clear"))
|
||||
.expect("chown --clear has a rule of its own");
|
||||
assert!(rule.contains("__fish_seen_subcommand_from chown"), "{rule}");
|
||||
assert!(rule.contains("worklane ls --ids"), "{rule}");
|
||||
let chown = command().find_subcommand("chown").expect("chown exists").clone();
|
||||
assert!(
|
||||
chown.get_arguments().any(|arg| arg.get_long() == Some("clear")),
|
||||
"`chown` has no --clear for the rule to complete"
|
||||
);
|
||||
assert!(
|
||||
!TICKET_FLAGS.contains(&"clear"),
|
||||
"--clear in TICKET_FLAGS would offer tickets to `set --clear`, which takes a field"
|
||||
);
|
||||
}
|
||||
|
||||
/// The flags completed as tickets have to be `relate`'s actual flags, or the rule
|
||||
/// completes an option nothing accepts.
|
||||
#[test]
|
||||
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}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
+175
-121
@@ -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, ChownArgs, LsArgs, RelateArgs, SetArgs,
|
||||
};
|
||||
use crate::install;
|
||||
use crate::util::*;
|
||||
|
||||
@@ -14,17 +16,13 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
let worklane_dir = dir.join(".worklane");
|
||||
|
||||
if worklane_dir.exists() {
|
||||
println!(
|
||||
"worklane already initialized in: {}",
|
||||
worklane_dir.display()
|
||||
);
|
||||
println!("worklane already initialized in: {}", worklane_dir.display());
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
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 +35,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 +60,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 +124,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.
|
||||
///
|
||||
@@ -130,10 +176,7 @@ fn filtered(
|
||||
campaign: Option<&str>,
|
||||
tag: Option<&str>,
|
||||
) -> Vec<TicketItem> {
|
||||
filter_by_tag(
|
||||
filter_by_campaign(filter_by_priority(items, level), campaign),
|
||||
tag,
|
||||
)
|
||||
filter_by_tag(filter_by_campaign(filter_by_priority(items, level), campaign), tag)
|
||||
}
|
||||
|
||||
/// Keep only the tickets carrying `tag`, or everything when none was asked for.
|
||||
@@ -197,9 +240,7 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
let backlog_dir = worklane_dir.join("backlog");
|
||||
|
||||
if !backlog_dir.exists() {
|
||||
return Err(anyhow!(
|
||||
"Backlog directory not found. Run `worklane init` first."
|
||||
));
|
||||
return Err(anyhow!("Backlog directory not found. Run `worklane init` first."));
|
||||
}
|
||||
|
||||
let id = uuid::Uuid::new_v4();
|
||||
@@ -207,10 +248,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 +315,16 @@ 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(())
|
||||
@@ -423,12 +469,7 @@ fn write_then_replace(
|
||||
|
||||
if let Err(e) = fs::rename(&temp, path) {
|
||||
let _ = fs::remove_file(&temp);
|
||||
return Err(anyhow!(
|
||||
"Could not write ticket '{}' at {}: {}",
|
||||
title,
|
||||
path.display(),
|
||||
e
|
||||
));
|
||||
return Err(anyhow!("Could not write ticket '{}' at {}: {}", title, path.display(), e));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -499,14 +540,8 @@ fn move_ticket_file(
|
||||
|
||||
// The content is correct and in one place by now, so a failure here leaves the
|
||||
// ticket where it started rather than half moved.
|
||||
fs::rename(&source, &dest).map_err(|e| {
|
||||
anyhow!(
|
||||
"Could not move ticket '{}' to {}: {}",
|
||||
title,
|
||||
dest.display(),
|
||||
e
|
||||
)
|
||||
})
|
||||
fs::rename(&source, &dest)
|
||||
.map_err(|e| anyhow!("Could not move ticket '{}' to {}: {}", title, dest.display(), e))
|
||||
}
|
||||
|
||||
/// Refuse a move while a ticket it is `blocked by` is not done.
|
||||
@@ -562,29 +597,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 +648,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)?;
|
||||
|
||||
@@ -745,40 +781,47 @@ fn save_ticket(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Take an edit, or record that it changed nothing.
|
||||
///
|
||||
/// Each edit is compared against the content going in, so a field set to the value it
|
||||
/// already holds is reported as unchanged rather than claimed as an update. That is also
|
||||
/// what makes clearing an already unset field free: the sentinel it writes is the one
|
||||
/// already there, so the strings match and nothing is written.
|
||||
fn apply(content: &mut String, changed: &mut Vec<&'static str>, field: &'static str, next: String) {
|
||||
if *content != next {
|
||||
content.clone_from(&next);
|
||||
changed.push(field);
|
||||
}
|
||||
}
|
||||
|
||||
fn report(fields: &[&str], title: &str, verb: &str) {
|
||||
if fields.is_empty() {
|
||||
println!("No changes to '{}'", color_text(title, Color::Green));
|
||||
return;
|
||||
}
|
||||
|
||||
println!(
|
||||
"{} {} on '{}'",
|
||||
verb,
|
||||
fields.join(", "),
|
||||
color_text(title, Color::Green)
|
||||
);
|
||||
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, Color::Green));
|
||||
}
|
||||
|
||||
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
if let Some(field) = args.contested() {
|
||||
let name = field.name();
|
||||
return Err(anyhow!(
|
||||
"--{name} and --clear {name} contradict each other, so nothing was written"
|
||||
));
|
||||
}
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let mut content = original.clone();
|
||||
let mut changed: Vec<&str> = Vec::new();
|
||||
|
||||
// Each edit is compared against the content going in, so a field set to the value
|
||||
// it already holds is reported as unchanged rather than claimed as an update.
|
||||
let mut apply = |content: &mut String, field: &'static str, next: String| {
|
||||
if *content != next {
|
||||
content.clone_from(&next);
|
||||
changed.push(field);
|
||||
}
|
||||
};
|
||||
let mut cleared: Vec<&str> = Vec::new();
|
||||
|
||||
if let Some(new_title) = &args.title {
|
||||
let next = set_title(&content, new_title)?;
|
||||
apply(&mut content, "title", next);
|
||||
apply(&mut content, &mut changed, "title", next);
|
||||
}
|
||||
|
||||
for (section, values) in section_args(&args.description, &args.acceptance, &args.plan) {
|
||||
@@ -789,32 +832,46 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
let items = section.normalise(values);
|
||||
if items.is_empty() {
|
||||
return Err(anyhow!(
|
||||
"An empty {} is not a way to clear the section, and clearing is not supported yet",
|
||||
section.label
|
||||
"An empty value is a paragraph break, not a way to empty the {}: use --clear {}",
|
||||
section.label,
|
||||
section.clear.map_or("", Clearable::name)
|
||||
));
|
||||
}
|
||||
|
||||
let next = set_section_body(&content, section, &items)?;
|
||||
apply(&mut content, section.label, next);
|
||||
apply(&mut content, &mut changed, section.label, next);
|
||||
}
|
||||
|
||||
if !args.tags.is_empty() {
|
||||
let next = set_metadata_field(&content, "Tags", &args.tags.join(", "), &title)?;
|
||||
apply(&mut content, "tags", next);
|
||||
apply(&mut content, &mut changed, "tags", next);
|
||||
}
|
||||
|
||||
if let Some(due) = &args.due {
|
||||
let next = set_metadata_field(&content, "Due", due, &title)?;
|
||||
apply(&mut content, "due", next);
|
||||
apply(&mut content, &mut changed, "due", next);
|
||||
}
|
||||
|
||||
if let Some(priority) = args.priority {
|
||||
let next = set_metadata_field(&content, "Priority", &priority.to_string(), &title)?;
|
||||
apply(&mut content, "priority", next);
|
||||
apply(&mut content, &mut changed, "priority", next);
|
||||
}
|
||||
|
||||
if changed.is_empty() {
|
||||
report(&changed, &title, "Updated");
|
||||
// Last, and into a list of their own. No field can be in both, since `contested`
|
||||
// refused that above, so the order is free and the report is what decides it: a
|
||||
// caller is told what was replaced and what was emptied in those words.
|
||||
for field in &args.clear {
|
||||
let next = match field.unset() {
|
||||
Unset::Field { field, sentinel } => {
|
||||
set_metadata_field(&content, field, sentinel, &title)?
|
||||
}
|
||||
Unset::Section(section) => clear_section_body(&content, section)?,
|
||||
};
|
||||
apply(&mut content, &mut cleared, field.label(), next);
|
||||
}
|
||||
|
||||
if changed.is_empty() && cleared.is_empty() {
|
||||
report(&[], &title, "Updated");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -822,7 +879,12 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, renamed, &content)?;
|
||||
|
||||
let shown = args.title.clone().unwrap_or(title);
|
||||
report(&changed, &shown, "Updated");
|
||||
if !changed.is_empty() {
|
||||
report(&changed, &shown, "Updated");
|
||||
}
|
||||
if !cleared.is_empty() {
|
||||
report(&cleared, &shown, "Cleared");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -835,13 +897,23 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
/// stay silent on the one it cannot, a ticket whose title is the username.
|
||||
///
|
||||
/// No-op detection compares the whole file, the way `set` does, so an owner set to the
|
||||
/// value it already holds is reported unchanged and nothing is written.
|
||||
pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
||||
/// value it already holds is reported unchanged and nothing is written. The same
|
||||
/// comparison is what makes clearing an already unset owner free.
|
||||
///
|
||||
/// **Clearing writes [`NOT_SET`], not the git user.** `add` falls back to the git user
|
||||
/// for a ticket it is filing, which is a default for something new; an owner taken away
|
||||
/// says nobody owns this, and putting the person running the command there instead would
|
||||
/// hand them a ticket they were giving up.
|
||||
pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
let (ticket_id, user) = args.target().ok_or_else(|| {
|
||||
anyhow!("chown takes a user and a ticket, or --clear with the ticket alone")
|
||||
})?;
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let content = set_metadata_field(&original, "Owner", user, &title)?;
|
||||
let content = set_metadata_field(&original, "Owner", user.unwrap_or(NOT_SET), &title)?;
|
||||
|
||||
if content == original {
|
||||
report(&[], &title, "Updated");
|
||||
@@ -850,7 +922,11 @@ pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
report(&["owner"], &title, "Updated");
|
||||
let verb = match user {
|
||||
Some(_) => "Updated",
|
||||
None => "Cleared",
|
||||
};
|
||||
report(&["owner"], &title, verb);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -925,10 +1001,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
));
|
||||
}
|
||||
|
||||
let relation = Relation {
|
||||
kind,
|
||||
target: target_uuid,
|
||||
};
|
||||
let relation = Relation { kind, target: target_uuid };
|
||||
|
||||
// Already held, either in the file or earlier in this call. Recording it
|
||||
// twice would read as two dependencies on one ticket.
|
||||
@@ -963,11 +1036,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
/// half-written campaign behind. `cmd_add` predates that primitive and still uses the
|
||||
/// plain write; the difference is noted on the ticket rather than fixed here.
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
let CampaignAddArgs {
|
||||
title,
|
||||
description,
|
||||
owner,
|
||||
} = args;
|
||||
let CampaignAddArgs { title, description, owner } = args;
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let dir = ensure_campaigns_dir(&worklane_dir)?;
|
||||
@@ -1043,10 +1112,7 @@ pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
println!("{}", "─".repeat(campaign.title.chars().count()));
|
||||
// No relations and no campaign of its own: a campaign is not a ticket, and neither
|
||||
// belongs to one.
|
||||
println!(
|
||||
"\n{}",
|
||||
content_trim_colored(&campaign.content, &Resolved::default())
|
||||
);
|
||||
println!("\n{}", content_trim_colored(&campaign.content, &Resolved::default()));
|
||||
|
||||
let grouped = members(worklane_dir, &campaign.uuid)?;
|
||||
let standing = Standing::of(&grouped);
|
||||
@@ -1059,10 +1125,7 @@ pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
if items.is_empty() {
|
||||
continue;
|
||||
}
|
||||
println!(
|
||||
"\n{}",
|
||||
color_text(&format!("[{}]", status.to_uppercase()), Color::Orange)
|
||||
);
|
||||
println!("\n{}", color_text(&format!("[{}]", status.to_uppercase()), Color::Orange));
|
||||
display_ticket_items(items);
|
||||
}
|
||||
|
||||
@@ -1083,8 +1146,7 @@ pub fn cmd_assign(campaign_search: &str, ticket_id: &str, start: &Path) -> Resul
|
||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let content =
|
||||
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
|
||||
let content = set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
|
||||
|
||||
if content == original {
|
||||
println!(
|
||||
@@ -1236,10 +1298,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
.collect();
|
||||
|
||||
if !changing.is_empty() {
|
||||
let lines: Vec<usize> = changing
|
||||
.iter()
|
||||
.map(|offset| criteria[*offset].line)
|
||||
.collect();
|
||||
let lines: Vec<usize> = changing.iter().map(|offset| criteria[*offset].line).collect();
|
||||
let updated = set_criteria(&content, &lines, checked);
|
||||
let uuid = parse_ticket_field(&content, "ID");
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
|
||||
@@ -1258,12 +1317,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
past.to_string()
|
||||
};
|
||||
|
||||
println!(
|
||||
"{} {}: {}",
|
||||
state,
|
||||
offset + 1,
|
||||
color_text(&criterion.text, Color::Green)
|
||||
);
|
||||
println!("{} {}: {}", state, offset + 1, color_text(&criterion.text, Color::Green));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
|
||||
+18
-22
@@ -75,9 +75,10 @@ pub static SKILLS: [Asset; 3] = [SKILL, REVIEW_SKILL, PLAN_SKILL];
|
||||
|
||||
/// The skill a name on the command line asks for.
|
||||
pub fn skill_named(name: &str) -> Result<&'static Asset> {
|
||||
SKILLS.iter().find(|asset| asset.name == name).ok_or_else(|| {
|
||||
anyhow!("no skill named {name:?}. This binary ships {}", skill_names())
|
||||
})
|
||||
SKILLS
|
||||
.iter()
|
||||
.find(|asset| asset.name == name)
|
||||
.ok_or_else(|| anyhow!("no skill named {name:?}. This binary ships {}", skill_names()))
|
||||
}
|
||||
|
||||
/// The names, for the errors that have to say what there is to choose from.
|
||||
@@ -173,10 +174,7 @@ mod tests {
|
||||
let root = root();
|
||||
let path = SKILL.path(root.path());
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Written(path.clone())
|
||||
);
|
||||
assert_eq!(SKILL.install(root.path(), false).unwrap(), Outcome::Written(path.clone()));
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
|
||||
}
|
||||
|
||||
@@ -201,16 +199,10 @@ mod tests {
|
||||
SKILL.install(root.path(), false).unwrap();
|
||||
std::fs::write(&path, "hand written\n").unwrap();
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Refused(path.clone())
|
||||
);
|
||||
assert_eq!(SKILL.install(root.path(), false).unwrap(), Outcome::Refused(path.clone()));
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), "hand written\n");
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), true).unwrap(),
|
||||
Outcome::Written(path.clone())
|
||||
);
|
||||
assert_eq!(SKILL.install(root.path(), true).unwrap(), Outcome::Written(path.clone()));
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
|
||||
}
|
||||
|
||||
@@ -254,8 +246,10 @@ mod tests {
|
||||
"the frontmatter name has to match the directory it installs into"
|
||||
);
|
||||
|
||||
let description = frontmatter_field(asset.content, "description")
|
||||
.unwrap_or_else(|| panic!("{} ships without a description to trigger on", asset.name));
|
||||
let description =
|
||||
frontmatter_field(asset.content, "description").unwrap_or_else(|| {
|
||||
panic!("{} ships without a description to trigger on", asset.name)
|
||||
});
|
||||
assert!(
|
||||
description.len() > 80,
|
||||
"{}: the description is what decides whether the skill loads at all",
|
||||
@@ -311,7 +305,9 @@ mod tests {
|
||||
if words.next() != Some("worklane") {
|
||||
continue;
|
||||
}
|
||||
let Some(candidate) = words.next() else { continue };
|
||||
let Some(candidate) = words.next() else {
|
||||
continue;
|
||||
};
|
||||
// A flag before the subcommand, as in the `mv -- -leading-title` example.
|
||||
if candidate.starts_with("--") && !known.iter().any(|k| k == candidate) {
|
||||
continue;
|
||||
@@ -386,9 +382,9 @@ mod tests {
|
||||
fn the_plan_skill_keeps_the_rules_that_bound_a_sweep() {
|
||||
for required in [
|
||||
"Propose the whole set of edits",
|
||||
"replaces the whole\nfield", // `set --tags` is the destructive one
|
||||
"cannot be cleared", // and a due date cannot be taken back
|
||||
"blocked by", // ordering constrains any dating plan
|
||||
"replaces the whole\nfield", // `set --tags` is the destructive one
|
||||
"not\nback to what it held", // and --clear is not an undo
|
||||
"blocked by", // ordering constrains any dating plan
|
||||
"worklane campaign ls",
|
||||
"does not touch",
|
||||
] {
|
||||
@@ -407,7 +403,7 @@ mod tests {
|
||||
#[test]
|
||||
fn the_review_skill_keeps_the_decisions_that_define_it() {
|
||||
for required in [
|
||||
"worklane show", // the ticket is read before the code
|
||||
"worklane show", // the ticket is read before the code
|
||||
"nothing names the ticket", // and the no-work-found case is answered
|
||||
"Never tick a criterion",
|
||||
"Do not move the ticket",
|
||||
|
||||
+14
-22
@@ -4,6 +4,7 @@ use clap::Parser;
|
||||
mod campaign;
|
||||
mod clipboard;
|
||||
mod command;
|
||||
mod completions;
|
||||
mod handlers;
|
||||
mod install;
|
||||
mod tui;
|
||||
@@ -46,35 +47,24 @@ 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)?;
|
||||
cmd_show(&id, &worklane_dir)
|
||||
}
|
||||
Some(Command::Mv {
|
||||
ticket,
|
||||
status,
|
||||
force,
|
||||
}) => cmd_mv(&ticket, &status, force, &start),
|
||||
Some(Command::Mv { ticket, status, force }) => cmd_mv(&ticket, status, force, &start),
|
||||
Some(Command::Set(args)) => cmd_set(&args, &start),
|
||||
Some(Command::Append(args)) => cmd_append(&args, &start),
|
||||
Some(Command::Relate(args)) => cmd_relate(&args, &start),
|
||||
Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start),
|
||||
Some(Command::Chown(args)) => cmd_chown(&args, &start),
|
||||
Some(Command::Check(args)) => cmd_check(&args, true, &start),
|
||||
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
||||
Some(Command::Comment {
|
||||
ticket,
|
||||
body,
|
||||
owner,
|
||||
}) => cmd_comment(&ticket, &body, &owner, &start),
|
||||
Some(Command::Comment { ticket, body, owner }) => {
|
||||
cmd_comment(&ticket, &body, &owner, &start)
|
||||
}
|
||||
Some(Command::Campaign { command }) => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
||||
CampaignCommand::Ls => {
|
||||
@@ -87,6 +77,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 }) => {
|
||||
@@ -111,10 +106,7 @@ fn install_panic_hook() {
|
||||
|
||||
fn restore_terminal() -> std::io::Result<()> {
|
||||
crossterm::terminal::disable_raw_mode()?;
|
||||
crossterm::execute!(
|
||||
std::io::stdout(),
|
||||
crossterm::terminal::LeaveAlternateScreen
|
||||
)
|
||||
crossterm::execute!(std::io::stdout(), crossterm::terminal::LeaveAlternateScreen)
|
||||
}
|
||||
|
||||
fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()> {
|
||||
|
||||
+78
-112
@@ -6,19 +6,19 @@
|
||||
//!
|
||||
//! **Read only.** Moving a card by keypress is a follow-up. Everything here observes.
|
||||
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, SystemTime};
|
||||
|
||||
use anyhow::{Context, Result};
|
||||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||||
use ratatui::Frame;
|
||||
use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect, Size};
|
||||
use ratatui::style::{Modifier, Style};
|
||||
use ratatui::text::{Line, Span, Text};
|
||||
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs, Wrap};
|
||||
use ratatui::Frame;
|
||||
|
||||
use crate::handlers::read_comments;
|
||||
use crate::util::*;
|
||||
@@ -71,10 +71,7 @@ pub fn projects(paths: &[PathBuf], start: &Path) -> Result<Vec<Project>> {
|
||||
continue;
|
||||
}
|
||||
|
||||
projects.push(Project {
|
||||
name: project_name(&dir),
|
||||
dir,
|
||||
});
|
||||
projects.push(Project { name: project_name(&dir), dir });
|
||||
}
|
||||
|
||||
Ok(projects)
|
||||
@@ -315,11 +312,7 @@ impl Board {
|
||||
if projects.len() > 1 {
|
||||
tabs.push(Tab::new(ALL.to_string()));
|
||||
}
|
||||
tabs.extend(
|
||||
projects
|
||||
.iter()
|
||||
.map(|project| Tab::new(project.name.clone())),
|
||||
);
|
||||
tabs.extend(projects.iter().map(|project| Tab::new(project.name.clone())));
|
||||
|
||||
let mut board = Board {
|
||||
tabs,
|
||||
@@ -775,10 +768,7 @@ fn detail_of(card: &Card) -> Detail {
|
||||
// Colour off for the text, which is what keeps escapes out of the paragraph, and the
|
||||
// relations arrive as rows so the board can style them itself.
|
||||
let mut parts = content_parts(&content, false, &resolved);
|
||||
parts.push(BodyPart::Text(format!(
|
||||
"\n{}",
|
||||
format_comments_with(&comments, false)
|
||||
)));
|
||||
parts.push(BodyPart::Text(format!("\n{}", format_comments_with(&comments, false))));
|
||||
|
||||
Detail {
|
||||
title: ticket.title.clone(),
|
||||
@@ -1136,12 +1126,7 @@ fn draw_columns(frame: &mut Frame, board: &Board, area: Rect) {
|
||||
};
|
||||
|
||||
// An empty status is an empty column, not a column that is not there.
|
||||
frame.render_widget(
|
||||
Paragraph::new(lines)
|
||||
.block(block)
|
||||
.scroll((offset, 0)),
|
||||
areas[index],
|
||||
);
|
||||
frame.render_widget(Paragraph::new(lines).block(block).scroll((offset, 0)), areas[index]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1285,12 +1270,11 @@ fn card_lines(card: &Card, selected: bool, width: u16) -> Vec<Line<'static>> {
|
||||
|
||||
let mut lines = vec![corner_line(left, due_span(&ticket.due), width)];
|
||||
|
||||
lines.extend(title_lines(&ticket.title, width).into_iter().map(|line| {
|
||||
Line::from(Span::styled(
|
||||
line,
|
||||
Style::default().add_modifier(emphasis),
|
||||
))
|
||||
}));
|
||||
lines.extend(
|
||||
title_lines(&ticket.title, width)
|
||||
.into_iter()
|
||||
.map(|line| Line::from(Span::styled(line, Style::default().add_modifier(emphasis)))),
|
||||
);
|
||||
|
||||
if let Some(row) = tags_line(&ticket.tags, width) {
|
||||
lines.push(row);
|
||||
@@ -1352,10 +1336,7 @@ fn tags_line(tags: &[String], width: u16) -> Option<Line<'static>> {
|
||||
if index > 0 {
|
||||
spans.push(Span::raw(" "));
|
||||
}
|
||||
spans.push(Span::styled(
|
||||
format!("#{tag}"),
|
||||
Style::default().fg(tag_color(tag).into()),
|
||||
));
|
||||
spans.push(Span::styled(format!("#{tag}"), Style::default().fg(tag_color(tag).into())));
|
||||
}
|
||||
|
||||
Some(Line::from(spans))
|
||||
@@ -1399,10 +1380,7 @@ fn due_span(due: &str) -> Option<Span<'static>> {
|
||||
false => Color::Cyan,
|
||||
};
|
||||
|
||||
Some(Span::styled(
|
||||
due_date(due).to_string(),
|
||||
Style::default().fg(colour.into()),
|
||||
))
|
||||
Some(Span::styled(due_date(due).to_string(), Style::default().fg(colour.into())))
|
||||
}
|
||||
|
||||
/// `left` at the left, `right` at the right, with the gap between them.
|
||||
@@ -1490,10 +1468,7 @@ fn title_lines(title: &str, width: u16) -> Vec<String> {
|
||||
|
||||
fn chars_in_chunks(word: &str, width: usize) -> Vec<String> {
|
||||
let chars: Vec<char> = word.chars().collect();
|
||||
chars
|
||||
.chunks(width)
|
||||
.map(|chunk| chunk.iter().collect())
|
||||
.collect()
|
||||
chars.chunks(width).map(|chunk| chunk.iter().collect()).collect()
|
||||
}
|
||||
|
||||
/// The row with an ellipsis on the end, making room for it if the row is full.
|
||||
@@ -1574,10 +1549,7 @@ fn draw_notice(frame: &mut Frame, notice: &Notice, area: Rect) {
|
||||
false => Style::default(),
|
||||
};
|
||||
|
||||
frame.render_widget(
|
||||
Paragraph::new(Span::styled(format!(" {}", notice.text), style)),
|
||||
area,
|
||||
);
|
||||
frame.render_widget(Paragraph::new(Span::styled(format!(" {}", notice.text), style)), area);
|
||||
}
|
||||
|
||||
/// The prompt, in place of the key list it would otherwise describe wrongly.
|
||||
@@ -1595,10 +1567,7 @@ fn draw_search(frame: &mut Frame, search: &Search, area: Rect) {
|
||||
let mut spans = vec![Span::raw(prompt.clone())];
|
||||
|
||||
if search.missed {
|
||||
spans.push(Span::styled(
|
||||
" no match",
|
||||
Style::default().fg(Color::BrightRed.into()),
|
||||
));
|
||||
spans.push(Span::styled(" no match", Style::default().fg(Color::BrightRed.into())));
|
||||
}
|
||||
spans.push(Span::styled(
|
||||
" enter jump esc cancel ",
|
||||
@@ -1737,11 +1706,8 @@ fn draw_detail(frame: &mut Frame, detail: &Detail, offset: u16, area: Rect) {
|
||||
// keys and a rendered checkbox take, and does not compete with the orange title.
|
||||
if let Some(indicator) = page_indicator(offset, last, text.height, overlay.width) {
|
||||
block = block.title_bottom(
|
||||
Line::from(Span::styled(
|
||||
indicator,
|
||||
Style::default().fg(Color::Grey.into()),
|
||||
))
|
||||
.right_aligned(),
|
||||
Line::from(Span::styled(indicator, Style::default().fg(Color::Grey.into())))
|
||||
.right_aligned(),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1865,10 +1831,7 @@ mod tests {
|
||||
|
||||
/// The screen the scrolling tests draw on, so the keypress and the draw measure the
|
||||
/// same overlay.
|
||||
const SCREEN: Size = Size {
|
||||
width: 120,
|
||||
height: 20,
|
||||
};
|
||||
const SCREEN: Size = Size { width: 120, height: 20 };
|
||||
|
||||
/// The rendered buffer as lines of text, escapes and styling dropped.
|
||||
fn render(board: &Board, width: u16, height: u16) -> Vec<String> {
|
||||
@@ -2191,7 +2154,8 @@ mod tests {
|
||||
/// it drops styling on the way out of the buffer.
|
||||
fn card_colour(dir: &Path, width: u16, needle: &str) -> Option<ratatui::style::Color> {
|
||||
let board = one_board(dir);
|
||||
let inner = card_width(Size { width, height: 20 }, board.tabbed(), board.visible().len(), 0);
|
||||
let inner =
|
||||
card_width(Size { width, height: 20 }, board.tabbed(), board.visible().len(), 0);
|
||||
let ticket = board.selected().expect("no card");
|
||||
|
||||
card_lines(ticket, false, inner)
|
||||
@@ -2432,7 +2396,8 @@ mod tests {
|
||||
let dir = board_dir();
|
||||
let before = digest(&dir);
|
||||
|
||||
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let path =
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let created = digest(&dir);
|
||||
assert_ne!(before, created, "a new ticket went unnoticed");
|
||||
|
||||
@@ -2448,7 +2413,8 @@ mod tests {
|
||||
#[test]
|
||||
fn the_digest_moves_when_a_ticket_is_edited_in_place() {
|
||||
let dir = board_dir();
|
||||
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let path =
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let before = digest(&dir);
|
||||
|
||||
let content = std::fs::read_to_string(&path).unwrap();
|
||||
@@ -2462,7 +2428,8 @@ mod tests {
|
||||
#[test]
|
||||
fn the_digest_moves_on_an_edit_of_the_same_length() {
|
||||
let dir = board_dir();
|
||||
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let path =
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
|
||||
let content = std::fs::read_to_string(&path).unwrap();
|
||||
let same_length = content.replace("A description.", "A descriptionA");
|
||||
@@ -2534,7 +2501,11 @@ mod tests {
|
||||
#[test]
|
||||
fn the_card_index_is_clamped_when_the_column_is_shorter() {
|
||||
let dir = board_dir();
|
||||
for (n, title) in [("11111111", "Alpha"), ("22222222", "Beta"), ("33333333", "Gamma")] {
|
||||
for (n, title) in [
|
||||
("11111111", "Alpha"),
|
||||
("22222222", "Beta"),
|
||||
("33333333", "Gamma"),
|
||||
] {
|
||||
write_ticket(&dir, "backlog", &format!("{n}-0000-4000-8000-000000000000"), title, "");
|
||||
}
|
||||
write_ticket(&dir, "committed", "44444444-0000-4000-8000-000000000000", "Delta", "");
|
||||
@@ -2572,10 +2543,7 @@ mod tests {
|
||||
|
||||
let top = render(&board, SCREEN.width, SCREEN.height).join("\n");
|
||||
assert!(top.contains("Ticket 01"), "{top}");
|
||||
assert!(
|
||||
!top.contains("Ticket 12"),
|
||||
"the fixture fits without scrolling:\n{top}"
|
||||
);
|
||||
assert!(!top.contains("Ticket 12"), "the fixture fits without scrolling:\n{top}");
|
||||
|
||||
board.select_card(11, SCREEN);
|
||||
|
||||
@@ -2693,10 +2661,7 @@ mod tests {
|
||||
// holding a scroll position for a highlight it no longer has.
|
||||
assert_eq!(board.current().card, 2);
|
||||
let back = render(&board, SCREEN.width, SCREEN.height).join("\n");
|
||||
assert!(
|
||||
back.contains("Ticket 03"),
|
||||
"returning lost the selection:\n{back}"
|
||||
);
|
||||
assert!(back.contains("Ticket 03"), "returning lost the selection:\n{back}");
|
||||
assert!(!back.contains("Ticket 12"), "{back}");
|
||||
}
|
||||
|
||||
@@ -2708,10 +2673,7 @@ mod tests {
|
||||
fill_column(&dir, "backlog", 12);
|
||||
|
||||
// Tall enough that every card fits, so the keypress stores no scroll at all.
|
||||
let roomy = Size {
|
||||
width: 120,
|
||||
height: 60,
|
||||
};
|
||||
let roomy = Size { width: 120, height: 60 };
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.select_card(11, roomy);
|
||||
@@ -2804,7 +2766,11 @@ mod tests {
|
||||
}
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(screen.join("\n").contains("Line 060"), "nothing scrolled:\n{}", screen.join("\n"));
|
||||
assert!(
|
||||
screen.join("\n").contains("Line 060"),
|
||||
"nothing scrolled:\n{}",
|
||||
screen.join("\n")
|
||||
);
|
||||
|
||||
let row = overlay_title_row(&screen, SCREEN.width, SCREEN.height);
|
||||
assert!(row.contains("(1111111)"), "the id scrolled away:\n{row}");
|
||||
@@ -2956,10 +2922,7 @@ mod tests {
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
|
||||
// Tall enough that the whole ticket is on screen at once.
|
||||
let roomy = Size {
|
||||
width: 120,
|
||||
height: 60,
|
||||
};
|
||||
let roomy = Size { width: 120, height: 60 };
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
@@ -3203,7 +3166,13 @@ mod tests {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "Alpha first", "");
|
||||
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "Beta second", "");
|
||||
write_ticket(&dir, "committed", "33333333-0000-4000-8000-000000000000", "Gamma third", "");
|
||||
write_ticket(
|
||||
&dir,
|
||||
"committed",
|
||||
"33333333-0000-4000-8000-000000000000",
|
||||
"Gamma third",
|
||||
"",
|
||||
);
|
||||
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Delta finished", "");
|
||||
dir
|
||||
}
|
||||
@@ -3522,8 +3491,7 @@ mod tests {
|
||||
board.open_search();
|
||||
type_query(&mut board, "gam");
|
||||
|
||||
let mut terminal =
|
||||
Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
|
||||
let mut terminal = Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
|
||||
terminal.draw(|frame| draw(frame, &board)).unwrap();
|
||||
|
||||
let at = terminal.get_cursor_position().unwrap();
|
||||
@@ -3696,9 +3664,9 @@ mod tests {
|
||||
the OSC 52 write is named"
|
||||
);
|
||||
|
||||
let cleared = source.find("board.clear_notice();").expect(
|
||||
"a notice that nothing clears sits in the footer for the rest of the session",
|
||||
);
|
||||
let cleared = source
|
||||
.find("board.clear_notice();")
|
||||
.expect("a notice that nothing clears sits in the footer for the rest of the session");
|
||||
let prompt = source.find("if board.search_key(key, screen)").unwrap();
|
||||
assert!(
|
||||
cleared < prompt,
|
||||
@@ -3883,10 +3851,7 @@ mod tests {
|
||||
|
||||
assert_eq!(project_label("alpha", 38, IDENTITY).as_deref(), Some("alpha"));
|
||||
// Room for three characters of a longer name, the last of them the ellipsis.
|
||||
assert_eq!(
|
||||
project_label("factry-core", 16, IDENTITY).as_deref(),
|
||||
Some("fa…")
|
||||
);
|
||||
assert_eq!(project_label("factry-core", 16, IDENTITY).as_deref(), Some("fa…"));
|
||||
assert_eq!(project_label("factry-core", 13, IDENTITY), None);
|
||||
assert_eq!(project_label("alpha", 4, IDENTITY), None);
|
||||
}
|
||||
@@ -3984,10 +3949,7 @@ mod tests {
|
||||
assert!(!marked_blocked(&board, "The waiter"));
|
||||
|
||||
let screen = render(&board, 120, 20).join("\n");
|
||||
assert!(
|
||||
!screen.contains(BLOCKED_MARK),
|
||||
"a cleared blocker still marked:\n{screen}"
|
||||
);
|
||||
assert!(!screen.contains(BLOCKED_MARK), "a cleared blocker still marked:\n{screen}");
|
||||
}
|
||||
|
||||
/// One open blocker out of two is still a reason not to start, the rule `mv` applies
|
||||
@@ -4056,7 +4018,11 @@ mod tests {
|
||||
assert!(wide[0].contains(BLOCKED_MARK), "no mark with room for it: {:?}", wide[0]);
|
||||
|
||||
let narrow = card_rows(&board, "The waiter", identity);
|
||||
assert!(!narrow[0].contains(BLOCKED_MARK), "mark kept over the column: {:?}", narrow[0]);
|
||||
assert!(
|
||||
!narrow[0].contains(BLOCKED_MARK),
|
||||
"mark kept over the column: {:?}",
|
||||
narrow[0]
|
||||
);
|
||||
assert!(narrow[0].contains(&id), "the identity gave way instead: {:?}", narrow[0]);
|
||||
assert!(narrow[0].chars().count() <= identity as usize, "row over the column");
|
||||
}
|
||||
@@ -4209,8 +4175,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// The style of the first cell drawing `symbol`, so a test can ask what colour a
|
||||
/// glyph actually reached the screen in rather than trusting the span it was built
|
||||
/// from.
|
||||
@@ -4291,16 +4255,20 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let content = std::fs::read_to_string(
|
||||
board.selected().expect("no selection").ticket.path.clone(),
|
||||
)
|
||||
.unwrap();
|
||||
let content =
|
||||
std::fs::read_to_string(board.selected().expect("no selection").ticket.path.clone())
|
||||
.unwrap();
|
||||
let rows = relations_for(&content, &dir).unwrap();
|
||||
let printed = render_relations(&rows, false);
|
||||
|
||||
assert!(!printed.is_empty(), "the fixture has no relations");
|
||||
assert!(
|
||||
board.detail.as_ref().unwrap().plain().contains(printed.trim_end()),
|
||||
board
|
||||
.detail
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.plain()
|
||||
.contains(printed.trim_end()),
|
||||
"the overlay drew a different block than the listing prints: {printed:?}"
|
||||
);
|
||||
}
|
||||
@@ -4467,7 +4435,10 @@ mod tests {
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
// Marked for its kind, and the mark sits ahead of the id.
|
||||
assert!(
|
||||
text.contains(&format!("blocked by {BLOCKED_MARK} {} (2222222) The target", status_mark(Some("backlog")).0)),
|
||||
text.contains(&format!(
|
||||
"blocked by {BLOCKED_MARK} {} (2222222) The target",
|
||||
status_mark(Some("backlog")).0
|
||||
)),
|
||||
"{text:?}"
|
||||
);
|
||||
assert!(!text.contains(target), "the bare uuid was drawn: {text:?}");
|
||||
@@ -4494,7 +4465,10 @@ mod tests {
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
assert!(
|
||||
text.contains(&format!("blocks {BLOCKED_MARK} {} (1111111) A holder", status_mark(Some("backlog")).0)),
|
||||
text.contains(&format!(
|
||||
"blocks {BLOCKED_MARK} {} (1111111) A holder",
|
||||
status_mark(Some("backlog")).0
|
||||
)),
|
||||
"{text:?}"
|
||||
);
|
||||
}
|
||||
@@ -4741,11 +4715,7 @@ mod tests {
|
||||
/// Located on the bottom border row rather than by searching the buffer for a glyph:
|
||||
/// `p` and `g` are all over the board, and `drawn_color` would answer about whichever
|
||||
/// card holds the first one.
|
||||
fn indicator_color(
|
||||
board: &Board,
|
||||
width: u16,
|
||||
height: u16,
|
||||
) -> Option<ratatui::style::Color> {
|
||||
fn indicator_color(board: &Board, width: u16, height: u16) -> Option<ratatui::style::Color> {
|
||||
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
|
||||
terminal.draw(|frame| draw(frame, board)).unwrap();
|
||||
let buffer = terminal.backend().buffer().clone();
|
||||
@@ -4754,9 +4724,7 @@ mod tests {
|
||||
let row = overlay.y + overlay.height - 1;
|
||||
|
||||
(overlay.x..overlay.x + overlay.width - 1)
|
||||
.find(|x| {
|
||||
buffer[(*x, row)].symbol() == "p" && buffer[(x + 1, row)].symbol() == "g"
|
||||
})
|
||||
.find(|x| buffer[(*x, row)].symbol() == "p" && buffer[(x + 1, row)].symbol() == "g")
|
||||
.map(|x| buffer[(x, row)].fg)
|
||||
}
|
||||
|
||||
@@ -4783,6 +4751,4 @@ mod tests {
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
+607
-129
File diff suppressed because it is too large
Load Diff
+60
-24
@@ -1,6 +1,6 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
@@ -106,9 +106,12 @@ fn add_joins_multiple_descriptions() {
|
||||
cmd.current_dir(temp.path())
|
||||
.args([
|
||||
"add",
|
||||
"--title", "Multi desc ticket",
|
||||
"--description", "Line one",
|
||||
"--description", "Line two",
|
||||
"--title",
|
||||
"Multi desc ticket",
|
||||
"--description",
|
||||
"Line one",
|
||||
"--description",
|
||||
"Line two",
|
||||
])
|
||||
.assert()
|
||||
.success();
|
||||
@@ -285,10 +288,7 @@ fn add_accepts_prose_values_that_begin_with_a_hyphen() {
|
||||
// Stored verbatim, hyphens and all
|
||||
assert!(content.contains("# -t is a flag name"), "was {content:?}");
|
||||
assert!(content.contains("-x does nothing"), "was {content:?}");
|
||||
assert!(
|
||||
content.contains("- [ ] --print should be supported"),
|
||||
"was {content:?}"
|
||||
);
|
||||
assert!(content.contains("- [ ] --print should be supported"), "was {content:?}");
|
||||
assert!(content.contains("1. -f skips the check"), "was {content:?}");
|
||||
}
|
||||
|
||||
@@ -308,10 +308,7 @@ fn add_still_accepts_the_equals_form() {
|
||||
|
||||
let content = only_ticket(&worklane);
|
||||
assert!(content.contains("# -x equals form"), "was {content:?}");
|
||||
assert!(
|
||||
content.contains("- [ ] --print via equals"),
|
||||
"was {content:?}"
|
||||
);
|
||||
assert!(content.contains("- [ ] --print via equals"), "was {content:?}");
|
||||
}
|
||||
|
||||
/// Never silently dropped: a value that is nothing but hyphens is content.
|
||||
@@ -328,10 +325,7 @@ fn add_stores_a_title_that_is_only_hyphens() {
|
||||
.success();
|
||||
|
||||
let content = only_ticket(&worklane);
|
||||
assert!(
|
||||
content.starts_with(&format!("# {}\n", bare)),
|
||||
"for {bare:?}: {content:?}"
|
||||
);
|
||||
assert!(content.starts_with(&format!("# {}\n", bare)), "for {bare:?}: {content:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -408,10 +402,7 @@ fn add_keeps_a_paragraph_break_in_the_description() {
|
||||
let mut show = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
show.current_dir(temp.path()).args(["show", "Two Paras"]);
|
||||
let stdout = String::from_utf8(show.assert().success().get_output().stdout.clone()).unwrap();
|
||||
assert!(
|
||||
stdout.contains("First paragraph.\n\nSecond paragraph."),
|
||||
"was {stdout:?}"
|
||||
);
|
||||
assert!(stdout.contains("First paragraph.\n\nSecond paragraph."), "was {stdout:?}");
|
||||
}
|
||||
|
||||
/// A break belongs between paragraphs, not against the section headings.
|
||||
@@ -482,7 +473,14 @@ fn add_stores_a_valid_due_date_unchanged() {
|
||||
/// and is not a day.
|
||||
#[test]
|
||||
fn add_refuses_a_due_date_that_is_not_a_real_iso_date() {
|
||||
for value in ["next friday", "29-08-2026", "2026-13-01", "2026-02-30", "2026/08/29", ""] {
|
||||
for value in [
|
||||
"next friday",
|
||||
"29-08-2026",
|
||||
"2026-13-01",
|
||||
"2026-02-30",
|
||||
"2026/08/29",
|
||||
"",
|
||||
] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
@@ -530,9 +528,10 @@ fn add_refuses_an_unpadded_due_date_rather_than_padding_it() {
|
||||
}
|
||||
|
||||
/// An empty value keeps the message about clearing, since that is what somebody typing
|
||||
/// it is reaching for.
|
||||
/// it is reaching for. On `add` the answer is to omit the flag, but the message names
|
||||
/// `--clear` because the same parser guards `set --due`, where that is the answer.
|
||||
#[test]
|
||||
fn an_empty_due_date_says_clearing_is_not_supported() {
|
||||
fn an_empty_due_date_points_at_clear() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
setup_worklane(&temp);
|
||||
|
||||
@@ -549,7 +548,8 @@ fn an_empty_due_date_says_clearing_is_not_supported() {
|
||||
)
|
||||
.to_string();
|
||||
|
||||
assert!(stderr.contains("clearing a field is not supported"), "{stderr}");
|
||||
assert!(stderr.contains("use --clear"), "{stderr}");
|
||||
assert!(!stderr.contains("not supported"), "{stderr}");
|
||||
}
|
||||
|
||||
fn read_only_ticket(dir: &Path) -> String {
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -487,7 +487,12 @@ fn a_campaign_that_no_longer_exists_reads_as_missing() {
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
fs::remove_file(worklane.join("campaigns").join(format!("{CAMP_A}_v1-release.md"))).unwrap();
|
||||
fs::remove_file(
|
||||
worklane
|
||||
.join("campaigns")
|
||||
.join(format!("{CAMP_A}_v1-release.md")),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let out = run(&temp, &["show", MEMBER]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
@@ -578,11 +583,7 @@ fn a_search_that_names_nothing_still_reports_no_ticket() {
|
||||
let out = run(&temp, &["show", "nothing at all"]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
assert!(
|
||||
stderr(&out).contains("No ticket found matching"),
|
||||
"{}",
|
||||
stderr(&out)
|
||||
);
|
||||
assert!(stderr(&out).contains("No ticket found matching"), "{}", stderr(&out));
|
||||
}
|
||||
|
||||
/// A campaign resolves by the same tiers a ticket does, so it can be ambiguous the same
|
||||
|
||||
+2
-9
@@ -298,10 +298,7 @@ fn show_numbers_the_criteria() {
|
||||
assert!(!stdout.contains("4. ["), "the handwritten line was numbered: {stdout:?}");
|
||||
|
||||
// And the description checkbox is left as it is, outside the numbering
|
||||
assert!(
|
||||
stdout.contains("- [ ] A checkbox in the description"),
|
||||
"{stdout:?}"
|
||||
);
|
||||
assert!(stdout.contains("- [ ] A checkbox in the description"), "{stdout:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -418,11 +415,7 @@ fn a_batch_that_would_change_nothing_writes_nothing() {
|
||||
assert!(out.status.success());
|
||||
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert_eq!(
|
||||
stdout.matches("Already checked").count(),
|
||||
3,
|
||||
"{stdout:?}"
|
||||
);
|
||||
assert_eq!(stdout.matches("Already checked").count(), 3, "{stdout:?}");
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
|
||||
+90
-11
@@ -89,11 +89,7 @@ fn chown_sets_the_owner() {
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "bob", UUID]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("owner"),
|
||||
"{:?}",
|
||||
@@ -139,10 +135,7 @@ fn chown_leaves_everything_it_was_not_asked_about_alone() {
|
||||
run(&temp, &["chown", "bob", UUID]);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(
|
||||
content.contains("- [x] Crit one"),
|
||||
"the tick was lost: {content}"
|
||||
);
|
||||
assert!(content.contains("- [x] Crit one"), "the tick was lost: {content}");
|
||||
assert!(
|
||||
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
||||
"the unknown section was lost: {content}"
|
||||
@@ -213,7 +206,8 @@ fn chown_refuses_a_swapped_call() {
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty user looks like a way to clear the field, and clearing is not supported.
|
||||
/// An empty user is still a usage error, and now points at the flag that does take the
|
||||
/// owner away.
|
||||
#[test]
|
||||
fn chown_refuses_an_empty_user_as_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
@@ -223,11 +217,96 @@ fn chown_refuses_an_empty_user_as_a_usage_error() {
|
||||
|
||||
let out = run(&temp, &["chown", "", UUID]);
|
||||
assert_eq!(out.status.code(), Some(2));
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("use --clear"), "{stderr:?}");
|
||||
assert!(!stderr.contains("not supported"), "{stderr:?}");
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// The owner goes back to the sentinel, not to the git user: an owner taken away says
|
||||
/// nobody owns this.
|
||||
#[test]
|
||||
fn chown_clear_returns_the_owner_to_unset() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "--clear", UUID]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
|
||||
String::from_utf8_lossy(&out.stdout).contains("Cleared owner"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Owner**: _Not set_"), "{content}");
|
||||
// Nothing else on the way past.
|
||||
assert!(content.contains("- **Status**: backlog"), "{content}");
|
||||
}
|
||||
|
||||
/// The ticket is still resolved the three usual ways when it arrives in the flag.
|
||||
#[test]
|
||||
fn chown_clear_resolves_the_ticket_it_is_given() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "--clear", "Original"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(ticket(&worklane).contains("- **Owner**: _Not set_"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chown_clear_on_an_unowned_ticket_is_no_change() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["chown", "--clear", UUID]);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "--clear", UUID]);
|
||||
assert!(out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
/// Setting an owner and clearing it are the two forms of the command, and clap keeps
|
||||
/// them apart rather than the handler picking one.
|
||||
#[test]
|
||||
fn chown_refuses_a_user_and_a_clear_together() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for args in [
|
||||
vec!["chown", "bob", "--clear", UUID],
|
||||
vec!["chown", "bob", UUID, "--clear", UUID],
|
||||
] {
|
||||
let out = run(&temp, &args);
|
||||
assert_eq!(out.status.code(), Some(2), "{args:?} was accepted");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("cannot be used with"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
|
||||
// And a bare --clear still needs the ticket it is meant to name.
|
||||
let out = run(&temp, &["chown", "--clear"]);
|
||||
assert_eq!(out.status.code(), Some(2));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("a value is required"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
@@ -17,11 +17,7 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
|
||||
worklane.path().to_path_buf()
|
||||
}
|
||||
|
||||
fn create_ticket(
|
||||
worklane_dir: &Path,
|
||||
status: &str,
|
||||
title: &str,
|
||||
) -> String {
|
||||
fn create_ticket(worklane_dir: &Path, status: &str, title: &str) -> String {
|
||||
let uuid = uuid::Uuid::new_v4().to_string();
|
||||
let slug = title
|
||||
.to_lowercase()
|
||||
|
||||
@@ -0,0 +1,77 @@
|
||||
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}");
|
||||
}
|
||||
@@ -54,11 +54,7 @@ fn every_skill_installs_outside_a_worklane_directory() {
|
||||
assert_eq!(std::fs::read_to_string(installed_plan(&home)).unwrap(), PLAN);
|
||||
|
||||
// Once, not per document: it is the one thing to do next, not part of an outcome.
|
||||
assert_eq!(
|
||||
stdout.matches("pick it up on their next session").count(),
|
||||
1,
|
||||
"{stdout}"
|
||||
);
|
||||
assert_eq!(stdout.matches("pick it up on their next session").count(), 1, "{stdout}");
|
||||
}
|
||||
|
||||
/// Narrowing to one document is the exception, and it must leave the others alone.
|
||||
@@ -72,7 +68,10 @@ fn a_named_skill_installs_only_that_one() {
|
||||
assert_eq!(out.status.code(), Some(0), "{stdout}");
|
||||
assert_eq!(std::fs::read_to_string(installed_review(&home)).unwrap(), REVIEW);
|
||||
assert!(!installed(&home).exists(), "a named install wrote the other document too");
|
||||
assert!(!installed_plan(&home).exists(), "a named install wrote the other document too");
|
||||
assert!(
|
||||
!installed_plan(&home).exists(),
|
||||
"a named install wrote the other document too"
|
||||
);
|
||||
}
|
||||
|
||||
/// A name nothing ships is a stop, with the choices in the message: guessing at the
|
||||
@@ -118,7 +117,10 @@ fn a_modified_copy_is_reported_and_needs_force() {
|
||||
assert_eq!(out.status.code(), Some(0), "{stdout}");
|
||||
assert!(stdout.contains("Differs from the version in this binary"), "{stdout}");
|
||||
assert!(stdout.contains("--force"), "{stdout}");
|
||||
assert!(stdout.contains("--print"), "the message never says how to compare: {stdout}");
|
||||
assert!(
|
||||
stdout.contains("--print"),
|
||||
"the message never says how to compare: {stdout}"
|
||||
);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(installed(&home)).unwrap(),
|
||||
"hand written\n",
|
||||
@@ -186,7 +188,10 @@ fn print_without_a_name_says_which_names_there_are() {
|
||||
assert_ne!(out.status.code(), Some(0), "{stderr}");
|
||||
assert!(stderr.contains("name the skill to print"), "{stderr}");
|
||||
assert!(stderr.contains("worklane-review"), "{stderr}");
|
||||
assert!(String::from_utf8_lossy(&out.stdout).is_empty(), "a document was printed anyway");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).is_empty(),
|
||||
"a document was printed anyway"
|
||||
);
|
||||
}
|
||||
|
||||
/// The command has to be findable by someone who does not already know it exists.
|
||||
|
||||
+243
-6
@@ -191,7 +191,11 @@ fn ls_handles_short_and_non_ascii_filenames() {
|
||||
}
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
|
||||
cmd.current_dir(temp.path())
|
||||
.arg("ls")
|
||||
.arg("backlog")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout.matches("Odd Name").count(), 3);
|
||||
@@ -209,7 +213,11 @@ fn ls_survives_a_malformed_created_at() {
|
||||
.unwrap();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
|
||||
cmd.current_dir(temp.path())
|
||||
.arg("ls")
|
||||
.arg("backlog")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Bad Date"));
|
||||
@@ -290,7 +298,10 @@ fn ls_shows_a_mark_for_the_level() {
|
||||
|
||||
// Piped, so no escapes: the glyph is carrying the level by itself
|
||||
assert!(!stdout.contains('\u{1b}'));
|
||||
assert!(stdout.contains("\u{25cf}\u{25cf} "), "no full meter for level 1 in {stdout:?}");
|
||||
assert!(
|
||||
stdout.contains("\u{25cf}\u{25cf} "),
|
||||
"no full meter for level 1 in {stdout:?}"
|
||||
);
|
||||
assert!(stdout.contains("\u{25cb}\u{25cb} "), "no empty meter for level 5");
|
||||
assert!(stdout.contains("\u{b7}\u{b7} "), "no unset mark");
|
||||
// The raw number is not what the listing shows
|
||||
@@ -340,7 +351,10 @@ fn ls_filters_by_tag_and_composes_with_status_and_priority() {
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Tagged bug"), "{stdout}");
|
||||
assert!(stdout.contains("Lower bug"), "{stdout}");
|
||||
assert!(stdout.contains("Started bug"), "a tagged ticket in another status was dropped");
|
||||
assert!(
|
||||
stdout.contains("Started bug"),
|
||||
"a tagged ticket in another status was dropped"
|
||||
);
|
||||
assert!(!stdout.contains("Tagged feature"), "an untagged ticket came through");
|
||||
// The counts are filtered too, since they are the same collect.
|
||||
assert!(stdout.contains("[BACKLOG] 2 tickets"), "{stdout}");
|
||||
@@ -436,8 +450,7 @@ fn ls_never_matches_a_ticket_carrying_no_tags() {
|
||||
// Nor does an empty tag reach the filter: the value parser refuses it, so nothing is
|
||||
// listed rather than everything.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", ""]);
|
||||
cmd.current_dir(temp.path()).args(["ls", "backlog", "--tag", ""]);
|
||||
cmd.assert().failure().code(2);
|
||||
}
|
||||
|
||||
@@ -470,3 +483,227 @@ 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}");
|
||||
}
|
||||
|
||||
+188
-12
@@ -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]
|
||||
@@ -463,7 +473,9 @@ fn stray_files(worklane: &std::path::Path) -> Vec<String> {
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| !["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str()))
|
||||
.filter(|name| {
|
||||
!["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str())
|
||||
})
|
||||
.collect();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
@@ -512,10 +524,7 @@ fn mv_never_leaves_stale_content_in_the_target_directory() {
|
||||
let moved = worklane.join("committed").join(&filename);
|
||||
assert!(moved.exists(), "ticket did not move");
|
||||
let content = fs::read_to_string(&moved).unwrap();
|
||||
assert!(
|
||||
content.contains("- **Status**: committed"),
|
||||
"stale status: {content:?}"
|
||||
);
|
||||
assert!(content.contains("- **Status**: committed"), "stale status: {content:?}");
|
||||
assert!(!content.contains("- **Status**: backlog"), "{content:?}");
|
||||
|
||||
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
|
||||
@@ -621,10 +630,7 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
|
||||
] {
|
||||
fs::write(
|
||||
worklane.join("backlog").join(format!("{}_foo.md", uuid)),
|
||||
format!(
|
||||
"# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n",
|
||||
uuid
|
||||
),
|
||||
format!("# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n", uuid),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
@@ -878,3 +884,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);
|
||||
}
|
||||
|
||||
+9
-17
@@ -118,11 +118,7 @@ fn a_target_resolves_by_uuid_prefix_title_or_filename() {
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", search]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{search}: {}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(out.status.success(), "{search}: {}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
ticket(&worklane, GATED).contains(&format!("- blocked by {}", BLOCKER)),
|
||||
"{search}: {}",
|
||||
@@ -249,11 +245,7 @@ fn a_relation_already_held_reports_no_change_and_writes_nothing() {
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
assert!(out.status.success());
|
||||
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
||||
assert_eq!(
|
||||
ticket(&worklane, GATED),
|
||||
before,
|
||||
"the relation was recorded twice"
|
||||
);
|
||||
assert_eq!(ticket(&worklane, GATED), before, "the relation was recorded twice");
|
||||
}
|
||||
|
||||
/// One direction is stored. The inverse is derived by a scan, so the ticket at the
|
||||
@@ -354,7 +346,9 @@ fn show_lists_the_relation_the_other_ticket_holds() {
|
||||
// `relates to` is symmetric, so it reads the same way from either end.
|
||||
let shown = stdout(&run(&temp, &["show", FIXED]));
|
||||
assert!(
|
||||
shown.contains(&format!("relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one")),
|
||||
shown.contains(&format!(
|
||||
"relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one"
|
||||
)),
|
||||
"{shown}"
|
||||
);
|
||||
}
|
||||
@@ -382,12 +376,10 @@ fn a_line_that_is_not_a_relation_is_an_error() {
|
||||
let worklane = board(&temp);
|
||||
|
||||
let path = find(&worklane, GATED);
|
||||
let content = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace(
|
||||
"## Metadata",
|
||||
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
|
||||
);
|
||||
let content = fs::read_to_string(&path).unwrap().replace(
|
||||
"## Metadata",
|
||||
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
|
||||
);
|
||||
fs::write(&path, content).unwrap();
|
||||
|
||||
let out = run(&temp, &["show", GATED]);
|
||||
|
||||
+318
-37
@@ -94,13 +94,20 @@ fn set_replaces_each_field_it_is_given() {
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"set", UUID,
|
||||
"--description", "Only paragraph.",
|
||||
"--acceptance", "New crit",
|
||||
"--plan", "New step",
|
||||
"--tags", "beta,gamma",
|
||||
"--due", "2026-12-31",
|
||||
"--priority", "1",
|
||||
"set",
|
||||
UUID,
|
||||
"--description",
|
||||
"Only paragraph.",
|
||||
"--acceptance",
|
||||
"New crit",
|
||||
"--plan",
|
||||
"New step",
|
||||
"--tags",
|
||||
"beta,gamma",
|
||||
"--due",
|
||||
"2026-12-31",
|
||||
"--priority",
|
||||
"1",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
@@ -190,7 +197,11 @@ fn set_reports_only_the_fields_that_changed() {
|
||||
assert!(!stdout.contains("due"), "{stdout:?}");
|
||||
}
|
||||
|
||||
/// An empty scalar looks like a way to clear a field, and clearing is not supported.
|
||||
/// An empty scalar is still a usage error, and the message now points at the flag that
|
||||
/// does clear a field, so the two do not contradict each other.
|
||||
///
|
||||
/// `--title` is the exception, and says only that the value cannot be empty: a title has
|
||||
/// no unset state to return to, so there is nothing to point at.
|
||||
#[test]
|
||||
fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
@@ -198,12 +209,244 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for flag in ["--title", "--due", "--tags"] {
|
||||
for (flag, expected) in [
|
||||
("--title", "value cannot be empty"),
|
||||
("--due", "use --clear"),
|
||||
("--tags", "use --clear"),
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, flag, ""]);
|
||||
assert_eq!(out.status.code(), Some(2), "{flag} was accepted");
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
|
||||
"{flag}: {:?}",
|
||||
!stderr.contains("not supported"),
|
||||
"{flag} still says clearing is unsupported: {stderr:?}"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty value is a paragraph break for a section, so it cannot also mean empty the
|
||||
/// section. The error names the flag that does, per section.
|
||||
#[test]
|
||||
fn set_refuses_an_empty_section_and_names_the_clear_for_it() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for (flag, expected) in [
|
||||
("--description", "--clear description"),
|
||||
("--acceptance", "--clear acceptance"),
|
||||
("--plan", "--clear plan"),
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, flag, ""]);
|
||||
assert_eq!(out.status.code(), Some(1), "{flag} was accepted");
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
|
||||
}
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// Every field `--clear` reaches, in one call, back to what a ticket is born with.
|
||||
#[test]
|
||||
fn clear_returns_every_field_it_reaches_to_unset() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"set",
|
||||
UUID,
|
||||
"--clear",
|
||||
"due",
|
||||
"--clear",
|
||||
"tags",
|
||||
"--clear",
|
||||
"priority",
|
||||
"--clear",
|
||||
"description",
|
||||
"--clear",
|
||||
"acceptance",
|
||||
"--clear",
|
||||
"plan",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Due**: _Not set_"), "{content}");
|
||||
assert!(content.contains("- **Tags**: _None_"), "{content}");
|
||||
assert!(content.contains("- **Priority**: _Not set_"), "{content}");
|
||||
assert!(
|
||||
content.contains("## Description\n_No description provided._\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains("## Acceptance Criteria\n_No acceptance criteria provided._\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains("## Implementation Plan\n_No implementation plan provided._\n"),
|
||||
"{content}"
|
||||
);
|
||||
|
||||
// The placeholder goes in bare, not dressed as an item of the section it replaces.
|
||||
assert!(!content.contains("- [ ] _No"), "{content}");
|
||||
assert!(!content.contains("1. _No"), "{content}");
|
||||
|
||||
// What --clear cannot reach is untouched, the handwritten section included.
|
||||
assert!(content.starts_with("# Original title\n"), "{content}");
|
||||
assert!(content.contains("- **Owner**: alice"), "{content}");
|
||||
assert!(content.contains("- **Status**: backlog"), "{content}");
|
||||
assert!(
|
||||
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
||||
"{content}"
|
||||
);
|
||||
}
|
||||
|
||||
/// A cleared ticket and one that was never given the field have to read the same, or
|
||||
/// clearing would be its own third state.
|
||||
#[test]
|
||||
fn a_cleared_ticket_reads_like_one_filed_without_the_fields() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
run(&temp, &["add", "--title", "Bare"]);
|
||||
run(
|
||||
&temp,
|
||||
&[
|
||||
"add",
|
||||
"--title",
|
||||
"Full",
|
||||
"--description",
|
||||
"A body.",
|
||||
"--acceptance",
|
||||
"One criterion",
|
||||
"--plan",
|
||||
"One step",
|
||||
"--tags",
|
||||
"alpha,beta",
|
||||
"--due",
|
||||
"2026-09-01",
|
||||
"--priority",
|
||||
"2",
|
||||
],
|
||||
);
|
||||
|
||||
let full = added(&worklane, "full");
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"set",
|
||||
&full.0,
|
||||
"--clear",
|
||||
"due",
|
||||
"--clear",
|
||||
"tags",
|
||||
"--clear",
|
||||
"priority",
|
||||
"--clear",
|
||||
"description",
|
||||
"--clear",
|
||||
"acceptance",
|
||||
"--clear",
|
||||
"plan",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let cleared = comparable(&fs::read_to_string(&full.1).unwrap());
|
||||
let bare = comparable(&fs::read_to_string(&added(&worklane, "bare").1).unwrap());
|
||||
assert_eq!(cleared, bare);
|
||||
}
|
||||
|
||||
/// The uuid and the file of the one ticket whose slug matches, as `add` wrote it.
|
||||
fn added(worklane: &Path, slug: &str) -> (String, PathBuf) {
|
||||
let entry = fs::read_dir(worklane.join("backlog"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.find(|e| e.file_name().to_string_lossy().ends_with(&format!("_{slug}.md")))
|
||||
.unwrap_or_else(|| panic!("no ticket slugged {slug}"));
|
||||
let name = entry.file_name().into_string().unwrap();
|
||||
let uuid = name.split('_').next().unwrap().to_string();
|
||||
(uuid, entry.path())
|
||||
}
|
||||
|
||||
/// A ticket without the three lines that are different by definition: its title, its
|
||||
/// uuid and the moment it was filed.
|
||||
fn comparable(content: &str) -> String {
|
||||
content
|
||||
.lines()
|
||||
.filter(|line| {
|
||||
!line.starts_with("# ")
|
||||
&& !line.contains("**ID**:")
|
||||
&& !line.contains("**Created At**:")
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
/// Nothing to take away is not a rewrite, per the same whole-file comparison a
|
||||
/// replacement uses.
|
||||
#[test]
|
||||
fn clearing_a_field_that_is_already_unset_is_no_change() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
|
||||
assert!(out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
/// Replaced and emptied are reported in those words, since a caller doing both in one
|
||||
/// call cannot tell which happened to which field otherwise.
|
||||
#[test]
|
||||
fn clear_is_reported_apart_from_a_replacement() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--priority", "1", "--clear", "due"]);
|
||||
assert!(out.status.success());
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert!(stdout.contains("Updated priority on 'Original title'"), "{stdout:?}");
|
||||
assert!(stdout.contains("Cleared due on 'Original title'"), "{stdout:?}");
|
||||
}
|
||||
|
||||
/// Replacing and clearing one field in a single call is a contradiction, and answering
|
||||
/// it by whichever was applied last would be a silent answer.
|
||||
#[test]
|
||||
fn clearing_and_replacing_the_same_field_is_refused() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for (flag, value, field) in [
|
||||
("--due", "2026-12-31", "due"),
|
||||
("--tags", "beta", "tags"),
|
||||
("--priority", "1", "priority"),
|
||||
("--acceptance", "A criterion", "acceptance"),
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, flag, value, "--clear", field]);
|
||||
assert_eq!(out.status.code(), Some(1), "{flag} with --clear {field} was accepted");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("contradict each other"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
@@ -211,25 +454,45 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty value is a paragraph break for a section, so an all-blank one is a
|
||||
/// clearing attempt rather than a break.
|
||||
/// The fields no writer of `set` can reach are not reachable through `--clear` either,
|
||||
/// and an unknown one is a usage error listing what is.
|
||||
#[test]
|
||||
fn set_refuses_to_clear_a_section() {
|
||||
fn clear_refuses_a_field_it_does_not_own() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--description", ""]);
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing is not supported"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
for field in [
|
||||
"owner",
|
||||
"title",
|
||||
"status",
|
||||
"campaign",
|
||||
"relations",
|
||||
"nonsense",
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, "--clear", field]);
|
||||
assert_eq!(out.status.code(), Some(2), "--clear {field} was accepted");
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("possible values"), "{field}: {stderr:?}");
|
||||
}
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// `--clear` on its own satisfies the at-least-one-field rule, since it is a field
|
||||
/// being written like any other.
|
||||
#[test]
|
||||
fn clear_alone_is_enough_of_a_field() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--clear", "due"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(ticket(&worklane).contains("- **Due**: _Not set_"));
|
||||
}
|
||||
|
||||
/// A bare `set <ticket>` would otherwise be a silent no-op.
|
||||
#[test]
|
||||
fn set_requires_at_least_one_field() {
|
||||
@@ -248,10 +511,7 @@ fn set_keeps_a_paragraph_break_in_a_replaced_description() {
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(
|
||||
&temp,
|
||||
&["set", UUID, "-d", "One.", "-d", "", "-d", "Two."],
|
||||
);
|
||||
run(&temp, &["set", UUID, "-d", "One.", "-d", "", "-d", "Two."]);
|
||||
|
||||
assert!(
|
||||
ticket(&worklane).contains("## Description\nOne.\n\nTwo.\n\n## Acceptance"),
|
||||
@@ -268,7 +528,14 @@ fn set_accepts_prose_that_begins_with_a_hyphen() {
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&["set", UUID, "-a", "--print should be supported", "-t", "-t is the title flag"],
|
||||
&[
|
||||
"set",
|
||||
UUID,
|
||||
"-a",
|
||||
"--print should be supported",
|
||||
"-t",
|
||||
"-t is the title flag",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
@@ -296,11 +563,16 @@ fn append_adds_a_paragraph_items_and_numbered_steps() {
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"append", UUID,
|
||||
"-d", "A third paragraph.",
|
||||
"-a", "Crit three",
|
||||
"-a", "Crit four",
|
||||
"-p", "Step three",
|
||||
"append",
|
||||
UUID,
|
||||
"-d",
|
||||
"A third paragraph.",
|
||||
"-a",
|
||||
"Crit three",
|
||||
"-a",
|
||||
"Crit four",
|
||||
"-p",
|
||||
"Step three",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
@@ -315,10 +587,7 @@ fn append_adds_a_paragraph_items_and_numbered_steps() {
|
||||
"{content}"
|
||||
);
|
||||
// Numbered on from the last step, and the steps above are untouched
|
||||
assert!(
|
||||
content.contains("1. Step one\n2. Step two\n3. Step three\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.contains("1. Step one\n2. Step two\n3. Step three\n"), "{content}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -342,14 +611,26 @@ fn append_replaces_an_empty_section_rather_than_following_its_placeholder() {
|
||||
|
||||
run(
|
||||
&temp,
|
||||
&["append", &uuid, "-d", "A description arrives late.", "-a", "First crit", "-p", "First step"],
|
||||
&[
|
||||
"append",
|
||||
&uuid,
|
||||
"-d",
|
||||
"A description arrives late.",
|
||||
"-a",
|
||||
"First crit",
|
||||
"-p",
|
||||
"First step",
|
||||
],
|
||||
);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(!content.contains("_No description provided._"), "{content}");
|
||||
assert!(!content.contains("_No acceptance criteria provided._"), "{content}");
|
||||
assert!(!content.contains("_No implementation plan provided._"), "{content}");
|
||||
assert!(content.contains("## Description\nA description arrives late.\n"), "{content}");
|
||||
assert!(
|
||||
content.contains("## Description\nA description arrives late.\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.contains("## Implementation Plan\n1. First step\n"), "{content}");
|
||||
}
|
||||
|
||||
|
||||
+38
-6
@@ -350,7 +350,10 @@ fn show_disambiguates_tickets_with_non_ascii_filenames() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
for (filename, title) in [("émigré-un.md", "Accented One"), ("日本語-二.md", "Accented Two")] {
|
||||
for (filename, title) in [
|
||||
("émigré-un.md", "Accented One"),
|
||||
("日本語-二.md", "Accented Two"),
|
||||
] {
|
||||
fs::write(
|
||||
worklane.join("backlog").join(filename),
|
||||
format!("# {}\n\n## Metadata\n\n- **ID**: 1234\n", title),
|
||||
@@ -444,11 +447,7 @@ fn show_prints_the_title_once() {
|
||||
cmd.current_dir(temp.path()).arg("show").arg("Once Only");
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
|
||||
assert_eq!(
|
||||
stdout.matches("Once Only").count(),
|
||||
1,
|
||||
"title repeated in {stdout:?}"
|
||||
);
|
||||
assert_eq!(stdout.matches("Once Only").count(), 1, "title repeated in {stdout:?}");
|
||||
// The rule under it is still the width of the title
|
||||
assert!(stdout.contains("Once Only\n─────────\n"), "{stdout:?}");
|
||||
}
|
||||
@@ -489,6 +488,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(
|
||||
|
||||
+3
-12
@@ -44,10 +44,7 @@ fn the_tui_outside_a_worklane_directory_gives_the_usual_message() {
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1), "{args:?}");
|
||||
assert!(
|
||||
stderr.contains("No .worklane directory found"),
|
||||
"{args:?}: {stderr:?}"
|
||||
);
|
||||
assert!(stderr.contains("No .worklane directory found"), "{args:?}: {stderr:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -66,10 +63,7 @@ fn the_tui_without_a_terminal_says_so_and_names_an_alternative() {
|
||||
assert_eq!(out.status.code(), Some(1), "{args:?}");
|
||||
assert!(stderr.contains("needs a terminal"), "{args:?}: {stderr:?}");
|
||||
assert!(stderr.contains("worklane ls"), "{args:?}: {stderr:?}");
|
||||
assert!(
|
||||
!stderr.contains("os error"),
|
||||
"the raw mode error leaked: {stderr:?}"
|
||||
);
|
||||
assert!(!stderr.contains("os error"), "the raw mode error leaked: {stderr:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -105,10 +99,7 @@ fn several_path_arguments_are_accepted() {
|
||||
let first = setup_project(&temp, "first");
|
||||
let second = setup_project(&temp, "second");
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&["tui", first.to_str().unwrap(), second.to_str().unwrap()],
|
||||
);
|
||||
let out = run(&temp, &["tui", first.to_str().unwrap(), second.to_str().unwrap()]);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1), "{stderr:?}");
|
||||
|
||||
Reference in New Issue
Block a user