(8556048) Take a relation off with relate --clear, and bump to 0.32.0
`relate` only added. A `--blocked-by` pointed at the wrong ticket was on that ticket forever, refusing every move it made until the target was done or `-f` was passed again, and a target that was deleted did not clean up either: the board carried a dead edge that nothing could clear and every later read of the ticket paid for. `--clear <kind> <target>` takes one off. It is on `relate` rather than on `set` for the reason `RELATIONS` is out of `section_args`: a relation names a target that has to be resolved first, so one writer owns both directions, the way `chown` owns setting an owner and clearing one. It names the target and not just the kind, because a ticket can hold several relations of one kind and emptying all of them is not what anybody is asking for. That is also why it is not spelled the way `set --clear` is, which names a field and empties it whole. Both spellings of the kind are taken, `blocked-by` from the flag and `blocked by` from the label: both are in front of the reader, the flag being what recorded the relation and the label what `show` prints and the file stores, so refusing the printed form would trap anyone clearing a row they had just read. `RelationKind::flag` is a match rather than a `replace` on the label, so the flag, the `--clear` value and the completion list cannot drift. `find_relation` searches the ticket's own edges by id prefix before it searches the board, and that order is the feature rather than an optimisation: no search of the board reaches a target whose ticket is gone, so the stored-target tier is the only thing that can clear a dangling edge, which is the case most likely to need clearing. Two stored targets under one prefix name the candidates instead of guessing, as an ambiguous ticket search already does. An edge the ticket does not hold reports no change, and a target naming nothing at all is an error. The two are different facts: the first is the state the caller asked for, and the second is a typo that a no-op would swallow. The resolver's own reason is carried through, so an ambiguous search says it is ambiguous rather than being reported as nothing found. Recording and clearing the same relation in one call is refused, and the check runs on what was *asked* for and not on what would be written. A relation already in the file is not among the additions, so comparing against those would have let `--blocked-by X --clear blocked-by X` quietly remove it. Removals rewrite the section from what is left and additions are appended to that, in that order and in two passes: a call with no `--clear` then takes exactly the path it always took. The last edge leaves the placeholder, which is the line `append` treats as no content, so the next `relate` replaces it rather than writing underneath it. The two values are one flag, so clap cannot type them apart. `num_args = 2` is per occurrence, which makes an odd number a usage error and every chunk a full pair, and `cleared` parses the kind before the ticket is resolved. Nothing is logged, in either direction, since `relate` never has: a log recording only the destructive half would read as though the additions had never happened. `chowns_clear_is_completed_with_tickets_and_sets_is_not` found the first rule carrying `-l clear` and there are now three, on three commands, each taking something different. It is `each_clear_flag_is_completed_for_its_own_command`, scoped per command, and `relate --clear` offers the kinds rather than a board listing, since tickets where the kind goes would be candidates it refuses. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
7994d98913
commit
0f0767ac00
+30
-1
@@ -852,12 +852,17 @@ pub struct AppendArgs {
|
||||
/// Each flag repeats, so several relations of one kind land in a single call. The
|
||||
/// targets are ticket searches, resolved by the same three tiers every other ticket
|
||||
/// argument is, and stored as the target's uuid.
|
||||
///
|
||||
/// `--clear` is the other direction, and it is here rather than on `set` for the reason
|
||||
/// Relations is absent from `section_args`: a relation names a target that has to be
|
||||
/// resolved first, so its one writer owns both adding and removing, the way `chown` owns
|
||||
/// both setting an owner and clearing one.
|
||||
#[derive(clap::Args)]
|
||||
#[command(group(
|
||||
clap::ArgGroup::new("relation_kinds")
|
||||
.required(true)
|
||||
.multiple(true)
|
||||
.args(["blocked_by", "regression_of", "relates_to"])
|
||||
.args(["blocked_by", "regression_of", "relates_to", "clear"])
|
||||
))]
|
||||
pub struct RelateArgs {
|
||||
/// Ticket UUID or title
|
||||
@@ -874,6 +879,18 @@ pub struct RelateArgs {
|
||||
/// Ticket this one is merely related to. Symmetric, so it is recorded once
|
||||
#[arg(long, value_parser = non_empty)]
|
||||
pub relates_to: Vec<String>,
|
||||
|
||||
/// Take a relation off: the kind, then the ticket it points at. Repeat the flag
|
||||
///
|
||||
/// Two values rather than one, because a ticket can hold several relations of one
|
||||
/// kind and emptying every `blocked by` on it is not usually what is wanted. That is
|
||||
/// also why this is not `set --clear`, which names a field and empties the whole of
|
||||
/// it: the "value" here is one edge among several, so the target has to be named too.
|
||||
///
|
||||
/// A `Vec<String>` because clap cannot type the two values of one flag apart.
|
||||
/// [`RelateArgs::cleared`] is where the pairs are split and the kind is parsed.
|
||||
#[arg(long, num_args = 2, value_names = ["KIND", "TARGET"], value_parser = non_empty)]
|
||||
pub clear: Vec<String>,
|
||||
}
|
||||
|
||||
impl RelateArgs {
|
||||
@@ -886,6 +903,18 @@ impl RelateArgs {
|
||||
(RelationKind::RelatesTo, &self.relates_to),
|
||||
]
|
||||
}
|
||||
|
||||
/// The relations asked to be taken off, as a kind and the search naming the target.
|
||||
///
|
||||
/// `num_args = 2` is per occurrence, so clap has already refused an odd number of
|
||||
/// values and every chunk is a full pair. A kind that is not one of the three is
|
||||
/// refused here, before the ticket is resolved and long before anything is written.
|
||||
pub fn cleared(&self) -> anyhow::Result<Vec<(RelationKind, &str)>> {
|
||||
self.clear
|
||||
.chunks(2)
|
||||
.map(|pair| Ok((RelationKind::parse_value(&pair[0])?, pair[1].as_str())))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// `check` and `uncheck` are separate commands rather than one verb with a flag,
|
||||
|
||||
Reference in New Issue
Block a user