Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c65e1b4ed7 | ||
|
|
6a800fb385 | ||
|
|
4ae7ef03ff | ||
|
|
73ffcad733 | ||
|
|
964ca342d8 | ||
|
|
cc5f9b8a46 | ||
|
|
175c1d016d |
@@ -0,0 +1,8 @@
|
||||
# Revisions that changed layout and nothing else. Teach git to look through them:
|
||||
#
|
||||
# git config blame.ignoreRevsFile .git-blame-ignore-revs
|
||||
#
|
||||
# Only a commit whose diff is pure formatting belongs here.
|
||||
|
||||
# Reformat with cargo fmt, and nothing else
|
||||
73ffcad73314621e299dc06ee688db9b4c4d6b29
|
||||
@@ -42,6 +42,20 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created, plus `campaigns/` in `cmd_campaign.rs`, which is also where the on-demand creation is tested from a board without it
|
||||
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
|
||||
- **`cargo clippy --all-targets` is clean. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
|
||||
- **`cargo fmt --check` is clean too, and `rustfmt.toml` is what makes that affordable.** rustfmt is the formatter here, run it. The config is four stable width settings and nothing else:
|
||||
|
||||
| setting | value | why |
|
||||
|---|---|---|
|
||||
| `max_width` | 100 | The tree's own habit, and the measured optimum: 90 costs 268 hunks and 120 costs 194, against 161 at 100 |
|
||||
| `fn_call_width` | 75 | A call stays whole if it fits in three quarters of the line. rustfmt's default of 60 is what expanded 276 of the 305 hunks the default config wanted |
|
||||
| `chain_width` | 65 | The same for a method chain |
|
||||
| `struct_lit_width` | 30 | A small struct literal stays whole, so `Size { width: 120, height: 20 }` is not six lines |
|
||||
|
||||
**The numbers were measured, not chosen.** Default rustfmt wanted 305 hunks and would have added 1418 lines of pure layout, because its sub-widths sit far below the 100 columns this tree is written to. `use_small_heuristics = "Max"` went the other way, 308 hunks and 796 lines *removed*, one-lining `if`/`else` and collapsing struct literals that were split on purpose. Coordinate descent over the stable width knobs landed here, at 161 hunks, and 98 of those are rustfmt *joining* calls that fit rather than breaking them. Sweeping any one of these four in either direction makes the diff bigger, so do not adjust one by eye; measure it the same way, with `cargo fmt --check | grep -c '^Diff in'`
|
||||
- What this does not buy: rustfmt has no rule for "keep parallel arms parallel", so a match whose arms are one line and four lines depending on the length of their contents is what it produces, and that is accepted. Reach for `#[rustfmt::skip]` only where the layout carries meaning a reader needs, not to win an argument about density
|
||||
- Do not add an unstable option. `cargo fmt` on stable ignores them with a warning, so the tree would format differently for whoever ran nightly
|
||||
- **Sixteen lines still run past 100 columns and every one of them is a single string literal**, a test fixture or an error message rustfmt cannot break. `format_strings` is deliberately left at its default: turning it on would let the formatter rewrite message text, and a message is prose. So `max_width` is where rustfmt breaks lines, not a limit the tree keeps
|
||||
- The reformat is `73ffcad`, and `.git-blame-ignore-revs` names it so `git blame` looks through it. Turn that on once per clone with `git config blame.ignoreRevsFile .git-blame-ignore-revs`. A commit belongs in that file only if its diff is pure layout
|
||||
|
||||
## Coding Guidelines
|
||||
|
||||
@@ -59,7 +73,8 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **`--due` is validated at parse time by `iso_date`, the way `--priority` is by `priority_level`.** A date that is not real is a usage error, exit 2, with nothing written, which is the whole point of leaving the scalars without `PROSE`. One parser serves `add` and `set`: the field has one definition of what it accepts, and validating only `add` would leave `set` open, which is the command a grooming sweep actually uses
|
||||
- **The shape is checked before chrono is asked.** `%Y-%m-%d` accepts an unpadded `2026-8-9`, which would be stored exactly as typed and sort before `2026-10-01` in any string comparison. Checking the length and the two dashes first is what lets a valid date be stored unchanged instead of normalised on the way in, which is the difference between validating and rewriting
|
||||
- **Strict on the way in, tolerant on the way out.** `util::due_date` still cuts `2026-12-31T09:30:00Z` down to its date. A file written before the parser existed, or by hand, can hold one and still has to render; refusing to display what is already stored would punish the reader for the writer's mistake
|
||||
- An empty `--due` keeps `non_empty`'s message about clearing rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is that clearing is not supported yet
|
||||
- An empty `--due` keeps the clearing message rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is the flag that does it
|
||||
- **There are two empty-value parsers, and which one an argument takes is the point.** `non_empty` says only that the value cannot be empty, for the arguments with no empty form: the `ls` filters, `relate`'s targets, and `set --title`, which addresses the ticket and names its file. `clearable` names `--clear`, for the arguments whose field does have one: `set --tags`, `--due` through `iso_date`, and the `chown` user. One message for both would either lie about `ls --tag` or leave the useful half unsaid. `add --due` takes the second one because `iso_date` is shared, and the answer it points at is a command later rather than the omission that would do it now, which is close enough to be worth the shared parser
|
||||
- **A status is a `util::Status`, not a string.** `mv --status` and the `ls` positional take the value enum, so an unknown status is a usage error at parse time naming the four, exit 2, and no handler checks. That is the same bargain `--due` and `--priority` take, and it is what lets the shells complete the four for free. `Status::ALL` is the flow order, which `status_dirs()` and `cmd_mv` both read rather than spelling the names again, and `DONE` is defined from it
|
||||
- The ticket positionals (`show <id>`, `mv <ticket>`, `comment <ticket>`) are also left alone, so a search term starting with a hyphen is a usage error. Reachable now that a hyphen-leading title can be stored: use the UUID, or put the flags first and separate with `--`, as in `mv --status committed -- -leading-title`
|
||||
- A bare `--` is a value when it follows an option (`--title -- ` stores `--`) and clap's end-of-options marker when it sits in a positional. So a `comment` body of exactly `--` needs its own separator, `comment <ticket> -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop
|
||||
@@ -72,16 +87,20 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **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
|
||||
- **Position is counted, not inferred.** The four `__worklane_*` predicates all read `$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. `first_arg_of` and `second_arg_of` count a top-level command's arguments, `nested_arg_of` matches a parent and a child so `campaign show <TAB>` can be told from `chown alice <TAB>`, which sit at the same token count, and `command_is` asks only which command this is, at any position in it
|
||||
- **Every rule carrying `-l` needs a `__worklane_command_is`, and `every_rule_naming_an_option_is_scoped_to_a_command` is what enforces it.** A bare `complete -c worklane -l tag` does not just complete that option's values, it tells fish the whole tool accepts `--tag`: `worklane init --<TAB>` offered six options that only `relate` and `ls` have. Fixed in 55ee6e3. `__fish_seen_subcommand_from ls` is not the scope to use, for the nesting reason above
|
||||
- **The five completion lists are kept honest by tests** that walk the clap definition and fail on an argument left out of them. `TICKET_COMMANDS` and `TICKET_SECOND_COMMANDS` by position, `TICKET_FLAGS`, `CAMPAIGN_COMMANDS`, `CAMPAIGN_NESTED_COMMANDS`, `CAMPAIGN_FLAGS` and `TAG_FLAGS` likewise. The walk is one function, `every_argument`, since the tests differ only in the id they look for. Each also asserts *how many* it found, so a walker that stopped finding arguments fails rather than passing every assertion by never running them
|
||||
- **A campaign is named in three shapes and a tag in one**, which is why the lists are not one list: a campaign is `assign`'s first positional, `campaign show`'s only argument and `ls --campaign`'s value, and each needs a different fish rule. A tag is only ever an option value, and its values come from a different command
|
||||
- **`ls --ids` is the machine-readable listing**, and one of the three outputs 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
|
||||
- **`campaign ls --ids` is the same flag and the same two fields for the other object**, and it deliberately skips the member counting the decorated listing does: `members()` reads every ticket on the board, and the caller here is a shell filling in candidates on a keypress. It also prints nothing on an empty board, where the decorated listing prints a sentence, because a sentence offered as a candidate is worse than no candidates
|
||||
- **`worklane tags` is the third, and it is a command rather than a mode on `ls`.** Two reasons: `ls --tag <tag>` answers what carries a tag and cannot answer what tags exist, which is the question a grooming sweep starts from, and a `--tags` beside a `--tag` is one letter from a filter that means something else. Alphabetical and case sensitive, matching the filter, so `bug` and `Bug` list separately and land next to each other, which is where a near-duplicate is spotted. Every status, done included: a tag that has fallen out of use is still part of what the vocabulary has been. `assets/PLAN.md` used to tell the agent to count tags with a `show` per ticket, and now points here
|
||||
|
||||
### Filtering the Listing
|
||||
- **The filters are one call, `filtered`,** because `ls` collects a column in three places (a named status, the counts, and the grouped listing) and three call sites are three chances to apply a different set. Every filter is an `Option` and none asked for keeps everything, which is what makes them compose in any combination without a rule per pair
|
||||
- **`--tag` matches whole values, not the field.** `parse_tags` has already split the comma-separated field, so the filter compares against those trimmed values: `--tag bug` is not answered by a ticket tagged `bugfix`, and `--tag "cli, filter"` matches nothing, because the field as written is not itself a tag. A ticket with no tags matches none
|
||||
- **Case sensitive**, the opinion the field already takes: `tag_color` draws `Bug` and `bug` in two colours because they are two tags. A filter that folded them would list tickets carrying a tag nobody asked for, and would hide exactly the split a grooming sweep is looking for
|
||||
- **One tag per invocation.** Several would have to decide between and and or, and neither reading is obviously right for a board this size. That decision is its own ticket, along with a substring or regex match and a tag filter on the tui
|
||||
- **A tag nothing carries lists nothing rather than being refused**, which is the opposite of `--campaign`. A campaign is an object that either exists or does not, so it is resolved before anything is read and an unknown one is an error. A tag is free text with no registry: there is nothing to resolve against, and refusing an unknown one would mean maintaining a vocabulary the format deliberately does not have. `assets/PLAN.md` tells the agent to check the spelling when a listing comes back empty, since that is the failure this trades for
|
||||
- **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, and `worklane tags` is what it checks against, since that is the failure this trades for
|
||||
- An emptied status keeps the message `ls` already gives, `No tickets in '<status>' status.`, rather than one per filter naming what excluded them. That is pre-existing behaviour for `--priority` and `--campaign`, and one message for every filter is the consistent half of it. If it should name the filter, that is a change to what the CLI prints for three flags at once and belongs in its own ticket
|
||||
- **`cmd_ls` 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
|
||||
|
||||
@@ -90,11 +109,24 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **One field, one writer.** `set` has no `--owner` (that is `chown`'s) and no `--status` (that is `mv`'s), and neither `add`, `set`, `append` nor `chown` can reach the three status stamps, which `mv` writes as a side effect of the move. Do not add any of them
|
||||
- `chown` takes the **user first and the ticket second**, after Unix `chown`, and is the only command that does not start with the ticket. Deliberate: the name borrows the Unix association, so the order borrows it too. A swap is left to `resolve_ticket`, which refuses a bare username as a ticket. No argument is inspected to see whether it *also* names a ticket, since such a check would only fire where resolution already fails and would stay silent on the one case it cannot catch, a ticket whose title is the username
|
||||
- `cmd_chown` is `set_metadata_field` plus `save_ticket`, with the same whole-file no-op comparison `set` uses and the same `report()` output, so nothing about writing a field lives twice
|
||||
- Sections are a table in `util.rs`: `DESCRIPTION`, `ACCEPTANCE`, `PLAN`, each with a heading, a label, the placeholder `add` writes when empty, and a `SectionKind`. Adding a section later is one entry, not edits in both commands
|
||||
- `apply()` is the one place an edit is taken or dropped, shared by `set`'s replaced list and its cleared one. It was a closure over the single list until there were two, and two closures carrying one rule is how a later edit changes it for one and not the other
|
||||
- Sections are a table in `util.rs`: `DESCRIPTION`, `ACCEPTANCE`, `PLAN`, each with a heading, a label, the placeholder `add` writes when empty, a `SectionKind` and the `--clear` value that empties it. Adding a section later is one entry, not edits in both commands
|
||||
- Everything is targeted line surgery, never a regenerated file. That is what keeps a ticked criterion ticked and a handwritten `## Notes` section intact when an unrelated field changes. `section_body()` finds the lines to touch, `set_metadata_line()` does the metadata, and every other byte is copied through
|
||||
- Appending to a numbered section continues from the count of steps already there and does not renumber what is above it, so a handwritten line in the section survives exactly as written
|
||||
- Appending to an empty section replaces the placeholder rather than following it, or the ticket would read `_No description provided._` above its description
|
||||
- An empty value is a paragraph break for the three sections and a usage error for the scalars, via `non_empty` in `command.rs`. Clearing a field is not supported yet, and the error says so rather than guessing
|
||||
- An empty value is a paragraph break for the three sections and a usage error for the scalars, via `non_empty` and `clearable` in `command.rs`. Neither spells clearing, and both errors name the flag that does
|
||||
|
||||
### Clearing a Field
|
||||
- **`set --clear <field>` is the one way to take a value away, and it is a flag with the field as its value.** Not a per-field `--clear-due`, which is a flag per field to keep in step with the field it undoes, and not an empty value, which is already a paragraph break for a section and would make an accidentally empty variable a silent delete. Repeatable, so one call empties as many fields as it likes
|
||||
- **`Clearable` is a `ValueEnum` in `util.rs`**, so an unknown field is a usage error at the door listing the six that are not, and the shells complete them for free. It is also the whole table of what can be cleared: `Due`, `Tags` and `Priority` clear to a sentinel, `Description`, `Acceptance` and `Plan` to their section's placeholder. `Title` is absent because it addresses the ticket and names its file, so there is no state to go back to; `Owner`, `Status`, `Campaign` and the stamps because clearing them through `set` is exactly the second writer the missing `set --owner` exists to prevent
|
||||
- **What is written is `NOT_SET` and `NONE`, the constants `add` writes.** A cleared ticket and one that was never given the field have to read the same, or clearing would be a third state that every parser then has to know about. `a_cleared_ticket_reads_like_one_filed_without_the_fields` compares the two files byte for byte, which is what keeps a new field honest
|
||||
- **The placeholder goes into a section bare, via `clear_section_body`.** `set_section_body` runs its items through `Section::render`, which would write `- [ ] _No acceptance criteria provided._`. Both are `replace_section_body` underneath, so the line surgery and the trailing blank line live once
|
||||
- **The pairing between a section and its `--clear` value is stored on both**, `Clearable::unset` one way and `Section::clear` the other, because the error for an empty value has to name the flag for *that* section and the section's label ("acceptance criteria") is not the flag's value ("acceptance"). `every_clearable_section_points_back_at_the_field_that_clears_it` keeps the two directions from drifting. `RELATIONS.clear` is `None`, the same rule that keeps it out of `section_args`
|
||||
- **Cleared fields are reported apart from replaced ones**, as `Cleared due on '...'` beside `Updated priority on '...'`. One list would say `Updated` of a field that was emptied, which is the opposite of what a caller needs to read back. The labels are the ones `set` already prints when it *writes* the field, so the two lines name a field the same way
|
||||
- **Replacing and clearing one field in a single call is refused**, by `SetArgs::contested`. clap cannot express it, because the field arrives as `--clear`'s value rather than in its name, and answering by whichever was applied last is a silent answer to a contradictory call
|
||||
- **Clearing the owner is `chown --clear <ticket>`, and `--clear` carries the ticket.** Owner has one writer and clearing it cannot introduce a second, so it lives on `chown`; but the ticket is `chown`'s *second* positional, and a bare flag would land it in the user's slot for the handler to read back out, which is hand-parsing what clap can state. The typed call is identical either way. `ChownArgs::target` returns the one shape the constraints allow, and an error rather than a panic for the combination they already refuse
|
||||
- **Clearing the owner writes `NOT_SET`, not the git user.** `add` falls back to the git user because it is filing something new; an owner taken away says nobody owns this, and putting the person running the command there instead hands them a ticket they were giving up
|
||||
- Clearing a field that is already unset writes the sentinel that is already there, so the whole-file comparison below reports no change and nothing is written. That is not a special case, and must not become one
|
||||
- No-op detection compares the whole file before and after each edit, so a field set to the value it already holds is reported unchanged and nothing is written
|
||||
- `find_ticket_file()` matches on the uuid, never the title. Duplicate titles are allowed, so a title scan can land on a different ticket than the one resolved: `mv <uuid-of-second>` used to move the first ticket sharing its title
|
||||
- `write_then_replace()` is the only way a ticket file is written. Content first, rename second, so a failure leaves a correct ticket under a stale name rather than a half-written one
|
||||
@@ -322,7 +354,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- The UUID tier applies from `MIN_ID_SEARCH` (4) characters up. Not 8: `ls` prints `SHORT_ID_WIDTH` (7) characters, so a longer minimum would drop the printed id out of the UUID tier and let any title quoting it win instead. Below the minimum the search is text, so `show 641` is a title search
|
||||
- The filename tier earns its place by reaching the middle of a UUID, which the prefix tier cannot. It is also why a short UUID search still resolves under a longer minimum, just at the wrong precedence, so a test for the minimum needs a decoy title to be meaningful
|
||||
- Ambiguous matches (multiple results) print options and exit(1)
|
||||
- Never return empty strings for required fields — use `_Not set_` or `_None_` as defaults
|
||||
- Never return empty strings for required fields — use the `NOT_SET` and `NONE` constants in `util.rs`, which are what `add` writes and what `--clear` puts back. `is_unknown_value` reads those two and nothing else
|
||||
- **`-None-` and `-Not set-` are not unset, and re-adding them would be a mistake with a plausible story behind it.** They were accepted by `is_unknown_value` from the day it was written, by analogy with the `**-Status**` field name the `mv` splicing bug really did produce, c230d2c. But no version of this tool ever wrote a hyphenated *value*: `git log -S` finds both spellings in exactly one commit, the one that added them to the check. Dead from birth, and dropped by bdddc09. `a_hyphenated_marker_is_not_unset` is what stops the analogy being drawn a second time
|
||||
- **The `**-Status**` repair in `is_status_line` is the opposite case and stays.** That corruption was real, `mv` wrote it, and the repair is what fixes a damaged ticket as it moves. Do not tidy the two away together on the grounds that they look alike
|
||||
|
||||
### Git Workflow
|
||||
- Commit format: `([ticketID]) [short description]`
|
||||
|
||||
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.17.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.17.1"
|
||||
version = "0.19.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -11,13 +11,14 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>`, `--tag <tag>` and `--campaign <campaign>`, which compose in any combination. `--tag` matches a whole value of the comma-separated Tags field, case sensitively, so `--tag bug` does not list a ticket tagged `bugfix` or one tagged `Bug`. `--ids` prints one ticket per line as its short id, a tab and its title, unstyled, done included, for a script or a completion |
|
||||
| `worklane show <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring |
|
||||
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions |
|
||||
| `worklane set <ticket>` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID |
|
||||
| `worklane set <ticket>` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID. `--clear <field>` returns a field to unset instead, repeatable, taking `due`, `tags`, `priority`, `description`, `acceptance` or `plan`, and writing back exactly what `add` writes for a field it was never given. No `title`, which addresses the ticket, and no `owner`, which is `chown`'s. Replacing and clearing the same field in one call is refused |
|
||||
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last |
|
||||
| `worklane relate <ticket>` | Records an edge to another ticket with `--blocked-by`, `--regression-of` or `--relates-to`, each repeatable. At least one required. Only the ticket named is written; `show` derives the other end by scanning. `mv` refuses to move a ticket blocked by one that is not done, unless `-f` |
|
||||
| `worklane chown <user> <ticket>` | Sets the Owner field, the only command that writes it. Free text, checked against nothing. User first and ticket second, after Unix `chown` |
|
||||
| `worklane chown <user> <ticket>` | Sets the Owner field, the only command that writes it. Free text, checked against nothing. User first and ticket second, after Unix `chown`. `worklane chown --clear <ticket>` returns the field to unset, taking the ticket in the flag since there is no user to give, and not to the git user `add` falls back to |
|
||||
| `worklane check <ticket> [criteria...]` | Ticks acceptance criteria, each by number as shown by `show` or by a substring. Several in one call, or `all` for every one of them. Prompts with the numbered list if none is given, or errors with it when there is no terminal |
|
||||
| `worklane uncheck <ticket> [criteria...]` | Unticks acceptance criteria, addressed the same way |
|
||||
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
|
||||
| `worklane tags` | Lists the tags the board carries as the tag, a tab and how many tickets carry it, one per line, unstyled and alphabetical. Case sensitive like `ls --tag`, so `bug` and `Bug` list separately and land next to each other. Every status, done included. The one command that answers what tags exist rather than what carries a tag already known |
|
||||
| `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 |
|
||||
|
||||
@@ -37,11 +38,16 @@ 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>
|
||||
worklane campaign show <TAB> the campaigns, from `campaign ls --ids`
|
||||
worklane assign <TAB> the same, since a campaign comes first here
|
||||
worklane ls --campaign <TAB> and again
|
||||
worklane ls --tag <TAB> the tags, from `worklane tags`, with their counts
|
||||
```
|
||||
|
||||
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
|
||||
The tickets come from `worklane ls --ids`, the campaigns from `worklane campaign ls --ids` and the tags
|
||||
from `worklane tags`, 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.
|
||||
|
||||
|
||||
+27
-18
@@ -16,11 +16,12 @@ which command owns which field. Read it too. This document is the judgement.
|
||||
|
||||
**Propose the whole set of edits, wait, then apply exactly what was approved.**
|
||||
|
||||
Every job here writes to many tickets at once, and no field can be cleared back to unset
|
||||
yet, so a date written onto the wrong ticket can only be overwritten, never taken off. A wrong
|
||||
edit to one ticket is a mistake; a wrong sweep is thirty of them with no undo. So a
|
||||
proposal is a list, one line per intended edit, each naming the ticket and the command
|
||||
that would make it:
|
||||
Every job here writes to many tickets at once, and nothing on the board records what a
|
||||
field held before you wrote to it. `--clear` puts a field back to unset, which is **not
|
||||
back to what it held**, so a date written over another date is gone. A wrong edit to one
|
||||
ticket is a mistake; a wrong sweep is thirty of them with no undo. So a proposal is a
|
||||
list, one line per intended edit, each naming the ticket and the command that would make
|
||||
it:
|
||||
|
||||
```
|
||||
(1b78a24) priority 3 -> 1 worklane set 1b78a24 --priority 1
|
||||
@@ -37,10 +38,10 @@ other way is editing the file by hand:
|
||||
|
||||
| Field | Writer |
|
||||
|-------|--------|
|
||||
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags` |
|
||||
| Priority, Due, Tags | `worklane set <ticket> --priority` / `--due` / `--tags`, and `--clear <field>` to empty one |
|
||||
| Relations | `worklane relate <ticket> --blocked-by` / `--regression-of` / `--relates-to` |
|
||||
| Campaign membership | `worklane assign <campaign> <ticket>` |
|
||||
| Owner | `worklane chown <user> <ticket>` |
|
||||
| Owner | `worklane chown <user> <ticket>`, and `worklane chown --clear <ticket>` to empty it |
|
||||
| Status | `worklane mv <ticket> --status <target>` |
|
||||
|
||||
**Never edit a ticket file directly.** The filename, the `Status` field and the directory
|
||||
@@ -57,16 +58,17 @@ worklane ls # every status, counts then tickets
|
||||
worklane ls backlog # one status
|
||||
worklane ls --priority 1 # the top of the pile
|
||||
worklane ls --tag bug # one tag's worth of the board
|
||||
worklane tags # the whole vocabulary, with counts
|
||||
worklane show 1b78a24 # one ticket, with its relations and comments
|
||||
worklane campaign ls # the goals that already exist
|
||||
```
|
||||
|
||||
`ls` prints the mark, the id, the title, the owner and the due date. It does **not**
|
||||
print tags, so the vocabulary itself still has to be read off the tickets: `--tag` answers
|
||||
"what is tagged `bug`" and cannot answer "what tags exist", which is the question a
|
||||
grooming sweep starts from. Count the vocabulary with a `show` per ticket, then use
|
||||
`--tag` to check each candidate, and remember that `--tag` matches whole values case
|
||||
sensitively: `bug` and `Bug` are two answers, which is exactly the split worth reporting.
|
||||
`ls` prints the mark, the id, the title, the owner and the due date, and **not** the tags.
|
||||
So the vocabulary comes from `worklane tags`, which is the one command that answers what
|
||||
tags exist rather than what carries a tag you already know. One line per tag, alphabetical,
|
||||
as the tag, a tab and its count. It is case sensitive like the filter, so `bug` and `Bug`
|
||||
list separately and, being alphabetical, land next to each other, which is where a
|
||||
near-duplicate is spotted. Start a tag sweep there rather than with a `show` per ticket.
|
||||
|
||||
Read `done` too when the question is about what to do next. What was finished last is the
|
||||
best evidence of what this board actually moves at, and a plan that ignores it is a wish.
|
||||
@@ -101,8 +103,9 @@ What to look for:
|
||||
|
||||
A value that is not a real calendar date in that exact form is refused before anything
|
||||
is written, so a typo costs nothing. `2026-8-9` is refused too: the padding is part of
|
||||
the format. What is still true is that a date, once written, **cannot be cleared**, only
|
||||
replaced by another date, so a plan applied to the wrong ticket has no undo.
|
||||
the format. A date can be taken off again with `worklane set <ticket> --clear due`. What
|
||||
that cannot do is recover the date that was there before it, so a plan applied over
|
||||
existing dates still has no undo.
|
||||
|
||||
Ask the system what today is rather than assuming it. A plan built on a guessed date is
|
||||
wrong by however much the guess was wrong.
|
||||
@@ -119,15 +122,21 @@ The rules a dating plan has to keep:
|
||||
whole backlog produces a board where every ticket is late, which is the same as no
|
||||
dates at all.
|
||||
- **Do not date `done`.** It is finished; a date on it is noise in every listing.
|
||||
- Leave the rest unset. An unset due date is honest about what has not been planned.
|
||||
- Leave the rest unset. An unset due date is honest about what has not been planned, and
|
||||
a date that turned out to be wrong is better cleared than left to read as a plan.
|
||||
|
||||
## Tags
|
||||
|
||||
`worklane set <ticket> --tags bug,cli` is the writer, and it **replaces the whole
|
||||
field**. Restate every tag the ticket should keep, or the ones you left out are gone.
|
||||
This is the single most destructive thing in this document.
|
||||
This is the single most destructive thing in this document. `--clear tags` empties the
|
||||
field on purpose, which is a different thing from emptying it by forgetting a tag.
|
||||
|
||||
Derive the vocabulary from the board rather than inventing one. Read the tickets, count
|
||||
`worklane tags` before and after a tag sweep is the cheapest check that it did what was
|
||||
proposed: a count that dropped where nothing was meant to change is a tag lost to the
|
||||
replace-the-whole-field rule above.
|
||||
|
||||
Derive the vocabulary from the board rather than inventing one. Read `worklane tags`, count
|
||||
what is actually used, and show the count before proposing anything. What to report:
|
||||
|
||||
- **Two spellings of one idea.** `bug` and `bugfix`, `tui` and `ui`. Pick the one already
|
||||
|
||||
+28
-7
@@ -65,6 +65,12 @@ against the whole values of the comma-separated `Tags` field, case sensitively,
|
||||
tags matches none. A tag nothing carries lists nothing rather than failing, so when a
|
||||
listing comes back empty check the spelling against a ticket you know is tagged.
|
||||
|
||||
`worklane tags` answers the other question, the one `--tag` cannot: **what tags exist**.
|
||||
One line per tag, alphabetical, as the tag, a tab and how many tickets carry it. Case
|
||||
sensitive, like the filter, so `bug` and `Bug` list separately and land next to each
|
||||
other, which is where a near-duplicate is spotted. Read it before inventing a tag, and
|
||||
read it when a `--tag` filter comes back emptier than expected.
|
||||
|
||||
## Working a ticket
|
||||
|
||||
```
|
||||
@@ -124,21 +130,34 @@ worklane add \
|
||||
Editing afterwards, on a ticket in any status:
|
||||
|
||||
```
|
||||
worklane set 1b78a24 --priority 1 # replace a field
|
||||
worklane set 1b78a24 --priority 1 # replace a field
|
||||
worklane set 1b78a24 --title "A better title" # renames the file, keeps the uuid
|
||||
worklane set 1b78a24 --clear due # take a value away again
|
||||
worklane set 1b78a24 --clear tags --clear plan # as many fields as you like
|
||||
worklane append 1b78a24 --acceptance "One more criterion"
|
||||
worklane append 1b78a24 --description "What was learned since."
|
||||
worklane chown alice 1b78a24 # hand the ticket to someone
|
||||
worklane chown --clear 1b78a24 # hand it back to nobody
|
||||
```
|
||||
|
||||
`set` replaces, `append` adds. Neither has `--owner` or `--status`: owner is `chown`'s
|
||||
and status is `mv`'s, so each field has exactly one writer. A field set to the value it
|
||||
already holds is reported unchanged and nothing is written.
|
||||
`set` replaces, `append` adds, `--clear` empties. Neither `set` nor `append` has
|
||||
`--owner` or `--status`: owner is `chown`'s and status is `mv`'s, so each field has
|
||||
exactly one writer. A field set to the value it already holds is reported unchanged and
|
||||
nothing is written, and so is a field cleared that was already unset.
|
||||
|
||||
**`--clear` takes the field as its value**, one of `due`, `tags`, `priority`,
|
||||
`description`, `acceptance` or `plan`, and repeats. It writes back exactly what `add`
|
||||
writes for a field it was never given: `_Not set_`, `_None_` for tags, and the section
|
||||
placeholder. There is no `--clear title`, because a title addresses the ticket and names
|
||||
its file. There is no `--clear owner` either: that is `chown --clear <ticket>`, which
|
||||
takes the ticket in the flag since there is no user to give, and returns the field to
|
||||
unset rather than to the git user. Replacing and clearing the same field in one call is
|
||||
refused rather than resolved.
|
||||
|
||||
`chown` takes the **user first and the ticket second**, after Unix `chown`, which is the
|
||||
one command here that does not start with the ticket. The user is free text and is
|
||||
checked against nothing. Swap the two and the call fails, because the username has to
|
||||
resolve as a ticket.
|
||||
resolve as a ticket. `--clear` replaces both arguments with the ticket alone.
|
||||
|
||||
`worklane init` creates `.worklane/` with the four status directories and the campaigns
|
||||
directory beside them, for a repo that has no board yet.
|
||||
@@ -190,6 +209,7 @@ there is no such thing as a done campaign holding an open ticket.
|
||||
worklane campaign add --title "v1 release" \
|
||||
--description "Everything that has to ship before the tag."
|
||||
worklane campaign ls # every campaign and how far it has got
|
||||
worklane campaign ls --ids # id and title, tab separated, like ls --ids
|
||||
worklane campaign show "v1 release" # its body, then its members by status
|
||||
worklane assign "v1 release" 1b78a24 # put a ticket in it
|
||||
worklane ls --campaign "v1 release" # only that campaign's tickets
|
||||
@@ -261,6 +281,7 @@ the candidates and exits 1 rather than guessing.
|
||||
`worklane mv --status committed -- -leading-title`.
|
||||
- A comment body of exactly `--` needs its own separator:
|
||||
`worklane comment 1b78a24 -- --`.
|
||||
- An empty value for a scalar is a usage error. Clearing a field back to unset is not
|
||||
supported yet.
|
||||
- An empty value for a scalar is a usage error, not a way to clear the field: use
|
||||
`--clear`. For a section an empty value is a paragraph break, so it cannot mean empty
|
||||
the section either, and an all-blank one is refused with the `--clear` for it named.
|
||||
- Piping is safe: `worklane ls | head -3` exits on the closed pipe instead of panicking.
|
||||
|
||||
@@ -24,9 +24,9 @@ fn git_sha() -> String {
|
||||
.output();
|
||||
|
||||
let sha = match output {
|
||||
Ok(output) if output.status.success() => String::from_utf8_lossy(&output.stdout)
|
||||
.trim()
|
||||
.to_string(),
|
||||
Ok(output) if output.status.success() => {
|
||||
String::from_utf8_lossy(&output.stdout).trim().to_string()
|
||||
}
|
||||
_ => String::new(),
|
||||
};
|
||||
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
# rustfmt is the formatter for this tree, and these four widths are what make it agree
|
||||
# with how the tree is already written. Measured, not chosen: the default config wanted
|
||||
# 305 hunks and +1418 lines of layout, `use_small_heuristics = "Max"` wanted 308 the
|
||||
# other way, and this lands at 161. The reasoning is in AGENTS.md beside the clippy rule.
|
||||
#
|
||||
# Sweeping any one of these in either direction makes the diff bigger. Measure before
|
||||
# changing one: `cargo fmt --check | grep -c '^Diff in'`.
|
||||
|
||||
# The habit the tree is written to, and the measured optimum: 90 costs 268 hunks, 120
|
||||
# costs 194.
|
||||
max_width = 100
|
||||
|
||||
# A call stays whole if it fits in three quarters of the line. rustfmt's default of 60
|
||||
# is what expands 276 of the 305 hunks the default config wants.
|
||||
fn_call_width = 75
|
||||
|
||||
# The same for a method chain.
|
||||
chain_width = 65
|
||||
|
||||
# A small struct literal stays whole, so `Size { width: 120, height: 20 }` is not six
|
||||
# lines. Above the default of 18, which is what explodes it.
|
||||
struct_lit_width = 30
|
||||
+2
-7
@@ -32,8 +32,7 @@ pub fn campaigns_dir(worklane_dir: &Path) -> PathBuf {
|
||||
pub fn ensure_campaigns_dir(worklane_dir: &Path) -> Result<PathBuf> {
|
||||
let dir = campaigns_dir(worklane_dir);
|
||||
|
||||
fs::create_dir_all(&dir)
|
||||
.map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
|
||||
fs::create_dir_all(&dir).map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
|
||||
|
||||
Ok(dir)
|
||||
}
|
||||
@@ -166,11 +165,7 @@ pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> Str
|
||||
return String::new();
|
||||
};
|
||||
|
||||
reference_cell(
|
||||
&uuid,
|
||||
index.get(&uuid).map(|campaign| campaign.title.as_str()),
|
||||
colored,
|
||||
)
|
||||
reference_cell(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()), colored)
|
||||
}
|
||||
|
||||
/// The parts [`content_trim`] cannot render from the ticket file alone.
|
||||
|
||||
+122
-19
@@ -4,7 +4,7 @@ use std::sync::LazyLock;
|
||||
|
||||
use chrono::NaiveDate;
|
||||
|
||||
use crate::util::{PRIORITY_RANGE, RelationKind, Status, priority_legend};
|
||||
use crate::util::{Clearable, PRIORITY_RANGE, RelationKind, Status, priority_legend};
|
||||
|
||||
/// clap wants a `&str` with a long enough lifetime, and the legend is built from
|
||||
/// the same ramp the listing uses rather than spelled out a second time.
|
||||
@@ -43,13 +43,31 @@ pub struct Cli {
|
||||
/// Reject an empty value at parse time, so it lands as a usage error rather than a
|
||||
/// runtime one.
|
||||
///
|
||||
/// An empty value looks like a way to clear a field, and clearing is not supported
|
||||
/// yet. Refusing it keeps the gap visible and stops an accidentally empty variable
|
||||
/// from silently blanking a field. Only the scalars use this: for the multi-line
|
||||
/// sections an empty value is a paragraph break.
|
||||
/// Two messages rather than one, because the arguments that use this fall into two
|
||||
/// kinds. A search term or a title has no empty form at all, and that is all this says.
|
||||
/// A field that *can* be emptied says so and names `--clear`, which is [`clearable`]
|
||||
/// below: an accidentally empty variable must not blank a field silently, and somebody
|
||||
/// typing an empty value on purpose is reaching for exactly the flag that does it.
|
||||
///
|
||||
/// Only the scalars use either one. For the multi-line sections an empty value is a
|
||||
/// paragraph break.
|
||||
fn non_empty(raw: &str) -> Result<String, String> {
|
||||
if raw.trim().is_empty() {
|
||||
return Err("value cannot be empty, and clearing a field is not supported yet".to_string());
|
||||
return Err("value cannot be empty".to_string());
|
||||
}
|
||||
|
||||
Ok(raw.to_string())
|
||||
}
|
||||
|
||||
/// Reject an empty value on an argument whose field can be cleared, and say how.
|
||||
///
|
||||
/// The message names no command, because the arguments that use this belong to three:
|
||||
/// `set --tags`, `set --due`, `add --due` and the `chown` user. `set` and `chown` both
|
||||
/// take a `--clear`; `add` does not, and there a field is left unset by omitting the
|
||||
/// flag, which is what the caller was reaching for anyway.
|
||||
fn clearable(raw: &str) -> Result<String, String> {
|
||||
if raw.trim().is_empty() {
|
||||
return Err("value cannot be empty, use --clear to return a field to unset".to_string());
|
||||
}
|
||||
|
||||
Ok(raw.to_string())
|
||||
@@ -73,7 +91,7 @@ fn non_empty(raw: &str) -> Result<String, String> {
|
||||
fn iso_date(raw: &str) -> Result<String, String> {
|
||||
// An empty value keeps the message that explains why it is refused, since somebody
|
||||
// typing it is reaching for a way to clear the field rather than mistyping a date.
|
||||
non_empty(raw)?;
|
||||
clearable(raw)?;
|
||||
|
||||
let bytes = raw.as_bytes();
|
||||
let shaped = raw.len() == 10 && bytes[4] == b'-' && bytes[7] == b'-';
|
||||
@@ -143,7 +161,7 @@ pub enum Command {
|
||||
/// Record a relation from one ticket to another
|
||||
Relate(RelateArgs),
|
||||
|
||||
/// Change the owner of a ticket
|
||||
/// Change the owner of a ticket, or return it to unset
|
||||
///
|
||||
/// User first, ticket second, after Unix `chown`. That reverses the ticket-first
|
||||
/// order `mv`, `comment` and `show` use, deliberately: the name borrows the Unix
|
||||
@@ -154,14 +172,7 @@ pub enum Command {
|
||||
/// username usually will not, so the call fails on its own. It is silently wrong
|
||||
/// only when both arguments resolve, which needs a ticket whose title matches the
|
||||
/// username.
|
||||
Chown {
|
||||
/// New owner. Free text, like `add --owner`, checked against nothing
|
||||
#[arg(value_parser = non_empty)]
|
||||
user: String,
|
||||
|
||||
/// Ticket UUID or title
|
||||
ticket: String,
|
||||
},
|
||||
Chown(ChownArgs),
|
||||
|
||||
/// Open the board view
|
||||
Tui {
|
||||
@@ -212,6 +223,16 @@ pub enum Command {
|
||||
ticket: String,
|
||||
},
|
||||
|
||||
/// List the tags the board carries, and how many tickets carry each
|
||||
///
|
||||
/// A command rather than a mode on `ls`, for two reasons. `ls --tag <tag>` answers
|
||||
/// "what is tagged bug" and cannot answer "what tags exist", which is the question a
|
||||
/// grooming sweep starts from; and a `--tags` beside a `--tag` is one letter away from
|
||||
/// a filter that means something else.
|
||||
///
|
||||
/// The output is machine-readable, like `ls --ids`: the tag, a tab, the count.
|
||||
Tags,
|
||||
|
||||
/// Print a shell completion script
|
||||
///
|
||||
/// The structure comes from the clap definition, so a flag added here appears
|
||||
@@ -252,7 +273,17 @@ pub enum CampaignCommand {
|
||||
Add(CampaignAddArgs),
|
||||
|
||||
/// List campaigns with their member counts
|
||||
Ls,
|
||||
Ls {
|
||||
/// Print one campaign per line as its id and title, tab separated, for a script
|
||||
/// or a completion
|
||||
///
|
||||
/// The same flag and the same two fields as `ls --ids`, since it answers the same
|
||||
/// question about a different object. Member counts are left out: counting them
|
||||
/// reads every ticket on the board, and the caller here is a shell filling in a
|
||||
/// candidate list on a keypress
|
||||
#[arg(long)]
|
||||
ids: bool,
|
||||
},
|
||||
|
||||
/// Show a campaign and its members grouped by status
|
||||
Show {
|
||||
@@ -361,7 +392,7 @@ pub struct AddArgs {
|
||||
clap::ArgGroup::new("set_fields")
|
||||
.required(true)
|
||||
.multiple(true)
|
||||
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority"])
|
||||
.args(["title", "description", "acceptance", "plan", "tags", "due", "priority", "clear"])
|
||||
))]
|
||||
pub struct SetArgs {
|
||||
/// Ticket UUID or title
|
||||
@@ -384,7 +415,7 @@ pub struct SetArgs {
|
||||
pub plan: Vec<String>,
|
||||
|
||||
/// Replace the tags
|
||||
#[arg(short = 'g', long, value_parser = non_empty)]
|
||||
#[arg(short = 'g', long, value_parser = clearable)]
|
||||
pub tags: Vec<String>,
|
||||
|
||||
/// Replace the due date (YYYY-MM-DD)
|
||||
@@ -398,6 +429,78 @@ pub struct SetArgs {
|
||||
/// Replace the priority, 1 (most urgent) to 5 (least)
|
||||
#[arg(long, value_parser = priority_level)]
|
||||
pub priority: Option<u8>,
|
||||
|
||||
/// Return a field to unset. Repeat the flag for more than one
|
||||
///
|
||||
/// The counterpart to the flag it names, and the only way to take a value away: an
|
||||
/// empty value is a paragraph break for a section and a usage error for a scalar, so
|
||||
/// neither can spell this. What goes back is what `add` writes for a field it was
|
||||
/// never given.
|
||||
///
|
||||
/// No `title`, which addresses the ticket and names its file, and no `owner`, which
|
||||
/// is `chown --clear`'s. The reasoning for each is on `util::Clearable`.
|
||||
#[arg(long, value_name = "FIELD")]
|
||||
pub clear: Vec<Clearable>,
|
||||
}
|
||||
|
||||
impl SetArgs {
|
||||
/// A field this call both replaces and clears, if there is one.
|
||||
///
|
||||
/// clap cannot express the conflict, because `--clear` carries the field as a value
|
||||
/// rather than in the flag's own name. So it is checked once here and refused, rather
|
||||
/// than resolved by whichever of the two happens to be applied last, which is a
|
||||
/// silent answer to a contradictory call.
|
||||
pub fn contested(&self) -> Option<Clearable> {
|
||||
self.clear.iter().copied().find(|field| match field {
|
||||
Clearable::Due => self.due.is_some(),
|
||||
Clearable::Tags => !self.tags.is_empty(),
|
||||
Clearable::Priority => self.priority.is_some(),
|
||||
Clearable::Description => !self.description.is_empty(),
|
||||
Clearable::Acceptance => !self.acceptance.is_empty(),
|
||||
Clearable::Plan => !self.plan.is_empty(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// `chown` is the only writer of Owner, so clearing the field has to live here too, and
|
||||
/// that is what shapes the arguments.
|
||||
///
|
||||
/// **`--clear` carries the ticket rather than being a bare flag.** The ticket is the
|
||||
/// *second* positional, so `chown --clear 1b78a24` with a plain flag would land the
|
||||
/// ticket in the user's slot, and reading it back out of there is hand-parsing what clap
|
||||
/// can state outright. The typed call is the same either way; only who checks it differs.
|
||||
///
|
||||
/// The two forms are mutually exclusive, and each argument says so, so a call carrying
|
||||
/// both is a usage error from clap rather than a decision made here.
|
||||
#[derive(clap::Args)]
|
||||
pub struct ChownArgs {
|
||||
/// New owner. Free text, like `add --owner`, checked against nothing
|
||||
#[arg(value_parser = clearable, required_unless_present = "clear", conflicts_with = "clear")]
|
||||
pub user: Option<String>,
|
||||
|
||||
/// Ticket UUID or title
|
||||
#[arg(required_unless_present = "clear", conflicts_with = "clear")]
|
||||
pub ticket: Option<String>,
|
||||
|
||||
/// Return the owner to unset on this ticket, which is named here since there is no
|
||||
/// user to name
|
||||
#[arg(long, value_name = "TICKET", value_parser = non_empty)]
|
||||
pub clear: Option<String>,
|
||||
}
|
||||
|
||||
impl ChownArgs {
|
||||
/// The ticket the call names, and the owner to write on it, `None` being unset.
|
||||
///
|
||||
/// `None` for the pair is unreachable while the constraints above hold, and is an
|
||||
/// error at the call site rather than a panic, so loosening one of them costs a
|
||||
/// message instead of a crash.
|
||||
pub fn target(&self) -> Option<(&str, Option<&str>)> {
|
||||
match (self.clear.as_deref(), self.user.as_deref(), self.ticket.as_deref()) {
|
||||
(Some(ticket), None, None) => Some((ticket, None)),
|
||||
(None, Some(user), Some(ticket)) => Some((ticket, Some(user))),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `append` only offers the sections that hold multiple lines, since appending to a
|
||||
|
||||
+262
-23
@@ -42,6 +42,30 @@ 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"];
|
||||
|
||||
/// Subcommands whose first positional is a campaign.
|
||||
///
|
||||
/// `assign` alone, which takes the campaign first and the ticket second. Kept honest by
|
||||
/// the same test the ticket lists are.
|
||||
pub const CAMPAIGN_COMMANDS: [&str; 1] = ["assign"];
|
||||
|
||||
/// Nested subcommands whose first argument is a campaign, as `parent child`.
|
||||
///
|
||||
/// `campaign show` is the only one, and it is why the fish half needs a third position
|
||||
/// helper: its argument is the *third* token, where `__worklane_first_arg_of` reads the
|
||||
/// second and `__worklane_second_arg_of` counts a top-level command's arguments. Neither
|
||||
/// can tell `campaign show <TAB>` from `chown alice <TAB>` by position.
|
||||
pub const CAMPAIGN_NESTED_COMMANDS: [(&str, &str); 1] = [("campaign", "show")];
|
||||
|
||||
/// Options whose value is a campaign.
|
||||
pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
|
||||
|
||||
/// Options whose value is a tag.
|
||||
///
|
||||
/// Its own list rather than a line in the block below, because the values come from a
|
||||
/// different command: a tag is not an object with an id, so `worklane tags` answers this
|
||||
/// one where `ls --ids` answers the tickets.
|
||||
pub const TAG_FLAGS: [&str; 1] = ["tag"];
|
||||
|
||||
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);
|
||||
@@ -59,11 +83,15 @@ pub fn generate(shell: Shell, out: &mut dyn io::Write) -> io::Result<()> {
|
||||
fn fish_dynamic() -> String {
|
||||
let ticket_commands = TICKET_COMMANDS.join(" ");
|
||||
let ticket_second_commands = TICKET_SECOND_COMMANDS.join(" ");
|
||||
let ticket_flags = TICKET_FLAGS
|
||||
let ticket_flags = flag_list(&TICKET_FLAGS);
|
||||
let campaign_commands = CAMPAIGN_COMMANDS.join(" ");
|
||||
let campaign_nested = CAMPAIGN_NESTED_COMMANDS
|
||||
.iter()
|
||||
.map(|flag| format!("-l {flag}"))
|
||||
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ");
|
||||
.join("; or ");
|
||||
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
|
||||
let tag_flags = flag_list(&TAG_FLAGS);
|
||||
let statuses = possible_values(Status::value_variants());
|
||||
let shells = possible_values(Shell::value_variants());
|
||||
let skills = SKILLS
|
||||
@@ -87,7 +115,7 @@ 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' \
|
||||
complete -c worklane -n '__worklane_command_is tui' \
|
||||
-a '(__fish_complete_directories)' -d project
|
||||
|
||||
# Position is counted rather than inferred from what has been typed: matching against
|
||||
@@ -108,6 +136,28 @@ function __worklane_second_arg_of
|
||||
test (count $tokens) -eq 3; and contains -- $tokens[2] $argv
|
||||
end
|
||||
|
||||
# The first argument of a nested subcommand, `worklane campaign show <TAB>`. Three tokens
|
||||
# with both names matched, rather than the token counting the two above do: `campaign show`
|
||||
# puts its argument where a top-level command puts its second, so counting alone would
|
||||
# offer campaigns to `chown alice <TAB>` and tickets here.
|
||||
function __worklane_nested_arg_of
|
||||
set -l tokens (commandline -opc)
|
||||
test (count $tokens) -eq 3; and test "$tokens[2]" = "$argv[1]"; and test "$tokens[3]" = "$argv[2]"
|
||||
end
|
||||
|
||||
# Which command this is, at any position in it. `$tokens[2]` again rather than
|
||||
# `__fish_seen_subcommand_from`, and for the reason spelled out above: `campaign ls` is an
|
||||
# `ls` that fish has seen, so scoping `--tag` with fish's own helper would offer it under a
|
||||
# command that does not take it.
|
||||
#
|
||||
# A rule carrying `-l` needs one of these. Without it fish takes the option as one the
|
||||
# whole tool accepts, and `worklane init --<TAB>` offered `--blocked-by`, `--tag` and four
|
||||
# others that only `relate` and `ls` have.
|
||||
function __worklane_command_is
|
||||
set -l tokens (commandline -opc)
|
||||
test (count $tokens) -ge 2; 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 \
|
||||
@@ -116,7 +166,26 @@ complete -c worklane \
|
||||
|
||||
# `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)'
|
||||
complete -c worklane -n '__worklane_command_is relate' {ticket_flags} \
|
||||
-x -a '(worklane ls --ids)'
|
||||
|
||||
# Campaigns, from `campaign ls --ids`, in the three places one is named: `assign`'s first
|
||||
# argument, `campaign show`'s only one, and `ls --campaign`.
|
||||
complete -c worklane \
|
||||
-n '__worklane_first_arg_of {campaign_commands}; or {campaign_nested}' \
|
||||
-a '(worklane campaign ls --ids)'
|
||||
complete -c worklane -n '__worklane_command_is ls' {campaign_flags} \
|
||||
-x -a '(worklane campaign ls --ids)'
|
||||
|
||||
# Tags come from `worklane tags` rather than from a listing of objects, since a tag has no
|
||||
# id. The count after the tab lands as fish's description, which is what makes the list
|
||||
# worth reading: it says which spelling the board actually uses.
|
||||
complete -c worklane -n '__worklane_command_is ls' {tag_flags} -x -a '(worklane tags)'
|
||||
|
||||
# `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 '__worklane_command_is 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
|
||||
@@ -131,6 +200,15 @@ complete -c worklane -n '__worklane_first_arg_of install-skill' -a '{skills}' -d
|
||||
)
|
||||
}
|
||||
|
||||
/// Option names as fish wants them on a `complete` line, `-l one -l two`.
|
||||
fn flag_list(flags: &[&str]) -> String {
|
||||
flags
|
||||
.iter()
|
||||
.map(|flag| format!("-l {flag}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
/// 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
|
||||
@@ -157,29 +235,68 @@ mod tests {
|
||||
cli
|
||||
}
|
||||
|
||||
/// Every argument in the tool, as the path that reaches it and the argument itself.
|
||||
///
|
||||
/// One walker for the honesty tests below, rather than each one repeating the
|
||||
/// traversal: they differ only in which id they are looking for. Two levels, which is
|
||||
/// as deep as the tool goes, and `help` is skipped because clap generates it and it
|
||||
/// takes no object of ours.
|
||||
fn every_argument() -> Vec<(Vec<String>, clap::Arg)> {
|
||||
let cli = command();
|
||||
let mut found = Vec::new();
|
||||
|
||||
for subcommand in cli.get_subcommands() {
|
||||
let name = subcommand.get_name().to_string();
|
||||
if name == "help" {
|
||||
continue;
|
||||
}
|
||||
for arg in subcommand.get_arguments() {
|
||||
found.push((vec![name.clone()], arg.clone()));
|
||||
}
|
||||
for nested in subcommand.get_subcommands() {
|
||||
let child = nested.get_name().to_string();
|
||||
if child == "help" {
|
||||
continue;
|
||||
}
|
||||
for arg in nested.get_arguments() {
|
||||
found.push((vec![name.clone(), child.clone()], arg.clone()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
found
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// Nested subcommands are walked now that `__worklane_nested_arg_of` exists, but
|
||||
/// nothing under `campaign` takes a ticket, so a nested one is a panic rather than a
|
||||
/// list: it would need a rule of its own in the fish block, and a name in a list here
|
||||
/// would look like it already had one.
|
||||
#[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() {
|
||||
for (path, arg) in every_argument() {
|
||||
// `show` calls it `id`; everything else calls it `ticket`.
|
||||
if !matches!(arg.get_id().as_str(), "ticket" | "id") {
|
||||
continue;
|
||||
}
|
||||
let name = path.join(" ");
|
||||
if arg.is_positional() {
|
||||
assert_eq!(
|
||||
path.len(),
|
||||
1,
|
||||
"`worklane {name}` takes a nested ticket argument, \
|
||||
which needs a rule in the fish block"
|
||||
);
|
||||
let top = path[0].as_str();
|
||||
match arg.get_index() {
|
||||
Some(1) => assert!(
|
||||
TICKET_COMMANDS.contains(&name),
|
||||
TICKET_COMMANDS.contains(&top),
|
||||
"`worklane {name}` takes a ticket first but is not in TICKET_COMMANDS"
|
||||
),
|
||||
Some(2) => assert!(
|
||||
TICKET_SECOND_COMMANDS.contains(&name),
|
||||
TICKET_SECOND_COMMANDS.contains(&top),
|
||||
"`worklane {name}` takes a ticket second but is not in \
|
||||
TICKET_SECOND_COMMANDS"
|
||||
),
|
||||
@@ -189,6 +306,97 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// The same for campaigns, which is why the lists above are three rather than one:
|
||||
/// a campaign is named as a first positional, as a nested subcommand's only argument,
|
||||
/// and as an option value, and each needs a different rule in the fish block.
|
||||
#[test]
|
||||
fn no_campaign_taking_argument_is_missing() {
|
||||
let mut seen = 0;
|
||||
for (path, arg) in every_argument() {
|
||||
if arg.get_id().as_str() != "campaign" {
|
||||
continue;
|
||||
}
|
||||
seen += 1;
|
||||
let name = path.join(" ");
|
||||
|
||||
if let Some(long) = arg.get_long() {
|
||||
assert!(
|
||||
CAMPAIGN_FLAGS.contains(&long),
|
||||
"`worklane {name} --{long}` takes a campaign but is not in CAMPAIGN_FLAGS"
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
assert_eq!(
|
||||
arg.get_index(),
|
||||
Some(1),
|
||||
"`worklane {name}` takes a campaign somewhere the fish block has no rule for"
|
||||
);
|
||||
|
||||
match path.as_slice() {
|
||||
[top] => assert!(
|
||||
CAMPAIGN_COMMANDS.contains(&top.as_str()),
|
||||
"`worklane {name}` takes a campaign first but is not in CAMPAIGN_COMMANDS"
|
||||
),
|
||||
[parent, child] => assert!(
|
||||
CAMPAIGN_NESTED_COMMANDS.contains(&(parent.as_str(), child.as_str())),
|
||||
"`worklane {name}` takes a campaign but is not in CAMPAIGN_NESTED_COMMANDS"
|
||||
),
|
||||
_ => panic!("`worklane {name}` is nested deeper than the fish block goes"),
|
||||
}
|
||||
}
|
||||
|
||||
// A guard on the walker itself: if it stopped finding arguments, every assertion
|
||||
// above would pass by never running.
|
||||
assert_eq!(seen, 3, "expected assign, campaign show and ls --campaign");
|
||||
}
|
||||
|
||||
/// Tags have their own list because their values come from `worklane tags` rather than
|
||||
/// from a listing of objects, so a second tag-taking option would need that rule and
|
||||
/// not the campaign one.
|
||||
#[test]
|
||||
fn no_tag_taking_option_is_missing() {
|
||||
let mut seen = 0;
|
||||
for (path, arg) in every_argument() {
|
||||
if arg.get_id().as_str() != "tag" {
|
||||
continue;
|
||||
}
|
||||
seen += 1;
|
||||
let name = path.join(" ");
|
||||
let long = arg.get_long().unwrap_or_else(|| {
|
||||
panic!(
|
||||
"`worklane {name}` takes a tag as a positional, \
|
||||
which the fish block has no rule for"
|
||||
)
|
||||
});
|
||||
assert!(
|
||||
TAG_FLAGS.contains(&long),
|
||||
"`worklane {name} --{long}` takes a tag but is not in TAG_FLAGS"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(seen, 1, "expected ls --tag");
|
||||
}
|
||||
|
||||
/// **Every rule naming an option has to say which command it belongs to.** A bare
|
||||
/// `complete -c worklane -l tag` tells fish the whole tool takes `--tag`, so
|
||||
/// `worklane init --<TAB>` offered six options that only `relate` and `ls` have. This
|
||||
/// is what stops the next rule being written the same way.
|
||||
#[test]
|
||||
fn every_rule_naming_an_option_is_scoped_to_a_command() {
|
||||
let script = fish_dynamic();
|
||||
// Rules are one logical line, continued with a trailing backslash.
|
||||
for rule in script.replace("\\\n", " ").lines() {
|
||||
if !rule.starts_with("complete") || !rule.contains("-l ") {
|
||||
continue;
|
||||
}
|
||||
assert!(
|
||||
rule.contains("__worklane_command_is"),
|
||||
"this rule declares an option for the whole tool: {rule}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_listed_command_is_a_real_subcommand() {
|
||||
let cli = command();
|
||||
@@ -198,6 +406,28 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// `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("__worklane_command_is 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]
|
||||
@@ -211,10 +441,7 @@ mod tests {
|
||||
.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}"
|
||||
);
|
||||
assert!(known.contains(&flag.to_string()), "`relate` has no --{flag}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -232,6 +459,18 @@ mod tests {
|
||||
assert!(script.contains("worklane-review"));
|
||||
}
|
||||
|
||||
/// The two listings the campaign and tag rules read, which are separate commands
|
||||
/// because a campaign has an id and a tag does not.
|
||||
#[test]
|
||||
fn the_fish_script_asks_worklane_for_its_campaigns_and_tags() {
|
||||
let script = fish_dynamic();
|
||||
assert!(script.contains("worklane campaign ls --ids"), "{script}");
|
||||
assert!(script.contains("worklane tags"), "{script}");
|
||||
// The nested position, which neither of the two counting helpers can reach.
|
||||
assert!(script.contains("__worklane_nested_arg_of campaign show"), "{script}");
|
||||
assert!(script.contains("__worklane_first_arg_of assign"), "{script}");
|
||||
}
|
||||
|
||||
/// 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.
|
||||
|
||||
+147
-90
@@ -1,12 +1,13 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
use chrono::Local;
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs;
|
||||
use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::campaign::*;
|
||||
use crate::command::{
|
||||
AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, LsArgs, RelateArgs, SetArgs,
|
||||
AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, ChownArgs, LsArgs, RelateArgs, SetArgs,
|
||||
};
|
||||
use crate::install;
|
||||
use crate::util::*;
|
||||
@@ -16,10 +17,7 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
let worklane_dir = dir.join(".worklane");
|
||||
|
||||
if worklane_dir.exists() {
|
||||
println!(
|
||||
"worklane already initialized in: {}",
|
||||
worklane_dir.display()
|
||||
);
|
||||
println!("worklane already initialized in: {}", worklane_dir.display());
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -179,10 +177,7 @@ fn filtered(
|
||||
campaign: Option<&str>,
|
||||
tag: Option<&str>,
|
||||
) -> Vec<TicketItem> {
|
||||
filter_by_tag(
|
||||
filter_by_campaign(filter_by_priority(items, level), campaign),
|
||||
tag,
|
||||
)
|
||||
filter_by_tag(filter_by_campaign(filter_by_priority(items, level), campaign), tag)
|
||||
}
|
||||
|
||||
/// Keep only the tickets carrying `tag`, or everything when none was asked for.
|
||||
@@ -246,9 +241,7 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
let backlog_dir = worklane_dir.join("backlog");
|
||||
|
||||
if !backlog_dir.exists() {
|
||||
return Err(anyhow!(
|
||||
"Backlog directory not found. Run `worklane init` first."
|
||||
));
|
||||
return Err(anyhow!("Backlog directory not found. Run `worklane init` first."));
|
||||
}
|
||||
|
||||
let id = uuid::Uuid::new_v4();
|
||||
@@ -256,10 +249,6 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
let filename = format!("{}_{}.md", id, slug);
|
||||
let filepath = backlog_dir.join(&filename);
|
||||
|
||||
if filepath.exists() {
|
||||
return Err(anyhow!("A ticket with this title already exists."));
|
||||
}
|
||||
|
||||
// Joined with a single newline, so an empty value is how a caller spells a
|
||||
// paragraph break and an all-blank description is no description at all.
|
||||
let description = trim_blank_ends(description);
|
||||
@@ -327,7 +316,16 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
);
|
||||
body.push('\n');
|
||||
|
||||
fs::write(&filepath, body)?;
|
||||
// No existence check ahead of this. The name carries a uuid generated a few lines
|
||||
// up, so a collision is not something that happens, and the branch that used to
|
||||
// guard the write claimed the *title* was taken, which is the opposite of what the
|
||||
// format allows: duplicate titles are supported and `add_allows_duplicate_titles`
|
||||
// pins it. `cmd_campaign_add` deliberately does not carry it either. What is left is
|
||||
// the write's own failure, named with the ticket and the path the way the other
|
||||
// writes in the tree name them.
|
||||
fs::write(&filepath, body).map_err(|e| {
|
||||
anyhow!("Could not write ticket '{}' at {}: {}", title, filepath.display(), e)
|
||||
})?;
|
||||
|
||||
println!("Created ticket: {}", filename);
|
||||
Ok(())
|
||||
@@ -472,12 +470,7 @@ fn write_then_replace(
|
||||
|
||||
if let Err(e) = fs::rename(&temp, path) {
|
||||
let _ = fs::remove_file(&temp);
|
||||
return Err(anyhow!(
|
||||
"Could not write ticket '{}' at {}: {}",
|
||||
title,
|
||||
path.display(),
|
||||
e
|
||||
));
|
||||
return Err(anyhow!("Could not write ticket '{}' at {}: {}", title, path.display(), e));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -548,14 +541,8 @@ fn move_ticket_file(
|
||||
|
||||
// The content is correct and in one place by now, so a failure here leaves the
|
||||
// ticket where it started rather than half moved.
|
||||
fs::rename(&source, &dest).map_err(|e| {
|
||||
anyhow!(
|
||||
"Could not move ticket '{}' to {}: {}",
|
||||
title,
|
||||
dest.display(),
|
||||
e
|
||||
)
|
||||
})
|
||||
fs::rename(&source, &dest)
|
||||
.map_err(|e| anyhow!("Could not move ticket '{}' to {}: {}", title, dest.display(), e))
|
||||
}
|
||||
|
||||
/// Refuse a move while a ticket it is `blocked by` is not done.
|
||||
@@ -795,40 +782,47 @@ fn save_ticket(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Take an edit, or record that it changed nothing.
|
||||
///
|
||||
/// Each edit is compared against the content going in, so a field set to the value it
|
||||
/// already holds is reported as unchanged rather than claimed as an update. That is also
|
||||
/// what makes clearing an already unset field free: the sentinel it writes is the one
|
||||
/// already there, so the strings match and nothing is written.
|
||||
fn apply(content: &mut String, changed: &mut Vec<&'static str>, field: &'static str, next: String) {
|
||||
if *content != next {
|
||||
content.clone_from(&next);
|
||||
changed.push(field);
|
||||
}
|
||||
}
|
||||
|
||||
fn report(fields: &[&str], title: &str, verb: &str) {
|
||||
if fields.is_empty() {
|
||||
println!("No changes to '{}'", color_text(title, Color::Green));
|
||||
return;
|
||||
}
|
||||
|
||||
println!(
|
||||
"{} {} on '{}'",
|
||||
verb,
|
||||
fields.join(", "),
|
||||
color_text(title, Color::Green)
|
||||
);
|
||||
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, Color::Green));
|
||||
}
|
||||
|
||||
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
if let Some(field) = args.contested() {
|
||||
let name = field.name();
|
||||
return Err(anyhow!(
|
||||
"--{name} and --clear {name} contradict each other, so nothing was written"
|
||||
));
|
||||
}
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let mut content = original.clone();
|
||||
let mut changed: Vec<&str> = Vec::new();
|
||||
|
||||
// Each edit is compared against the content going in, so a field set to the value
|
||||
// it already holds is reported as unchanged rather than claimed as an update.
|
||||
let mut apply = |content: &mut String, field: &'static str, next: String| {
|
||||
if *content != next {
|
||||
content.clone_from(&next);
|
||||
changed.push(field);
|
||||
}
|
||||
};
|
||||
let mut cleared: Vec<&str> = Vec::new();
|
||||
|
||||
if let Some(new_title) = &args.title {
|
||||
let next = set_title(&content, new_title)?;
|
||||
apply(&mut content, "title", next);
|
||||
apply(&mut content, &mut changed, "title", next);
|
||||
}
|
||||
|
||||
for (section, values) in section_args(&args.description, &args.acceptance, &args.plan) {
|
||||
@@ -839,32 +833,46 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
let items = section.normalise(values);
|
||||
if items.is_empty() {
|
||||
return Err(anyhow!(
|
||||
"An empty {} is not a way to clear the section, and clearing is not supported yet",
|
||||
section.label
|
||||
"An empty value is a paragraph break, not a way to empty the {}: use --clear {}",
|
||||
section.label,
|
||||
section.clear.map_or("", Clearable::name)
|
||||
));
|
||||
}
|
||||
|
||||
let next = set_section_body(&content, section, &items)?;
|
||||
apply(&mut content, section.label, next);
|
||||
apply(&mut content, &mut changed, section.label, next);
|
||||
}
|
||||
|
||||
if !args.tags.is_empty() {
|
||||
let next = set_metadata_field(&content, "Tags", &args.tags.join(", "), &title)?;
|
||||
apply(&mut content, "tags", next);
|
||||
apply(&mut content, &mut changed, "tags", next);
|
||||
}
|
||||
|
||||
if let Some(due) = &args.due {
|
||||
let next = set_metadata_field(&content, "Due", due, &title)?;
|
||||
apply(&mut content, "due", next);
|
||||
apply(&mut content, &mut changed, "due", next);
|
||||
}
|
||||
|
||||
if let Some(priority) = args.priority {
|
||||
let next = set_metadata_field(&content, "Priority", &priority.to_string(), &title)?;
|
||||
apply(&mut content, "priority", next);
|
||||
apply(&mut content, &mut changed, "priority", next);
|
||||
}
|
||||
|
||||
if changed.is_empty() {
|
||||
report(&changed, &title, "Updated");
|
||||
// Last, and into a list of their own. No field can be in both, since `contested`
|
||||
// refused that above, so the order is free and the report is what decides it: a
|
||||
// caller is told what was replaced and what was emptied in those words.
|
||||
for field in &args.clear {
|
||||
let next = match field.unset() {
|
||||
Unset::Field { field, sentinel } => {
|
||||
set_metadata_field(&content, field, sentinel, &title)?
|
||||
}
|
||||
Unset::Section(section) => clear_section_body(&content, section)?,
|
||||
};
|
||||
apply(&mut content, &mut cleared, field.label(), next);
|
||||
}
|
||||
|
||||
if changed.is_empty() && cleared.is_empty() {
|
||||
report(&[], &title, "Updated");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -872,7 +880,12 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, renamed, &content)?;
|
||||
|
||||
let shown = args.title.clone().unwrap_or(title);
|
||||
report(&changed, &shown, "Updated");
|
||||
if !changed.is_empty() {
|
||||
report(&changed, &shown, "Updated");
|
||||
}
|
||||
if !cleared.is_empty() {
|
||||
report(&cleared, &shown, "Cleared");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -885,13 +898,23 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
/// stay silent on the one it cannot, a ticket whose title is the username.
|
||||
///
|
||||
/// No-op detection compares the whole file, the way `set` does, so an owner set to the
|
||||
/// value it already holds is reported unchanged and nothing is written.
|
||||
pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
||||
/// value it already holds is reported unchanged and nothing is written. The same
|
||||
/// comparison is what makes clearing an already unset owner free.
|
||||
///
|
||||
/// **Clearing writes [`NOT_SET`], not the git user.** `add` falls back to the git user
|
||||
/// for a ticket it is filing, which is a default for something new; an owner taken away
|
||||
/// says nobody owns this, and putting the person running the command there instead would
|
||||
/// hand them a ticket they were giving up.
|
||||
pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
let (ticket_id, user) = args.target().ok_or_else(|| {
|
||||
anyhow!("chown takes a user and a ticket, or --clear with the ticket alone")
|
||||
})?;
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let content = set_metadata_field(&original, "Owner", user, &title)?;
|
||||
let content = set_metadata_field(&original, "Owner", user.unwrap_or(NOT_SET), &title)?;
|
||||
|
||||
if content == original {
|
||||
report(&[], &title, "Updated");
|
||||
@@ -900,7 +923,11 @@ pub fn cmd_chown(user: &str, ticket_id: &str, start: &Path) -> Result<()> {
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
report(&["owner"], &title, "Updated");
|
||||
let verb = match user {
|
||||
Some(_) => "Updated",
|
||||
None => "Cleared",
|
||||
};
|
||||
report(&["owner"], &title, verb);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -975,10 +1002,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
));
|
||||
}
|
||||
|
||||
let relation = Relation {
|
||||
kind,
|
||||
target: target_uuid,
|
||||
};
|
||||
let relation = Relation { kind, target: target_uuid };
|
||||
|
||||
// Already held, either in the file or earlier in this call. Recording it
|
||||
// twice would read as two dependencies on one ticket.
|
||||
@@ -1013,11 +1037,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
/// half-written campaign behind. `cmd_add` predates that primitive and still uses the
|
||||
/// plain write; the difference is noted on the ticket rather than fixed here.
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
let CampaignAddArgs {
|
||||
title,
|
||||
description,
|
||||
owner,
|
||||
} = args;
|
||||
let CampaignAddArgs { title, description, owner } = args;
|
||||
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let dir = ensure_campaigns_dir(&worklane_dir)?;
|
||||
@@ -1051,9 +1071,19 @@ pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
/// scan per row rather than one scan reused, and it is deliberate: the alternative is a
|
||||
/// map from campaign uuid to counts built in a single walk, which is worth writing when
|
||||
/// a board has enough campaigns to notice and is premature now.
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
let index = CampaignIndex::load(worklane_dir)?;
|
||||
|
||||
// Ahead of the empty check, which prints prose: a completion must offer nothing
|
||||
// rather than offer a sentence, the same bargain `list_ids` takes with a missing
|
||||
// status directory.
|
||||
if ids {
|
||||
for campaign in index.iter() {
|
||||
println!("{}\t{}", short_id(&campaign.uuid), campaign.title);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if index.is_empty() {
|
||||
println!("No campaigns yet. `worklane campaign add --title` files one.");
|
||||
return Ok(());
|
||||
@@ -1081,6 +1111,48 @@ pub fn cmd_campaign_ls(worklane_dir: &Path) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Every tag on the board, with how many tickets carry it.
|
||||
///
|
||||
/// The vocabulary itself, which nothing else could answer: `ls --tag` filters by a tag
|
||||
/// already known, and the decorated listing does not print tags at all. A grooming sweep
|
||||
/// starts by asking what the vocabulary *is*, and `assets/PLAN.md` used to have to say
|
||||
/// that the question could only be answered by reading the tickets.
|
||||
///
|
||||
/// **Alphabetical, and case sensitive.** `--tag` matches a whole value case sensitively,
|
||||
/// so `bug` and `Bug` are two tags and listing them as one would hide the reason a filter
|
||||
/// came back short. Sorting puts them next to each other, which is where a near-duplicate
|
||||
/// is spotted.
|
||||
///
|
||||
/// Machine-readable, the second output in the tree that is: the tag, a tab, the count.
|
||||
/// Fish reads what follows the tab as a description, a script takes `cut -f1`, and neither
|
||||
/// wants an escape sequence. Every status, done included, for the reason `ls --ids`
|
||||
/// includes it: a tag retired months ago is still part of the answer to what the
|
||||
/// vocabulary has been.
|
||||
pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
// BTreeMap rather than a sort afterwards: the order is the point, and the counting
|
||||
// wants a map anyway.
|
||||
let mut counts: BTreeMap<String, usize> = BTreeMap::new();
|
||||
|
||||
for status in status_dirs() {
|
||||
let status_path = worklane_dir.join(status);
|
||||
// Skipped rather than refused, as in `list_ids`, and for the same reason.
|
||||
if !status_path.exists() {
|
||||
continue;
|
||||
}
|
||||
for item in collect_ticket_items(&status_path)? {
|
||||
for tag in item.tags {
|
||||
*counts.entry(tag).or_default() += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (tag, count) in counts {
|
||||
println!("{}\t{}", tag, count);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Show a campaign, then its members grouped by status.
|
||||
///
|
||||
/// Every status is shown, done included, unlike `ls`, which leaves done out of its
|
||||
@@ -1093,10 +1165,7 @@ pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
println!("{}", "─".repeat(campaign.title.chars().count()));
|
||||
// No relations and no campaign of its own: a campaign is not a ticket, and neither
|
||||
// belongs to one.
|
||||
println!(
|
||||
"\n{}",
|
||||
content_trim_colored(&campaign.content, &Resolved::default())
|
||||
);
|
||||
println!("\n{}", content_trim_colored(&campaign.content, &Resolved::default()));
|
||||
|
||||
let grouped = members(worklane_dir, &campaign.uuid)?;
|
||||
let standing = Standing::of(&grouped);
|
||||
@@ -1109,10 +1178,7 @@ pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
if items.is_empty() {
|
||||
continue;
|
||||
}
|
||||
println!(
|
||||
"\n{}",
|
||||
color_text(&format!("[{}]", status.to_uppercase()), Color::Orange)
|
||||
);
|
||||
println!("\n{}", color_text(&format!("[{}]", status.to_uppercase()), Color::Orange));
|
||||
display_ticket_items(items);
|
||||
}
|
||||
|
||||
@@ -1133,8 +1199,7 @@ pub fn cmd_assign(campaign_search: &str, ticket_id: &str, start: &Path) -> Resul
|
||||
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
|
||||
let content =
|
||||
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
|
||||
let content = set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
|
||||
|
||||
if content == original {
|
||||
println!(
|
||||
@@ -1286,10 +1351,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
.collect();
|
||||
|
||||
if !changing.is_empty() {
|
||||
let lines: Vec<usize> = changing
|
||||
.iter()
|
||||
.map(|offset| criteria[*offset].line)
|
||||
.collect();
|
||||
let lines: Vec<usize> = changing.iter().map(|offset| criteria[*offset].line).collect();
|
||||
let updated = set_criteria(&content, &lines, checked);
|
||||
let uuid = parse_ticket_field(&content, "ID");
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
|
||||
@@ -1308,12 +1370,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
past.to_string()
|
||||
};
|
||||
|
||||
println!(
|
||||
"{} {}: {}",
|
||||
state,
|
||||
offset + 1,
|
||||
color_text(&criterion.text, Color::Green)
|
||||
);
|
||||
println!("{} {}: {}", state, offset + 1, color_text(&criterion.text, Color::Green));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
|
||||
+18
-22
@@ -75,9 +75,10 @@ pub static SKILLS: [Asset; 3] = [SKILL, REVIEW_SKILL, PLAN_SKILL];
|
||||
|
||||
/// The skill a name on the command line asks for.
|
||||
pub fn skill_named(name: &str) -> Result<&'static Asset> {
|
||||
SKILLS.iter().find(|asset| asset.name == name).ok_or_else(|| {
|
||||
anyhow!("no skill named {name:?}. This binary ships {}", skill_names())
|
||||
})
|
||||
SKILLS
|
||||
.iter()
|
||||
.find(|asset| asset.name == name)
|
||||
.ok_or_else(|| anyhow!("no skill named {name:?}. This binary ships {}", skill_names()))
|
||||
}
|
||||
|
||||
/// The names, for the errors that have to say what there is to choose from.
|
||||
@@ -173,10 +174,7 @@ mod tests {
|
||||
let root = root();
|
||||
let path = SKILL.path(root.path());
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Written(path.clone())
|
||||
);
|
||||
assert_eq!(SKILL.install(root.path(), false).unwrap(), Outcome::Written(path.clone()));
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
|
||||
}
|
||||
|
||||
@@ -201,16 +199,10 @@ mod tests {
|
||||
SKILL.install(root.path(), false).unwrap();
|
||||
std::fs::write(&path, "hand written\n").unwrap();
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Refused(path.clone())
|
||||
);
|
||||
assert_eq!(SKILL.install(root.path(), false).unwrap(), Outcome::Refused(path.clone()));
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), "hand written\n");
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), true).unwrap(),
|
||||
Outcome::Written(path.clone())
|
||||
);
|
||||
assert_eq!(SKILL.install(root.path(), true).unwrap(), Outcome::Written(path.clone()));
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
|
||||
}
|
||||
|
||||
@@ -254,8 +246,10 @@ mod tests {
|
||||
"the frontmatter name has to match the directory it installs into"
|
||||
);
|
||||
|
||||
let description = frontmatter_field(asset.content, "description")
|
||||
.unwrap_or_else(|| panic!("{} ships without a description to trigger on", asset.name));
|
||||
let description =
|
||||
frontmatter_field(asset.content, "description").unwrap_or_else(|| {
|
||||
panic!("{} ships without a description to trigger on", asset.name)
|
||||
});
|
||||
assert!(
|
||||
description.len() > 80,
|
||||
"{}: the description is what decides whether the skill loads at all",
|
||||
@@ -311,7 +305,9 @@ mod tests {
|
||||
if words.next() != Some("worklane") {
|
||||
continue;
|
||||
}
|
||||
let Some(candidate) = words.next() else { continue };
|
||||
let Some(candidate) = words.next() else {
|
||||
continue;
|
||||
};
|
||||
// A flag before the subcommand, as in the `mv -- -leading-title` example.
|
||||
if candidate.starts_with("--") && !known.iter().any(|k| k == candidate) {
|
||||
continue;
|
||||
@@ -386,9 +382,9 @@ mod tests {
|
||||
fn the_plan_skill_keeps_the_rules_that_bound_a_sweep() {
|
||||
for required in [
|
||||
"Propose the whole set of edits",
|
||||
"replaces the whole\nfield", // `set --tags` is the destructive one
|
||||
"cannot be cleared", // and a due date cannot be taken back
|
||||
"blocked by", // ordering constrains any dating plan
|
||||
"replaces the whole\nfield", // `set --tags` is the destructive one
|
||||
"not\nback to what it held", // and --clear is not an undo
|
||||
"blocked by", // ordering constrains any dating plan
|
||||
"worklane campaign ls",
|
||||
"does not touch",
|
||||
] {
|
||||
@@ -407,7 +403,7 @@ mod tests {
|
||||
#[test]
|
||||
fn the_review_skill_keeps_the_decisions_that_define_it() {
|
||||
for required in [
|
||||
"worklane show", // the ticket is read before the code
|
||||
"worklane show", // the ticket is read before the code
|
||||
"nothing names the ticket", // and the no-work-found case is answered
|
||||
"Never tick a criterion",
|
||||
"Do not move the ticket",
|
||||
|
||||
+12
-17
@@ -55,27 +55,21 @@ fn main() -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_show(&id, &worklane_dir)
|
||||
}
|
||||
Some(Command::Mv {
|
||||
ticket,
|
||||
status,
|
||||
force,
|
||||
}) => cmd_mv(&ticket, status, force, &start),
|
||||
Some(Command::Mv { ticket, status, force }) => cmd_mv(&ticket, status, force, &start),
|
||||
Some(Command::Set(args)) => cmd_set(&args, &start),
|
||||
Some(Command::Append(args)) => cmd_append(&args, &start),
|
||||
Some(Command::Relate(args)) => cmd_relate(&args, &start),
|
||||
Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start),
|
||||
Some(Command::Chown(args)) => cmd_chown(&args, &start),
|
||||
Some(Command::Check(args)) => cmd_check(&args, true, &start),
|
||||
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
||||
Some(Command::Comment {
|
||||
ticket,
|
||||
body,
|
||||
owner,
|
||||
}) => cmd_comment(&ticket, &body, &owner, &start),
|
||||
Some(Command::Comment { ticket, body, owner }) => {
|
||||
cmd_comment(&ticket, &body, &owner, &start)
|
||||
}
|
||||
Some(Command::Campaign { command }) => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
||||
CampaignCommand::Ls => {
|
||||
CampaignCommand::Ls { ids } => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_campaign_ls(&worklane_dir)
|
||||
cmd_campaign_ls(&worklane_dir, ids)
|
||||
}
|
||||
CampaignCommand::Show { campaign } => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
@@ -83,6 +77,10 @@ fn main() -> Result<()> {
|
||||
}
|
||||
},
|
||||
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
|
||||
Some(Command::Tags) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_tags(&worklane_dir)
|
||||
}
|
||||
// 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 }) => {
|
||||
@@ -112,10 +110,7 @@ fn install_panic_hook() {
|
||||
|
||||
fn restore_terminal() -> std::io::Result<()> {
|
||||
crossterm::terminal::disable_raw_mode()?;
|
||||
crossterm::execute!(
|
||||
std::io::stdout(),
|
||||
crossterm::terminal::LeaveAlternateScreen
|
||||
)
|
||||
crossterm::execute!(std::io::stdout(), crossterm::terminal::LeaveAlternateScreen)
|
||||
}
|
||||
|
||||
fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()> {
|
||||
|
||||
+78
-112
@@ -6,19 +6,19 @@
|
||||
//!
|
||||
//! **Read only.** Moving a card by keypress is a follow-up. Everything here observes.
|
||||
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, SystemTime};
|
||||
|
||||
use anyhow::{Context, Result};
|
||||
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||||
use ratatui::Frame;
|
||||
use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect, Size};
|
||||
use ratatui::style::{Modifier, Style};
|
||||
use ratatui::text::{Line, Span, Text};
|
||||
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs, Wrap};
|
||||
use ratatui::Frame;
|
||||
|
||||
use crate::handlers::read_comments;
|
||||
use crate::util::*;
|
||||
@@ -71,10 +71,7 @@ pub fn projects(paths: &[PathBuf], start: &Path) -> Result<Vec<Project>> {
|
||||
continue;
|
||||
}
|
||||
|
||||
projects.push(Project {
|
||||
name: project_name(&dir),
|
||||
dir,
|
||||
});
|
||||
projects.push(Project { name: project_name(&dir), dir });
|
||||
}
|
||||
|
||||
Ok(projects)
|
||||
@@ -315,11 +312,7 @@ impl Board {
|
||||
if projects.len() > 1 {
|
||||
tabs.push(Tab::new(ALL.to_string()));
|
||||
}
|
||||
tabs.extend(
|
||||
projects
|
||||
.iter()
|
||||
.map(|project| Tab::new(project.name.clone())),
|
||||
);
|
||||
tabs.extend(projects.iter().map(|project| Tab::new(project.name.clone())));
|
||||
|
||||
let mut board = Board {
|
||||
tabs,
|
||||
@@ -775,10 +768,7 @@ fn detail_of(card: &Card) -> Detail {
|
||||
// Colour off for the text, which is what keeps escapes out of the paragraph, and the
|
||||
// relations arrive as rows so the board can style them itself.
|
||||
let mut parts = content_parts(&content, false, &resolved);
|
||||
parts.push(BodyPart::Text(format!(
|
||||
"\n{}",
|
||||
format_comments_with(&comments, false)
|
||||
)));
|
||||
parts.push(BodyPart::Text(format!("\n{}", format_comments_with(&comments, false))));
|
||||
|
||||
Detail {
|
||||
title: ticket.title.clone(),
|
||||
@@ -1136,12 +1126,7 @@ fn draw_columns(frame: &mut Frame, board: &Board, area: Rect) {
|
||||
};
|
||||
|
||||
// An empty status is an empty column, not a column that is not there.
|
||||
frame.render_widget(
|
||||
Paragraph::new(lines)
|
||||
.block(block)
|
||||
.scroll((offset, 0)),
|
||||
areas[index],
|
||||
);
|
||||
frame.render_widget(Paragraph::new(lines).block(block).scroll((offset, 0)), areas[index]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1285,12 +1270,11 @@ fn card_lines(card: &Card, selected: bool, width: u16) -> Vec<Line<'static>> {
|
||||
|
||||
let mut lines = vec![corner_line(left, due_span(&ticket.due), width)];
|
||||
|
||||
lines.extend(title_lines(&ticket.title, width).into_iter().map(|line| {
|
||||
Line::from(Span::styled(
|
||||
line,
|
||||
Style::default().add_modifier(emphasis),
|
||||
))
|
||||
}));
|
||||
lines.extend(
|
||||
title_lines(&ticket.title, width)
|
||||
.into_iter()
|
||||
.map(|line| Line::from(Span::styled(line, Style::default().add_modifier(emphasis)))),
|
||||
);
|
||||
|
||||
if let Some(row) = tags_line(&ticket.tags, width) {
|
||||
lines.push(row);
|
||||
@@ -1352,10 +1336,7 @@ fn tags_line(tags: &[String], width: u16) -> Option<Line<'static>> {
|
||||
if index > 0 {
|
||||
spans.push(Span::raw(" "));
|
||||
}
|
||||
spans.push(Span::styled(
|
||||
format!("#{tag}"),
|
||||
Style::default().fg(tag_color(tag).into()),
|
||||
));
|
||||
spans.push(Span::styled(format!("#{tag}"), Style::default().fg(tag_color(tag).into())));
|
||||
}
|
||||
|
||||
Some(Line::from(spans))
|
||||
@@ -1399,10 +1380,7 @@ fn due_span(due: &str) -> Option<Span<'static>> {
|
||||
false => Color::Cyan,
|
||||
};
|
||||
|
||||
Some(Span::styled(
|
||||
due_date(due).to_string(),
|
||||
Style::default().fg(colour.into()),
|
||||
))
|
||||
Some(Span::styled(due_date(due).to_string(), Style::default().fg(colour.into())))
|
||||
}
|
||||
|
||||
/// `left` at the left, `right` at the right, with the gap between them.
|
||||
@@ -1490,10 +1468,7 @@ fn title_lines(title: &str, width: u16) -> Vec<String> {
|
||||
|
||||
fn chars_in_chunks(word: &str, width: usize) -> Vec<String> {
|
||||
let chars: Vec<char> = word.chars().collect();
|
||||
chars
|
||||
.chunks(width)
|
||||
.map(|chunk| chunk.iter().collect())
|
||||
.collect()
|
||||
chars.chunks(width).map(|chunk| chunk.iter().collect()).collect()
|
||||
}
|
||||
|
||||
/// The row with an ellipsis on the end, making room for it if the row is full.
|
||||
@@ -1574,10 +1549,7 @@ fn draw_notice(frame: &mut Frame, notice: &Notice, area: Rect) {
|
||||
false => Style::default(),
|
||||
};
|
||||
|
||||
frame.render_widget(
|
||||
Paragraph::new(Span::styled(format!(" {}", notice.text), style)),
|
||||
area,
|
||||
);
|
||||
frame.render_widget(Paragraph::new(Span::styled(format!(" {}", notice.text), style)), area);
|
||||
}
|
||||
|
||||
/// The prompt, in place of the key list it would otherwise describe wrongly.
|
||||
@@ -1595,10 +1567,7 @@ fn draw_search(frame: &mut Frame, search: &Search, area: Rect) {
|
||||
let mut spans = vec![Span::raw(prompt.clone())];
|
||||
|
||||
if search.missed {
|
||||
spans.push(Span::styled(
|
||||
" no match",
|
||||
Style::default().fg(Color::BrightRed.into()),
|
||||
));
|
||||
spans.push(Span::styled(" no match", Style::default().fg(Color::BrightRed.into())));
|
||||
}
|
||||
spans.push(Span::styled(
|
||||
" enter jump esc cancel ",
|
||||
@@ -1737,11 +1706,8 @@ fn draw_detail(frame: &mut Frame, detail: &Detail, offset: u16, area: Rect) {
|
||||
// keys and a rendered checkbox take, and does not compete with the orange title.
|
||||
if let Some(indicator) = page_indicator(offset, last, text.height, overlay.width) {
|
||||
block = block.title_bottom(
|
||||
Line::from(Span::styled(
|
||||
indicator,
|
||||
Style::default().fg(Color::Grey.into()),
|
||||
))
|
||||
.right_aligned(),
|
||||
Line::from(Span::styled(indicator, Style::default().fg(Color::Grey.into())))
|
||||
.right_aligned(),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1865,10 +1831,7 @@ mod tests {
|
||||
|
||||
/// The screen the scrolling tests draw on, so the keypress and the draw measure the
|
||||
/// same overlay.
|
||||
const SCREEN: Size = Size {
|
||||
width: 120,
|
||||
height: 20,
|
||||
};
|
||||
const SCREEN: Size = Size { width: 120, height: 20 };
|
||||
|
||||
/// The rendered buffer as lines of text, escapes and styling dropped.
|
||||
fn render(board: &Board, width: u16, height: u16) -> Vec<String> {
|
||||
@@ -2191,7 +2154,8 @@ mod tests {
|
||||
/// it drops styling on the way out of the buffer.
|
||||
fn card_colour(dir: &Path, width: u16, needle: &str) -> Option<ratatui::style::Color> {
|
||||
let board = one_board(dir);
|
||||
let inner = card_width(Size { width, height: 20 }, board.tabbed(), board.visible().len(), 0);
|
||||
let inner =
|
||||
card_width(Size { width, height: 20 }, board.tabbed(), board.visible().len(), 0);
|
||||
let ticket = board.selected().expect("no card");
|
||||
|
||||
card_lines(ticket, false, inner)
|
||||
@@ -2432,7 +2396,8 @@ mod tests {
|
||||
let dir = board_dir();
|
||||
let before = digest(&dir);
|
||||
|
||||
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let path =
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let created = digest(&dir);
|
||||
assert_ne!(before, created, "a new ticket went unnoticed");
|
||||
|
||||
@@ -2448,7 +2413,8 @@ mod tests {
|
||||
#[test]
|
||||
fn the_digest_moves_when_a_ticket_is_edited_in_place() {
|
||||
let dir = board_dir();
|
||||
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let path =
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let before = digest(&dir);
|
||||
|
||||
let content = std::fs::read_to_string(&path).unwrap();
|
||||
@@ -2462,7 +2428,8 @@ mod tests {
|
||||
#[test]
|
||||
fn the_digest_moves_on_an_edit_of_the_same_length() {
|
||||
let dir = board_dir();
|
||||
let path = write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
let path =
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
|
||||
let content = std::fs::read_to_string(&path).unwrap();
|
||||
let same_length = content.replace("A description.", "A descriptionA");
|
||||
@@ -2534,7 +2501,11 @@ mod tests {
|
||||
#[test]
|
||||
fn the_card_index_is_clamped_when_the_column_is_shorter() {
|
||||
let dir = board_dir();
|
||||
for (n, title) in [("11111111", "Alpha"), ("22222222", "Beta"), ("33333333", "Gamma")] {
|
||||
for (n, title) in [
|
||||
("11111111", "Alpha"),
|
||||
("22222222", "Beta"),
|
||||
("33333333", "Gamma"),
|
||||
] {
|
||||
write_ticket(&dir, "backlog", &format!("{n}-0000-4000-8000-000000000000"), title, "");
|
||||
}
|
||||
write_ticket(&dir, "committed", "44444444-0000-4000-8000-000000000000", "Delta", "");
|
||||
@@ -2572,10 +2543,7 @@ mod tests {
|
||||
|
||||
let top = render(&board, SCREEN.width, SCREEN.height).join("\n");
|
||||
assert!(top.contains("Ticket 01"), "{top}");
|
||||
assert!(
|
||||
!top.contains("Ticket 12"),
|
||||
"the fixture fits without scrolling:\n{top}"
|
||||
);
|
||||
assert!(!top.contains("Ticket 12"), "the fixture fits without scrolling:\n{top}");
|
||||
|
||||
board.select_card(11, SCREEN);
|
||||
|
||||
@@ -2693,10 +2661,7 @@ mod tests {
|
||||
// holding a scroll position for a highlight it no longer has.
|
||||
assert_eq!(board.current().card, 2);
|
||||
let back = render(&board, SCREEN.width, SCREEN.height).join("\n");
|
||||
assert!(
|
||||
back.contains("Ticket 03"),
|
||||
"returning lost the selection:\n{back}"
|
||||
);
|
||||
assert!(back.contains("Ticket 03"), "returning lost the selection:\n{back}");
|
||||
assert!(!back.contains("Ticket 12"), "{back}");
|
||||
}
|
||||
|
||||
@@ -2708,10 +2673,7 @@ mod tests {
|
||||
fill_column(&dir, "backlog", 12);
|
||||
|
||||
// Tall enough that every card fits, so the keypress stores no scroll at all.
|
||||
let roomy = Size {
|
||||
width: 120,
|
||||
height: 60,
|
||||
};
|
||||
let roomy = Size { width: 120, height: 60 };
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.select_card(11, roomy);
|
||||
@@ -2804,7 +2766,11 @@ mod tests {
|
||||
}
|
||||
|
||||
let screen = render(&board, SCREEN.width, SCREEN.height);
|
||||
assert!(screen.join("\n").contains("Line 060"), "nothing scrolled:\n{}", screen.join("\n"));
|
||||
assert!(
|
||||
screen.join("\n").contains("Line 060"),
|
||||
"nothing scrolled:\n{}",
|
||||
screen.join("\n")
|
||||
);
|
||||
|
||||
let row = overlay_title_row(&screen, SCREEN.width, SCREEN.height);
|
||||
assert!(row.contains("(1111111)"), "the id scrolled away:\n{row}");
|
||||
@@ -2956,10 +2922,7 @@ mod tests {
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "First one", "");
|
||||
|
||||
// Tall enough that the whole ticket is on screen at once.
|
||||
let roomy = Size {
|
||||
width: 120,
|
||||
height: 60,
|
||||
};
|
||||
let roomy = Size { width: 120, height: 60 };
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
@@ -3203,7 +3166,13 @@ mod tests {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "backlog", "11111111-0000-4000-8000-000000000000", "Alpha first", "");
|
||||
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "Beta second", "");
|
||||
write_ticket(&dir, "committed", "33333333-0000-4000-8000-000000000000", "Gamma third", "");
|
||||
write_ticket(
|
||||
&dir,
|
||||
"committed",
|
||||
"33333333-0000-4000-8000-000000000000",
|
||||
"Gamma third",
|
||||
"",
|
||||
);
|
||||
write_ticket(&dir, "done", "44444444-0000-4000-8000-000000000000", "Delta finished", "");
|
||||
dir
|
||||
}
|
||||
@@ -3522,8 +3491,7 @@ mod tests {
|
||||
board.open_search();
|
||||
type_query(&mut board, "gam");
|
||||
|
||||
let mut terminal =
|
||||
Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
|
||||
let mut terminal = Terminal::new(TestBackend::new(SCREEN.width, SCREEN.height)).unwrap();
|
||||
terminal.draw(|frame| draw(frame, &board)).unwrap();
|
||||
|
||||
let at = terminal.get_cursor_position().unwrap();
|
||||
@@ -3696,9 +3664,9 @@ mod tests {
|
||||
the OSC 52 write is named"
|
||||
);
|
||||
|
||||
let cleared = source.find("board.clear_notice();").expect(
|
||||
"a notice that nothing clears sits in the footer for the rest of the session",
|
||||
);
|
||||
let cleared = source
|
||||
.find("board.clear_notice();")
|
||||
.expect("a notice that nothing clears sits in the footer for the rest of the session");
|
||||
let prompt = source.find("if board.search_key(key, screen)").unwrap();
|
||||
assert!(
|
||||
cleared < prompt,
|
||||
@@ -3883,10 +3851,7 @@ mod tests {
|
||||
|
||||
assert_eq!(project_label("alpha", 38, IDENTITY).as_deref(), Some("alpha"));
|
||||
// Room for three characters of a longer name, the last of them the ellipsis.
|
||||
assert_eq!(
|
||||
project_label("factry-core", 16, IDENTITY).as_deref(),
|
||||
Some("fa…")
|
||||
);
|
||||
assert_eq!(project_label("factry-core", 16, IDENTITY).as_deref(), Some("fa…"));
|
||||
assert_eq!(project_label("factry-core", 13, IDENTITY), None);
|
||||
assert_eq!(project_label("alpha", 4, IDENTITY), None);
|
||||
}
|
||||
@@ -3984,10 +3949,7 @@ mod tests {
|
||||
assert!(!marked_blocked(&board, "The waiter"));
|
||||
|
||||
let screen = render(&board, 120, 20).join("\n");
|
||||
assert!(
|
||||
!screen.contains(BLOCKED_MARK),
|
||||
"a cleared blocker still marked:\n{screen}"
|
||||
);
|
||||
assert!(!screen.contains(BLOCKED_MARK), "a cleared blocker still marked:\n{screen}");
|
||||
}
|
||||
|
||||
/// One open blocker out of two is still a reason not to start, the rule `mv` applies
|
||||
@@ -4056,7 +4018,11 @@ mod tests {
|
||||
assert!(wide[0].contains(BLOCKED_MARK), "no mark with room for it: {:?}", wide[0]);
|
||||
|
||||
let narrow = card_rows(&board, "The waiter", identity);
|
||||
assert!(!narrow[0].contains(BLOCKED_MARK), "mark kept over the column: {:?}", narrow[0]);
|
||||
assert!(
|
||||
!narrow[0].contains(BLOCKED_MARK),
|
||||
"mark kept over the column: {:?}",
|
||||
narrow[0]
|
||||
);
|
||||
assert!(narrow[0].contains(&id), "the identity gave way instead: {:?}", narrow[0]);
|
||||
assert!(narrow[0].chars().count() <= identity as usize, "row over the column");
|
||||
}
|
||||
@@ -4209,8 +4175,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// The style of the first cell drawing `symbol`, so a test can ask what colour a
|
||||
/// glyph actually reached the screen in rather than trusting the span it was built
|
||||
/// from.
|
||||
@@ -4291,16 +4255,20 @@ mod tests {
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
|
||||
let content = std::fs::read_to_string(
|
||||
board.selected().expect("no selection").ticket.path.clone(),
|
||||
)
|
||||
.unwrap();
|
||||
let content =
|
||||
std::fs::read_to_string(board.selected().expect("no selection").ticket.path.clone())
|
||||
.unwrap();
|
||||
let rows = relations_for(&content, &dir).unwrap();
|
||||
let printed = render_relations(&rows, false);
|
||||
|
||||
assert!(!printed.is_empty(), "the fixture has no relations");
|
||||
assert!(
|
||||
board.detail.as_ref().unwrap().plain().contains(printed.trim_end()),
|
||||
board
|
||||
.detail
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.plain()
|
||||
.contains(printed.trim_end()),
|
||||
"the overlay drew a different block than the listing prints: {printed:?}"
|
||||
);
|
||||
}
|
||||
@@ -4467,7 +4435,10 @@ mod tests {
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
// Marked for its kind, and the mark sits ahead of the id.
|
||||
assert!(
|
||||
text.contains(&format!("blocked by {BLOCKED_MARK} {} (2222222) The target", status_mark(Some("backlog")).0)),
|
||||
text.contains(&format!(
|
||||
"blocked by {BLOCKED_MARK} {} (2222222) The target",
|
||||
status_mark(Some("backlog")).0
|
||||
)),
|
||||
"{text:?}"
|
||||
);
|
||||
assert!(!text.contains(target), "the bare uuid was drawn: {text:?}");
|
||||
@@ -4494,7 +4465,10 @@ mod tests {
|
||||
|
||||
let text = &board.detail.as_ref().expect("no detail").plain();
|
||||
assert!(
|
||||
text.contains(&format!("blocks {BLOCKED_MARK} {} (1111111) A holder", status_mark(Some("backlog")).0)),
|
||||
text.contains(&format!(
|
||||
"blocks {BLOCKED_MARK} {} (1111111) A holder",
|
||||
status_mark(Some("backlog")).0
|
||||
)),
|
||||
"{text:?}"
|
||||
);
|
||||
}
|
||||
@@ -4741,11 +4715,7 @@ mod tests {
|
||||
/// Located on the bottom border row rather than by searching the buffer for a glyph:
|
||||
/// `p` and `g` are all over the board, and `drawn_color` would answer about whichever
|
||||
/// card holds the first one.
|
||||
fn indicator_color(
|
||||
board: &Board,
|
||||
width: u16,
|
||||
height: u16,
|
||||
) -> Option<ratatui::style::Color> {
|
||||
fn indicator_color(board: &Board, width: u16, height: u16) -> Option<ratatui::style::Color> {
|
||||
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
|
||||
terminal.draw(|frame| draw(frame, board)).unwrap();
|
||||
let buffer = terminal.backend().buffer().clone();
|
||||
@@ -4754,9 +4724,7 @@ mod tests {
|
||||
let row = overlay.y + overlay.height - 1;
|
||||
|
||||
(overlay.x..overlay.x + overlay.width - 1)
|
||||
.find(|x| {
|
||||
buffer[(*x, row)].symbol() == "p" && buffer[(x + 1, row)].symbol() == "g"
|
||||
})
|
||||
.find(|x| buffer[(*x, row)].symbol() == "p" && buffer[(x + 1, row)].symbol() == "g")
|
||||
.map(|x| buffer[(x, row)].fg)
|
||||
}
|
||||
|
||||
@@ -4783,6 +4751,4 @@ mod tests {
|
||||
|
||||
std::fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
+372
-129
@@ -44,11 +44,7 @@ pub fn should_use_colors() -> bool {
|
||||
let no_color = std::env::var("NO_COLOR").ok();
|
||||
let term = std::env::var("TERM").ok();
|
||||
|
||||
colors_wanted(
|
||||
std::io::stdout().is_terminal(),
|
||||
no_color.as_deref(),
|
||||
term.as_deref(),
|
||||
)
|
||||
colors_wanted(std::io::stdout().is_terminal(), no_color.as_deref(), term.as_deref())
|
||||
})
|
||||
}
|
||||
|
||||
@@ -272,9 +268,7 @@ pub fn find_worklane_dir(start: &Path) -> Result<std::path::PathBuf> {
|
||||
}
|
||||
}
|
||||
|
||||
Err(anyhow!(
|
||||
"No .worklane directory found. Run `worklane init` first."
|
||||
))
|
||||
Err(anyhow!("No .worklane directory found. Run `worklane init` first."))
|
||||
}
|
||||
|
||||
/// Width of the abbreviated id shown by `ls` and by the disambiguation list.
|
||||
@@ -728,11 +722,7 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
|
||||
criterion += 1;
|
||||
result.push_str(&paint(&format!("{}.", criterion), Color::Cyan, colored));
|
||||
result.push(' ');
|
||||
result.push_str(&paint(
|
||||
if checked { "[x]" } else { "[ ]" },
|
||||
Color::Grey,
|
||||
colored,
|
||||
));
|
||||
result.push_str(&paint(if checked { "[x]" } else { "[ ]" }, Color::Grey, colored));
|
||||
result.push(' ');
|
||||
result.push_str(&colorize_bold(text, colored));
|
||||
result.push('\n');
|
||||
@@ -936,9 +926,31 @@ fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> Strin
|
||||
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_";
|
||||
|
||||
/// Whether a field holds one of the two markers that mean it holds nothing.
|
||||
///
|
||||
/// The two constants and nothing else. `-None-` and `-Not set-` were accepted here from
|
||||
/// the day the function was written, by analogy with the `**-Status**` field name the
|
||||
/// `mv` splicing bug really did produce, c230d2c. But no version of this tool ever wrote
|
||||
/// a hyphenated *value*: `git log -S` finds the two spellings in exactly one commit, the
|
||||
/// one that added them to this line. They were dead from birth, and a ticket that somehow
|
||||
/// holds one now reads as the text it is rather than being quietly taken for unset, which
|
||||
/// is the right way round for corruption nobody can produce.
|
||||
pub fn is_unknown_value(value: &str) -> bool {
|
||||
let trimmed = value.trim();
|
||||
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.
|
||||
@@ -1017,7 +1029,7 @@ pub fn parse_ticket_field(content: &str, field: &str) -> String {
|
||||
metadata_lines(content)
|
||||
.find_map(|line| metadata_field_body(line).strip_prefix(&prefix))
|
||||
.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 {
|
||||
@@ -1094,12 +1106,8 @@ fn remove_metadata_line(content: &str, field: &str) -> Option<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(|| {
|
||||
anyhow!(
|
||||
"Ticket '{}' has no Status field in its Metadata section",
|
||||
title
|
||||
)
|
||||
})
|
||||
set_metadata_line(content, "Status", target_status, is_status_line)
|
||||
.ok_or_else(|| anyhow!("Ticket '{}' has no Status field in its Metadata section", title))
|
||||
}
|
||||
|
||||
/// Rewrite a metadata field other than Status.
|
||||
@@ -1114,13 +1122,7 @@ pub fn set_metadata_field(content: &str, field: &str, value: &str, title: &str)
|
||||
set_metadata_line(content, field, value, |line| {
|
||||
metadata_field_body(line).starts_with(&prefix)
|
||||
})
|
||||
.ok_or_else(|| {
|
||||
anyhow!(
|
||||
"Ticket '{}' has no {} field in its Metadata section",
|
||||
title,
|
||||
field
|
||||
)
|
||||
})
|
||||
.ok_or_else(|| anyhow!("Ticket '{}' has no {} field in its Metadata section", title, field))
|
||||
}
|
||||
|
||||
/// The metadata field naming the campaign a ticket belongs to.
|
||||
@@ -1371,6 +1373,12 @@ pub struct Section {
|
||||
/// appending to an empty section replaces the placeholder rather than following it.
|
||||
pub placeholder: &'static str,
|
||||
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 {
|
||||
@@ -1378,6 +1386,7 @@ pub const DESCRIPTION: Section = Section {
|
||||
label: "description",
|
||||
placeholder: "_No description provided._",
|
||||
kind: SectionKind::Prose,
|
||||
clear: Some(Clearable::Description),
|
||||
};
|
||||
|
||||
pub const ACCEPTANCE: Section = Section {
|
||||
@@ -1385,6 +1394,7 @@ pub const ACCEPTANCE: Section = Section {
|
||||
label: "acceptance criteria",
|
||||
placeholder: "_No acceptance criteria provided._",
|
||||
kind: SectionKind::Checklist,
|
||||
clear: Some(Clearable::Acceptance),
|
||||
};
|
||||
|
||||
pub const PLAN: Section = Section {
|
||||
@@ -1392,6 +1402,7 @@ pub const PLAN: Section = Section {
|
||||
label: "implementation plan",
|
||||
placeholder: "_No implementation plan provided._",
|
||||
kind: SectionKind::Numbered,
|
||||
clear: Some(Clearable::Plan),
|
||||
};
|
||||
|
||||
/// The edges to other tickets, one per line.
|
||||
@@ -1405,6 +1416,7 @@ pub const RELATIONS: Section = Section {
|
||||
label: "relations",
|
||||
placeholder: "_No relations._",
|
||||
kind: SectionKind::Bullets,
|
||||
clear: None,
|
||||
};
|
||||
|
||||
impl Section {
|
||||
@@ -1438,6 +1450,105 @@ 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.
|
||||
fn is_numbered_item(line: &str) -> bool {
|
||||
let digits = line.chars().take_while(|c| c.is_ascii_digit()).count();
|
||||
@@ -1481,12 +1592,32 @@ fn join_lines(lines: &[String]) -> String {
|
||||
|
||||
/// 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> {
|
||||
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 body = section_body(&lines, section.heading)
|
||||
.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();
|
||||
out.extend(section.render(items, 1));
|
||||
out.extend(body_lines);
|
||||
// One blank line before whatever section follows, matching how `add` writes it.
|
||||
if body.end < lines.len() {
|
||||
out.push(String::new());
|
||||
@@ -1938,10 +2069,7 @@ pub struct Cell {
|
||||
|
||||
impl Cell {
|
||||
fn plain(text: impl Into<String>) -> Self {
|
||||
Cell {
|
||||
text: text.into(),
|
||||
color: None,
|
||||
}
|
||||
Cell { text: text.into(), color: None }
|
||||
}
|
||||
|
||||
fn colored(text: impl Into<String>, color: Color) -> Self {
|
||||
@@ -1979,14 +2107,17 @@ pub fn relation_rows(stored: &[Relation], index: &RelationIndex, uuid: &str) ->
|
||||
})
|
||||
.collect();
|
||||
|
||||
rows.extend(index.inbound(uuid).into_iter().map(|(kind, holder)| {
|
||||
RelationRow {
|
||||
kind,
|
||||
label: kind.inverse_label(),
|
||||
uuid: holder.uuid.clone(),
|
||||
target: target_of(Some(holder)),
|
||||
}
|
||||
}));
|
||||
rows.extend(
|
||||
index
|
||||
.inbound(uuid)
|
||||
.into_iter()
|
||||
.map(|(kind, holder)| RelationRow {
|
||||
kind,
|
||||
label: kind.inverse_label(),
|
||||
uuid: holder.uuid.clone(),
|
||||
target: target_of(Some(holder)),
|
||||
}),
|
||||
);
|
||||
|
||||
rows
|
||||
}
|
||||
@@ -2054,11 +2185,7 @@ pub fn relations_for(content: &str, worklane_dir: &Path) -> Result<Vec<RelationR
|
||||
let stored = parse_relations(content, &title)?;
|
||||
let index = RelationIndex::load(worklane_dir)?;
|
||||
|
||||
Ok(relation_rows(
|
||||
&stored,
|
||||
&index,
|
||||
&parse_ticket_field(content, "ID"),
|
||||
))
|
||||
Ok(relation_rows(&stored, &index, &parse_ticket_field(content, "ID")))
|
||||
}
|
||||
|
||||
/// One acceptance criterion as it sits in the file.
|
||||
@@ -2129,11 +2256,7 @@ pub fn numbered_criteria(criteria: &[Criterion], shown: &[usize]) -> String {
|
||||
format!(
|
||||
" {} {} {}",
|
||||
paint(&format!("{}.", offset + 1), Color::Cyan, colored),
|
||||
paint(
|
||||
if criterion.checked { "[x]" } else { "[ ]" },
|
||||
Color::Grey,
|
||||
colored
|
||||
),
|
||||
paint(if criterion.checked { "[x]" } else { "[ ]" }, Color::Grey, colored),
|
||||
criterion.text
|
||||
)
|
||||
})
|
||||
@@ -2515,10 +2638,7 @@ pub fn display_ticket_items(items: &[TicketItem]) {
|
||||
let priority = show_priority(item.priority, colored);
|
||||
|
||||
if item.created.is_empty() {
|
||||
println!(
|
||||
" {} ({}) {} | Owner: {} | Due: {}",
|
||||
priority, id, item.title, owner, due
|
||||
);
|
||||
println!(" {} ({}) {} | Owner: {} | Due: {}", priority, id, item.title, owner, due);
|
||||
} else {
|
||||
let created = paint(&item.created, Color::Cyan, colored);
|
||||
println!(
|
||||
@@ -2653,6 +2773,21 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// The hyphenated spellings are values like any other, and this is what says so.
|
||||
///
|
||||
/// They were accepted as unset for months without any version of the tool ever
|
||||
/// writing one, so the risk this pins is somebody re-adding them by analogy with the
|
||||
/// `**-Status**` repair in `is_status_line`, which guards a corruption that was real.
|
||||
#[test]
|
||||
fn a_hyphenated_marker_is_not_unset() {
|
||||
for legacy in ["-None-", "-Not set-", "-Nothing-"] {
|
||||
assert!(
|
||||
!is_unknown_value(legacy),
|
||||
"{legacy} is read as unset, so a corrupted field would pass for an empty one"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn ticket_with_priority(raw: &str) -> String {
|
||||
format!("# T\n\n## Metadata\n\n- **Priority**: {}\n", raw)
|
||||
}
|
||||
@@ -2686,17 +2821,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_field_only_mentioned_in_prose_reads_as_unset() {
|
||||
let content = "# T\n\n## Description\n- **Due**: 2026-12-31\n\n## Metadata\n\n- **ID**: x\n";
|
||||
let content =
|
||||
"# T\n\n## Description\n- **Due**: 2026-12-31\n\n## Metadata\n\n- **ID**: x\n";
|
||||
assert_eq!(parse_ticket_field(content, "Due"), "_Not set_");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_field_lookup_needs_the_metadata_heading() {
|
||||
// No section, no fields: there is nothing to anchor to.
|
||||
assert_eq!(
|
||||
parse_ticket_field("# T\n\n- **Owner**: alice\n", "Owner"),
|
||||
"_Not set_"
|
||||
);
|
||||
assert_eq!(parse_ticket_field("# T\n\n- **Owner**: alice\n", "Owner"), "_Not set_");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -2731,7 +2864,8 @@ mod tests {
|
||||
#[test]
|
||||
fn setting_the_status_needs_the_field_in_the_metadata_section() {
|
||||
// A Status line above the section is prose, so this is a ticket without the field.
|
||||
let content = "# T\n\n## Description\n- **Status**: backlog\n\n## Metadata\n\n- **ID**: x\n";
|
||||
let content =
|
||||
"# T\n\n## Description\n- **Status**: backlog\n\n## Metadata\n\n- **ID**: x\n";
|
||||
assert!(set_status_field(content, "committed", "T").is_err());
|
||||
}
|
||||
|
||||
@@ -2843,8 +2977,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_line_that_is_not_a_field_is_carried_through() {
|
||||
let rendered =
|
||||
render_metadata_table(&["- **ID**: abc", "a hand written note"], false, "");
|
||||
let rendered = render_metadata_table(&["- **ID**: abc", "a hand written note"], false, "");
|
||||
|
||||
assert_eq!(
|
||||
rendered,
|
||||
@@ -2989,7 +3122,10 @@ mod tests {
|
||||
let counted: Vec<Option<Progress>> = items.iter().map(|item| item.criteria).collect();
|
||||
|
||||
assert!(counted.contains(&Some(Progress { met: 1, total: 2 })), "{counted:?}");
|
||||
assert!(counted.contains(&None), "a ticket with no criteria got a count: {counted:?}");
|
||||
assert!(
|
||||
counted.contains(&None),
|
||||
"a ticket with no criteria got a count: {counted:?}"
|
||||
);
|
||||
|
||||
fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
@@ -3043,9 +3179,15 @@ mod tests {
|
||||
/// Absent, unset and empty are one answer: no tags.
|
||||
#[test]
|
||||
fn parse_tags_reads_an_unset_or_missing_field_as_none() {
|
||||
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Tags**: _None_\n"), Vec::<String>::new());
|
||||
assert_eq!(
|
||||
parse_tags("# T\n\n## Metadata\n\n- **Tags**: _None_\n"),
|
||||
Vec::<String>::new()
|
||||
);
|
||||
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Tags**:\n"), Vec::<String>::new());
|
||||
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Owner**: alice\n"), Vec::<String>::new());
|
||||
assert_eq!(
|
||||
parse_tags("# T\n\n## Metadata\n\n- **Owner**: alice\n"),
|
||||
Vec::<String>::new()
|
||||
);
|
||||
assert_eq!(parse_tags("# T\n\n## Metadata\n\n- **Tags**: , ,\n"), Vec::<String>::new());
|
||||
}
|
||||
|
||||
@@ -3102,9 +3244,7 @@ mod tests {
|
||||
set_or_insert_metadata_field(&content, CAMPAIGN_FIELD, "c-uuid", "T").unwrap();
|
||||
|
||||
assert!(
|
||||
updated.contains(
|
||||
"- **Owner**: alice\n- **Campaign**: c-uuid\n\n## Notes\nAfter.\n"
|
||||
),
|
||||
updated.contains("- **Owner**: alice\n- **Campaign**: c-uuid\n\n## Notes\nAfter.\n"),
|
||||
"{updated}"
|
||||
);
|
||||
}
|
||||
@@ -3113,9 +3253,8 @@ mod tests {
|
||||
/// most one campaign.
|
||||
#[test]
|
||||
fn a_field_already_there_is_rewritten_rather_than_added() {
|
||||
let content = with_metadata(
|
||||
"- **ID**: abc\n- **Campaign**: first\n- **Status**: backlog\n",
|
||||
);
|
||||
let content =
|
||||
with_metadata("- **ID**: abc\n- **Campaign**: first\n- **Status**: backlog\n");
|
||||
|
||||
let updated =
|
||||
set_or_insert_metadata_field(&content, CAMPAIGN_FIELD, "second", "T").unwrap();
|
||||
@@ -3131,8 +3270,7 @@ mod tests {
|
||||
let content = "# T\n\n## Description\n- **Campaign**: not a field\n\n\
|
||||
## Metadata\n\n- **ID**: abc\n- **Status**: backlog\n";
|
||||
|
||||
let updated =
|
||||
set_or_insert_metadata_field(content, CAMPAIGN_FIELD, "c-uuid", "T").unwrap();
|
||||
let updated = set_or_insert_metadata_field(content, CAMPAIGN_FIELD, "c-uuid", "T").unwrap();
|
||||
|
||||
assert!(updated.contains("- **Campaign**: not a field"), "{updated}");
|
||||
assert!(
|
||||
@@ -3165,10 +3303,7 @@ mod tests {
|
||||
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("- **Submitted On**: 2026-08-22 10:11:12"), "{updated}");
|
||||
assert!(!updated.contains("**Committed On**"), "{updated}");
|
||||
}
|
||||
|
||||
@@ -3213,8 +3348,7 @@ mod tests {
|
||||
- **Status**: reviewing\n",
|
||||
);
|
||||
|
||||
let updated =
|
||||
set_status_stamp(&content, Status::Done, "2026-08-22 10:11:12", "T").unwrap();
|
||||
let updated = set_status_stamp(&content, Status::Done, "2026-08-22 10:11:12", "T").unwrap();
|
||||
|
||||
assert!(
|
||||
updated.contains(
|
||||
@@ -3257,10 +3391,7 @@ mod tests {
|
||||
#[test]
|
||||
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("- **Campaign**: _Not set_\n")),
|
||||
None
|
||||
);
|
||||
assert_eq!(parse_campaign(&with_metadata("- **Campaign**: _Not set_\n")), None);
|
||||
assert_eq!(
|
||||
parse_campaign(&with_metadata("- **Campaign**: c-uuid\n")),
|
||||
Some("c-uuid".to_string())
|
||||
@@ -3293,10 +3424,7 @@ mod tests {
|
||||
let rendered = content_trim_colored("# T\n\n## Description\nbody\n", &Resolved::default());
|
||||
|
||||
// Eleven characters, not fourteen: the rule used to span "## Description"
|
||||
assert!(
|
||||
rendered.starts_with("Description\n───────────\n"),
|
||||
"{rendered:?}"
|
||||
);
|
||||
assert!(rendered.starts_with("Description\n───────────\n"), "{rendered:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -3308,7 +3436,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn the_body_leaves_the_title_to_cmd_show() {
|
||||
let rendered = content_trim_colored("# Only Once\n\n## Description\nbody\n", &Resolved::default());
|
||||
let rendered =
|
||||
content_trim_colored("# Only Once\n\n## Description\nbody\n", &Resolved::default());
|
||||
|
||||
assert!(!rendered.contains("Only Once"), "{rendered:?}");
|
||||
// And no gap where it was
|
||||
@@ -3335,9 +3464,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn blank_values_are_trimmed_from_the_ends_but_kept_inside() {
|
||||
let owned = |values: &[&str]| -> Vec<String> {
|
||||
values.iter().map(|v| v.to_string()).collect()
|
||||
};
|
||||
let owned =
|
||||
|values: &[&str]| -> Vec<String> { values.iter().map(|v| v.to_string()).collect() };
|
||||
|
||||
// A break between paragraphs is content
|
||||
let two_paragraphs = owned(&["First.", "", "Second."]);
|
||||
@@ -3390,8 +3518,13 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn levels_sort_ahead_of_invalid_which_sorts_ahead_of_unset() {
|
||||
let mut ranks = [Priority::Unset, Priority::Level(5), Priority::Invalid, Priority::Level(1)]
|
||||
.map(|p| p.rank());
|
||||
let mut ranks = [
|
||||
Priority::Unset,
|
||||
Priority::Level(5),
|
||||
Priority::Invalid,
|
||||
Priority::Level(1),
|
||||
]
|
||||
.map(|p| p.rank());
|
||||
ranks.sort();
|
||||
assert_eq!(
|
||||
ranks,
|
||||
@@ -3422,7 +3555,10 @@ mod tests {
|
||||
#[test]
|
||||
fn the_glyph_alone_distinguishes_every_state() {
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
for state in PRIORITY_RANGE.map(Priority::Level).chain([Priority::Unset, Priority::Invalid]) {
|
||||
for state in PRIORITY_RANGE
|
||||
.map(Priority::Level)
|
||||
.chain([Priority::Unset, Priority::Invalid])
|
||||
{
|
||||
let (glyph, _) = priority_mark(state);
|
||||
assert!(seen.insert(glyph), "{glyph} is used for more than one state");
|
||||
}
|
||||
@@ -3485,10 +3621,7 @@ mod tests {
|
||||
#[test]
|
||||
fn an_invalid_level_is_marked_wrong_not_unset() {
|
||||
assert_eq!(priority_mark(Priority::Invalid).0, "??");
|
||||
assert_ne!(
|
||||
priority_mark(Priority::Invalid),
|
||||
priority_mark(Priority::Unset)
|
||||
);
|
||||
assert_ne!(priority_mark(Priority::Invalid), priority_mark(Priority::Unset));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -3519,11 +3652,11 @@ mod tests {
|
||||
|
||||
for colour in Color::ALL {
|
||||
assert!(!colour.ansi().is_empty(), "{colour:?} has no escape");
|
||||
assert!(colour.ansi().starts_with("\x1b["), "{colour:?} is not an SGR sequence");
|
||||
assert!(
|
||||
colour.ansi().starts_with("\x1b["),
|
||||
"{colour:?} is not an SGR sequence"
|
||||
seen.insert(ratatui::style::Color::from(colour)),
|
||||
"{colour:?} shares its ratatui colour"
|
||||
);
|
||||
assert!(seen.insert(ratatui::style::Color::from(colour)), "{colour:?} shares its ratatui colour");
|
||||
}
|
||||
|
||||
assert_eq!(seen.len(), Color::ALL.len());
|
||||
@@ -3550,11 +3683,12 @@ mod tests {
|
||||
assert_eq!(tag_color("bug"), tag_color("bug"));
|
||||
assert_eq!(tag_color("frontend"), tag_color("frontend"));
|
||||
|
||||
let spread: std::collections::HashSet<Color> =
|
||||
["bug", "feature", "cli", "tui", "docs", "chore", "output", "skills"]
|
||||
.iter()
|
||||
.map(|tag| tag_color(tag))
|
||||
.collect();
|
||||
let spread: std::collections::HashSet<Color> = [
|
||||
"bug", "feature", "cli", "tui", "docs", "chore", "output", "skills",
|
||||
]
|
||||
.iter()
|
||||
.map(|tag| tag_color(tag))
|
||||
.collect();
|
||||
assert!(spread.len() > 3, "the mapping collapses the vocabulary: {spread:?}");
|
||||
}
|
||||
|
||||
@@ -3628,7 +3762,10 @@ mod tests {
|
||||
// The separator the file holds comes back as it went in, spacing and all.
|
||||
assert_eq!(strip_escapes(&painted), "bug, cli");
|
||||
assert_eq!(strip_escapes(&metadata_value_cell("Tags", "bug,cli", true, "")), "bug,cli");
|
||||
assert_eq!(strip_escapes(&metadata_value_cell("Tags", " bug , cli ", true, "")), " bug , cli ");
|
||||
assert_eq!(
|
||||
strip_escapes(&metadata_value_cell("Tags", " bug , cli ", true, "")),
|
||||
" bug , cli "
|
||||
);
|
||||
}
|
||||
|
||||
/// An unset value stays grey, since the Tags branch sits behind the unknown check.
|
||||
@@ -3705,7 +3842,13 @@ mod tests {
|
||||
/// Every one of these reached the old byte offsets from an unvalidated file.
|
||||
#[test]
|
||||
fn unparseable_created_at_drops_the_column() {
|
||||
for value in ["_Not set_", "", "2026-08-20", "日本語日本語日本語", "not a date at all"] {
|
||||
for value in [
|
||||
"_Not set_",
|
||||
"",
|
||||
"2026-08-20",
|
||||
"日本語日本語日本語",
|
||||
"not a date at all",
|
||||
] {
|
||||
assert_eq!(format_created_at(value), "", "for {value:?}");
|
||||
}
|
||||
}
|
||||
@@ -3788,7 +3931,74 @@ mod tests {
|
||||
assert!(error.contains("is not a relation"), "{error}");
|
||||
assert!(error.contains("blocked by"), "{error}");
|
||||
|
||||
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]
|
||||
@@ -3978,11 +4188,7 @@ mod tests {
|
||||
let (mark, colour) = relation_mark(kind);
|
||||
assert!(!mark.is_empty(), "{kind:?} has no mark");
|
||||
assert!(seen.insert(mark), "{kind:?} shares its mark with another kind");
|
||||
assert_ne!(
|
||||
colour,
|
||||
Color::Green,
|
||||
"{kind:?} is drawn in the colour that means a title"
|
||||
);
|
||||
assert_ne!(colour, Color::Green, "{kind:?} is drawn in the colour that means a title");
|
||||
}
|
||||
|
||||
assert_eq!(seen.len(), 3, "{seen:?}");
|
||||
@@ -4049,10 +4255,7 @@ mod tests {
|
||||
// status mark cannot: `?` holds the column so the id does not move, and
|
||||
// `_missing_` is what says the target is gone.
|
||||
assert_eq!(
|
||||
render_relations(
|
||||
&relation_rows(&stored, &RelationIndex::new(Vec::new()), SELF),
|
||||
false
|
||||
),
|
||||
render_relations(&relation_rows(&stored, &RelationIndex::new(Vec::new()), SELF), false),
|
||||
format!("blocked by {BLOCKED_MARK} ? (b1b2c3d) _missing_\n")
|
||||
);
|
||||
}
|
||||
@@ -4060,10 +4263,7 @@ mod tests {
|
||||
#[test]
|
||||
fn a_ticket_with_no_relations_at_either_end_renders_no_block() {
|
||||
let index = RelationIndex::new(vec![related(TARGET, "Elsewhere", "backlog", Vec::new())]);
|
||||
assert_eq!(
|
||||
render_relations(&relation_rows(&[], &index, SELF), false),
|
||||
""
|
||||
);
|
||||
assert_eq!(render_relations(&relation_rows(&[], &index, SELF), false), "");
|
||||
}
|
||||
|
||||
/// Without the guard every ticket with no ID field relates to every other one that
|
||||
@@ -4089,7 +4289,20 @@ mod tests {
|
||||
"# T\n\n## Relations\n- blocked by {}\n\n## Metadata\n\n- **ID**: {}\n",
|
||||
TARGET, SELF
|
||||
);
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocked by", TARGET, "The blocker", "backlog")], ..Default::default() });
|
||||
let rendered = content_trim(
|
||||
&content,
|
||||
false,
|
||||
&Resolved {
|
||||
relations: vec![row(
|
||||
RelationKind::BlockedBy,
|
||||
"blocked by",
|
||||
TARGET,
|
||||
"The blocker",
|
||||
"backlog",
|
||||
)],
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
|
||||
assert!(
|
||||
rendered.contains(&format!("Relations\n─────────\n\nblocked by {BLOCKED_MARK} {} (b1b2c3d) The blocker\n\nMetadata", smark("backlog"))),
|
||||
@@ -4103,8 +4316,22 @@ mod tests {
|
||||
/// have kept it, ahead of the metadata.
|
||||
#[test]
|
||||
fn the_body_injects_the_block_when_the_file_has_no_section() {
|
||||
let content = format!("# T\n\n## Description\nBody.\n\n## Metadata\n\n- **ID**: {}\n", SELF);
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "The gated one", "committed")], ..Default::default() });
|
||||
let content =
|
||||
format!("# T\n\n## Description\nBody.\n\n## Metadata\n\n- **ID**: {}\n", SELF);
|
||||
let rendered = content_trim(
|
||||
&content,
|
||||
false,
|
||||
&Resolved {
|
||||
relations: vec![row(
|
||||
RelationKind::BlockedBy,
|
||||
"blocks",
|
||||
SELF,
|
||||
"The gated one",
|
||||
"committed",
|
||||
)],
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
|
||||
assert!(
|
||||
rendered.contains(&format!("Body.\n\nRelations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) The gated one\n\nMetadata", smark("committed"))),
|
||||
@@ -4116,9 +4343,22 @@ mod tests {
|
||||
/// worth more at the end than dropped.
|
||||
#[test]
|
||||
fn the_body_appends_the_block_when_there_is_no_metadata() {
|
||||
let rendered = content_trim("# T\n\n## Description\nBody.\n", false, &Resolved { relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "X", "done")], ..Default::default() });
|
||||
let rendered = content_trim(
|
||||
"# T\n\n## Description\nBody.\n",
|
||||
false,
|
||||
&Resolved {
|
||||
relations: vec![row(RelationKind::BlockedBy, "blocks", SELF, "X", "done")],
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
|
||||
assert!(rendered.ends_with(&format!("Relations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) X\n", smark("done"))), "{rendered:?}");
|
||||
assert!(
|
||||
rendered.ends_with(&format!(
|
||||
"Relations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) X\n",
|
||||
smark("done")
|
||||
)),
|
||||
"{rendered:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// No block and a section holding only its placeholder: the section renders as it
|
||||
@@ -4128,6 +4368,9 @@ mod tests {
|
||||
let content = "# T\n\n## Relations\n_No relations._\n\n## Metadata\n\n- **ID**: x\n";
|
||||
let rendered = content_trim(content, false, &Resolved::default());
|
||||
|
||||
assert!(rendered.contains("Relations\n─────────\n\n_No relations._\n"), "{rendered:?}");
|
||||
assert!(
|
||||
rendered.contains("Relations\n─────────\n\n_No relations._\n"),
|
||||
"{rendered:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+60
-24
@@ -1,6 +1,6 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
@@ -106,9 +106,12 @@ fn add_joins_multiple_descriptions() {
|
||||
cmd.current_dir(temp.path())
|
||||
.args([
|
||||
"add",
|
||||
"--title", "Multi desc ticket",
|
||||
"--description", "Line one",
|
||||
"--description", "Line two",
|
||||
"--title",
|
||||
"Multi desc ticket",
|
||||
"--description",
|
||||
"Line one",
|
||||
"--description",
|
||||
"Line two",
|
||||
])
|
||||
.assert()
|
||||
.success();
|
||||
@@ -285,10 +288,7 @@ fn add_accepts_prose_values_that_begin_with_a_hyphen() {
|
||||
// Stored verbatim, hyphens and all
|
||||
assert!(content.contains("# -t is a flag name"), "was {content:?}");
|
||||
assert!(content.contains("-x does nothing"), "was {content:?}");
|
||||
assert!(
|
||||
content.contains("- [ ] --print should be supported"),
|
||||
"was {content:?}"
|
||||
);
|
||||
assert!(content.contains("- [ ] --print should be supported"), "was {content:?}");
|
||||
assert!(content.contains("1. -f skips the check"), "was {content:?}");
|
||||
}
|
||||
|
||||
@@ -308,10 +308,7 @@ fn add_still_accepts_the_equals_form() {
|
||||
|
||||
let content = only_ticket(&worklane);
|
||||
assert!(content.contains("# -x equals form"), "was {content:?}");
|
||||
assert!(
|
||||
content.contains("- [ ] --print via equals"),
|
||||
"was {content:?}"
|
||||
);
|
||||
assert!(content.contains("- [ ] --print via equals"), "was {content:?}");
|
||||
}
|
||||
|
||||
/// Never silently dropped: a value that is nothing but hyphens is content.
|
||||
@@ -328,10 +325,7 @@ fn add_stores_a_title_that_is_only_hyphens() {
|
||||
.success();
|
||||
|
||||
let content = only_ticket(&worklane);
|
||||
assert!(
|
||||
content.starts_with(&format!("# {}\n", bare)),
|
||||
"for {bare:?}: {content:?}"
|
||||
);
|
||||
assert!(content.starts_with(&format!("# {}\n", bare)), "for {bare:?}: {content:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -408,10 +402,7 @@ fn add_keeps_a_paragraph_break_in_the_description() {
|
||||
let mut show = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
show.current_dir(temp.path()).args(["show", "Two Paras"]);
|
||||
let stdout = String::from_utf8(show.assert().success().get_output().stdout.clone()).unwrap();
|
||||
assert!(
|
||||
stdout.contains("First paragraph.\n\nSecond paragraph."),
|
||||
"was {stdout:?}"
|
||||
);
|
||||
assert!(stdout.contains("First paragraph.\n\nSecond paragraph."), "was {stdout:?}");
|
||||
}
|
||||
|
||||
/// A break belongs between paragraphs, not against the section headings.
|
||||
@@ -482,7 +473,14 @@ fn add_stores_a_valid_due_date_unchanged() {
|
||||
/// and is not a day.
|
||||
#[test]
|
||||
fn add_refuses_a_due_date_that_is_not_a_real_iso_date() {
|
||||
for value in ["next friday", "29-08-2026", "2026-13-01", "2026-02-30", "2026/08/29", ""] {
|
||||
for value in [
|
||||
"next friday",
|
||||
"29-08-2026",
|
||||
"2026-13-01",
|
||||
"2026-02-30",
|
||||
"2026/08/29",
|
||||
"",
|
||||
] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
@@ -530,9 +528,10 @@ fn add_refuses_an_unpadded_due_date_rather_than_padding_it() {
|
||||
}
|
||||
|
||||
/// An empty value keeps the message about clearing, since that is what somebody typing
|
||||
/// it is reaching for.
|
||||
/// it is reaching for. On `add` the answer is to omit the flag, but the message names
|
||||
/// `--clear` because the same parser guards `set --due`, where that is the answer.
|
||||
#[test]
|
||||
fn an_empty_due_date_says_clearing_is_not_supported() {
|
||||
fn an_empty_due_date_points_at_clear() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
setup_worklane(&temp);
|
||||
|
||||
@@ -549,7 +548,8 @@ fn an_empty_due_date_says_clearing_is_not_supported() {
|
||||
)
|
||||
.to_string();
|
||||
|
||||
assert!(stderr.contains("clearing a field is not supported"), "{stderr}");
|
||||
assert!(stderr.contains("use --clear"), "{stderr}");
|
||||
assert!(!stderr.contains("not supported"), "{stderr}");
|
||||
}
|
||||
|
||||
fn read_only_ticket(dir: &Path) -> String {
|
||||
@@ -561,3 +561,39 @@ fn read_only_ticket(dir: &Path) -> String {
|
||||
|
||||
fs::read_to_string(file.path()).unwrap()
|
||||
}
|
||||
|
||||
fn chmod(path: &Path, mode: u32) {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let mut perms = fs::metadata(path).unwrap().permissions();
|
||||
perms.set_mode(mode);
|
||||
fs::set_permissions(path, perms).unwrap();
|
||||
}
|
||||
|
||||
/// A duplicate title is not a failure, so the only thing left to refuse is the write
|
||||
/// itself, and it is named with the ticket and the path rather than raised as a bare io
|
||||
/// error. The branch this replaces could not fire at all: the filename carries a fresh
|
||||
/// uuid, and its message claimed the title was taken.
|
||||
#[test]
|
||||
fn add_names_the_ticket_and_the_path_when_the_write_fails() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let backlog = worklane.join("backlog");
|
||||
|
||||
chmod(&backlog, 0o555);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let assert = cmd
|
||||
.current_dir(temp.path())
|
||||
.args(["add", "--title", "Unwritable"])
|
||||
.assert()
|
||||
.failure();
|
||||
|
||||
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
||||
assert!(stderr.contains("Unwritable"), "{stderr}");
|
||||
assert!(stderr.contains("unwritable.md"), "{stderr}");
|
||||
assert!(!stderr.contains("already exists"), "{stderr}");
|
||||
|
||||
chmod(&backlog, 0o755);
|
||||
assert_eq!(fs::read_dir(&backlog).unwrap().count(), 0);
|
||||
}
|
||||
|
||||
+48
-6
@@ -413,6 +413,47 @@ fn campaign_ls_lists_campaigns_with_their_member_counts() {
|
||||
assert!(listing.contains("v2 release | no members"), "{listing}");
|
||||
}
|
||||
|
||||
/// The machine-readable listing, the same two fields and the same shape as `ls --ids`.
|
||||
#[test]
|
||||
fn campaign_ls_ids_prints_the_id_and_the_title_tab_separated() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let _worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
|
||||
let out = run(&temp, &["campaign", "ls", "--ids"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
|
||||
let listing = stdout(&out);
|
||||
assert_eq!(
|
||||
listing.lines().collect::<Vec<_>>(),
|
||||
vec![
|
||||
format!("{}\tv1 release", &CAMP_A[..7]),
|
||||
format!("{}\tv2 release", &CAMP_B[..7]),
|
||||
]
|
||||
);
|
||||
|
||||
// Nothing decorated: no heading, no member count, no escape.
|
||||
assert!(!listing.contains("Campaigns:"), "{listing}");
|
||||
assert!(!listing.contains("done"), "{listing}");
|
||||
assert!(!listing.contains('\u{1b}'), "{listing}");
|
||||
}
|
||||
|
||||
/// A completion offers nothing rather than a sentence, so the empty case that prints
|
||||
/// prose for a reader has to stay out of the parsed path.
|
||||
#[test]
|
||||
fn campaign_ls_ids_says_nothing_on_a_board_with_no_campaigns() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
setup_worklane(&temp);
|
||||
|
||||
let out = run(&temp, &["campaign", "ls", "--ids"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert_eq!(stdout(&out), "");
|
||||
|
||||
// The decorated listing still explains itself.
|
||||
assert!(stdout(&run(&temp, &["campaign", "ls"])).contains("No campaigns yet"));
|
||||
}
|
||||
|
||||
/// A campaign is done when it holds members and every one of them is done. An empty one
|
||||
/// is neither, which is why it reads `no members` rather than `0/0 done`.
|
||||
#[test]
|
||||
@@ -487,7 +528,12 @@ fn a_campaign_that_no_longer_exists_reads_as_missing() {
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["assign", "v1 release", MEMBER]);
|
||||
fs::remove_file(worklane.join("campaigns").join(format!("{CAMP_A}_v1-release.md"))).unwrap();
|
||||
fs::remove_file(
|
||||
worklane
|
||||
.join("campaigns")
|
||||
.join(format!("{CAMP_A}_v1-release.md")),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let out = run(&temp, &["show", MEMBER]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
@@ -578,11 +624,7 @@ fn a_search_that_names_nothing_still_reports_no_ticket() {
|
||||
let out = run(&temp, &["show", "nothing at all"]);
|
||||
|
||||
assert!(!out.status.success());
|
||||
assert!(
|
||||
stderr(&out).contains("No ticket found matching"),
|
||||
"{}",
|
||||
stderr(&out)
|
||||
);
|
||||
assert!(stderr(&out).contains("No ticket found matching"), "{}", stderr(&out));
|
||||
}
|
||||
|
||||
/// A campaign resolves by the same tiers a ticket does, so it can be ambiguous the same
|
||||
|
||||
+2
-9
@@ -298,10 +298,7 @@ fn show_numbers_the_criteria() {
|
||||
assert!(!stdout.contains("4. ["), "the handwritten line was numbered: {stdout:?}");
|
||||
|
||||
// And the description checkbox is left as it is, outside the numbering
|
||||
assert!(
|
||||
stdout.contains("- [ ] A checkbox in the description"),
|
||||
"{stdout:?}"
|
||||
);
|
||||
assert!(stdout.contains("- [ ] A checkbox in the description"), "{stdout:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -418,11 +415,7 @@ fn a_batch_that_would_change_nothing_writes_nothing() {
|
||||
assert!(out.status.success());
|
||||
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert_eq!(
|
||||
stdout.matches("Already checked").count(),
|
||||
3,
|
||||
"{stdout:?}"
|
||||
);
|
||||
assert_eq!(stdout.matches("Already checked").count(), 3, "{stdout:?}");
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
|
||||
+90
-11
@@ -89,11 +89,7 @@ fn chown_sets_the_owner() {
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "bob", UUID]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("owner"),
|
||||
"{:?}",
|
||||
@@ -139,10 +135,7 @@ fn chown_leaves_everything_it_was_not_asked_about_alone() {
|
||||
run(&temp, &["chown", "bob", UUID]);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(
|
||||
content.contains("- [x] Crit one"),
|
||||
"the tick was lost: {content}"
|
||||
);
|
||||
assert!(content.contains("- [x] Crit one"), "the tick was lost: {content}");
|
||||
assert!(
|
||||
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
||||
"the unknown section was lost: {content}"
|
||||
@@ -213,7 +206,8 @@ fn chown_refuses_a_swapped_call() {
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty user looks like a way to clear the field, and clearing is not supported.
|
||||
/// An empty user is still a usage error, and now points at the flag that does take the
|
||||
/// owner away.
|
||||
#[test]
|
||||
fn chown_refuses_an_empty_user_as_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
@@ -223,11 +217,96 @@ fn chown_refuses_an_empty_user_as_a_usage_error() {
|
||||
|
||||
let out = run(&temp, &["chown", "", UUID]);
|
||||
assert_eq!(out.status.code(), Some(2));
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("use --clear"), "{stderr:?}");
|
||||
assert!(!stderr.contains("not supported"), "{stderr:?}");
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// The owner goes back to the sentinel, not to the git user: an owner taken away says
|
||||
/// nobody owns this.
|
||||
#[test]
|
||||
fn chown_clear_returns_the_owner_to_unset() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "--clear", UUID]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
|
||||
String::from_utf8_lossy(&out.stdout).contains("Cleared owner"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Owner**: _Not set_"), "{content}");
|
||||
// Nothing else on the way past.
|
||||
assert!(content.contains("- **Status**: backlog"), "{content}");
|
||||
}
|
||||
|
||||
/// The ticket is still resolved the three usual ways when it arrives in the flag.
|
||||
#[test]
|
||||
fn chown_clear_resolves_the_ticket_it_is_given() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "--clear", "Original"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(ticket(&worklane).contains("- **Owner**: _Not set_"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chown_clear_on_an_unowned_ticket_is_no_change() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["chown", "--clear", UUID]);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["chown", "--clear", UUID]);
|
||||
assert!(out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
/// Setting an owner and clearing it are the two forms of the command, and clap keeps
|
||||
/// them apart rather than the handler picking one.
|
||||
#[test]
|
||||
fn chown_refuses_a_user_and_a_clear_together() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for args in [
|
||||
vec!["chown", "bob", "--clear", UUID],
|
||||
vec!["chown", "bob", UUID, "--clear", UUID],
|
||||
] {
|
||||
let out = run(&temp, &args);
|
||||
assert_eq!(out.status.code(), Some(2), "{args:?} was accepted");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("cannot be used with"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
|
||||
// And a bare --clear still needs the ticket it is meant to name.
|
||||
let out = run(&temp, &["chown", "--clear"]);
|
||||
assert_eq!(out.status.code(), Some(2));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("a value is required"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
@@ -17,11 +17,7 @@ fn setup_worklane(temp: &TempDir) -> PathBuf {
|
||||
worklane.path().to_path_buf()
|
||||
}
|
||||
|
||||
fn create_ticket(
|
||||
worklane_dir: &Path,
|
||||
status: &str,
|
||||
title: &str,
|
||||
) -> String {
|
||||
fn create_ticket(worklane_dir: &Path, status: &str, title: &str) -> String {
|
||||
let uuid = uuid::Uuid::new_v4().to_string();
|
||||
let slug = title
|
||||
.to_lowercase()
|
||||
|
||||
@@ -13,10 +13,7 @@ fn script(shell: &str) -> String {
|
||||
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"
|
||||
);
|
||||
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());
|
||||
}
|
||||
@@ -56,10 +53,7 @@ fn no_other_shell_gets_the_fish_half() {
|
||||
!out.contains("__worklane_first_arg_of"),
|
||||
"fish-only helpers leaked into {shell}"
|
||||
);
|
||||
assert!(
|
||||
!out.contains("worklane ls --ids"),
|
||||
"the dynamic half leaked into {shell}"
|
||||
);
|
||||
assert!(!out.contains("worklane ls --ids"), "the dynamic half leaked into {shell}");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -54,11 +54,7 @@ fn every_skill_installs_outside_a_worklane_directory() {
|
||||
assert_eq!(std::fs::read_to_string(installed_plan(&home)).unwrap(), PLAN);
|
||||
|
||||
// Once, not per document: it is the one thing to do next, not part of an outcome.
|
||||
assert_eq!(
|
||||
stdout.matches("pick it up on their next session").count(),
|
||||
1,
|
||||
"{stdout}"
|
||||
);
|
||||
assert_eq!(stdout.matches("pick it up on their next session").count(), 1, "{stdout}");
|
||||
}
|
||||
|
||||
/// Narrowing to one document is the exception, and it must leave the others alone.
|
||||
@@ -72,7 +68,10 @@ fn a_named_skill_installs_only_that_one() {
|
||||
assert_eq!(out.status.code(), Some(0), "{stdout}");
|
||||
assert_eq!(std::fs::read_to_string(installed_review(&home)).unwrap(), REVIEW);
|
||||
assert!(!installed(&home).exists(), "a named install wrote the other document too");
|
||||
assert!(!installed_plan(&home).exists(), "a named install wrote the other document too");
|
||||
assert!(
|
||||
!installed_plan(&home).exists(),
|
||||
"a named install wrote the other document too"
|
||||
);
|
||||
}
|
||||
|
||||
/// A name nothing ships is a stop, with the choices in the message: guessing at the
|
||||
@@ -118,7 +117,10 @@ fn a_modified_copy_is_reported_and_needs_force() {
|
||||
assert_eq!(out.status.code(), Some(0), "{stdout}");
|
||||
assert!(stdout.contains("Differs from the version in this binary"), "{stdout}");
|
||||
assert!(stdout.contains("--force"), "{stdout}");
|
||||
assert!(stdout.contains("--print"), "the message never says how to compare: {stdout}");
|
||||
assert!(
|
||||
stdout.contains("--print"),
|
||||
"the message never says how to compare: {stdout}"
|
||||
);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(installed(&home)).unwrap(),
|
||||
"hand written\n",
|
||||
@@ -186,7 +188,10 @@ fn print_without_a_name_says_which_names_there_are() {
|
||||
assert_ne!(out.status.code(), Some(0), "{stderr}");
|
||||
assert!(stderr.contains("name the skill to print"), "{stderr}");
|
||||
assert!(stderr.contains("worklane-review"), "{stderr}");
|
||||
assert!(String::from_utf8_lossy(&out.stdout).is_empty(), "a document was printed anyway");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).is_empty(),
|
||||
"a document was printed anyway"
|
||||
);
|
||||
}
|
||||
|
||||
/// The command has to be findable by someone who does not already know it exists.
|
||||
|
||||
+21
-7
@@ -191,7 +191,11 @@ fn ls_handles_short_and_non_ascii_filenames() {
|
||||
}
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
|
||||
cmd.current_dir(temp.path())
|
||||
.arg("ls")
|
||||
.arg("backlog")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout.matches("Odd Name").count(), 3);
|
||||
@@ -209,7 +213,11 @@ fn ls_survives_a_malformed_created_at() {
|
||||
.unwrap();
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
|
||||
cmd.current_dir(temp.path())
|
||||
.arg("ls")
|
||||
.arg("backlog")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Bad Date"));
|
||||
@@ -290,7 +298,10 @@ fn ls_shows_a_mark_for_the_level() {
|
||||
|
||||
// Piped, so no escapes: the glyph is carrying the level by itself
|
||||
assert!(!stdout.contains('\u{1b}'));
|
||||
assert!(stdout.contains("\u{25cf}\u{25cf} "), "no full meter for level 1 in {stdout:?}");
|
||||
assert!(
|
||||
stdout.contains("\u{25cf}\u{25cf} "),
|
||||
"no full meter for level 1 in {stdout:?}"
|
||||
);
|
||||
assert!(stdout.contains("\u{25cb}\u{25cb} "), "no empty meter for level 5");
|
||||
assert!(stdout.contains("\u{b7}\u{b7} "), "no unset mark");
|
||||
// The raw number is not what the listing shows
|
||||
@@ -340,7 +351,10 @@ fn ls_filters_by_tag_and_composes_with_status_and_priority() {
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert!(stdout.contains("Tagged bug"), "{stdout}");
|
||||
assert!(stdout.contains("Lower bug"), "{stdout}");
|
||||
assert!(stdout.contains("Started bug"), "a tagged ticket in another status was dropped");
|
||||
assert!(
|
||||
stdout.contains("Started bug"),
|
||||
"a tagged ticket in another status was dropped"
|
||||
);
|
||||
assert!(!stdout.contains("Tagged feature"), "an untagged ticket came through");
|
||||
// The counts are filtered too, since they are the same collect.
|
||||
assert!(stdout.contains("[BACKLOG] 2 tickets"), "{stdout}");
|
||||
@@ -436,8 +450,7 @@ fn ls_never_matches_a_ticket_carrying_no_tags() {
|
||||
// Nor does an empty tag reach the filter: the value parser refuses it, so nothing is
|
||||
// listed rather than everything.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "backlog", "--tag", ""]);
|
||||
cmd.current_dir(temp.path()).args(["ls", "backlog", "--tag", ""]);
|
||||
cmd.assert().failure().code(2);
|
||||
}
|
||||
|
||||
@@ -584,7 +597,8 @@ fn ls_ids_still_takes_the_filters() {
|
||||
);
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]);
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["ls", "--ids", "--tag", "cli"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}");
|
||||
}
|
||||
|
||||
+5
-9
@@ -473,7 +473,9 @@ fn stray_files(worklane: &std::path::Path) -> Vec<String> {
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| !["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str()))
|
||||
.filter(|name| {
|
||||
!["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str())
|
||||
})
|
||||
.collect();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
@@ -522,10 +524,7 @@ fn mv_never_leaves_stale_content_in_the_target_directory() {
|
||||
let moved = worklane.join("committed").join(&filename);
|
||||
assert!(moved.exists(), "ticket did not move");
|
||||
let content = fs::read_to_string(&moved).unwrap();
|
||||
assert!(
|
||||
content.contains("- **Status**: committed"),
|
||||
"stale status: {content:?}"
|
||||
);
|
||||
assert!(content.contains("- **Status**: committed"), "stale status: {content:?}");
|
||||
assert!(!content.contains("- **Status**: backlog"), "{content:?}");
|
||||
|
||||
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
|
||||
@@ -631,10 +630,7 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
|
||||
] {
|
||||
fs::write(
|
||||
worklane.join("backlog").join(format!("{}_foo.md", uuid)),
|
||||
format!(
|
||||
"# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n",
|
||||
uuid
|
||||
),
|
||||
format!("# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n", uuid),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
+9
-17
@@ -118,11 +118,7 @@ fn a_target_resolves_by_uuid_prefix_title_or_filename() {
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", search]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{search}: {}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(out.status.success(), "{search}: {}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
ticket(&worklane, GATED).contains(&format!("- blocked by {}", BLOCKER)),
|
||||
"{search}: {}",
|
||||
@@ -249,11 +245,7 @@ fn a_relation_already_held_reports_no_change_and_writes_nothing() {
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
assert!(out.status.success());
|
||||
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
||||
assert_eq!(
|
||||
ticket(&worklane, GATED),
|
||||
before,
|
||||
"the relation was recorded twice"
|
||||
);
|
||||
assert_eq!(ticket(&worklane, GATED), before, "the relation was recorded twice");
|
||||
}
|
||||
|
||||
/// One direction is stored. The inverse is derived by a scan, so the ticket at the
|
||||
@@ -354,7 +346,9 @@ fn show_lists_the_relation_the_other_ticket_holds() {
|
||||
// `relates to` is symmetric, so it reads the same way from either end.
|
||||
let shown = stdout(&run(&temp, &["show", FIXED]));
|
||||
assert!(
|
||||
shown.contains(&format!("relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one")),
|
||||
shown.contains(&format!(
|
||||
"relates to {RELATES_MARK} {BACKLOG_MARK} (641e3d5) The gated one"
|
||||
)),
|
||||
"{shown}"
|
||||
);
|
||||
}
|
||||
@@ -382,12 +376,10 @@ fn a_line_that_is_not_a_relation_is_an_error() {
|
||||
let worklane = board(&temp);
|
||||
|
||||
let path = find(&worklane, GATED);
|
||||
let content = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace(
|
||||
"## Metadata",
|
||||
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
|
||||
);
|
||||
let content = fs::read_to_string(&path).unwrap().replace(
|
||||
"## Metadata",
|
||||
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
|
||||
);
|
||||
fs::write(&path, content).unwrap();
|
||||
|
||||
let out = run(&temp, &["show", GATED]);
|
||||
|
||||
+318
-37
@@ -94,13 +94,20 @@ fn set_replaces_each_field_it_is_given() {
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"set", UUID,
|
||||
"--description", "Only paragraph.",
|
||||
"--acceptance", "New crit",
|
||||
"--plan", "New step",
|
||||
"--tags", "beta,gamma",
|
||||
"--due", "2026-12-31",
|
||||
"--priority", "1",
|
||||
"set",
|
||||
UUID,
|
||||
"--description",
|
||||
"Only paragraph.",
|
||||
"--acceptance",
|
||||
"New crit",
|
||||
"--plan",
|
||||
"New step",
|
||||
"--tags",
|
||||
"beta,gamma",
|
||||
"--due",
|
||||
"2026-12-31",
|
||||
"--priority",
|
||||
"1",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
@@ -190,7 +197,11 @@ fn set_reports_only_the_fields_that_changed() {
|
||||
assert!(!stdout.contains("due"), "{stdout:?}");
|
||||
}
|
||||
|
||||
/// An empty scalar looks like a way to clear a field, and clearing is not supported.
|
||||
/// An empty scalar is still a usage error, and the message now points at the flag that
|
||||
/// does clear a field, so the two do not contradict each other.
|
||||
///
|
||||
/// `--title` is the exception, and says only that the value cannot be empty: a title has
|
||||
/// no unset state to return to, so there is nothing to point at.
|
||||
#[test]
|
||||
fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
@@ -198,12 +209,244 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for flag in ["--title", "--due", "--tags"] {
|
||||
for (flag, expected) in [
|
||||
("--title", "value cannot be empty"),
|
||||
("--due", "use --clear"),
|
||||
("--tags", "use --clear"),
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, flag, ""]);
|
||||
assert_eq!(out.status.code(), Some(2), "{flag} was accepted");
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing a field is not supported"),
|
||||
"{flag}: {:?}",
|
||||
!stderr.contains("not supported"),
|
||||
"{flag} still says clearing is unsupported: {stderr:?}"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty value is a paragraph break for a section, so it cannot also mean empty the
|
||||
/// section. The error names the flag that does, per section.
|
||||
#[test]
|
||||
fn set_refuses_an_empty_section_and_names_the_clear_for_it() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for (flag, expected) in [
|
||||
("--description", "--clear description"),
|
||||
("--acceptance", "--clear acceptance"),
|
||||
("--plan", "--clear plan"),
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, flag, ""]);
|
||||
assert_eq!(out.status.code(), Some(1), "{flag} was accepted");
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains(expected), "{flag}: {stderr:?}");
|
||||
}
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// Every field `--clear` reaches, in one call, back to what a ticket is born with.
|
||||
#[test]
|
||||
fn clear_returns_every_field_it_reaches_to_unset() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"set",
|
||||
UUID,
|
||||
"--clear",
|
||||
"due",
|
||||
"--clear",
|
||||
"tags",
|
||||
"--clear",
|
||||
"priority",
|
||||
"--clear",
|
||||
"description",
|
||||
"--clear",
|
||||
"acceptance",
|
||||
"--clear",
|
||||
"plan",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Due**: _Not set_"), "{content}");
|
||||
assert!(content.contains("- **Tags**: _None_"), "{content}");
|
||||
assert!(content.contains("- **Priority**: _Not set_"), "{content}");
|
||||
assert!(
|
||||
content.contains("## Description\n_No description provided._\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains("## Acceptance Criteria\n_No acceptance criteria provided._\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(
|
||||
content.contains("## Implementation Plan\n_No implementation plan provided._\n"),
|
||||
"{content}"
|
||||
);
|
||||
|
||||
// The placeholder goes in bare, not dressed as an item of the section it replaces.
|
||||
assert!(!content.contains("- [ ] _No"), "{content}");
|
||||
assert!(!content.contains("1. _No"), "{content}");
|
||||
|
||||
// What --clear cannot reach is untouched, the handwritten section included.
|
||||
assert!(content.starts_with("# Original title\n"), "{content}");
|
||||
assert!(content.contains("- **Owner**: alice"), "{content}");
|
||||
assert!(content.contains("- **Status**: backlog"), "{content}");
|
||||
assert!(
|
||||
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
||||
"{content}"
|
||||
);
|
||||
}
|
||||
|
||||
/// A cleared ticket and one that was never given the field have to read the same, or
|
||||
/// clearing would be its own third state.
|
||||
#[test]
|
||||
fn a_cleared_ticket_reads_like_one_filed_without_the_fields() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
run(&temp, &["add", "--title", "Bare"]);
|
||||
run(
|
||||
&temp,
|
||||
&[
|
||||
"add",
|
||||
"--title",
|
||||
"Full",
|
||||
"--description",
|
||||
"A body.",
|
||||
"--acceptance",
|
||||
"One criterion",
|
||||
"--plan",
|
||||
"One step",
|
||||
"--tags",
|
||||
"alpha,beta",
|
||||
"--due",
|
||||
"2026-09-01",
|
||||
"--priority",
|
||||
"2",
|
||||
],
|
||||
);
|
||||
|
||||
let full = added(&worklane, "full");
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"set",
|
||||
&full.0,
|
||||
"--clear",
|
||||
"due",
|
||||
"--clear",
|
||||
"tags",
|
||||
"--clear",
|
||||
"priority",
|
||||
"--clear",
|
||||
"description",
|
||||
"--clear",
|
||||
"acceptance",
|
||||
"--clear",
|
||||
"plan",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let cleared = comparable(&fs::read_to_string(&full.1).unwrap());
|
||||
let bare = comparable(&fs::read_to_string(&added(&worklane, "bare").1).unwrap());
|
||||
assert_eq!(cleared, bare);
|
||||
}
|
||||
|
||||
/// The uuid and the file of the one ticket whose slug matches, as `add` wrote it.
|
||||
fn added(worklane: &Path, slug: &str) -> (String, PathBuf) {
|
||||
let entry = fs::read_dir(worklane.join("backlog"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.find(|e| e.file_name().to_string_lossy().ends_with(&format!("_{slug}.md")))
|
||||
.unwrap_or_else(|| panic!("no ticket slugged {slug}"));
|
||||
let name = entry.file_name().into_string().unwrap();
|
||||
let uuid = name.split('_').next().unwrap().to_string();
|
||||
(uuid, entry.path())
|
||||
}
|
||||
|
||||
/// A ticket without the three lines that are different by definition: its title, its
|
||||
/// uuid and the moment it was filed.
|
||||
fn comparable(content: &str) -> String {
|
||||
content
|
||||
.lines()
|
||||
.filter(|line| {
|
||||
!line.starts_with("# ")
|
||||
&& !line.contains("**ID**:")
|
||||
&& !line.contains("**Created At**:")
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
/// Nothing to take away is not a rewrite, per the same whole-file comparison a
|
||||
/// replacement uses.
|
||||
#[test]
|
||||
fn clearing_a_field_that_is_already_unset_is_no_change() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--clear", "due", "--clear", "tags"]);
|
||||
assert!(out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
||||
}
|
||||
|
||||
/// Replaced and emptied are reported in those words, since a caller doing both in one
|
||||
/// call cannot tell which happened to which field otherwise.
|
||||
#[test]
|
||||
fn clear_is_reported_apart_from_a_replacement() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--priority", "1", "--clear", "due"]);
|
||||
assert!(out.status.success());
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
assert!(stdout.contains("Updated priority on 'Original title'"), "{stdout:?}");
|
||||
assert!(stdout.contains("Cleared due on 'Original title'"), "{stdout:?}");
|
||||
}
|
||||
|
||||
/// Replacing and clearing one field in a single call is a contradiction, and answering
|
||||
/// it by whichever was applied last would be a silent answer.
|
||||
#[test]
|
||||
fn clearing_and_replacing_the_same_field_is_refused() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
for (flag, value, field) in [
|
||||
("--due", "2026-12-31", "due"),
|
||||
("--tags", "beta", "tags"),
|
||||
("--priority", "1", "priority"),
|
||||
("--acceptance", "A criterion", "acceptance"),
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, flag, value, "--clear", field]);
|
||||
assert_eq!(out.status.code(), Some(1), "{flag} with --clear {field} was accepted");
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("contradict each other"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
@@ -211,25 +454,45 @@ fn set_refuses_an_empty_scalar_as_a_usage_error() {
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// An empty value is a paragraph break for a section, so an all-blank one is a
|
||||
/// clearing attempt rather than a break.
|
||||
/// The fields no writer of `set` can reach are not reachable through `--clear` either,
|
||||
/// and an unknown one is a usage error listing what is.
|
||||
#[test]
|
||||
fn set_refuses_to_clear_a_section() {
|
||||
fn clear_refuses_a_field_it_does_not_own() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--description", ""]);
|
||||
assert_eq!(out.status.code(), Some(1));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("clearing is not supported"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
for field in [
|
||||
"owner",
|
||||
"title",
|
||||
"status",
|
||||
"campaign",
|
||||
"relations",
|
||||
"nonsense",
|
||||
] {
|
||||
let out = run(&temp, &["set", UUID, "--clear", field]);
|
||||
assert_eq!(out.status.code(), Some(2), "--clear {field} was accepted");
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("possible values"), "{field}: {stderr:?}");
|
||||
}
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// `--clear` on its own satisfies the at-least-one-field rule, since it is a field
|
||||
/// being written like any other.
|
||||
#[test]
|
||||
fn clear_alone_is_enough_of_a_field() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["set", UUID, "--clear", "due"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(ticket(&worklane).contains("- **Due**: _Not set_"));
|
||||
}
|
||||
|
||||
/// A bare `set <ticket>` would otherwise be a silent no-op.
|
||||
#[test]
|
||||
fn set_requires_at_least_one_field() {
|
||||
@@ -248,10 +511,7 @@ fn set_keeps_a_paragraph_break_in_a_replaced_description() {
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
run(
|
||||
&temp,
|
||||
&["set", UUID, "-d", "One.", "-d", "", "-d", "Two."],
|
||||
);
|
||||
run(&temp, &["set", UUID, "-d", "One.", "-d", "", "-d", "Two."]);
|
||||
|
||||
assert!(
|
||||
ticket(&worklane).contains("## Description\nOne.\n\nTwo.\n\n## Acceptance"),
|
||||
@@ -268,7 +528,14 @@ fn set_accepts_prose_that_begins_with_a_hyphen() {
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&["set", UUID, "-a", "--print should be supported", "-t", "-t is the title flag"],
|
||||
&[
|
||||
"set",
|
||||
UUID,
|
||||
"-a",
|
||||
"--print should be supported",
|
||||
"-t",
|
||||
"-t is the title flag",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
@@ -296,11 +563,16 @@ fn append_adds_a_paragraph_items_and_numbered_steps() {
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"append", UUID,
|
||||
"-d", "A third paragraph.",
|
||||
"-a", "Crit three",
|
||||
"-a", "Crit four",
|
||||
"-p", "Step three",
|
||||
"append",
|
||||
UUID,
|
||||
"-d",
|
||||
"A third paragraph.",
|
||||
"-a",
|
||||
"Crit three",
|
||||
"-a",
|
||||
"Crit four",
|
||||
"-p",
|
||||
"Step three",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
@@ -315,10 +587,7 @@ fn append_adds_a_paragraph_items_and_numbered_steps() {
|
||||
"{content}"
|
||||
);
|
||||
// Numbered on from the last step, and the steps above are untouched
|
||||
assert!(
|
||||
content.contains("1. Step one\n2. Step two\n3. Step three\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.contains("1. Step one\n2. Step two\n3. Step three\n"), "{content}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -342,14 +611,26 @@ fn append_replaces_an_empty_section_rather_than_following_its_placeholder() {
|
||||
|
||||
run(
|
||||
&temp,
|
||||
&["append", &uuid, "-d", "A description arrives late.", "-a", "First crit", "-p", "First step"],
|
||||
&[
|
||||
"append",
|
||||
&uuid,
|
||||
"-d",
|
||||
"A description arrives late.",
|
||||
"-a",
|
||||
"First crit",
|
||||
"-p",
|
||||
"First step",
|
||||
],
|
||||
);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(!content.contains("_No description provided._"), "{content}");
|
||||
assert!(!content.contains("_No acceptance criteria provided._"), "{content}");
|
||||
assert!(!content.contains("_No implementation plan provided._"), "{content}");
|
||||
assert!(content.contains("## Description\nA description arrives late.\n"), "{content}");
|
||||
assert!(
|
||||
content.contains("## Description\nA description arrives late.\n"),
|
||||
"{content}"
|
||||
);
|
||||
assert!(content.contains("## Implementation Plan\n1. First step\n"), "{content}");
|
||||
}
|
||||
|
||||
|
||||
+5
-6
@@ -350,7 +350,10 @@ fn show_disambiguates_tickets_with_non_ascii_filenames() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
for (filename, title) in [("émigré-un.md", "Accented One"), ("日本語-二.md", "Accented Two")] {
|
||||
for (filename, title) in [
|
||||
("émigré-un.md", "Accented One"),
|
||||
("日本語-二.md", "Accented Two"),
|
||||
] {
|
||||
fs::write(
|
||||
worklane.join("backlog").join(filename),
|
||||
format!("# {}\n\n## Metadata\n\n- **ID**: 1234\n", title),
|
||||
@@ -444,11 +447,7 @@ fn show_prints_the_title_once() {
|
||||
cmd.current_dir(temp.path()).arg("show").arg("Once Only");
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
|
||||
assert_eq!(
|
||||
stdout.matches("Once Only").count(),
|
||||
1,
|
||||
"title repeated in {stdout:?}"
|
||||
);
|
||||
assert_eq!(stdout.matches("Once Only").count(), 1, "title repeated in {stdout:?}");
|
||||
// The rule under it is still the width of the title
|
||||
assert!(stdout.contains("Once Only\n─────────\n"), "{stdout:?}");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
//! `worklane tags`, the tag vocabulary.
|
||||
//!
|
||||
//! The command exists because `--tag` answers what carries a tag and cannot answer what
|
||||
//! tags exist, which is the question a grooming sweep starts from. So the properties
|
||||
//! under test are the ones that question needs: every status counted, case kept apart,
|
||||
//! alphabetical order, and an output a shell can parse.
|
||||
|
||||
use assert_cmd::Command;
|
||||
use assert_fs::TempDir;
|
||||
use assert_fs::fixture::{PathChild, PathCreateDir};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
||||
|
||||
fn setup_worklane(temp: &TempDir) -> PathBuf {
|
||||
let worklane = temp.child(".worklane");
|
||||
worklane.create_dir_all().unwrap();
|
||||
|
||||
for dir in ["backlog", "committed", "reviewing", "done"] {
|
||||
worklane.child(dir).create_dir_all().unwrap();
|
||||
}
|
||||
|
||||
worklane.path().to_path_buf()
|
||||
}
|
||||
|
||||
/// A ticket carrying `tags` verbatim, so a test can write the field the way a hand-made
|
||||
/// ticket would: spaced, unspaced, unset or absent.
|
||||
fn create_ticket(worklane: &Path, status: &str, uuid: &str, tags: &str) {
|
||||
let path = worklane.join(status).join(format!("{uuid}_ticket.md"));
|
||||
fs::write(
|
||||
&path,
|
||||
format!(
|
||||
"# Ticket {uuid}\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
Prose that says **Tags**: not-a-field, in the body.\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {uuid}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: {tags}\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: {status}\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(args);
|
||||
cmd.assert().get_output().clone()
|
||||
}
|
||||
|
||||
fn tags(temp: &TempDir) -> Vec<String> {
|
||||
let out = run(temp, &["tags"]);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
.lines()
|
||||
.map(str::to_string)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Every status, done included, and the count is tickets rather than mentions.
|
||||
#[test]
|
||||
fn tags_counts_every_tag_on_the_board() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "backlog", "11111111", "bug, cli");
|
||||
create_ticket(&worklane, "committed", "22222222", "bug,tui");
|
||||
create_ticket(&worklane, "done", "33333333", "bug");
|
||||
|
||||
assert_eq!(tags(&temp), vec!["bug\t3", "cli\t1", "tui\t1"]);
|
||||
}
|
||||
|
||||
/// Alphabetical, which is the property that makes a near-duplicate findable: the two
|
||||
/// spellings land next to each other.
|
||||
#[test]
|
||||
fn tags_are_alphabetical_so_near_duplicates_are_adjacent() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "backlog", "11111111", "tui,bug,bugfix,cli");
|
||||
|
||||
assert_eq!(tags(&temp), vec!["bug\t1", "bugfix\t1", "cli\t1", "tui\t1"]);
|
||||
}
|
||||
|
||||
/// Case sensitive, like the `--tag` filter. Folding the two together here would hide the
|
||||
/// reason a filter came back short.
|
||||
#[test]
|
||||
fn tags_keeps_case_apart_the_way_the_filter_does() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "backlog", "11111111", "bug");
|
||||
create_ticket(&worklane, "backlog", "22222222", "Bug");
|
||||
|
||||
assert_eq!(tags(&temp), vec!["Bug\t1", "bug\t1"]);
|
||||
|
||||
// And the filter agrees with the listing, which is the point of keeping them apart.
|
||||
let filtered = String::from_utf8_lossy(&run(&temp, &["ls", "--tag", "bug", "--ids"]).stdout)
|
||||
.lines()
|
||||
.count();
|
||||
assert_eq!(filtered, 1);
|
||||
}
|
||||
|
||||
/// An unset field, an absent one and a field of separators are all no tags, the same
|
||||
/// three cases `parse_tags` folds together.
|
||||
#[test]
|
||||
fn tags_ignores_a_ticket_with_nothing_to_count() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "backlog", "11111111", "_None_");
|
||||
create_ticket(&worklane, "backlog", "22222222", " , ,");
|
||||
create_ticket(&worklane, "backlog", "33333333", "");
|
||||
// No Tags field at all, the way a hand-made ticket can be.
|
||||
fs::write(
|
||||
worklane.join("backlog").join("44444444_bare.md"),
|
||||
"# Bare\n\n## Metadata\n\n- **ID**: 44444444\n- **Status**: backlog\n",
|
||||
)
|
||||
.unwrap();
|
||||
create_ticket(&worklane, "backlog", "55555555", "real");
|
||||
|
||||
assert_eq!(tags(&temp), vec!["real\t1"]);
|
||||
}
|
||||
|
||||
/// A board with no tags prints nothing rather than a sentence, since a completion reads
|
||||
/// this and a sentence would become a candidate.
|
||||
#[test]
|
||||
fn tags_says_nothing_on_a_board_with_no_tags() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
setup_worklane(&temp);
|
||||
|
||||
let out = run(&temp, &["tags"]);
|
||||
assert!(out.status.success());
|
||||
assert_eq!(String::from_utf8_lossy(&out.stdout), "");
|
||||
}
|
||||
|
||||
/// Unstyled, like `ls --ids`: a shell reads this and an escape sequence would land in
|
||||
/// the candidate.
|
||||
#[test]
|
||||
fn tags_is_unstyled() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog", "11111111", "bug");
|
||||
|
||||
let listing = String::from_utf8_lossy(&run(&temp, &["tags"]).stdout).to_string();
|
||||
assert!(!listing.contains('\u{1b}'), "{listing:?}");
|
||||
}
|
||||
|
||||
/// The Tags line in a Description is prose, not a field, the same rule every other
|
||||
/// metadata read follows.
|
||||
#[test]
|
||||
fn tags_reads_only_the_metadata_section() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog", "11111111", "bug");
|
||||
|
||||
assert_eq!(tags(&temp), vec!["bug\t1"]);
|
||||
}
|
||||
|
||||
/// A missing status directory is skipped rather than refused, as in `ls --ids`: the
|
||||
/// caller is usually a shell, and an error over the prompt is worse than fewer answers.
|
||||
#[test]
|
||||
fn tags_skips_a_missing_status_directory() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog", "11111111", "bug");
|
||||
fs::remove_dir_all(worklane.join("reviewing")).unwrap();
|
||||
|
||||
assert_eq!(tags(&temp), vec!["bug\t1"]);
|
||||
}
|
||||
+3
-12
@@ -44,10 +44,7 @@ fn the_tui_outside_a_worklane_directory_gives_the_usual_message() {
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1), "{args:?}");
|
||||
assert!(
|
||||
stderr.contains("No .worklane directory found"),
|
||||
"{args:?}: {stderr:?}"
|
||||
);
|
||||
assert!(stderr.contains("No .worklane directory found"), "{args:?}: {stderr:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -66,10 +63,7 @@ fn the_tui_without_a_terminal_says_so_and_names_an_alternative() {
|
||||
assert_eq!(out.status.code(), Some(1), "{args:?}");
|
||||
assert!(stderr.contains("needs a terminal"), "{args:?}: {stderr:?}");
|
||||
assert!(stderr.contains("worklane ls"), "{args:?}: {stderr:?}");
|
||||
assert!(
|
||||
!stderr.contains("os error"),
|
||||
"the raw mode error leaked: {stderr:?}"
|
||||
);
|
||||
assert!(!stderr.contains("os error"), "the raw mode error leaked: {stderr:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -105,10 +99,7 @@ fn several_path_arguments_are_accepted() {
|
||||
let first = setup_project(&temp, "first");
|
||||
let second = setup_project(&temp, "second");
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&["tui", first.to_str().unwrap(), second.to_str().unwrap()],
|
||||
);
|
||||
let out = run(&temp, &["tui", first.to_str().unwrap(), second.to_str().unwrap()]);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
|
||||
assert_eq!(out.status.code(), Some(1), "{stderr:?}");
|
||||
|
||||
Reference in New Issue
Block a user