Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7470255a22 |
@@ -96,7 +96,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **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 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
|
||||
- **`campaign add --codename` is validated at parse time by `codename`**, which is `non_empty` plus one word. The board draws it as a label with a mark and no quoting, so `~beaver release` on that row reads as two labels and the second one is not a campaign; a title is where a sentence goes. Nothing else is checked: there is no registry of codenames, the same reason `ls --tag` refuses to validate a tag, and a length limit would be a number invented in the parser when the row that draws it already drops a label it cannot hold
|
||||
- **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
|
||||
- **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. **`append --tags` is the one place the field has an empty form and the argument still takes `non_empty`**: `append` has no `--clear` of its own, so naming one would send the caller looking on this command for a flag that is `set`'s
|
||||
- **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
|
||||
@@ -111,8 +111,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **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.** 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
|
||||
- **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 last against the test-local `TAG_LIST_FLAGS` and `TAG_NEW_COMMANDS` for the tag arguments that deliberately get no rule. 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, the first argument of `campaign show` and `campaign set`, 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
|
||||
- **`TAG_FLAGS` holds pairs where the others hold names**, because the two options that take one tag are spelled differently: `ls --tag` filters on one and `append --tags` adds them, so a single rule naming both would tell fish that each command accepts the other's flag. One rule per pair, generated in `fish_dynamic`. `add --tags` and `set --tags` are in the test's `TAG_LIST_FLAGS` instead and get no rule: they take the *whole* list, so the token at the cursor is `bug,tui` and fish replaces a token entire, which would throw away what is already typed. The test walks both `tag` and `tags`, so the next one has to say which of the two it is
|
||||
- **`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
|
||||
@@ -478,7 +479,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **A mechanical entry renders as one line and a comment as it always did.** A field change is one fact, and a paragraph for it would bury the comments it sits between. The labels are padded to `Kind::LABEL_WIDTH`, `campaign` being the longest of the four, so the bodies line up under each other
|
||||
- **A campaign entry records `Campaign::name`, the codename or failing that the title, never the uuid the field holds.** Settled when the entry is written, not left to the renderer: a log is a record, and resolving at read time would let an entry change meaning when a campaign is renamed. A `before` uuid the board no longer has reads `_missing_`, the way the Campaign field itself renders a dangling one, and a ticket never assigned starts from `_Not set_` (f774a33)
|
||||
- **`--actor` is on every command that writes an entry**, spelled from one `ACTOR_HELP` in `command.rs`: a flag documented differently on each command reads as four flags. `--actor-from-git` rides beside it from its own one string, the same way. On `chown` it sits beside `user`, which is the ticket's new assignee — the two are different questions and that command answers both
|
||||
- **`set --actor` reaches only the entry `--tags` writes**, since tags are the one field of that command's that is logged. Documented on the flag rather than left for a reader to notice from the absence of entries
|
||||
- **`set --actor` reaches only the entry `--tags` writes**, since tags are the one field of that command's that is logged. Documented on the flag rather than left for a reader to notice from the absence of entries. `append --actor` is the same flag for the same reason: `append --tags` moves the same field, so it writes the same `Kind::Tags` entry, and a tag added without replacing the rest would otherwise be the one tag change the log missed
|
||||
|
||||
### Shipping the Agent Assets
|
||||
- The skill is embedded with `include_str!` from `assets/SKILL.md`, not copied by an install script. `cargo install` places binaries and nothing else, so an installed document that is not in the binary is a document that drifts from it
|
||||
|
||||
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.32.17"
|
||||
version = "0.32.18"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.32.17"
|
||||
version = "0.32.18"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -12,7 +12,7 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `worklane show <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring. A campaign is addressed the same way, plus its exact codename, which wins over all three. Ends with the ticket's history: every comment on it and every change to its status, owner or tags, oldest first, each naming who made it |
|
||||
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions. `--status discarded` is exempt and reachable from anywhere, for a ticket that will not be done; leaving `discarded` is a backward move and needs `-f`. Discarding is refused while open tickets are blocked by the ticket, `-f` overrides. Records a `status` entry in the ticket's history, after the move: a refused or no-op move records nothing. `--actor` names the writer of that entry |
|
||||
| `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. `--tags` records a `tags` entry in the ticket's history, with the tags before and after, and it is the only field of this command's that is logged; `--actor` names the writer of that entry |
|
||||
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last |
|
||||
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`, or to the tags with `--tags`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last. `--tags` keeps the tags the ticket already carries, ignores one it already has, and takes several as a repeated flag or separated by commas, the way the field itself is written; it is the counterpart to `set --tags`, which replaces the whole field. It records a `tags` entry in the ticket's history, and `--actor` names the writer of that entry, this command's only logged field as it is `set`'s. Emptying a field is `set --clear`, which has no counterpart here |
|
||||
| `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, and a derived row that reads exactly like a stored one is drawn once. `relates to` on a ticket whose target already stores it reports no change, since it is the same edge; `blocked by` and `regression of` read differently from the far end, so a mutual pair is two rows. `mv` refuses to move a ticket blocked by one that is not done, unless `-f`. `--clear <kind> <target>` takes an edge off instead, repeatable, the kind spelled either way, `blocked-by` or `blocked by`. The target resolves against the edges the ticket holds first, by id prefix, which is the only way to reach one whose ticket has been deleted, then as an ordinary ticket search. An edge the ticket does not hold reports no change; a target naming nothing at all is an error. Recording and clearing the same edge in one call is refused |
|
||||
| `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. Records an `owner` entry in the ticket's history, with the owner before and after; `--actor` names who made the change, which is not the same as the user argument |
|
||||
| `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 |
|
||||
|
||||
+14
-8
@@ -169,16 +169,21 @@ 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 append 1b78a24 --tags tui # add a tag, keeping the ones there
|
||||
worklane chown alice 1b78a24 # hand the ticket to someone
|
||||
worklane chown --clear 1b78a24 # hand it back to nobody
|
||||
```
|
||||
|
||||
`set` replaces, `append` adds, `--clear` empties. `set --tags` overwrites the whole
|
||||
field: to add a tag to a ticket that already carries one, replace the value with every
|
||||
tag separated by commas. 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.
|
||||
field, so **use `append --tags` to add a tag to a ticket that already carries some**: it
|
||||
keeps what is there, and a tag the ticket already has is reported as no change rather
|
||||
than added twice, so you do not have to read the ticket first. Several in one call by
|
||||
repeating the flag or by separating them with commas, `--tags "bug, tui"`, since that is
|
||||
how the field itself is written. Reach for `set --tags` when the whole list is being
|
||||
replaced, and `set --clear tags` to empty it: `append` has neither. 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`
|
||||
@@ -339,8 +344,8 @@ existing ticket will have been written from a different angle.
|
||||
|
||||
`show` ends with a HISTORY block: every comment on the ticket and every change to its
|
||||
status, owner, tags or campaign, oldest first, each naming who made it. You do not write
|
||||
these by hand. `mv`, `chown`, `set --tags` and `assign` record themselves, and a call
|
||||
that changes nothing records nothing. A campaign move is recorded by codename, or by
|
||||
these by hand. `mv`, `chown`, `set --tags`, `append --tags` and `assign` record
|
||||
themselves, and a call that changes nothing records nothing. A campaign move is recorded by codename, or by
|
||||
title for a campaign that has none, not by the uuid the field holds.
|
||||
|
||||
```
|
||||
@@ -380,7 +385,8 @@ you to move a ticket, or to put words on the board as their comment, so name the
|
||||
the flag — the move was theirs and the words are theirs, and an entry carrying your name
|
||||
reads later as though you decided both. Otherwise leave it off, unless your instructions
|
||||
say to use it. It is spelled the same on every command that writes an entry: `comment`,
|
||||
`mv`, `chown`, `set` and `assign`.
|
||||
`mv`, `chown`, `set`, `append` and `assign`. On the last two it reaches only the entry
|
||||
`--tags` writes, since that is the one field either of them logs.
|
||||
|
||||
Acting for the person without knowing how they spell themselves? `--actor-from-git`
|
||||
attributes the entry to the detected git user instead of `WORKLANE_ACTOR`, so their name
|
||||
|
||||
+16
-3
@@ -358,7 +358,7 @@ export const set = tool({
|
||||
|
||||
export const append = tool({
|
||||
description:
|
||||
"Add to a section of an existing worklane ticket without replacing what is there. The description gains a new paragraph; acceptance criteria and plan steps are added to the end of their lists, with steps numbered on from the last. Ticked criteria and handwritten content are left alone. To replace a section outright, use set.",
|
||||
"Add to an existing worklane ticket without replacing what is there. The description gains a new paragraph; acceptance criteria and plan steps are added to the end of their lists, with steps numbered on from the last; tags are added to the ones the ticket already carries. Ticked criteria and handwritten content are left alone. To replace a section or the whole tag list outright, use set.",
|
||||
args: {
|
||||
ticket: tool.schema
|
||||
.string()
|
||||
@@ -375,6 +375,14 @@ export const append = tool({
|
||||
.string()
|
||||
.describe("Implementation plan steps to add, one per line.")
|
||||
.optional(),
|
||||
tags: tool.schema
|
||||
.string()
|
||||
.describe("Tags to add, comma separated, keeping the ones the ticket already carries. A tag it already has is reported as no change rather than added twice, so the ticket does not have to be read first.")
|
||||
.optional(),
|
||||
actor: tool.schema
|
||||
.string()
|
||||
.describe("Who the entry is attributed to. Only reaches the entry tags writes, since that is the one field of this command's that is logged. If omitted, WORKLANE_ACTOR is used, then the git user.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.ticket) {
|
||||
@@ -395,9 +403,14 @@ export const append = tool({
|
||||
if (args.plan) {
|
||||
itemLines(args.plan).forEach((line: string) => cmd.push("--plan", line));
|
||||
}
|
||||
if (args.tags) cmd.push("--tags", args.tags);
|
||||
// Last, and not counted as a field: the length check below is what refuses a call
|
||||
// that names nothing to add, and an actor alone adds nothing. Same shape as set.
|
||||
const fields = cmd.length;
|
||||
if (args.actor) cmd.push("--actor", args.actor);
|
||||
|
||||
if (cmd.length === 2) {
|
||||
return "Error appending: give at least one section to add to";
|
||||
if (fields === 2) {
|
||||
return "Error appending: give at least one field to add to";
|
||||
}
|
||||
|
||||
try {
|
||||
|
||||
+26
-4
@@ -858,14 +858,15 @@ impl ChownArgs {
|
||||
}
|
||||
}
|
||||
|
||||
/// `append` only offers the sections that hold multiple lines, since appending to a
|
||||
/// scalar has no meaning.
|
||||
/// `append` offers the fields something can be added to without disturbing what is
|
||||
/// already in them: the three sections that hold multiple lines, and Tags, which is a
|
||||
/// list. Appending to a scalar has no meaning, so there is no `--priority` or `--due`.
|
||||
#[derive(clap::Args)]
|
||||
#[command(group(
|
||||
clap::ArgGroup::new("append_fields")
|
||||
.required(true)
|
||||
.multiple(true)
|
||||
.args(["description", "acceptance", "plan"])
|
||||
.args(["description", "acceptance", "plan", "tags"])
|
||||
))]
|
||||
pub struct AppendArgs {
|
||||
/// Ticket UUID or title
|
||||
@@ -882,6 +883,24 @@ pub struct AppendArgs {
|
||||
/// Add implementation plan steps, numbered on from the last. Repeat the flag
|
||||
#[arg(short, long, allow_hyphen_values = PROSE)]
|
||||
pub plan: Vec<String>,
|
||||
|
||||
/// Add tags, keeping the ones the ticket already carries. Repeat the flag, or
|
||||
/// separate them with commas
|
||||
///
|
||||
/// `non_empty` rather than the `clearable` that `set --tags` takes. That message
|
||||
/// names `--clear`, and this command has none: emptying the field is
|
||||
/// `set --clear tags`, so pointing at a flag that is not here would send the caller
|
||||
/// looking for it on `append`.
|
||||
#[arg(short = 'g', long, value_parser = non_empty)]
|
||||
pub tags: Vec<String>,
|
||||
|
||||
/// Only reaches the entry `--tags` writes, since that is the one field of this
|
||||
/// command's that is logged, exactly as on `set`
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
pub actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
pub actor_from_git: bool,
|
||||
}
|
||||
|
||||
/// `relate` is the only writer of the Relations section, the way `chown` is the only
|
||||
@@ -1080,6 +1099,9 @@ mod tests {
|
||||
|
||||
// A guard on the walker itself: if it stopped finding commands, every assertion
|
||||
// above would pass by never running.
|
||||
assert_eq!(seen, 5, "expected comment, mv, chown, set and assign to carry --actor");
|
||||
assert_eq!(
|
||||
seen, 6,
|
||||
"expected comment, mv, chown, set, append and assign to carry --actor"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+51
-11
@@ -64,12 +64,22 @@ pub const CAMPAIGN_NESTED_COMMANDS: [(&str, &str); 3] = [
|
||||
/// Options whose value is a campaign.
|
||||
pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
|
||||
|
||||
/// Options whose value is a tag.
|
||||
/// Options whose value is a tag, as the command that takes it and the flag's long name.
|
||||
///
|
||||
/// 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"];
|
||||
///
|
||||
/// Pairs rather than the flat list the other flag lists are, because the two spellings
|
||||
/// differ: `ls --tag` filters on one and `append --tags` adds them, so a single rule
|
||||
/// naming both options would tell fish that each command takes the other's flag. One
|
||||
/// rule per pair instead.
|
||||
///
|
||||
/// `add --tags` and `set --tags` are deliberately absent. Both take the *whole* list, so
|
||||
/// the token being completed is `bug,tui` and fish replaces a token entire: offering one
|
||||
/// tag there would throw away the ones already typed. `append --tags` is the one where
|
||||
/// naming a single tag is the ordinary call.
|
||||
pub const TAG_FLAGS: [(&str, &str); 2] = [("ls", "tag"), ("append", "tags")];
|
||||
|
||||
/// Nested commands whose first argument is a tag the board already has.
|
||||
///
|
||||
@@ -110,7 +120,16 @@ fn fish_dynamic() -> String {
|
||||
.collect::<Vec<_>>()
|
||||
.join("; or ");
|
||||
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
|
||||
let tag_flags = flag_list(&TAG_FLAGS);
|
||||
let tag_flags = TAG_FLAGS
|
||||
.iter()
|
||||
.map(|(command, flag)| {
|
||||
format!(
|
||||
"complete -c worklane -n '__worklane_command_is {command}' -l {flag} \\\n \
|
||||
-x -a '(worklane tags | cut -f1,3)'"
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
let tag_nested = TAG_NESTED_COMMANDS
|
||||
.iter()
|
||||
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
|
||||
@@ -218,8 +237,10 @@ complete -c worklane -n '__worklane_command_is ls' {campaign_flags} \
|
||||
# What is left is the annotation, and a tag the board carries but has never declared has
|
||||
# none: it is offered with no description at all, which is the near-duplicate the file was
|
||||
# added to catch. The count used to be the description and said the same thing more weakly.
|
||||
complete -c worklane -n '__worklane_command_is ls' {tag_flags} \
|
||||
-x -a '(worklane tags | cut -f1,3)'
|
||||
#
|
||||
# One rule per command, from `TAG_FLAGS`: `ls --tag` and `append --tags` are spelled
|
||||
# differently, so a single rule naming both options would offer each under the other.
|
||||
{tag_flags}
|
||||
|
||||
# And `tags set` names one that is already declared, so it reads the same listing. `tags
|
||||
# add` has no rule on purpose: it takes a tag the board does not have, so the candidates
|
||||
@@ -410,14 +431,28 @@ mod tests {
|
||||
/// about what the fish block is missing, which is a test's question.
|
||||
const TAG_NEW_COMMANDS: [(&str, &str); 1] = [("tags", "add")];
|
||||
|
||||
/// Options taking a whole comma-separated list of tags rather than one.
|
||||
///
|
||||
/// `add --tags` and `set --tags` write the field entire, so what is being typed at the
|
||||
/// cursor is `bug,tui` and fish replaces a token whole: a rule offering one tag there
|
||||
/// would throw away the ones already in the token. `append --tags` adds to what is
|
||||
/// there, so a single tag is the ordinary value and it earns a rule. Recorded rather
|
||||
/// than skipped, for the reason `TAG_NEW_COMMANDS` is: the next `--tags` has to say
|
||||
/// which of the two it is.
|
||||
const TAG_LIST_FLAGS: [(&str, &str); 2] = [("add", "tags"), ("set", "tags")];
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// Both spellings are walked, `tag` and `tags`: they are the same object under two
|
||||
/// argument names, and looking at only the singular is how `set --tags` went years
|
||||
/// without anybody deciding whether it wanted a rule.
|
||||
#[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" {
|
||||
if !matches!(arg.get_id().as_str(), "tag" | "tags") {
|
||||
continue;
|
||||
}
|
||||
seen += 1;
|
||||
@@ -440,13 +475,18 @@ mod tests {
|
||||
continue;
|
||||
};
|
||||
|
||||
let pair = (name.as_str(), long);
|
||||
assert!(
|
||||
TAG_FLAGS.contains(&long),
|
||||
"`worklane {name} --{long}` takes a tag but is not in TAG_FLAGS"
|
||||
TAG_FLAGS.contains(&pair) || TAG_LIST_FLAGS.contains(&pair),
|
||||
"`worklane {name} --{long}` takes a tag, so it belongs in TAG_FLAGS if one \
|
||||
tag is the ordinary value and TAG_LIST_FLAGS if the value is the whole list"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(seen, 3, "expected ls --tag, tags add and tags set");
|
||||
assert_eq!(
|
||||
seen, 6,
|
||||
"expected ls --tag, tags add, tags set, add --tags, set --tags and append --tags"
|
||||
);
|
||||
}
|
||||
|
||||
/// **Every rule naming an option has to say which command it belongs to.** A bare
|
||||
@@ -589,8 +629,8 @@ mod tests {
|
||||
|
||||
assert_eq!(
|
||||
reading.len(),
|
||||
2,
|
||||
"expected the ls --tag rule and the tags set one: {reading:?}"
|
||||
3,
|
||||
"expected the ls --tag rule, the append --tags one and the tags set one: {reading:?}"
|
||||
);
|
||||
for line in reading {
|
||||
assert!(line.contains("(worklane tags | cut -f1,3)"), "{line}");
|
||||
|
||||
@@ -1135,12 +1135,83 @@ pub fn cmd_append(args: &AppendArgs, start: &Path, sink: &mut Sink) -> Result<()
|
||||
changed.push(section.label);
|
||||
}
|
||||
|
||||
// Through `apply`, unlike the sections above: appending a section always adds
|
||||
// something, and appending a tag the ticket already carries is the no-op this flag
|
||||
// exists to make free.
|
||||
if !args.tags.is_empty() {
|
||||
let next =
|
||||
set_metadata_field(&content, "Tags", &appended_tags(&content, &args.tags)?, &title)?;
|
||||
apply(&mut content, &mut changed, "tags", next);
|
||||
}
|
||||
|
||||
// The only way to reach here with nothing to write is a `--tags` the ticket already
|
||||
// satisfied, since every other field on this command adds or refuses. Reported in the
|
||||
// words `set` uses for the same answer.
|
||||
if changed.is_empty() {
|
||||
report(sink, &[], &title, "Appended to")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
// Tags are logged wherever they change, so the one command that adds to them without
|
||||
// replacing them logs too. Same shape as `set`'s, down to the before and after being
|
||||
// read off the field rather than off the flag: what the entry records is where the
|
||||
// field went, not what this call asked for.
|
||||
if changed.contains(&"tags") {
|
||||
write_entry(
|
||||
&worklane_dir,
|
||||
&uuid,
|
||||
Kind::Tags,
|
||||
&change(
|
||||
&parse_ticket_field(&original, "Tags"),
|
||||
&parse_ticket_field(&content, "Tags"),
|
||||
),
|
||||
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
|
||||
"",
|
||||
)?;
|
||||
}
|
||||
|
||||
report(sink, &changed, &title, "Appended to")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The ticket's tags with the call's merged onto the end, or the refusal for a call that
|
||||
/// named none.
|
||||
///
|
||||
/// A tag the ticket already carries is not added a second time, which is the whole
|
||||
/// difference from `set --tags`: appending means the caller does not have to know what is
|
||||
/// there already, so naming one that is reports no change rather than doubling it. New
|
||||
/// ones go on the end in the order they were given rather than sorted, so the field goes
|
||||
/// on reading as what was added when.
|
||||
///
|
||||
/// The values are split on commas the way the stored field is, so `--tags "bug, tui"`
|
||||
/// names two tags and matches the two a ticket carrying them already holds. Without that
|
||||
/// the pair would land as a single tag nothing can filter by, which is what `tag_value`
|
||||
/// refuses outright for the vocabulary; here it is split instead, because `set --tags`
|
||||
/// takes the comma form on this same field and refusing it on its counterpart would be a
|
||||
/// trap.
|
||||
///
|
||||
/// A call whose every value comes out blank is refused rather than written, the way
|
||||
/// [`appended_items`] refuses one: `--tags ","` names nothing, and writing the field back
|
||||
/// unchanged would report an append that never happened. Emptying the field is
|
||||
/// `set --clear tags`.
|
||||
fn appended_tags(content: &str, values: &[String]) -> Result<String> {
|
||||
let added: Vec<String> = values.iter().flat_map(|value| split_tags(value)).collect();
|
||||
if added.is_empty() {
|
||||
return Err(anyhow!("Nothing to append to the tags: every value given was blank"));
|
||||
}
|
||||
|
||||
let mut tags = parse_tags(content);
|
||||
for tag in added {
|
||||
if !tags.contains(&tag) {
|
||||
tags.push(tag);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(tags.join(", "))
|
||||
}
|
||||
|
||||
/// Record a relation from one ticket to another.
|
||||
///
|
||||
/// One side is written and the inverse is derived wherever it is shown. `blocked by`
|
||||
|
||||
+10
@@ -1608,6 +1608,16 @@ pub fn parse_tags(content: &str) -> Vec<String> {
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
split_tags(&value)
|
||||
}
|
||||
|
||||
/// The tags in one comma-separated value, trimmed and without the empty ones.
|
||||
///
|
||||
/// Split out of [`parse_tags`] because a value typed on the command line is separated the
|
||||
/// same way the stored field is: `append --tags "bug, tui"` names two tags, and merging
|
||||
/// that into what a ticket already carries has to see two or it stores the pair as one
|
||||
/// tag and adds it again on the next call.
|
||||
pub fn split_tags(value: &str) -> Vec<String> {
|
||||
value
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
|
||||
@@ -676,6 +676,140 @@ fn append_requires_at_least_one_section() {
|
||||
assert_eq!(run(&temp, &["append", UUID]).status.code(), Some(2));
|
||||
}
|
||||
|
||||
/// The reason the flag exists: `set --tags` writes the whole field, so adding one tag to
|
||||
/// a ticket that already carries some meant knowing and retyping every one of them.
|
||||
#[test]
|
||||
fn append_adds_a_tag_and_keeps_the_ones_already_there() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["append", UUID, "--tags", "beta"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Tags**: alpha, beta"), "{content}");
|
||||
// The sections and the other fields are as untouched as they are by any other append
|
||||
assert!(content.contains("- [x] Crit one\n- [ ] Crit two\n"), "{content}");
|
||||
assert!(content.contains("- **Priority**: 3"), "{content}");
|
||||
}
|
||||
|
||||
/// Idempotent on purpose: the caller of an append does not have to know what is there
|
||||
/// already, so naming a tag the ticket carries is reported as no change and writes
|
||||
/// nothing, the way an unchanged field is everywhere else.
|
||||
#[test]
|
||||
fn append_ignores_a_tag_the_ticket_already_carries() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["append", UUID, "--tags", "alpha"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes to"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
|
||||
// And the one already there is not added a second time beside a new one
|
||||
run(&temp, &["append", UUID, "--tags", "alpha", "--tags", "beta"]);
|
||||
assert!(
|
||||
ticket(&worklane).contains("- **Tags**: alpha, beta"),
|
||||
"{}",
|
||||
ticket(&worklane)
|
||||
);
|
||||
}
|
||||
|
||||
/// Two spellings for the same call, because the stored field is comma separated too and
|
||||
/// `set --tags` takes that form on this very field: refusing it on the counterpart would
|
||||
/// be a trap. New tags land in the order they were given, after the ones already there.
|
||||
#[test]
|
||||
fn append_takes_several_tags_by_repeated_flag_or_by_comma() {
|
||||
for args in [
|
||||
vec!["append", UUID, "--tags", "bug", "--tags", "tui"],
|
||||
vec!["append", UUID, "--tags", "bug, tui"],
|
||||
vec!["append", UUID, "-g", "bug,tui"],
|
||||
] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &args);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{args:?}: {:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(ticket(&worklane).contains("- **Tags**: alpha, bug, tui"), "{args:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A value that names no tag is refused rather than written, the way an all-blank section
|
||||
/// value is: `--tags ","` adds nothing, and writing the field back unchanged would report
|
||||
/// an append that never happened. Emptying the field is `set --clear tags`.
|
||||
#[test]
|
||||
fn append_refuses_a_tags_value_that_names_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
// Empty at the parser, before the ticket is even resolved
|
||||
let empty = run(&temp, &["append", UUID, "--tags", ""]);
|
||||
assert_eq!(empty.status.code(), Some(2));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&empty.stderr).contains("value cannot be empty"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&empty.stderr)
|
||||
);
|
||||
// The message must not name a `--clear` this command does not have
|
||||
assert!(
|
||||
!String::from_utf8_lossy(&empty.stderr).contains("use --clear"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&empty.stderr)
|
||||
);
|
||||
|
||||
// Separators only, which the parser cannot see is empty
|
||||
let blank = run(&temp, &["append", UUID, "--tags", ", ,"]);
|
||||
assert_eq!(blank.status.code(), Some(1));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&blank.stderr).contains("Nothing to append to the tags"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&blank.stderr)
|
||||
);
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// A ticket with no tags starts the list rather than appending to the sentinel.
|
||||
#[test]
|
||||
fn append_writes_the_first_tag_over_the_unset_sentinel() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
add.current_dir(temp.path())
|
||||
.args(["add", "--title", "Untagged"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let uuid = fs::read_dir(worklane.join("backlog"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.next()
|
||||
.map(|name| name.split('_').next().unwrap().to_string())
|
||||
.unwrap();
|
||||
|
||||
run(&temp, &["append", &uuid, "--tags", "bug"]);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Tags**: bug"), "{content}");
|
||||
assert!(!content.contains("_None_"), "{content}");
|
||||
}
|
||||
|
||||
/// Owner belongs to chown and status to mv, so neither command offers them.
|
||||
#[test]
|
||||
fn neither_command_can_write_owner_or_status() {
|
||||
|
||||
+45
-3
@@ -275,6 +275,36 @@ fn clearing_the_tags_writes_a_tags_entry() {
|
||||
assert!(entry.starts_with("**Tags**\nalpha → _None_\n"), "{entry:?}");
|
||||
}
|
||||
|
||||
/// Tags are logged wherever they change, so the command that adds to them logs the same
|
||||
/// entry the one that replaces them does. The values come off the field rather than off
|
||||
/// the flag, so the entry records where the field went and not what the call added: an
|
||||
/// append of `beta` onto `alpha` reads as the pair, not as `beta`.
|
||||
#[test]
|
||||
fn appending_a_tag_writes_a_tags_entry() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog");
|
||||
|
||||
run(&temp, &["append", UUID, "--tags", "beta"]);
|
||||
|
||||
let entry = only_entry(&worklane, "tags");
|
||||
assert!(entry.starts_with("**Tags**\nalpha → alpha, beta\n"), "{entry:?}");
|
||||
}
|
||||
|
||||
/// The sections are not logged, and appending to one is not a tag change: an append that
|
||||
/// touches no tag writes nothing, so the log does not fill with the edits it deliberately
|
||||
/// leaves out.
|
||||
#[test]
|
||||
fn appending_to_a_section_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog");
|
||||
|
||||
run(&temp, &["append", UUID, "--acceptance", "One more criterion"]);
|
||||
|
||||
assert_eq!(entries(&worklane), vec![]);
|
||||
}
|
||||
|
||||
/// The entry names the campaign the way a reader knows it, the codename, not the uuid
|
||||
/// the field actually holds. A ticket never assigned starts from the sentinel an unset
|
||||
/// field reads as everywhere else.
|
||||
@@ -433,6 +463,7 @@ fn a_no_op_edit_writes_nothing() {
|
||||
vec!["mv", UUID, "--status", "backlog"],
|
||||
vec!["chown", "alice", UUID],
|
||||
vec!["set", UUID, "--tags", "alpha"],
|
||||
vec!["append", UUID, "--tags", "alpha"],
|
||||
] {
|
||||
let out = run(&temp, &args);
|
||||
assert!(
|
||||
@@ -577,10 +608,11 @@ fn the_actor_flag_names_the_writer_on_every_command_that_writes_one() {
|
||||
run(&temp, &["mv", UUID, "--status", "committed", "--actor", "opencode"]);
|
||||
run(&temp, &["chown", "bob", UUID, "--actor", "opencode"]);
|
||||
run(&temp, &["set", UUID, "--tags", "beta", "--actor", "opencode"]);
|
||||
run(&temp, &["append", UUID, "--tags", "gamma", "--actor", "opencode"]);
|
||||
run(&temp, &["assign", "v1", UUID, "--actor", "opencode"]);
|
||||
|
||||
let found = entries(&worklane);
|
||||
assert_eq!(found.len(), 5, "{found:?}");
|
||||
assert_eq!(found.len(), 6, "{found:?}");
|
||||
for (name, content) in found {
|
||||
assert!(content.contains("**Author**: opencode"), "{name}: {content:?}");
|
||||
}
|
||||
@@ -609,10 +641,11 @@ fn actor_from_git_names_the_git_user_on_every_command_that_writes_one() {
|
||||
run_for_the_human(&temp, &["mv", UUID, "--status", "committed", "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["chown", "bob", UUID, "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["set", UUID, "--tags", "beta", "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["append", UUID, "--tags", "gamma", "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["assign", "v1", UUID, "--actor-from-git"]);
|
||||
|
||||
let found = entries(&worklane);
|
||||
assert_eq!(found.len(), 5, "{found:?}");
|
||||
assert_eq!(found.len(), 6, "{found:?}");
|
||||
for (name, content) in found {
|
||||
assert!(content.contains("**Author**: Ansho Rei"), "{name}: {content:?}");
|
||||
}
|
||||
@@ -627,7 +660,7 @@ fn actor_and_actor_from_git_are_refused_together() {
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog");
|
||||
|
||||
let calls: [&[&str]; 5] = [
|
||||
let calls: [&[&str]; 6] = [
|
||||
&[
|
||||
"comment",
|
||||
UUID,
|
||||
@@ -662,6 +695,15 @@ fn actor_and_actor_from_git_are_refused_together() {
|
||||
"opencode",
|
||||
"--actor-from-git",
|
||||
],
|
||||
&[
|
||||
"append",
|
||||
UUID,
|
||||
"--tags",
|
||||
"beta",
|
||||
"--actor",
|
||||
"opencode",
|
||||
"--actor-from-git",
|
||||
],
|
||||
&[
|
||||
"assign",
|
||||
"v1",
|
||||
|
||||
Reference in New Issue
Block a user