Show the target's status beside the relation kind, and bump to 0.15.2
A row now carries two marks, kind then status: what sort of edge this is, then
how far the ticket at the other end has got. `blocked by × ◐ (6ce2c47) Title`.
Two questions are asked of this block, which rows hold this ticket up and
whether the ones that do are finished, and one glyph could not answer both.
○ not started, ◐ under way, ● finished, in grey, orange, cyan and green: the
shape says how far the target has got and the colour tells the two middle
stages apart, since committed and reviewing are both half circles. Green is the
colour the priority ramp deliberately leaves out because it means a title; on a
one-cell mark with no title behind it nothing else wants it, and it is the
obvious colour for done. Orange keeps the meaning it already has, Status.
These are the priority meter's own circles, and what keeps a status from
reading as a level is width: the meter is always two cells, a status mark is
one. the_status_mark_is_one_cell_where_the_meter_is_two pins both halves, and a
card carries the meter and never a status mark while the block carries the
status mark and never a meter.
The kind mark survives a target the board cannot find and the status mark
cannot, since a kind is read from the ticket's own file and a status from the
board. ? holds the column so the id does not move when one target has gone, and
_missing_ is what says it is gone.
Committed and reviewing are told apart by colour alone, so a pipe cannot tell
them apart: both read as under way. Accepted, since ● and ○ are the two answers
usually wanted and show on the target settles the rest, and assets/SKILL.md now
says so outright rather than leaving an agent to work it out from a colourless
half circle.
RelationTarget is back, carrying the title and the status in one Option because
they come from the same lookup. It went out in 5ae9c7f when nothing read the
status and came back one commit later, which is what a field nothing reads
costs: right at the time, churn either way.
A patch: 0.15.0 was the arrival of a marked relations block and this is still
settling what it marks. Three minors in an hour would read as three features.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
5ae9c7fe00
commit
ae3ee1bb9e
+206
-30
@@ -1757,6 +1757,45 @@ pub const RELATES_MARK: &str = "\u{2192}";
|
||||
/// The mark a regression row carries, pointing back at the fix it undid.
|
||||
pub const REGRESSION_MARK: &str = "\u{2190}";
|
||||
|
||||
/// The mark for the status of a relation's target, and the colour it is drawn in.
|
||||
///
|
||||
/// One circle where the priority meter is always two, which is what keeps the two apart:
|
||||
/// the meter reads `\u{25cf}\u{25d0}` and a status reads `\u{25d0}`, and they never sit in the same column.
|
||||
/// `the_status_mark_is_one_cell_where_the_meter_is_two` pins that, since it is the whole
|
||||
/// reason a circle is safe here when it is not safe on a card.
|
||||
///
|
||||
/// `\u{25cb}` not started, `\u{25d0}` under way, `\u{25cf}` finished, so the shape carries how far the
|
||||
/// target has got and the colour says which of the two middle stages it is in. A ramp
|
||||
/// inside one column, the way the priority meter reuses the palette: grey for the pile
|
||||
/// nobody has picked up, orange for work in hand, cyan for work waiting on a reader,
|
||||
/// green for done. Green is the one the priority ramp deliberately leaves out because it
|
||||
/// means a title, and it is safe on a one-cell mark that no title sits behind.
|
||||
const STATUS_MARKS: [(&str, &str, Color); 4] = [
|
||||
("backlog", "\u{25cb}", Color::Grey),
|
||||
("committed", "\u{25d0}", Color::Orange),
|
||||
("reviewing", "\u{25d0}", Color::Cyan),
|
||||
("done", "\u{25cf}", Color::Green),
|
||||
];
|
||||
|
||||
/// The mark for a status, or `?` for a target the board no longer holds.
|
||||
///
|
||||
/// A placeholder rather than a blank, so the id column does not move when one row's
|
||||
/// target has gone, and grey rather than a stage of the flow: the `_missing_` beside it
|
||||
/// is grey for the same reason. An unrecognised value reads the same way, since the
|
||||
/// status comes from the directory the ticket was found in and guessing at a fifth stage
|
||||
/// would mark a status nothing can act on. `every_status_has_a_mark` pins the pairing
|
||||
/// against `status_dirs`.
|
||||
pub fn status_mark(status: Option<&str>) -> (&'static str, Color) {
|
||||
let found = status.and_then(|status| {
|
||||
STATUS_MARKS
|
||||
.iter()
|
||||
.find(|(name, _, _)| *name == status)
|
||||
.map(|(_, mark, colour)| (*mark, *colour))
|
||||
});
|
||||
|
||||
found.unwrap_or(("?", Color::Grey))
|
||||
}
|
||||
|
||||
/// The glyph and colour for a kind of relation.
|
||||
///
|
||||
/// The label already names the kind in words, and this is what makes the block scannable
|
||||
@@ -1778,8 +1817,8 @@ pub fn relation_mark(kind: RelationKind) -> (&'static str, Color) {
|
||||
|
||||
/// One row of the Relations block: which relation, and what it points at.
|
||||
///
|
||||
/// The title is `None` for a uuid the board no longer holds, which is the one case with
|
||||
/// nothing to name.
|
||||
/// The target is `None` for a uuid the board no longer holds, which is the one case with
|
||||
/// neither a name nor a status to show.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RelationRow {
|
||||
/// Which edge this is, which decides the mark. Kept beside the label rather than
|
||||
@@ -1789,8 +1828,20 @@ pub struct RelationRow {
|
||||
/// The kind as it reads from this end, which is what the row is padded against.
|
||||
pub label: &'static str,
|
||||
pub uuid: String,
|
||||
/// The title of the ticket it names, once the board has been read for it.
|
||||
pub title: Option<String>,
|
||||
/// The ticket it names, once the board has been read for it.
|
||||
pub target: Option<RelationTarget>,
|
||||
}
|
||||
|
||||
/// What a relation points at: what to call it, and how far it has got.
|
||||
///
|
||||
/// One `Option` around both rather than two, because they come from the same lookup and
|
||||
/// so are absent together. The status is here again after 5ae9c7f took it out: the mark
|
||||
/// keyed on the kind alone for one commit, and a blocking row's state is the thing a
|
||||
/// reader most wants without leaving the ticket.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RelationTarget {
|
||||
pub title: String,
|
||||
pub status: String,
|
||||
}
|
||||
|
||||
/// A run of text and the colour it is drawn in, or `None` for the default foreground.
|
||||
@@ -1830,15 +1881,20 @@ impl Cell {
|
||||
/// CLI and the board cannot disagree about which edges there are, what they are called
|
||||
/// or which direction comes first.
|
||||
pub fn relation_rows(stored: &[Relation], index: &RelationIndex, uuid: &str) -> Vec<RelationRow> {
|
||||
let target_of = |ticket: Option<&RelatedTicket>| {
|
||||
ticket.map(|ticket| RelationTarget {
|
||||
title: ticket.title.clone(),
|
||||
status: ticket.status.clone(),
|
||||
})
|
||||
};
|
||||
|
||||
let mut rows: Vec<RelationRow> = stored
|
||||
.iter()
|
||||
.map(|relation| RelationRow {
|
||||
kind: relation.kind,
|
||||
label: relation.kind.label(),
|
||||
uuid: relation.target.clone(),
|
||||
title: index
|
||||
.get(&relation.target)
|
||||
.map(|ticket| ticket.title.clone()),
|
||||
target: target_of(index.get(&relation.target)),
|
||||
})
|
||||
.collect();
|
||||
|
||||
@@ -1847,7 +1903,7 @@ pub fn relation_rows(stored: &[Relation], index: &RelationIndex, uuid: &str) ->
|
||||
kind,
|
||||
label: kind.inverse_label(),
|
||||
uuid: holder.uuid.clone(),
|
||||
title: Some(holder.title.clone()),
|
||||
target: target_of(Some(holder)),
|
||||
}
|
||||
}));
|
||||
|
||||
@@ -1869,18 +1925,27 @@ pub fn relation_cells(rows: &[RelationRow]) -> Vec<Vec<Cell>> {
|
||||
|
||||
rows.iter()
|
||||
.map(|row| {
|
||||
let (mark, colour) = relation_mark(row.kind);
|
||||
let (kind, kind_colour) = relation_mark(row.kind);
|
||||
let (status, status_colour) =
|
||||
status_mark(row.target.as_ref().map(|target| target.status.as_str()));
|
||||
let padding = " ".repeat(width - row.label.chars().count());
|
||||
|
||||
// The mark goes ahead of the id, where it describes the target rather than
|
||||
// the row: every row carries one, so nothing is pushed out of line the way
|
||||
// the card's blocked mark would have been.
|
||||
// Kind, then state, then who: what sort of edge this is, how far the ticket
|
||||
// at the other end has got, and which ticket that is. Both marks go ahead of
|
||||
// the id, where they describe the target rather than the row, and every row
|
||||
// carries both, so nothing is pushed out of line the way the card's blocked
|
||||
// mark would have been.
|
||||
let mut cells = vec![
|
||||
Cell::plain(format!("{}{}{}", row.label, padding, COLUMN_GUTTER)),
|
||||
Cell::colored(mark, colour),
|
||||
Cell::colored(kind, kind_colour),
|
||||
Cell::plain(" "),
|
||||
Cell::colored(status, status_colour),
|
||||
Cell::plain(" "),
|
||||
];
|
||||
cells.extend(reference_cells(&row.uuid, row.title.as_deref()));
|
||||
cells.extend(reference_cells(
|
||||
&row.uuid,
|
||||
row.target.as_ref().map(|target| target.title.as_str()),
|
||||
));
|
||||
|
||||
cells
|
||||
})
|
||||
@@ -3396,15 +3461,30 @@ mod tests {
|
||||
|
||||
/// One row as the block shows it, for a test about where the block goes rather than
|
||||
/// about how it was derived.
|
||||
fn row(kind: RelationKind, label: &'static str, uuid: &str, title: &str) -> RelationRow {
|
||||
fn row(
|
||||
kind: RelationKind,
|
||||
label: &'static str,
|
||||
uuid: &str,
|
||||
title: &str,
|
||||
status: &str,
|
||||
) -> RelationRow {
|
||||
RelationRow {
|
||||
kind,
|
||||
label,
|
||||
uuid: uuid.to_string(),
|
||||
title: Some(title.to_string()),
|
||||
target: Some(RelationTarget {
|
||||
title: title.to_string(),
|
||||
status: status.to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
/// The status mark as the block draws it, so a row assertion reads like the row.
|
||||
/// The glyphs themselves are pinned literally by `the_status_marks_are_pinned`.
|
||||
fn smark(status: &str) -> &'static str {
|
||||
status_mark(Some(status)).0
|
||||
}
|
||||
|
||||
const TARGET: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
||||
const SELF: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
|
||||
@@ -3535,13 +3615,101 @@ mod tests {
|
||||
assert_eq!(
|
||||
render_relations(&relation_rows(&stored, &index, SELF), false),
|
||||
format!(
|
||||
"regression of {REGRESSION_MARK} (b1b2c3d) The blocker\n\
|
||||
blocks {BLOCKED_MARK} (ccccccc) The other one\n\
|
||||
relates to {RELATES_MARK} (ccccccc) The other one\n"
|
||||
"regression of {REGRESSION_MARK} {backlog} (b1b2c3d) The blocker\n\
|
||||
blocks {BLOCKED_MARK} {reviewing} (ccccccc) The other one\n\
|
||||
relates to {RELATES_MARK} {reviewing} (ccccccc) The other one\n",
|
||||
backlog = smark("backlog"),
|
||||
reviewing = smark("reviewing"),
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/// The mapping itself, literally, so a change to a glyph or a colour is a decision
|
||||
/// rather than a surprise. Every other assertion about a row interpolates these.
|
||||
#[test]
|
||||
fn the_status_marks_are_pinned() {
|
||||
assert_eq!(status_mark(Some("backlog")), ("\u{25cb}", Color::Grey));
|
||||
assert_eq!(status_mark(Some("committed")), ("\u{25d0}", Color::Orange));
|
||||
assert_eq!(status_mark(Some("reviewing")), ("\u{25d0}", Color::Cyan));
|
||||
assert_eq!(status_mark(Some("done")), ("\u{25cf}", Color::Green));
|
||||
assert_eq!(status_mark(None), ("?", Color::Grey));
|
||||
}
|
||||
|
||||
/// Every status the board holds is told apart from the other three. The shape does
|
||||
/// not do it alone, since committed and reviewing are both half circles, so it is the
|
||||
/// pair that has to be unique. Pinned against `status_dirs` rather than the four
|
||||
/// names written out here, so a status added later fails this instead of silently
|
||||
/// reading as `?`.
|
||||
#[test]
|
||||
fn every_status_has_a_mark() {
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
|
||||
for status in status_dirs() {
|
||||
let (mark, colour) = status_mark(Some(status));
|
||||
assert_ne!(mark, "?", "{status} has no mark of its own");
|
||||
assert!(
|
||||
seen.insert((mark, colour)),
|
||||
"{status} is drawn exactly like another status"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(seen.len(), 4, "{seen:?}");
|
||||
}
|
||||
|
||||
/// An unrecognised value reads as missing rather than as a fifth stage of the flow.
|
||||
#[test]
|
||||
fn a_status_the_board_does_not_use_reads_as_missing() {
|
||||
assert_eq!(status_mark(Some("elsewhere")), ("?", Color::Grey));
|
||||
assert_eq!(status_mark(Some("")), ("?", Color::Grey));
|
||||
}
|
||||
|
||||
/// The circles are the priority meter's glyphs, and this is what keeps a status from
|
||||
/// being read as a level: the meter is always two cells and a status mark is one.
|
||||
/// A card carries the meter and never a status mark; the block carries the status
|
||||
/// mark and never a meter.
|
||||
#[test]
|
||||
fn the_status_mark_is_one_cell_where_the_meter_is_two() {
|
||||
for status in status_dirs() {
|
||||
assert_eq!(
|
||||
status_mark(Some(status)).0.chars().count(),
|
||||
1,
|
||||
"{status} is drawn wide enough to read as a priority meter"
|
||||
);
|
||||
}
|
||||
|
||||
for priority in [
|
||||
Priority::Level(1),
|
||||
Priority::Level(3),
|
||||
Priority::Level(5),
|
||||
Priority::Unset,
|
||||
] {
|
||||
assert_eq!(
|
||||
priority_mark(priority).0.chars().count(),
|
||||
2,
|
||||
"{priority:?} is drawn narrow enough to read as a status mark"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The mark on each row is the status of the ticket that row names, not of the ticket
|
||||
/// being read, so four relations in four statuses read four ways.
|
||||
#[test]
|
||||
fn the_block_marks_each_target_with_its_own_status() {
|
||||
let rows: Vec<RelationRow> = status_dirs()
|
||||
.into_iter()
|
||||
.map(|status| row(RelationKind::RelatesTo, "relates to", TARGET, status, status))
|
||||
.collect();
|
||||
|
||||
let rendered = render_relations(&rows, false);
|
||||
for status in status_dirs() {
|
||||
assert!(
|
||||
rendered.contains(&format!("{} (b1b2c3d) {status}", smark(status))),
|
||||
"no {status} row marked {:?}:\n{rendered}",
|
||||
smark(status)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Every kind has a mark of its own, and no two share one: the mark is what makes the
|
||||
/// block scannable without reading the labels, so two kinds drawn alike would defeat
|
||||
/// it.
|
||||
@@ -3584,8 +3752,15 @@ mod tests {
|
||||
let stored = vec![relation(RelationKind::BlockedBy, TARGET)];
|
||||
|
||||
let rendered = render_relations(&relation_rows(&stored, &index, SELF), false);
|
||||
assert!(rendered.contains(&format!("blocked by {BLOCKED_MARK} (b1b2c3d)")), "{rendered}");
|
||||
assert!(rendered.contains(&format!("blocks {BLOCKED_MARK} (ccccccc)")), "{rendered}");
|
||||
let backlog = smark("backlog");
|
||||
assert!(
|
||||
rendered.contains(&format!("blocked by {BLOCKED_MARK} {backlog} (b1b2c3d)")),
|
||||
"{rendered}"
|
||||
);
|
||||
assert!(
|
||||
rendered.contains(&format!("blocks {BLOCKED_MARK} {backlog} (ccccccc)")),
|
||||
"{rendered}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The cards spend the circles on priority, two cells away from nothing at all, so a
|
||||
@@ -3618,14 +3793,15 @@ mod tests {
|
||||
fn a_target_the_board_does_not_have_renders_as_missing() {
|
||||
let stored = vec![relation(RelationKind::BlockedBy, TARGET)];
|
||||
|
||||
// The mark is the kind, which is known from the ticket's own file, so it survives
|
||||
// a target the board cannot find. `_missing_` is what says the target is gone.
|
||||
// The kind mark survives, since it is read from this ticket's own file, and the
|
||||
// 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
|
||||
),
|
||||
format!("blocked by {BLOCKED_MARK} (b1b2c3d) _missing_\n")
|
||||
format!("blocked by {BLOCKED_MARK} ? (b1b2c3d) _missing_\n")
|
||||
);
|
||||
}
|
||||
|
||||
@@ -3661,10 +3837,10 @@ 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")], ..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")),
|
||||
rendered.contains(&format!("Relations\n─────────\n\nblocked by {BLOCKED_MARK} {} (b1b2c3d) The blocker\n\nMetadata", smark("backlog"))),
|
||||
"{rendered:?}"
|
||||
);
|
||||
assert!(!rendered.contains(TARGET), "the bare uuid was printed: {rendered:?}");
|
||||
@@ -3676,10 +3852,10 @@ mod tests {
|
||||
#[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")], ..Default::default() });
|
||||
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")),
|
||||
rendered.contains(&format!("Body.\n\nRelations\n─────────\n\nblocks {BLOCKED_MARK} {} (641e3d5) The gated one\n\nMetadata", smark("committed"))),
|
||||
"{rendered:?}"
|
||||
);
|
||||
}
|
||||
@@ -3688,9 +3864,9 @@ 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")], ..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")), "{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
|
||||
|
||||
Reference in New Issue
Block a user