(03bdc76) Draw a symmetric relation once, and refuse the mirror, and bump to 0.32.1

`relate` refused a relation the ticket already held but never looked at what
the target held, so both ends of a `relates to` could store a line. `show` then
drew the same neighbour twice under the same label, since `RelatesTo` maps to
itself in `inverse_label`: one row from the stored line and one derived from the
far ticket's mirror of it, indistinguishable. Live on this board, where 8556048
and 8c8a520 each stored the other.

Both ends of the fix, because they do different jobs. `relation_rows` drops a
derived row that reads exactly like a stored one, which repairs the boards that
already hold both directions without an edit. `cmd_relate` refuses to store the
mirror in the first place, reporting no change since the edge is already
recorded at the far end, which stops it recurring. Neither alone closes it.

The dedupe keys on the **label** and the target, not the kind and the target.
Two tickets each blocking the other is two facts and the block has to say both,
`blocked by` from this end and `blocks` from the other; keying on the kind would
fold them into one row and lose half of what the ticket says. Only a symmetric
kind can collide with its own stored line, and `RelationKind::is_symmetric`
derives that from `label() == inverse_label()` rather than naming `RelatesTo`,
so a kind added later answers by construction. The same gate is what keeps the
refusal off a cycle: a target holding `blocked by <this>` is not a duplicate.

The stored row is the survivor, not the derived one, because it is the line
`relate --clear` can address. The consequence is worth knowing and is written
down: with both ends holding a line, clearing one leaves the other's, which then
draws as the derived row. Correct, since the far end still asserts the relation.

4179958 decided that `relates to` is symmetric and "written once, not onto both
files". Nothing enforced it until now.

The board's own data is left alone. 8556048 and 8c8a520 still both store the
line and the block now draws it once, which is what the criterion asked for.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-25 12:41:49 +02:00
co-authored by Claude Opus 5
parent 0f0767ac00
commit 00a64adca8
9 changed files with 274 additions and 6 deletions
+121
View File
@@ -2123,6 +2123,16 @@ impl RelationKind {
}
}
/// Whether the kind reads the same from both ends, which is `relates to` alone.
///
/// Derived from the two labels rather than listed, so a kind added later answers this
/// by construction. A symmetric kind is the only one whose derived row can collide
/// with its own stored line: `blocked by` from one end reads as `blocks` from the
/// other, and those are two different things to say about one pair of tickets.
pub fn is_symmetric(self) -> bool {
self.label() == self.inverse_label()
}
/// Every kind, so a caller can walk them without listing them a second time.
pub const ALL: [RelationKind; 3] = [
RelationKind::BlockedBy,
@@ -2569,10 +2579,30 @@ pub fn relation_rows(stored: &[Relation], index: &RelationIndex, uuid: &str) ->
})
.collect();
// How each stored row reads, which is what a derived row is checked against below.
// Collected first because the check cannot borrow `rows` while extending it.
let drawn: Vec<(&'static str, String)> =
rows.iter().map(|row| (row.label, row.uuid.clone())).collect();
rows.extend(
index
.inbound(uuid)
// A derived row that reads exactly like a stored one is not a second fact.
// Both ends of a symmetric relation can hold a line, since nothing stopped
// that until 03bdc76, and the block drew the same neighbour twice under the
// same label. The stored row is the one kept: it is the line `--clear` can
// address, where the derived one is on a file this ticket does not own.
//
// Keyed on the label and the target rather than the kind and the target,
// which is what keeps a mutual block as two rows: `blocked by` and `blocks`
// are different things to say about one pair, and only a symmetric kind,
// whose inverse label is its own, can collide with itself.
.into_iter()
.filter(|(kind, holder)| {
!drawn
.iter()
.any(|(label, target)| *label == kind.inverse_label() && *target == holder.uuid)
})
.map(|(kind, holder)| RelationRow {
kind,
label: kind.inverse_label(),
@@ -5655,6 +5685,97 @@ Plain line with **bold** and a [link](http://x.test/a).
}
}
/// `relates to` alone reads the same from both ends, and it is derived from the two
/// labels rather than listed, so a kind added later answers by construction.
#[test]
fn only_relates_to_is_symmetric() {
for kind in RelationKind::ALL {
assert_eq!(
kind.is_symmetric(),
kind == RelationKind::RelatesTo,
"{kind:?} claims symmetry it does not have, or has one it does not claim"
);
assert_eq!(kind.is_symmetric(), kind.label() == kind.inverse_label(), "{kind:?}");
}
}
/// Both ends of a symmetric relation can hold a line, since nothing stopped that
/// until 03bdc76, and the block drew the same neighbour twice under the same label.
/// The derived row goes and the stored one stays: it is the line `--clear` can
/// address, where the derived one lives on a file this ticket does not own.
#[test]
fn a_derived_row_that_reads_like_a_stored_one_is_drawn_once() {
let index = RelationIndex::new(vec![related(
TARGET,
"The neighbour",
"backlog",
vec![relation(RelationKind::RelatesTo, SELF)],
)]);
let stored = vec![relation(RelationKind::RelatesTo, TARGET)];
let rows = relation_rows(&stored, &index, SELF);
assert_eq!(rows.len(), 1, "the same edge is drawn twice: {rows:?}");
assert_eq!(rows[0].label, "relates to");
assert_eq!(rows[0].uuid, TARGET);
// The stored one, which is what `--clear` addresses. Both ends carry the same
// label here, so the label cannot say which survived: the count is what does.
assert_eq!(
render_relations(&rows, false),
format!("relates to {RELATES_MARK} {} (b1b2c3d) The neighbour\n", smark("backlog"))
);
}
/// Only where the row would read the same. A pair of tickets each blocking the other
/// is two facts, and the block says both: `blocked by` from this end and `blocks`
/// from the other. Deduping on the kind rather than on the label would have folded
/// them into one and lost half of what the ticket says.
#[test]
fn a_mutual_relation_of_an_asymmetric_kind_keeps_both_rows() {
for kind in RelationKind::ALL.into_iter().filter(|kind| !kind.is_symmetric()) {
let index = RelationIndex::new(vec![related(
TARGET,
"The other one",
"backlog",
vec![relation(kind, SELF)],
)]);
let stored = vec![relation(kind, TARGET)];
let rows = relation_rows(&stored, &index, SELF);
assert_eq!(rows.len(), 2, "{kind:?} lost a row: {rows:?}");
assert_eq!(rows[0].label, kind.label(), "{kind:?}");
assert_eq!(rows[1].label, kind.inverse_label(), "{kind:?}");
}
}
/// The dedupe is per target, not per kind: a second neighbour holding its own
/// `relates to` is a different edge and keeps its row.
#[test]
fn a_second_neighbours_derived_row_survives_the_dedupe() {
const OTHER: &str = "cccccccc-1111-4222-8333-444444444444";
let index = RelationIndex::new(vec![
related(
TARGET,
"The neighbour",
"backlog",
vec![relation(RelationKind::RelatesTo, SELF)],
),
related(
OTHER,
"Another one",
"backlog",
vec![relation(RelationKind::RelatesTo, SELF)],
),
]);
let stored = vec![relation(RelationKind::RelatesTo, TARGET)];
let rows = relation_rows(&stored, &index, SELF);
assert_eq!(rows.len(), 2, "{rows:?}");
assert_eq!(rows[0].uuid, TARGET, "the stored row is not first: {rows:?}");
assert_eq!(rows[1].uuid, OTHER, "the other neighbour was dropped: {rows:?}");
}
/// Both directions of one kind carry the same mark, since the kind is what the mark
/// says and the label is what says which way it points.
#[test]