Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
cc5f9b8a46 | ||
|
|
175c1d016d | ||
|
|
139c9b012f | ||
|
|
373ba519b3 |
@@ -3,6 +3,7 @@
|
|||||||
## Project Structure
|
## Project Structure
|
||||||
- `src/main.rs` - dispatch, the SIGPIPE reset, and the TUI event loop
|
- `src/main.rs` - dispatch, the SIGPIPE reset, and the TUI event loop
|
||||||
- `src/command.rs` - CLI argument definitions using clap derive
|
- `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/handlers.rs` - one `cmd_*` per subcommand
|
||||||
- `src/util.rs` - the ticket format, resolution, rendering and the palette
|
- `src/util.rs` - the ticket format, resolution, rendering and the palette
|
||||||
- `src/campaign.rs` - the campaign file format, its resolution, its index and its members
|
- `src/campaign.rs` - the campaign file format, its resolution, its index and its members
|
||||||
@@ -20,7 +21,8 @@
|
|||||||
## Ticket File Format
|
## Ticket File Format
|
||||||
- Filenames: `<uuid_v4>_<slug>.md`
|
- 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
|
- 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`
|
- Format: `**Field Name**: value`
|
||||||
- Ticket structure: `# Title` → `## Description` → `## Acceptance Criteria` → `## Implementation Plan` → `## Metadata`
|
- Ticket structure: `# Title` → `## Description` → `## Acceptance Criteria` → `## Implementation Plan` → `## Metadata`
|
||||||
- Comments stored in `.worklane/comments/<ticket_uuid>/<timestamp>.md` with `**Comment**`, `**Author**`, `**Time**` fields
|
- Comments stored in `.worklane/comments/<ticket_uuid>/<timestamp>.md` with `**Comment**`, `**Author**`, `**Time**` fields
|
||||||
@@ -57,13 +59,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
|
- **`--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
|
- **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
|
- **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`
|
- 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
|
- 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
|
- `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
|
- **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
|
- `--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
|
### 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
|
- **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
|
- **`--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 +84,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
|
- **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
|
- **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
|
- 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
|
### 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
|
- `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
|
- `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
|
- `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
|
- 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 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
|
- 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
|
- 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
|
- `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
|
- `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 +336,7 @@ 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 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
|
- 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)
|
- 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 both, plus the two hyphenated spellings an earlier version wrote
|
||||||
|
|
||||||
### Git Workflow
|
### Git Workflow
|
||||||
- Commit format: `([ticketID]) [short description]`
|
- Commit format: `([ticketID]) [short description]`
|
||||||
|
|||||||
Generated
+11
-1
@@ -208,6 +208,15 @@ dependencies = [
|
|||||||
"strsim",
|
"strsim",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "clap_complete"
|
||||||
|
version = "4.6.9"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "3be2ad0423bdbbb0e25bc89add796f3559706d4a95e1bc98e4d9662a957b6a19"
|
||||||
|
dependencies = [
|
||||||
|
"clap",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "clap_derive"
|
name = "clap_derive"
|
||||||
version = "4.6.1"
|
version = "4.6.1"
|
||||||
@@ -1494,13 +1503,14 @@ dependencies = [
|
|||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "worklane"
|
name = "worklane"
|
||||||
version = "0.16.1"
|
version = "0.18.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"anyhow",
|
"anyhow",
|
||||||
"assert_cmd",
|
"assert_cmd",
|
||||||
"assert_fs",
|
"assert_fs",
|
||||||
"chrono",
|
"chrono",
|
||||||
"clap",
|
"clap",
|
||||||
|
"clap_complete",
|
||||||
"crossterm",
|
"crossterm",
|
||||||
"libc",
|
"libc",
|
||||||
"ratatui",
|
"ratatui",
|
||||||
|
|||||||
+2
-1
@@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "worklane"
|
name = "worklane"
|
||||||
version = "0.16.1"
|
version = "0.18.0"
|
||||||
edition = "2024"
|
edition = "2024"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
@@ -14,6 +14,7 @@ libc = "0.2"
|
|||||||
# widget until one of us changed.
|
# widget until one of us changed.
|
||||||
ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] }
|
ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] }
|
||||||
crossterm = "0.28"
|
crossterm = "0.28"
|
||||||
|
clap_complete = "4.6.9"
|
||||||
|
|
||||||
[dev-dependencies]
|
[dev-dependencies]
|
||||||
assert_cmd = "2"
|
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` 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 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 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 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 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 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 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 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 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 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 |
|
| `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
|
## Exit codes
|
||||||
| Code | Meaning |
|
| Code | Meaning |
|
||||||
|------|---------|
|
|------|---------|
|
||||||
| 0 | Success |
|
| 0 | Success |
|
||||||
| 1 | An error, such as no matching ticket or an ambiguous search |
|
| 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 | 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
|
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.**
|
**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
|
Every job here writes to many tickets at once, and nothing on the board records what a
|
||||||
yet, so a date written onto the wrong ticket can only be overwritten, never taken off. A wrong
|
field held before you wrote to it. `--clear` puts a field back to unset, which is **not
|
||||||
edit to one ticket is a mistake; a wrong sweep is thirty of them with no undo. So a
|
back to what it held**, so a date written over another date is gone. A wrong edit to one
|
||||||
proposal is a list, one line per intended edit, each naming the ticket and the command
|
ticket is a mistake; a wrong sweep is thirty of them with no undo. So a proposal is a
|
||||||
that would make it:
|
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
|
(1b78a24) priority 3 -> 1 worklane set 1b78a24 --priority 1
|
||||||
@@ -37,10 +38,10 @@ other way is editing the file by hand:
|
|||||||
|
|
||||||
| Field | Writer |
|
| 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` |
|
| Relations | `worklane relate <ticket> --blocked-by` / `--regression-of` / `--relates-to` |
|
||||||
| Campaign membership | `worklane assign <campaign> <ticket>` |
|
| 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>` |
|
| Status | `worklane mv <ticket> --status <target>` |
|
||||||
|
|
||||||
**Never edit a ticket file directly.** The filename, the `Status` field and the directory
|
**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
|
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
|
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
|
the format. A date can be taken off again with `worklane set <ticket> --clear due`. What
|
||||||
replaced by another date, so a plan applied to the wrong ticket has no undo.
|
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
|
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.
|
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
|
whole backlog produces a board where every ticket is late, which is the same as no
|
||||||
dates at all.
|
dates at all.
|
||||||
- **Do not date `done`.** It is finished; a date on it is noise in every listing.
|
- **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
|
## Tags
|
||||||
|
|
||||||
`worklane set <ticket> --tags bug,cli` is the writer, and it **replaces the whole
|
`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.
|
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
|
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:
|
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
|
A move is also refused while the ticket is blocked by one that is not done yet, see
|
||||||
[Relating tickets](#relating-tickets).
|
[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
|
## 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.
|
`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:
|
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
|
`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
|
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:
|
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 --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 --acceptance "One more criterion"
|
||||||
worklane append 1b78a24 --description "What was learned since."
|
worklane append 1b78a24 --description "What was learned since."
|
||||||
worklane chown alice 1b78a24 # hand the ticket to someone
|
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
|
`set` replaces, `append` adds, `--clear` empties. Neither `set` nor `append` has
|
||||||
and status is `mv`'s, so each field has exactly one writer. A field set to the value it
|
`--owner` or `--status`: owner is `chown`'s and status is `mv`'s, so each field has
|
||||||
already holds is reported unchanged and nothing is written.
|
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
|
`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
|
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
|
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
|
`worklane init` creates `.worklane/` with the four status directories and the campaigns
|
||||||
directory beside them, for a repo that has no board yet.
|
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>`
|
- Related but not the same: file it, and record it with `relate <new> --relates-to <old>`
|
||||||
rather than only mentioning the id in prose.
|
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
|
## Addressing a ticket
|
||||||
|
|
||||||
Every command that takes a ticket accepts, in this order of precedence:
|
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`.
|
`worklane mv --status committed -- -leading-title`.
|
||||||
- A comment body of exactly `--` needs its own separator:
|
- A comment body of exactly `--` needs its own separator:
|
||||||
`worklane comment 1b78a24 -- --`.
|
`worklane comment 1b78a24 -- --`.
|
||||||
- An empty value for a scalar is a usage error. Clearing a field back to unset is not
|
- An empty value for a scalar is a usage error, not a way to clear the field: use
|
||||||
supported yet.
|
`--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.
|
- Piping is safe: `worklane ls | head -3` exits on the closed pipe instead of panicking.
|
||||||
|
|||||||
+145
-36
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
|
|||||||
|
|
||||||
use chrono::NaiveDate;
|
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
|
/// 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.
|
/// 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
|
/// Reject an empty value at parse time, so it lands as a usage error rather than a
|
||||||
/// runtime one.
|
/// runtime one.
|
||||||
///
|
///
|
||||||
/// An empty value looks like a way to clear a field, and clearing is not supported
|
/// Two messages rather than one, because the arguments that use this fall into two
|
||||||
/// yet. Refusing it keeps the gap visible and stops an accidentally empty variable
|
/// kinds. A search term or a title has no empty form at all, and that is all this says.
|
||||||
/// from silently blanking a field. Only the scalars use this: for the multi-line
|
/// A field that *can* be emptied says so and names `--clear`, which is [`clearable`]
|
||||||
/// sections an empty value is a paragraph break.
|
/// 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> {
|
fn non_empty(raw: &str) -> Result<String, String> {
|
||||||
if raw.trim().is_empty() {
|
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())
|
Ok(raw.to_string())
|
||||||
@@ -73,7 +91,7 @@ fn non_empty(raw: &str) -> Result<String, String> {
|
|||||||
fn iso_date(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
|
// 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.
|
// 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 bytes = raw.as_bytes();
|
||||||
let shaped = raw.len() == 10 && bytes[4] == b'-' && bytes[7] == b'-';
|
let shaped = raw.len() == 10 && bytes[4] == b'-' && bytes[7] == b'-';
|
||||||
@@ -112,22 +130,7 @@ pub enum Command {
|
|||||||
|
|
||||||
/// List tickets, optionally filtered by status
|
/// List tickets, optionally filtered by status
|
||||||
#[command(after_help = PRIORITY_LEGEND.as_str())]
|
#[command(after_help = PRIORITY_LEGEND.as_str())]
|
||||||
Ls {
|
Ls(LsArgs),
|
||||||
/// 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>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Show a ticket by UUID or title
|
/// Show a ticket by UUID or title
|
||||||
Show {
|
Show {
|
||||||
@@ -140,9 +143,9 @@ pub enum Command {
|
|||||||
/// Ticket UUID or title
|
/// Ticket UUID or title
|
||||||
ticket: String,
|
ticket: String,
|
||||||
|
|
||||||
/// Target status (backlog, committed, reviewing, done)
|
/// Target status
|
||||||
#[arg(short, long)]
|
#[arg(short, long)]
|
||||||
status: String,
|
status: Status,
|
||||||
|
|
||||||
/// Force move (allows backward or non-sequential moves)
|
/// Force move (allows backward or non-sequential moves)
|
||||||
#[arg(short, long)]
|
#[arg(short, long)]
|
||||||
@@ -158,7 +161,7 @@ pub enum Command {
|
|||||||
/// Record a relation from one ticket to another
|
/// Record a relation from one ticket to another
|
||||||
Relate(RelateArgs),
|
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
|
/// User first, ticket second, after Unix `chown`. That reverses the ticket-first
|
||||||
/// order `mv`, `comment` and `show` use, deliberately: the name borrows the Unix
|
/// 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
|
/// 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
|
/// only when both arguments resolve, which needs a ticket whose title matches the
|
||||||
/// username.
|
/// username.
|
||||||
Chown {
|
Chown(ChownArgs),
|
||||||
/// New owner. Free text, like `add --owner`, checked against nothing
|
|
||||||
#[arg(value_parser = non_empty)]
|
|
||||||
user: String,
|
|
||||||
|
|
||||||
/// Ticket UUID or title
|
|
||||||
ticket: String,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Open the board view
|
/// Open the board view
|
||||||
Tui {
|
Tui {
|
||||||
@@ -227,6 +223,16 @@ pub enum Command {
|
|||||||
ticket: String,
|
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
|
/// Install the agent skills that teach an agent to use worklane
|
||||||
///
|
///
|
||||||
/// Every shipped document by default. The optional name narrows it to one, and
|
/// Every shipped document by default. The optional name narrows it to one, and
|
||||||
@@ -288,6 +294,33 @@ pub struct CampaignAddArgs {
|
|||||||
pub owner: Option<String>,
|
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
|
/// `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
|
/// 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.
|
/// for, and `set`, `append` and `check` already pass their arguments this way.
|
||||||
@@ -339,7 +372,7 @@ pub struct AddArgs {
|
|||||||
clap::ArgGroup::new("set_fields")
|
clap::ArgGroup::new("set_fields")
|
||||||
.required(true)
|
.required(true)
|
||||||
.multiple(true)
|
.multiple(true)
|
||||||
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority"])
|
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority", "clear"])
|
||||||
))]
|
))]
|
||||||
pub struct SetArgs {
|
pub struct SetArgs {
|
||||||
/// Ticket UUID or title
|
/// Ticket UUID or title
|
||||||
@@ -362,7 +395,7 @@ pub struct SetArgs {
|
|||||||
pub plan: Vec<String>,
|
pub plan: Vec<String>,
|
||||||
|
|
||||||
/// Replace the tags
|
/// Replace the tags
|
||||||
#[arg(short = 'g', long, value_parser = non_empty)]
|
#[arg(short = 'g', long, value_parser = clearable)]
|
||||||
pub tags: Vec<String>,
|
pub tags: Vec<String>,
|
||||||
|
|
||||||
/// Replace the due date (YYYY-MM-DD)
|
/// Replace the due date (YYYY-MM-DD)
|
||||||
@@ -376,6 +409,82 @@ pub struct SetArgs {
|
|||||||
/// Replace the priority, 1 (most urgent) to 5 (least)
|
/// Replace the priority, 1 (most urgent) to 5 (least)
|
||||||
#[arg(long, value_parser = priority_level)]
|
#[arg(long, value_parser = priority_level)]
|
||||||
pub priority: Option<u8>,
|
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
|
/// `append` only offers the sections that hold multiple lines, since appending to a
|
||||||
|
|||||||
@@ -0,0 +1,320 @@
|
|||||||
|
//! 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}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
+166
-61
@@ -5,7 +5,9 @@ use std::io::{BufRead, IsTerminal, Write};
|
|||||||
use std::path::Path;
|
use std::path::Path;
|
||||||
|
|
||||||
use crate::campaign::*;
|
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::install;
|
||||||
use crate::util::*;
|
use crate::util::*;
|
||||||
|
|
||||||
@@ -23,8 +25,7 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
|||||||
|
|
||||||
fs::create_dir_all(&worklane_dir)?;
|
fs::create_dir_all(&worklane_dir)?;
|
||||||
|
|
||||||
let folders = ["backlog", "committed", "reviewing", "done"];
|
for folder in status_dirs() {
|
||||||
for folder in &folders {
|
|
||||||
fs::create_dir_all(worklane_dir.join(folder))?;
|
fs::create_dir_all(worklane_dir.join(folder))?;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -37,21 +38,22 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn cmd_ls(
|
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||||
status_filter: &Option<String>,
|
|
||||||
priority_filter: Option<u8>,
|
|
||||||
tag_filter: &Option<String>,
|
|
||||||
campaign_filter: &Option<String>,
|
|
||||||
worklane_dir: &Path,
|
|
||||||
) -> Result<()> {
|
|
||||||
// Resolved before anything is read, so an unknown campaign is refused rather than
|
// Resolved before anything is read, so an unknown campaign is refused rather than
|
||||||
// silently listing nothing, and the name is available for the heading.
|
// silently listing nothing, and the name is available for the heading. Ahead of the
|
||||||
let campaign = match campaign_filter {
|
// `--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)?),
|
Some(search) => Some(resolve_campaign(search, worklane_dir)?),
|
||||||
None => None,
|
None => None,
|
||||||
};
|
};
|
||||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
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 {
|
if let Some(campaign) = &campaign {
|
||||||
println!(
|
println!(
|
||||||
@@ -61,12 +63,18 @@ pub fn cmd_ls(
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
if let Some(status) = status_filter {
|
if let Some(status) = args.status {
|
||||||
|
let status = status.as_str();
|
||||||
let status_path = worklane_dir.join(status);
|
let status_path = worklane_dir.join(status);
|
||||||
if !status_path.exists() {
|
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!(
|
return Err(anyhow!(
|
||||||
"Status '{}' not found. Valid statuses: backlog, committed, reviewing, done",
|
"No '{}' directory in {}. Every board has all four; creating it is enough.",
|
||||||
status
|
status,
|
||||||
|
worklane_dir.display()
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -119,6 +127,47 @@ pub fn cmd_ls(
|
|||||||
Ok(())
|
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
|
/// The listing filters in one call, so the three places `ls` collects a column cannot
|
||||||
/// end up applying a different set of them.
|
/// end up applying a different set of them.
|
||||||
///
|
///
|
||||||
@@ -207,10 +256,6 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
|||||||
let filename = format!("{}_{}.md", id, slug);
|
let filename = format!("{}_{}.md", id, slug);
|
||||||
let filepath = backlog_dir.join(&filename);
|
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
|
// 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.
|
// paragraph break and an all-blank description is no description at all.
|
||||||
let description = trim_blank_ends(description);
|
let description = trim_blank_ends(description);
|
||||||
@@ -278,7 +323,21 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
|||||||
);
|
);
|
||||||
body.push('\n');
|
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);
|
println!("Created ticket: {}", filename);
|
||||||
Ok(())
|
Ok(())
|
||||||
@@ -562,29 +621,20 @@ fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()>
|
|||||||
))
|
))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -> Result<()> {
|
/// A status is a [`Status`] rather than a string, so an unknown one is clap's to refuse
|
||||||
let valid_statuses = ["backlog", "committed", "reviewing", "done"];
|
/// and nothing here has to check. What is left is the order of the flow, which is
|
||||||
let forward_order = ["backlog", "committed", "reviewing", "done"];
|
/// `Status::ALL`.
|
||||||
|
pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Result<()> {
|
||||||
if !valid_statuses.contains(&target_status) {
|
let target_status = target.as_str();
|
||||||
return Err(anyhow!(
|
|
||||||
"Invalid target status '{}'. Valid statuses: {}",
|
|
||||||
target_status,
|
|
||||||
valid_statuses.join(", ")
|
|
||||||
));
|
|
||||||
}
|
|
||||||
|
|
||||||
let worklane_dir = find_worklane_dir(start)?;
|
let worklane_dir = find_worklane_dir(start)?;
|
||||||
let (current_status, title, resolved) = resolve_ticket(ticket_id, &worklane_dir)?;
|
let (current_status, title, resolved) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||||
|
|
||||||
let current_idx = forward_order
|
let current_idx = Status::ALL
|
||||||
.iter()
|
.iter()
|
||||||
.position(|&s| s == current_status)
|
.position(|status| status.as_str() == current_status)
|
||||||
.unwrap();
|
|
||||||
let target_idx = forward_order
|
|
||||||
.iter()
|
|
||||||
.position(|&s| s == target_status)
|
|
||||||
.unwrap();
|
.unwrap();
|
||||||
|
let target_idx = Status::ALL.iter().position(|status| *status == target).unwrap();
|
||||||
|
|
||||||
if !force && target_idx < current_idx {
|
if !force && target_idx < current_idx {
|
||||||
return Err(anyhow!(
|
return Err(anyhow!(
|
||||||
@@ -622,6 +672,16 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
|
|||||||
// refused for that reason rather than for whatever the lookup notices first.
|
// refused for that reason rather than for whatever the lookup notices first.
|
||||||
let content = set_status_field(&resolved, target_status, &title)?;
|
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 =
|
let found_filename =
|
||||||
find_ticket_file(¤t_path, &parse_ticket_field(&resolved, "ID"), &title)?;
|
find_ticket_file(¤t_path, &parse_ticket_field(&resolved, "ID"), &title)?;
|
||||||
|
|
||||||
@@ -745,6 +805,19 @@ fn save_ticket(
|
|||||||
Ok(())
|
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) {
|
fn report(fields: &[&str], title: &str, verb: &str) {
|
||||||
if fields.is_empty() {
|
if fields.is_empty() {
|
||||||
println!("No changes to '{}'", color_text(title, Color::Green));
|
println!("No changes to '{}'", color_text(title, Color::Green));
|
||||||
@@ -760,25 +833,24 @@ fn report(fields: &[&str], title: &str, verb: &str) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
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 worklane_dir = find_worklane_dir(start)?;
|
||||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||||
let uuid = parse_ticket_field(&original, "ID");
|
let uuid = parse_ticket_field(&original, "ID");
|
||||||
|
|
||||||
let mut content = original.clone();
|
let mut content = original.clone();
|
||||||
let mut changed: Vec<&str> = Vec::new();
|
let mut changed: Vec<&str> = Vec::new();
|
||||||
|
let mut cleared: 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);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
if let Some(new_title) = &args.title {
|
if let Some(new_title) = &args.title {
|
||||||
let next = set_title(&content, new_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) {
|
for (section, values) in section_args(&args.description, &args.acceptance, &args.plan) {
|
||||||
@@ -789,32 +861,46 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
|||||||
let items = section.normalise(values);
|
let items = section.normalise(values);
|
||||||
if items.is_empty() {
|
if items.is_empty() {
|
||||||
return Err(anyhow!(
|
return Err(anyhow!(
|
||||||
"An empty {} is not a way to clear the section, and clearing is not supported yet",
|
"An empty value is a paragraph break, not a way to empty the {}: use --clear {}",
|
||||||
section.label
|
section.label,
|
||||||
|
section.clear.map_or("", Clearable::name)
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
|
||||||
let next = set_section_body(&content, section, &items)?;
|
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() {
|
if !args.tags.is_empty() {
|
||||||
let next = set_metadata_field(&content, "Tags", &args.tags.join(", "), &title)?;
|
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 {
|
if let Some(due) = &args.due {
|
||||||
let next = set_metadata_field(&content, "Due", due, &title)?;
|
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 {
|
if let Some(priority) = args.priority {
|
||||||
let next = set_metadata_field(&content, "Priority", &priority.to_string(), &title)?;
|
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() {
|
// Last, and into a list of their own. No field can be in both, since `contested`
|
||||||
report(&changed, &title, "Updated");
|
// 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(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -822,7 +908,12 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
|||||||
save_ticket(&worklane_dir, &status, &uuid, &title, renamed, &content)?;
|
save_ticket(&worklane_dir, &status, &uuid, &title, renamed, &content)?;
|
||||||
|
|
||||||
let shown = args.title.clone().unwrap_or(title);
|
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(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -835,13 +926,23 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
|||||||
/// stay silent on the one it cannot, a ticket whose title is the username.
|
/// 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
|
/// 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.
|
/// value it already holds is reported unchanged and nothing is written. The same
|
||||||
pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
/// 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 worklane_dir = find_worklane_dir(start)?;
|
||||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||||
let uuid = parse_ticket_field(&original, "ID");
|
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 {
|
if content == original {
|
||||||
report(&[], &title, "Updated");
|
report(&[], &title, "Updated");
|
||||||
@@ -850,7 +951,11 @@ pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
|||||||
|
|
||||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
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(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
+1
-1
@@ -387,7 +387,7 @@ mod tests {
|
|||||||
for required in [
|
for required in [
|
||||||
"Propose the whole set of edits",
|
"Propose the whole set of edits",
|
||||||
"replaces the whole\nfield", // `set --tags` is the destructive one
|
"replaces the whole\nfield", // `set --tags` is the destructive one
|
||||||
"cannot be cleared", // and a due date cannot be taken back
|
"not\nback to what it held", // and --clear is not an undo
|
||||||
"blocked by", // ordering constrains any dating plan
|
"blocked by", // ordering constrains any dating plan
|
||||||
"worklane campaign ls",
|
"worklane campaign ls",
|
||||||
"does not touch",
|
"does not touch",
|
||||||
|
|||||||
+10
-9
@@ -4,6 +4,7 @@ use clap::Parser;
|
|||||||
mod campaign;
|
mod campaign;
|
||||||
mod clipboard;
|
mod clipboard;
|
||||||
mod command;
|
mod command;
|
||||||
|
mod completions;
|
||||||
mod handlers;
|
mod handlers;
|
||||||
mod install;
|
mod install;
|
||||||
mod tui;
|
mod tui;
|
||||||
@@ -46,14 +47,9 @@ fn main() -> Result<()> {
|
|||||||
Some(Command::Tui { paths }) => run_tui(&paths, &start),
|
Some(Command::Tui { paths }) => run_tui(&paths, &start),
|
||||||
Some(Command::Init) => cmd_init(&start),
|
Some(Command::Init) => cmd_init(&start),
|
||||||
Some(Command::Add(args)) => cmd_add(&args, &start),
|
Some(Command::Add(args)) => cmd_add(&args, &start),
|
||||||
Some(Command::Ls {
|
Some(Command::Ls(args)) => {
|
||||||
status,
|
|
||||||
priority,
|
|
||||||
tag,
|
|
||||||
campaign,
|
|
||||||
}) => {
|
|
||||||
let worklane_dir = find_worklane_dir(&start)?;
|
let worklane_dir = find_worklane_dir(&start)?;
|
||||||
cmd_ls(&status, priority, &tag, &campaign, &worklane_dir)
|
cmd_ls(&args, &worklane_dir)
|
||||||
}
|
}
|
||||||
Some(Command::Show { id }) => {
|
Some(Command::Show { id }) => {
|
||||||
let worklane_dir = find_worklane_dir(&start)?;
|
let worklane_dir = find_worklane_dir(&start)?;
|
||||||
@@ -63,11 +59,11 @@ fn main() -> Result<()> {
|
|||||||
ticket,
|
ticket,
|
||||||
status,
|
status,
|
||||||
force,
|
force,
|
||||||
}) => cmd_mv(&ticket, &status, force, &start),
|
}) => cmd_mv(&ticket, status, force, &start),
|
||||||
Some(Command::Set(args)) => cmd_set(&args, &start),
|
Some(Command::Set(args)) => cmd_set(&args, &start),
|
||||||
Some(Command::Append(args)) => cmd_append(&args, &start),
|
Some(Command::Append(args)) => cmd_append(&args, &start),
|
||||||
Some(Command::Relate(args)) => cmd_relate(&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::Check(args)) => cmd_check(&args, true, &start),
|
||||||
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
||||||
Some(Command::Comment {
|
Some(Command::Comment {
|
||||||
@@ -87,6 +83,11 @@ fn main() -> Result<()> {
|
|||||||
}
|
}
|
||||||
},
|
},
|
||||||
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
|
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
|
// No board is looked for: the point of the skill is to teach an agent worklane
|
||||||
// before there is a `.worklane` anywhere.
|
// before there is a `.worklane` anywhere.
|
||||||
Some(Command::InstallSkill { skill, force, print }) => {
|
Some(Command::InstallSkill { skill, force, print }) => {
|
||||||
|
|||||||
+450
-9
@@ -936,9 +936,22 @@ fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> Strin
|
|||||||
result
|
result
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// What a scalar metadata field holds when it holds nothing.
|
||||||
|
///
|
||||||
|
/// A constant rather than a literal per site, because it is now written on purpose:
|
||||||
|
/// clearing a field puts it back, and the value it goes back to has to be the one `add`
|
||||||
|
/// wrote, or a cleared ticket and a never-set one would differ in the file.
|
||||||
|
pub const NOT_SET: &str = "_Not set_";
|
||||||
|
|
||||||
|
/// The same for Tags, which is a list.
|
||||||
|
///
|
||||||
|
/// A list that holds nothing reads as none rather than as not set, which is the
|
||||||
|
/// distinction `add` already makes and clearing has to keep.
|
||||||
|
pub const NONE: &str = "_None_";
|
||||||
|
|
||||||
pub fn is_unknown_value(value: &str) -> bool {
|
pub fn is_unknown_value(value: &str) -> bool {
|
||||||
let trimmed = value.trim();
|
let trimmed = value.trim();
|
||||||
trimmed == "_None_" || trimmed == "_Not set_" || trimmed == "-None-" || trimmed == "-Not set-"
|
trimmed == NONE || trimmed == NOT_SET || trimmed == "-None-" || trimmed == "-Not set-"
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Replace `**bold**` with colour, or leave the line exactly as it is.
|
/// Replace `**bold**` with colour, or leave the line exactly as it is.
|
||||||
@@ -1017,7 +1030,7 @@ pub fn parse_ticket_field(content: &str, field: &str) -> String {
|
|||||||
metadata_lines(content)
|
metadata_lines(content)
|
||||||
.find_map(|line| metadata_field_body(line).strip_prefix(&prefix))
|
.find_map(|line| metadata_field_body(line).strip_prefix(&prefix))
|
||||||
.map(|value| value.trim().to_string())
|
.map(|value| value.trim().to_string())
|
||||||
.unwrap_or_else(|| "_Not set_".to_string())
|
.unwrap_or_else(|| NOT_SET.to_string())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn is_status_line(line: &str) -> bool {
|
fn is_status_line(line: &str) -> bool {
|
||||||
@@ -1064,6 +1077,35 @@ fn set_metadata_line(
|
|||||||
if found { Some(updated) } else { None }
|
if found { Some(updated) } else { None }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Drop one field from the Metadata section, leaving every other line untouched.
|
||||||
|
///
|
||||||
|
/// Scoped to the section for the same reason as [`set_metadata_line`], and shaped like
|
||||||
|
/// it: nothing means there was no such field, so a caller that removes a field a ticket
|
||||||
|
/// never carried leaves the content exactly as it found it rather than rewriting it
|
||||||
|
/// into an identical string.
|
||||||
|
fn remove_metadata_line(content: &str, field: &str) -> Option<String> {
|
||||||
|
let prefix = format!("**{}**:", field);
|
||||||
|
let mut updated = String::with_capacity(content.len());
|
||||||
|
let mut in_metadata = false;
|
||||||
|
let mut found = false;
|
||||||
|
|
||||||
|
for line in content.lines() {
|
||||||
|
if line.starts_with("## ") {
|
||||||
|
in_metadata = is_metadata_heading(line);
|
||||||
|
}
|
||||||
|
|
||||||
|
if in_metadata && !found && metadata_field_body(line).starts_with(&prefix) {
|
||||||
|
found = true;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
updated.push_str(line);
|
||||||
|
updated.push('\n');
|
||||||
|
}
|
||||||
|
|
||||||
|
if found { Some(updated) } else { None }
|
||||||
|
}
|
||||||
|
|
||||||
pub fn set_status_field(content: &str, target_status: &str, title: &str) -> Result<String> {
|
pub fn set_status_field(content: &str, target_status: &str, title: &str) -> Result<String> {
|
||||||
set_metadata_line(content, "Status", target_status, is_status_line).ok_or_else(|| {
|
set_metadata_line(content, "Status", target_status, is_status_line).ok_or_else(|| {
|
||||||
anyhow!(
|
anyhow!(
|
||||||
@@ -1136,20 +1178,26 @@ pub fn parse_tags(content: &str) -> Vec<String> {
|
|||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The metadata fields in the order `add` writes them, with `Campaign` in its place
|
/// The metadata fields in the order `add` writes them, with the fields no ticket is
|
||||||
/// among them.
|
/// born with in their places among them.
|
||||||
///
|
///
|
||||||
/// The anchor list for inserting a field the file does not have yet, exactly as
|
/// The anchor list for inserting a field the file does not have yet, exactly as
|
||||||
/// [`SECTION_ORDER`] is for a missing section. Campaign sits beside Status because the
|
/// [`SECTION_ORDER`] is for a missing section. Campaign sits beside Status because the
|
||||||
/// two answer the same kind of question, where the ticket belongs rather than what it
|
/// two answer the same kind of question, where the ticket belongs rather than what it
|
||||||
/// is, and Status stays last, which is where every file already keeps it.
|
/// is, and Status stays last, which is where every file already keeps it. The three
|
||||||
const METADATA_ORDER: [&str; 8] = [
|
/// stamps follow `Created At`, since they answer the same question it does about a
|
||||||
|
/// later moment, and they are in flow order for a reader who sees one after another
|
||||||
|
/// across a board.
|
||||||
|
const METADATA_ORDER: [&str; 11] = [
|
||||||
"ID",
|
"ID",
|
||||||
"Priority",
|
"Priority",
|
||||||
"Tags",
|
"Tags",
|
||||||
"Due",
|
"Due",
|
||||||
"Owner",
|
"Owner",
|
||||||
"Created At",
|
"Created At",
|
||||||
|
COMMITTED_ON_FIELD,
|
||||||
|
SUBMITTED_ON_FIELD,
|
||||||
|
COMPLETED_ON_FIELD,
|
||||||
CAMPAIGN_FIELD,
|
CAMPAIGN_FIELD,
|
||||||
"Status",
|
"Status",
|
||||||
];
|
];
|
||||||
@@ -1228,6 +1276,52 @@ fn insert_metadata_field(content: &str, field: &str, value: &str, title: &str) -
|
|||||||
Ok(join_lines(&out))
|
Ok(join_lines(&out))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The metadata fields `mv` stamps with the time a ticket entered a status. Backlog has
|
||||||
|
// none: a ticket is filed there, and `Created At` already records when, so a fourth
|
||||||
|
// field would say the same thing for every ticket that has never moved.
|
||||||
|
pub const COMMITTED_ON_FIELD: &str = "Committed On";
|
||||||
|
pub const SUBMITTED_ON_FIELD: &str = "Submitted On";
|
||||||
|
pub const COMPLETED_ON_FIELD: &str = "Completed On";
|
||||||
|
|
||||||
|
/// Stamp the field of the status being entered and drop the other two.
|
||||||
|
///
|
||||||
|
/// A stamp is present exactly while the ticket sits in its status, so the three are
|
||||||
|
/// mutually exclusive: entering writes one, leaving removes it, and re-entering
|
||||||
|
/// restamps rather than keeping the first value. That is what keeps a ticket moved
|
||||||
|
/// backward under `-f` from carrying a `Completed On` for work it has undone, and it is
|
||||||
|
/// the line between these fields and d4ce964's history log. Metadata carries current
|
||||||
|
/// state, which is why `Status` is a field at all; the trail of how the ticket got here
|
||||||
|
/// belongs to the log, and a stamp left behind would be a second copy of that job.
|
||||||
|
///
|
||||||
|
/// The time comes in as a string rather than being read here, so the caller stamps the
|
||||||
|
/// same moment it reports and a test can pin the value.
|
||||||
|
pub fn set_status_stamp(content: &str, target: Status, now: &str, title: &str) -> Result<String> {
|
||||||
|
let mut content = content.to_string();
|
||||||
|
|
||||||
|
// Every status but the target, so a skipping move under `-f` clears the stamps of
|
||||||
|
// the stages it jumped over as well as the one it left.
|
||||||
|
for status in Status::ALL {
|
||||||
|
if status == target {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
let Some(field) = status.stamp_field() else {
|
||||||
|
continue;
|
||||||
|
};
|
||||||
|
|
||||||
|
if let Some(updated) = remove_metadata_line(&content, field) {
|
||||||
|
content = updated;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
match target.stamp_field() {
|
||||||
|
// Inserted on demand, the way Campaign is: every ticket written before these
|
||||||
|
// fields existed carries none of them.
|
||||||
|
Some(field) => set_or_insert_metadata_field(&content, field, now, title),
|
||||||
|
None => Ok(content),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// Rewrite the title heading, the first `# ` line in the file.
|
/// Rewrite the title heading, the first `# ` line in the file.
|
||||||
///
|
///
|
||||||
/// `## ` headings do not match: the second character has to be a space.
|
/// `## ` headings do not match: the second character has to be a space.
|
||||||
@@ -1290,6 +1384,12 @@ pub struct Section {
|
|||||||
/// appending to an empty section replaces the placeholder rather than following it.
|
/// appending to an empty section replaces the placeholder rather than following it.
|
||||||
pub placeholder: &'static str,
|
pub placeholder: &'static str,
|
||||||
pub kind: SectionKind,
|
pub kind: SectionKind,
|
||||||
|
/// The `--clear` value that empties this section, where `set` can reach it at all.
|
||||||
|
///
|
||||||
|
/// `None` for Relations, for the same reason it is absent from `section_args`: its
|
||||||
|
/// only writer is `relate`, so `set` has no way to fill it and no business emptying
|
||||||
|
/// it either.
|
||||||
|
pub clear: Option<Clearable>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub const DESCRIPTION: Section = Section {
|
pub const DESCRIPTION: Section = Section {
|
||||||
@@ -1297,6 +1397,7 @@ pub const DESCRIPTION: Section = Section {
|
|||||||
label: "description",
|
label: "description",
|
||||||
placeholder: "_No description provided._",
|
placeholder: "_No description provided._",
|
||||||
kind: SectionKind::Prose,
|
kind: SectionKind::Prose,
|
||||||
|
clear: Some(Clearable::Description),
|
||||||
};
|
};
|
||||||
|
|
||||||
pub const ACCEPTANCE: Section = Section {
|
pub const ACCEPTANCE: Section = Section {
|
||||||
@@ -1304,6 +1405,7 @@ pub const ACCEPTANCE: Section = Section {
|
|||||||
label: "acceptance criteria",
|
label: "acceptance criteria",
|
||||||
placeholder: "_No acceptance criteria provided._",
|
placeholder: "_No acceptance criteria provided._",
|
||||||
kind: SectionKind::Checklist,
|
kind: SectionKind::Checklist,
|
||||||
|
clear: Some(Clearable::Acceptance),
|
||||||
};
|
};
|
||||||
|
|
||||||
pub const PLAN: Section = Section {
|
pub const PLAN: Section = Section {
|
||||||
@@ -1311,6 +1413,7 @@ pub const PLAN: Section = Section {
|
|||||||
label: "implementation plan",
|
label: "implementation plan",
|
||||||
placeholder: "_No implementation plan provided._",
|
placeholder: "_No implementation plan provided._",
|
||||||
kind: SectionKind::Numbered,
|
kind: SectionKind::Numbered,
|
||||||
|
clear: Some(Clearable::Plan),
|
||||||
};
|
};
|
||||||
|
|
||||||
/// The edges to other tickets, one per line.
|
/// The edges to other tickets, one per line.
|
||||||
@@ -1324,6 +1427,7 @@ pub const RELATIONS: Section = Section {
|
|||||||
label: "relations",
|
label: "relations",
|
||||||
placeholder: "_No relations._",
|
placeholder: "_No relations._",
|
||||||
kind: SectionKind::Bullets,
|
kind: SectionKind::Bullets,
|
||||||
|
clear: None,
|
||||||
};
|
};
|
||||||
|
|
||||||
impl Section {
|
impl Section {
|
||||||
@@ -1357,6 +1461,108 @@ impl Section {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A field `set --clear` can return to the state a new ticket is born in.
|
||||||
|
///
|
||||||
|
/// The names are the flags they undo, so `--clear due` reads as the opposite of
|
||||||
|
/// `--due`. Three fields a ticket carries are deliberately absent:
|
||||||
|
///
|
||||||
|
/// - **Title** has no unset state. It addresses the ticket, it names the file through
|
||||||
|
/// its slug, and `add` requires it, so there is nothing to go back to.
|
||||||
|
/// - **Owner** is `chown`'s, and clearing it through `set` would give the field a
|
||||||
|
/// second writer, which is the rule the missing `set --owner` exists to keep.
|
||||||
|
/// - **Status**, **Campaign** and the three stamps belong to `mv` and `assign` for the
|
||||||
|
/// same reason.
|
||||||
|
#[derive(Copy, Clone, Debug, PartialEq, Eq, clap::ValueEnum)]
|
||||||
|
pub enum Clearable {
|
||||||
|
Due,
|
||||||
|
Tags,
|
||||||
|
Priority,
|
||||||
|
Description,
|
||||||
|
Acceptance,
|
||||||
|
Plan,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// What clearing a field writes back.
|
||||||
|
pub enum Unset {
|
||||||
|
/// A metadata line, back to the sentinel `add` writes when the flag is omitted.
|
||||||
|
Field {
|
||||||
|
field: &'static str,
|
||||||
|
sentinel: &'static str,
|
||||||
|
},
|
||||||
|
/// A section body, back to the placeholder `add` writes for an empty one.
|
||||||
|
Section(&'static Section),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Clearable {
|
||||||
|
/// Every field that can be cleared.
|
||||||
|
///
|
||||||
|
/// `#[cfg(test)]` because nothing in the binary walks the list: clap emits the
|
||||||
|
/// values for `--clear` from the `ValueEnum` itself, so the only caller is the suite
|
||||||
|
/// that checks each one against the ticket it empties.
|
||||||
|
#[cfg(test)]
|
||||||
|
pub const ALL: [Clearable; 6] = [
|
||||||
|
Clearable::Due,
|
||||||
|
Clearable::Tags,
|
||||||
|
Clearable::Priority,
|
||||||
|
Clearable::Description,
|
||||||
|
Clearable::Acceptance,
|
||||||
|
Clearable::Plan,
|
||||||
|
];
|
||||||
|
|
||||||
|
/// What clearing the field amounts to.
|
||||||
|
///
|
||||||
|
/// The sentinels are [`NOT_SET`] and [`NONE`] rather than strings written out here,
|
||||||
|
/// so a cleared field is byte-identical to one `add` left alone. That is the whole
|
||||||
|
/// promise of the command: a ticket that has been cleared and one that was never
|
||||||
|
/// given the field read the same.
|
||||||
|
pub fn unset(self) -> Unset {
|
||||||
|
match self {
|
||||||
|
Clearable::Due => Unset::Field {
|
||||||
|
field: "Due",
|
||||||
|
sentinel: NOT_SET,
|
||||||
|
},
|
||||||
|
Clearable::Tags => Unset::Field {
|
||||||
|
field: "Tags",
|
||||||
|
sentinel: NONE,
|
||||||
|
},
|
||||||
|
Clearable::Priority => Unset::Field {
|
||||||
|
field: "Priority",
|
||||||
|
sentinel: NOT_SET,
|
||||||
|
},
|
||||||
|
Clearable::Description => Unset::Section(&DESCRIPTION),
|
||||||
|
Clearable::Acceptance => Unset::Section(&ACCEPTANCE),
|
||||||
|
Clearable::Plan => Unset::Section(&PLAN),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The value the flag takes, as clap spells it.
|
||||||
|
///
|
||||||
|
/// Written out rather than read off `to_possible_value`, because it is used in error
|
||||||
|
/// messages that tell a caller what to type and a `&'static str` is what those want.
|
||||||
|
/// `the_clear_values_are_the_names_clap_accepts` keeps the two in step.
|
||||||
|
pub fn name(self) -> &'static str {
|
||||||
|
match self {
|
||||||
|
Clearable::Due => "due",
|
||||||
|
Clearable::Tags => "tags",
|
||||||
|
Clearable::Priority => "priority",
|
||||||
|
Clearable::Description => "description",
|
||||||
|
Clearable::Acceptance => "acceptance",
|
||||||
|
Clearable::Plan => "plan",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// How the change is named in output.
|
||||||
|
///
|
||||||
|
/// The label `set` already prints when it *writes* the field, so a cleared field is
|
||||||
|
/// named the way a replaced one is rather than in the flag's own spelling.
|
||||||
|
pub fn label(self) -> &'static str {
|
||||||
|
match self.unset() {
|
||||||
|
Unset::Field { .. } => self.name(),
|
||||||
|
Unset::Section(section) => section.label,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// Whether the line opens with `N. `, the shape a numbered step is stored in.
|
/// Whether the line opens with `N. `, the shape a numbered step is stored in.
|
||||||
fn is_numbered_item(line: &str) -> bool {
|
fn is_numbered_item(line: &str) -> bool {
|
||||||
let digits = line.chars().take_while(|c| c.is_ascii_digit()).count();
|
let digits = line.chars().take_while(|c| c.is_ascii_digit()).count();
|
||||||
@@ -1400,12 +1606,32 @@ fn join_lines(lines: &[String]) -> String {
|
|||||||
|
|
||||||
/// Replace a section's body with `items`, leaving every line outside it untouched.
|
/// Replace a section's body with `items`, leaving every line outside it untouched.
|
||||||
pub fn set_section_body(content: &str, section: &Section, items: &[String]) -> Result<String> {
|
pub fn set_section_body(content: &str, section: &Section, items: &[String]) -> Result<String> {
|
||||||
|
replace_section_body(content, section, section.render(items, 1))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return a section to the placeholder `add` writes for an empty one.
|
||||||
|
///
|
||||||
|
/// Not [`set_section_body`] with the placeholder as its one item: the placeholder is a
|
||||||
|
/// line of the format rather than content, and `render` would dress it as `- [ ] _No
|
||||||
|
/// acceptance criteria provided._` in every section but the description. It is the same
|
||||||
|
/// line `append` already treats as no content, so a cleared section can be appended to
|
||||||
|
/// without the placeholder being left above what follows it.
|
||||||
|
pub fn clear_section_body(content: &str, section: &Section) -> Result<String> {
|
||||||
|
replace_section_body(content, section, vec![section.placeholder.to_string()])
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The line surgery both of the above are, given a body that is already rendered.
|
||||||
|
fn replace_section_body(
|
||||||
|
content: &str,
|
||||||
|
section: &Section,
|
||||||
|
body_lines: Vec<String>,
|
||||||
|
) -> Result<String> {
|
||||||
let lines: Vec<&str> = content.lines().collect();
|
let lines: Vec<&str> = content.lines().collect();
|
||||||
let body = section_body(&lines, section.heading)
|
let body = section_body(&lines, section.heading)
|
||||||
.ok_or_else(|| anyhow!("Ticket has no {} section", section.label))?;
|
.ok_or_else(|| anyhow!("Ticket has no {} section", section.label))?;
|
||||||
|
|
||||||
let mut out: Vec<String> = lines[..body.start].iter().map(|l| l.to_string()).collect();
|
let mut out: Vec<String> = lines[..body.start].iter().map(|l| l.to_string()).collect();
|
||||||
out.extend(section.render(items, 1));
|
out.extend(body_lines);
|
||||||
// One blank line before whatever section follows, matching how `add` writes it.
|
// One blank line before whatever section follows, matching how `add` writes it.
|
||||||
if body.end < lines.len() {
|
if body.end < lines.len() {
|
||||||
out.push(String::new());
|
out.push(String::new());
|
||||||
@@ -2162,8 +2388,62 @@ pub fn trim_blank_ends(values: &[String]) -> &[String] {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A status, as clap accepts it and as the directory is named.
|
||||||
|
///
|
||||||
|
/// An enum rather than the string it was, so an unknown status is a usage error at parse
|
||||||
|
/// time with the four listed, the way `priority_level` and `iso_date` refuse a bad level
|
||||||
|
/// or date. That is the bargain the scalars already take, see AGENTS.md: nothing is
|
||||||
|
/// written, the exit code is 2, and no handler has to check. It also gives every shell
|
||||||
|
/// that completes possible values the four names for free.
|
||||||
|
///
|
||||||
|
/// The variants are in flow order, which is the order `mv` reads to decide whether a
|
||||||
|
/// move goes forward, and the order [`status_dirs`] hands the two views.
|
||||||
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
|
||||||
|
pub enum Status {
|
||||||
|
Backlog,
|
||||||
|
Committed,
|
||||||
|
Reviewing,
|
||||||
|
Done,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Status {
|
||||||
|
/// Every status, in flow order. The one list, which [`status_dirs`] and `mv` both
|
||||||
|
/// read rather than spelling the four names again.
|
||||||
|
pub const ALL: [Status; 4] = [
|
||||||
|
Status::Backlog,
|
||||||
|
Status::Committed,
|
||||||
|
Status::Reviewing,
|
||||||
|
Status::Done,
|
||||||
|
];
|
||||||
|
|
||||||
|
/// The field `mv` stamps on entering this status, for the three that have one.
|
||||||
|
///
|
||||||
|
/// Derived from the status rather than spelled at the call site, so the mapping is
|
||||||
|
/// in one place and a fifth status either brings its own stamp or explicitly has
|
||||||
|
/// none.
|
||||||
|
pub const fn stamp_field(self) -> Option<&'static str> {
|
||||||
|
match self {
|
||||||
|
Status::Backlog => None,
|
||||||
|
Status::Committed => Some(COMMITTED_ON_FIELD),
|
||||||
|
Status::Reviewing => Some(SUBMITTED_ON_FIELD),
|
||||||
|
Status::Done => Some(COMPLETED_ON_FIELD),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The directory name, which is also what clap accepts and what the `Status` field
|
||||||
|
/// holds. A `const fn` so [`DONE`] can be defined from it.
|
||||||
|
pub const fn as_str(self) -> &'static str {
|
||||||
|
match self {
|
||||||
|
Status::Backlog => "backlog",
|
||||||
|
Status::Committed => "committed",
|
||||||
|
Status::Reviewing => "reviewing",
|
||||||
|
Status::Done => "done",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn status_dirs() -> Vec<&'static str> {
|
pub fn status_dirs() -> Vec<&'static str> {
|
||||||
vec!["backlog", "committed", "reviewing", DONE]
|
Status::ALL.iter().map(|status| status.as_str()).collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The end of the flow, and the one status both views treat differently: `ls` counts it
|
/// The end of the flow, and the one status both views treat differently: `ls` counts it
|
||||||
@@ -2173,7 +2453,7 @@ pub fn status_dirs() -> Vec<&'static str> {
|
|||||||
/// It is deliberately last in `status_dirs()`. The board leans on that: hiding done drops
|
/// It is deliberately last in `status_dirs()`. The board leans on that: hiding done drops
|
||||||
/// the final column, so the other three keep their indices and the selection only has to
|
/// the final column, so the other three keep their indices and the selection only has to
|
||||||
/// be handled when it is sitting on done itself.
|
/// be handled when it is sitting on done itself.
|
||||||
pub const DONE: &str = "done";
|
pub const DONE: &str = Status::Done.as_str();
|
||||||
|
|
||||||
/// Lowest and highest level a ticket can carry. 1 is the most urgent, which is
|
/// Lowest and highest level a ticket can carry. 1 is the most urgent, which is
|
||||||
/// what the `p1` to `p3` tags this replaced already meant.
|
/// what the `p1` to `p3` tags this replaced already meant.
|
||||||
@@ -3019,6 +3299,106 @@ mod tests {
|
|||||||
assert!(error.to_string().contains("Campaign"), "{error}");
|
assert!(error.to_string().contains("Campaign"), "{error}");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The one stamp the target status carries, and nothing of the others: the fields
|
||||||
|
/// are current state, not a record of every stage the ticket has been through.
|
||||||
|
#[test]
|
||||||
|
fn entering_a_status_stamps_its_field_and_clears_the_rest() {
|
||||||
|
let content = with_metadata(
|
||||||
|
"- **ID**: abc\n- **Committed On**: 2026-08-01 09:00:00\n- **Status**: committed\n",
|
||||||
|
);
|
||||||
|
|
||||||
|
let updated =
|
||||||
|
set_status_stamp(&content, Status::Reviewing, "2026-08-22 10:11:12", "T").unwrap();
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
updated.contains("- **Submitted On**: 2026-08-22 10:11:12"),
|
||||||
|
"{updated}"
|
||||||
|
);
|
||||||
|
assert!(!updated.contains("**Committed On**"), "{updated}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Backlog has no stamp of its own, so a backward move under `-f` leaves the ticket
|
||||||
|
/// carrying none rather than a Completed On for work it has undone.
|
||||||
|
#[test]
|
||||||
|
fn moving_back_to_backlog_leaves_no_stamp_behind() {
|
||||||
|
let content = with_metadata(
|
||||||
|
"- **ID**: abc\n- **Completed On**: 2026-08-01 09:00:00\n- **Status**: done\n",
|
||||||
|
);
|
||||||
|
|
||||||
|
let updated =
|
||||||
|
set_status_stamp(&content, Status::Backlog, "2026-08-22 10:11:12", "T").unwrap();
|
||||||
|
|
||||||
|
assert!(!updated.contains("**Completed On**"), "{updated}");
|
||||||
|
assert!(!updated.contains("2026-08-22 10:11:12"), "{updated}");
|
||||||
|
assert!(updated.contains("- **ID**: abc\n- **Status**: done\n"), "{updated}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Re-entry is the time of the move that brought it back, not the first one.
|
||||||
|
#[test]
|
||||||
|
fn re_entering_a_status_restamps_rather_than_keeping_the_earlier_value() {
|
||||||
|
let content = with_metadata(
|
||||||
|
"- **ID**: abc\n- **Committed On**: 2026-08-01 09:00:00\n- **Status**: backlog\n",
|
||||||
|
);
|
||||||
|
|
||||||
|
let updated =
|
||||||
|
set_status_stamp(&content, Status::Committed, "2026-08-22 10:11:12", "T").unwrap();
|
||||||
|
|
||||||
|
assert_eq!(updated.matches("**Committed On**:").count(), 1, "{updated}");
|
||||||
|
assert!(!updated.contains("2026-08-01 09:00:00"), "{updated}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Against METADATA_ORDER, like Campaign: after Created At, which answers the same
|
||||||
|
/// kind of question, and never past Status, which every file keeps last.
|
||||||
|
#[test]
|
||||||
|
fn a_stamp_is_inserted_in_its_place_on_a_ticket_that_predates_the_field() {
|
||||||
|
let content = with_metadata(
|
||||||
|
"- **ID**: abc\n\
|
||||||
|
- **Created At**: 2026-08-01 09:00:00\n\
|
||||||
|
- **Campaign**: c-uuid\n\
|
||||||
|
- **Status**: reviewing\n",
|
||||||
|
);
|
||||||
|
|
||||||
|
let updated =
|
||||||
|
set_status_stamp(&content, Status::Done, "2026-08-22 10:11:12", "T").unwrap();
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
updated.contains(
|
||||||
|
"- **Created At**: 2026-08-01 09:00:00\n\
|
||||||
|
- **Completed On**: 2026-08-22 10:11:12\n\
|
||||||
|
- **Campaign**: c-uuid\n\
|
||||||
|
- **Status**: reviewing\n"
|
||||||
|
),
|
||||||
|
"{updated}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Removal is scoped to the section for the same reason the write is: a description
|
||||||
|
/// quoting a field marker is prose, and rewriting it would corrupt the ticket text
|
||||||
|
/// while leaving the real field in place.
|
||||||
|
#[test]
|
||||||
|
fn a_marker_in_the_description_is_not_the_field_being_removed() {
|
||||||
|
let content = "# T\n\n## Description\n- **Committed On**: not a field\n\n\
|
||||||
|
## Metadata\n\n- **ID**: abc\n- **Status**: backlog\n";
|
||||||
|
|
||||||
|
let updated =
|
||||||
|
set_status_stamp(content, Status::Backlog, "2026-08-22 10:11:12", "T").unwrap();
|
||||||
|
|
||||||
|
assert!(updated.contains("- **Committed On**: not a field"), "{updated}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Nothing to remove is not a rewrite: the content comes back byte for byte, which
|
||||||
|
/// is what keeps a move that stamps nothing from touching the file's shape.
|
||||||
|
#[test]
|
||||||
|
fn removing_a_field_the_ticket_does_not_carry_leaves_the_content_alone() {
|
||||||
|
let content = with_metadata("- **ID**: abc\n- **Status**: backlog\n");
|
||||||
|
|
||||||
|
assert_eq!(remove_metadata_line(&content, COMPLETED_ON_FIELD), None);
|
||||||
|
assert_eq!(
|
||||||
|
set_status_stamp(&content, Status::Backlog, "2026-08-22 10:11:12", "T").unwrap(),
|
||||||
|
content
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn a_campaign_field_that_is_unset_or_absent_reads_as_no_campaign() {
|
fn a_campaign_field_that_is_unset_or_absent_reads_as_no_campaign() {
|
||||||
assert_eq!(parse_campaign(&with_metadata("- **ID**: abc\n")), None);
|
assert_eq!(parse_campaign(&with_metadata("- **ID**: abc\n")), None);
|
||||||
@@ -3556,6 +3936,67 @@ mod tests {
|
|||||||
assert!(parse_relation("- blocked by").unwrap_err().to_string().contains("no target"));
|
assert!(parse_relation("- blocked by").unwrap_err().to_string().contains("no target"));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The two directions of the pairing have to agree, or `--clear acceptance` would
|
||||||
|
/// empty one section while the error message about an empty value named another.
|
||||||
|
#[test]
|
||||||
|
fn every_clearable_section_points_back_at_the_field_that_clears_it() {
|
||||||
|
for field in Clearable::ALL {
|
||||||
|
if let Unset::Section(section) = field.unset() {
|
||||||
|
assert_eq!(
|
||||||
|
section.clear,
|
||||||
|
Some(field),
|
||||||
|
"{} does not point back at --clear {}",
|
||||||
|
section.heading,
|
||||||
|
field.name()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert_eq!(RELATIONS.clear, None, "set must not be able to empty Relations");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The names are written out for the error messages, so this is what keeps them the
|
||||||
|
/// names clap actually accepts.
|
||||||
|
#[test]
|
||||||
|
fn the_clear_values_are_the_names_clap_accepts() {
|
||||||
|
for field in Clearable::ALL {
|
||||||
|
let possible = clap::ValueEnum::to_possible_value(&field).expect("not hidden");
|
||||||
|
assert_eq!(possible.get_name(), field.name());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The sentinel a cleared field goes back to is the one `add` writes for a field it
|
||||||
|
/// was never given, which is the whole promise of the flag.
|
||||||
|
#[test]
|
||||||
|
fn a_cleared_scalar_holds_the_sentinel_add_writes() {
|
||||||
|
for field in Clearable::ALL {
|
||||||
|
let Unset::Field { field: name, sentinel } = field.unset() else {
|
||||||
|
continue;
|
||||||
|
};
|
||||||
|
let expected = match name {
|
||||||
|
"Tags" => NONE,
|
||||||
|
_ => NOT_SET,
|
||||||
|
};
|
||||||
|
assert_eq!(sentinel, expected, "{name}");
|
||||||
|
assert!(is_unknown_value(sentinel), "{name} clears to something readable as set");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The placeholder goes in as a line of the format, not as an item: dressed by
|
||||||
|
/// `render` it would read `- [ ] _No acceptance criteria provided._`.
|
||||||
|
#[test]
|
||||||
|
fn clearing_a_section_writes_the_bare_placeholder() {
|
||||||
|
let content = "# T\n\n## Acceptance Criteria\n- [x] Done\n- [ ] Not\n\n## Metadata\n\n- **ID**: x\n";
|
||||||
|
let cleared = clear_section_body(content, &ACCEPTANCE).unwrap();
|
||||||
|
assert!(
|
||||||
|
cleared.contains(&format!("## Acceptance Criteria\n{}\n", ACCEPTANCE.placeholder)),
|
||||||
|
"{cleared}"
|
||||||
|
);
|
||||||
|
// Everything outside the section is where it was.
|
||||||
|
assert!(cleared.contains("- **ID**: x"), "{cleared}");
|
||||||
|
// And a second clear is the same string, which is what makes the no-op free.
|
||||||
|
assert_eq!(clear_section_body(&cleared, &ACCEPTANCE).unwrap(), cleared);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn the_placeholder_is_no_relations_rather_than_a_bad_line() {
|
fn the_placeholder_is_no_relations_rather_than_a_bad_line() {
|
||||||
let content = format!(
|
let content = format!(
|
||||||
|
|||||||
+41
-3
@@ -530,9 +530,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
|
/// 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]
|
#[test]
|
||||||
fn an_empty_due_date_says_clearing_is_not_supported() {
|
fn an_empty_due_date_points_at_clear() {
|
||||||
let temp = TempDir::new().unwrap();
|
let temp = TempDir::new().unwrap();
|
||||||
setup_worklane(&temp);
|
setup_worklane(&temp);
|
||||||
|
|
||||||
@@ -549,7 +550,8 @@ fn an_empty_due_date_says_clearing_is_not_supported() {
|
|||||||
)
|
)
|
||||||
.to_string();
|
.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 {
|
fn read_only_ticket(dir: &Path) -> String {
|
||||||
@@ -561,3 +563,39 @@ fn read_only_ticket(dir: &Path) -> String {
|
|||||||
|
|
||||||
fs::read_to_string(file.path()).unwrap()
|
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);
|
||||||
|
}
|
||||||
|
|||||||
+88
-2
@@ -213,7 +213,8 @@ fn chown_refuses_a_swapped_call() {
|
|||||||
assert_eq!(ticket(&worklane), before);
|
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]
|
#[test]
|
||||||
fn chown_refuses_an_empty_user_as_a_usage_error() {
|
fn chown_refuses_an_empty_user_as_a_usage_error() {
|
||||||
let temp = TempDir::new().unwrap();
|
let temp = TempDir::new().unwrap();
|
||||||
@@ -223,11 +224,96 @@ fn chown_refuses_an_empty_user_as_a_usage_error() {
|
|||||||
|
|
||||||
let out = run(&temp, &["chown", "", UUID]);
|
let out = run(&temp, &["chown", "", UUID]);
|
||||||
assert_eq!(out.status.code(), Some(2));
|
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!(
|
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)
|
String::from_utf8_lossy(&out.stderr)
|
||||||
);
|
);
|
||||||
|
|
||||||
assert_eq!(ticket(&worklane), before);
|
assert_eq!(ticket(&worklane), before);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,83 @@
|
|||||||
|
use assert_cmd::Command;
|
||||||
|
|
||||||
|
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||||
|
|
||||||
|
fn script(shell: &str) -> String {
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
let assert = cmd.arg("completions").arg(shell).assert().success();
|
||||||
|
String::from_utf8(assert.get_output().stdout.clone()).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Every shell clap can generate for, since the README names all five.
|
||||||
|
#[test]
|
||||||
|
fn completions_prints_a_script_for_every_shell() {
|
||||||
|
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
|
||||||
|
let out = script(shell);
|
||||||
|
assert!(
|
||||||
|
out.contains("worklane"),
|
||||||
|
"the {shell} script never names the command"
|
||||||
|
);
|
||||||
|
// Long enough to be a script rather than an empty file with a comment in it.
|
||||||
|
assert!(out.len() > 500, "the {shell} script is {} bytes", out.len());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// No board is looked for, the way `install-skill` looks for none: the script comes off
|
||||||
|
/// the clap definition and is the same wherever it is run. Run from a temp directory
|
||||||
|
/// with no `.worklane` above it, which every other command refuses.
|
||||||
|
#[test]
|
||||||
|
fn completions_needs_no_board() {
|
||||||
|
let temp = assert_fs::TempDir::new().unwrap();
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path())
|
||||||
|
.arg("completions")
|
||||||
|
.arg("fish")
|
||||||
|
.assert()
|
||||||
|
.success();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn fish_gets_both_halves() {
|
||||||
|
let out = script("fish");
|
||||||
|
// clap's, which is where the subcommands and the flags come from.
|
||||||
|
assert!(out.contains("__fish_worklane_needs_command"));
|
||||||
|
assert!(out.contains("install-skill"));
|
||||||
|
// Ours, which is where the tickets come from.
|
||||||
|
assert!(out.contains("__worklane_first_arg_of"));
|
||||||
|
assert!(out.contains("worklane ls --ids"));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The fish half is fish syntax, so it must not reach any other shell's output.
|
||||||
|
#[test]
|
||||||
|
fn no_other_shell_gets_the_fish_half() {
|
||||||
|
for shell in ["bash", "zsh", "elvish", "powershell"] {
|
||||||
|
let out = script(shell);
|
||||||
|
assert!(
|
||||||
|
!out.contains("__worklane_first_arg_of"),
|
||||||
|
"fish-only helpers leaked into {shell}"
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
!out.contains("worklane ls --ids"),
|
||||||
|
"the dynamic half leaked into {shell}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The four statuses reach fish twice over, from clap for the `mv` option and from the
|
||||||
|
/// appended half for the `ls` positional, which clap emits nothing for.
|
||||||
|
#[test]
|
||||||
|
fn fish_is_offered_every_status() {
|
||||||
|
let out = script("fish");
|
||||||
|
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||||
|
assert!(out.contains(status), "fish is never offered {status}");
|
||||||
|
}
|
||||||
|
assert!(out.contains("-a 'backlog committed reviewing done' -d status"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_unknown_shell_is_a_usage_error() {
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
let assert = cmd.arg("completions").arg("tcsh").assert().code(2);
|
||||||
|
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||||
|
assert!(stderr.contains("invalid value 'tcsh'"), "{stderr}");
|
||||||
|
}
|
||||||
+223
@@ -470,3 +470,226 @@ fn ls_with_a_tag_nothing_carries_lists_nothing() {
|
|||||||
assert!(stdout.contains("[BACKLOG] 0 tickets"), "{stdout}");
|
assert!(stdout.contains("[BACKLOG] 0 tickets"), "{stdout}");
|
||||||
assert!(!stdout.contains("Tagged bug"), "{stdout}");
|
assert!(!stdout.contains("Tagged bug"), "{stdout}");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A ticket with an id of its own, since `create_ticket` gives every fixture the same
|
||||||
|
/// uuid and `--ids` is the one output where the id is the whole point.
|
||||||
|
fn create_ticket_with_id(
|
||||||
|
worklane_dir: &std::path::Path,
|
||||||
|
status: &str,
|
||||||
|
title: &str,
|
||||||
|
uuid: &str,
|
||||||
|
tags: &str,
|
||||||
|
) {
|
||||||
|
let ticket_body = format!(
|
||||||
|
"# {title}\n\n## Metadata\n\n- **ID**: {uuid}\n- **Tags**: {tags}\n- **Owner**: alice\n- **Status**: {status}\n"
|
||||||
|
);
|
||||||
|
let filename = format!("{uuid}_{}.md", slug(title));
|
||||||
|
fs::write(worklane_dir.join(status).join(filename), ticket_body).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The slug rule, as AGENTS.md requires: derived, never written by hand.
|
||||||
|
fn slug(title: &str) -> String {
|
||||||
|
title
|
||||||
|
.to_lowercase()
|
||||||
|
.chars()
|
||||||
|
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
||||||
|
.map(|c| if c == ' ' { '-' } else { c })
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// One ticket per line, the seven-character id then a tab then the title, and nothing
|
||||||
|
/// else: no heading, no counts, no owner or due column.
|
||||||
|
#[test]
|
||||||
|
fn ls_ids_prints_the_id_and_the_title_and_nothing_else() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
let worklane = setup_worklane(&temp);
|
||||||
|
|
||||||
|
create_ticket_with_id(
|
||||||
|
&worklane,
|
||||||
|
"backlog",
|
||||||
|
"Feature A",
|
||||||
|
"1b78a24c-0000-0000-0000-000000000001",
|
||||||
|
"bug",
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||||
|
cmd.assert().success();
|
||||||
|
|
||||||
|
let stdout = get_stdout(&mut cmd);
|
||||||
|
assert_eq!(stdout, "1b78a24\tFeature A\n", "{stdout:?}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Every status, done included, where the decorated listing leaves done out. A
|
||||||
|
/// completion has to be able to name a finished ticket.
|
||||||
|
#[test]
|
||||||
|
fn ls_ids_includes_done_and_narrows_to_a_named_status() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
let worklane = setup_worklane(&temp);
|
||||||
|
|
||||||
|
create_ticket_with_id(
|
||||||
|
&worklane,
|
||||||
|
"backlog",
|
||||||
|
"Still open",
|
||||||
|
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||||
|
"bug",
|
||||||
|
);
|
||||||
|
create_ticket_with_id(
|
||||||
|
&worklane,
|
||||||
|
"done",
|
||||||
|
"Finished",
|
||||||
|
"bbbbbbb2-0000-0000-0000-000000000002",
|
||||||
|
"bug",
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||||
|
let stdout = get_stdout(&mut cmd);
|
||||||
|
assert!(stdout.contains("Still open"), "{stdout}");
|
||||||
|
assert!(stdout.contains("Finished"), "a done ticket cannot be named: {stdout}");
|
||||||
|
|
||||||
|
// The decorated listing is unchanged: done is counted, not listed.
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).arg("ls");
|
||||||
|
let stdout = get_stdout(&mut cmd);
|
||||||
|
assert!(!stdout.contains("Finished"), "{stdout}");
|
||||||
|
|
||||||
|
// The positional still narrows it.
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).args(["ls", "done", "--ids"]);
|
||||||
|
let stdout = get_stdout(&mut cmd);
|
||||||
|
assert_eq!(stdout, "bbbbbbb\tFinished\n", "{stdout:?}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The filters apply to `--ids` exactly as they do to the listing, so a completion can
|
||||||
|
/// be narrowed the same way.
|
||||||
|
#[test]
|
||||||
|
fn ls_ids_still_takes_the_filters() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
let worklane = setup_worklane(&temp);
|
||||||
|
|
||||||
|
create_ticket_with_id(
|
||||||
|
&worklane,
|
||||||
|
"backlog",
|
||||||
|
"Tagged bug",
|
||||||
|
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||||
|
"bug",
|
||||||
|
);
|
||||||
|
create_ticket_with_id(
|
||||||
|
&worklane,
|
||||||
|
"backlog",
|
||||||
|
"Tagged cli",
|
||||||
|
"bbbbbbb2-0000-0000-0000-000000000002",
|
||||||
|
"cli",
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]);
|
||||||
|
let stdout = get_stdout(&mut cmd);
|
||||||
|
assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An unknown campaign is refused before anything is read, even here. A completion that
|
||||||
|
/// listed the whole board because the name was misspelled would be worse than one that
|
||||||
|
/// printed nothing.
|
||||||
|
#[test]
|
||||||
|
fn ls_ids_still_refuses_an_unknown_campaign() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
let worklane = setup_worklane(&temp);
|
||||||
|
|
||||||
|
create_ticket_with_id(
|
||||||
|
&worklane,
|
||||||
|
"backlog",
|
||||||
|
"Feature A",
|
||||||
|
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||||
|
"bug",
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path())
|
||||||
|
.args(["ls", "--ids", "--campaign", "no such campaign"]);
|
||||||
|
cmd.assert().failure();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A status the board is missing is skipped rather than refused, unlike the listing:
|
||||||
|
/// the caller is a shell filling in candidates, and an error printed over the prompt is
|
||||||
|
/// worse there than no candidates.
|
||||||
|
#[test]
|
||||||
|
fn ls_ids_is_quiet_about_a_missing_status_directory() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
let worklane = temp.child(".worklane");
|
||||||
|
worklane.create_dir_all().unwrap();
|
||||||
|
worklane.child("backlog").create_dir_all().unwrap();
|
||||||
|
|
||||||
|
create_ticket_with_id(
|
||||||
|
worklane.path(),
|
||||||
|
"backlog",
|
||||||
|
"Feature A",
|
||||||
|
"aaaaaaa1-0000-0000-0000-000000000001",
|
||||||
|
"bug",
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
|
||||||
|
cmd.assert().success();
|
||||||
|
let stdout = get_stdout(&mut cmd);
|
||||||
|
assert_eq!(stdout, "aaaaaaa\tFeature A\n", "{stdout:?}");
|
||||||
|
|
||||||
|
// The listing still says so, since a person reading it can act on it.
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).args(["ls", "done"]);
|
||||||
|
let assert = cmd.assert().failure();
|
||||||
|
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||||
|
assert!(stderr.contains("No 'done' directory"), "{stderr}");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A status outside the four is clap's to refuse now, so it is a usage error naming the
|
||||||
|
/// four rather than a runtime one.
|
||||||
|
#[test]
|
||||||
|
fn ls_names_the_four_statuses_when_given_another() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
setup_worklane(&temp);
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
let assert = cmd
|
||||||
|
.current_dir(temp.path())
|
||||||
|
.args(["ls", "nonexistent"])
|
||||||
|
.assert()
|
||||||
|
.code(2);
|
||||||
|
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||||
|
assert!(stderr.contains("invalid value 'nonexistent'"), "{stderr}");
|
||||||
|
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||||
|
assert!(stderr.contains(status), "{status} is not offered: {stderr}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The listing reads the fields it prints and nothing else, so the stamps `mv` writes
|
||||||
|
/// do not reach it. Pinned against a ticket carrying one, since a listing that started
|
||||||
|
/// showing them would change the output every board and completion script parses.
|
||||||
|
#[test]
|
||||||
|
fn ls_output_is_unchanged_by_a_status_stamp() {
|
||||||
|
let temp = TempDir::new().unwrap();
|
||||||
|
let worklane = setup_worklane(&temp);
|
||||||
|
|
||||||
|
create_ticket(&worklane, "committed", "Stamped", "alice", "2026-06-01");
|
||||||
|
let path = worklane
|
||||||
|
.join("committed")
|
||||||
|
.join("00000000-0000-0000-0000-000000000001_stamped.md");
|
||||||
|
let before = {
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
||||||
|
get_stdout(&mut cmd)
|
||||||
|
};
|
||||||
|
|
||||||
|
let stamped = fs::read_to_string(&path)
|
||||||
|
.unwrap()
|
||||||
|
.replace("- **Status**:", "- **Committed On**: 2026-08-22 09:14:30\n- **Status**:");
|
||||||
|
fs::write(&path, stamped).unwrap();
|
||||||
|
|
||||||
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||||
|
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
||||||
|
let after = get_stdout(&mut cmd);
|
||||||
|
|
||||||
|
assert_eq!(after, before);
|
||||||
|
assert!(!after.contains("Committed On"), "{after}");
|
||||||
|
}
|
||||||
|
|||||||
+183
-3
@@ -277,13 +277,16 @@ fn mv_ignores_already_in_same_status() {
|
|||||||
assert!(worklane.join("reviewing").join(&filename).exists());
|
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]
|
#[test]
|
||||||
fn mv_rejects_invalid_status() {
|
fn mv_rejects_invalid_status() {
|
||||||
let temp = TempDir::new().unwrap();
|
let temp = TempDir::new().unwrap();
|
||||||
let worklane = setup_worklane(&temp);
|
let worklane = setup_worklane(&temp);
|
||||||
|
|
||||||
let id = "abc123def456789012345678901234567890";
|
let id = "abc123def456789012345678901234567890";
|
||||||
let _filename = create_ticket(
|
let filename = create_ticket(
|
||||||
&worklane,
|
&worklane,
|
||||||
"backlog",
|
"backlog",
|
||||||
"Invalid Target",
|
"Invalid Target",
|
||||||
@@ -301,10 +304,17 @@ fn mv_rejects_invalid_status() {
|
|||||||
.arg("--status")
|
.arg("--status")
|
||||||
.arg("invalid")
|
.arg("invalid")
|
||||||
.assert()
|
.assert()
|
||||||
.failure();
|
.code(2);
|
||||||
|
|
||||||
let stderr = get_stderr(&mut cmd);
|
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]
|
#[test]
|
||||||
@@ -878,3 +888,173 @@ fn mv_ignores_the_kinds_that_are_not_blockers() {
|
|||||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||||
assert!(worklane.join("committed").join(&filename).exists());
|
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);
|
||||||
|
}
|
||||||
|
|||||||
+246
-14
@@ -190,7 +190,11 @@ fn set_reports_only_the_fields_that_changed() {
|
|||||||
assert!(!stdout.contains("due"), "{stdout:?}");
|
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]
|
#[test]
|
||||||
fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||||
let temp = TempDir::new().unwrap();
|
let temp = TempDir::new().unwrap();
|
||||||
@@ -198,12 +202,227 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
|||||||
create_ticket(&worklane);
|
create_ticket(&worklane);
|
||||||
let before = 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, ""]);
|
let out = run(&temp, &["set", UUID, flag, ""]);
|
||||||
assert_eq!(out.status.code(), Some(2), "{flag} was accepted");
|
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!(
|
assert!(
|
||||||
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
|
!stderr.contains("not supported"),
|
||||||
"{flag}: {:?}",
|
"{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)
|
String::from_utf8_lossy(&out.stderr)
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
@@ -211,25 +430,38 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
|||||||
assert_eq!(ticket(&worklane), before);
|
assert_eq!(ticket(&worklane), before);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// An empty value is a paragraph break for a section, so an all-blank one is a
|
/// The fields no writer of `set` can reach are not reachable through `--clear` either,
|
||||||
/// clearing attempt rather than a break.
|
/// and an unknown one is a usage error listing what is.
|
||||||
#[test]
|
#[test]
|
||||||
fn set_refuses_to_clear_a_section() {
|
fn clear_refuses_a_field_it_does_not_own() {
|
||||||
let temp = TempDir::new().unwrap();
|
let temp = TempDir::new().unwrap();
|
||||||
let worklane = setup_worklane(&temp);
|
let worklane = setup_worklane(&temp);
|
||||||
create_ticket(&worklane);
|
create_ticket(&worklane);
|
||||||
let before = ticket(&worklane);
|
let before = ticket(&worklane);
|
||||||
|
|
||||||
let out = run(&temp, &["set", UUID, "--description", ""]);
|
for field in ["owner", "title", "status", "campaign", "relations", "nonsense"] {
|
||||||
assert_eq!(out.status.code(), Some(1));
|
let out = run(&temp, &["set", UUID, "--clear", field]);
|
||||||
assert!(
|
assert_eq!(out.status.code(), Some(2), "--clear {field} was accepted");
|
||||||
String::from_utf8_lossy(&out.stderr).contains("clearing is not supported"),
|
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||||
"{:?}",
|
assert!(stderr.contains("possible values"), "{field}: {stderr:?}");
|
||||||
String::from_utf8_lossy(&out.stderr)
|
}
|
||||||
);
|
|
||||||
assert_eq!(ticket(&worklane), before);
|
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.
|
/// A bare `set <ticket>` would otherwise be a silent no-op.
|
||||||
#[test]
|
#[test]
|
||||||
fn set_requires_at_least_one_field() {
|
fn set_requires_at_least_one_field() {
|
||||||
|
|||||||
@@ -489,6 +489,39 @@ fn show_renders_the_metadata_as_an_aligned_table() {
|
|||||||
assert!(content.contains("- **Owner**: alice"));
|
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.
|
/// 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) {
|
fn ticket_with(worklane: &std::path::Path, status: &str, uuid: &str, title: &str, slug: &str) {
|
||||||
fs::write(
|
fs::write(
|
||||||
|
|||||||
Reference in New Issue
Block a user