(6ce2c47) Mark each relation with the status of the ticket it names
The Relations block named each target and said nothing about where it was, so the question actually asked of it, whether a blocker is finished, meant closing the overlay and going to find the other ticket. Each row now carries a mark for its target's status, ahead of the id, where it describes the target rather than the row. A rising bar, U+2581 through U+2588 for backlog to done, and ? for a target the board no longer holds. Not a circle: the cards spend those on the priority meter two cells from nothing at all, and another circle would be read as a level. The ramp is also the meaning, so the shape says which status it is. The colour could not. Every colour in the guideline already means one thing and the eight tag slots are reserved, so four status colours could only have come out of something else's meaning. So the shape carries the status and the colour says only that it is one: orange, which is what Status already means, and grey on the missing mark, beside the _missing_ that grey already spells. An unrecognised status reads as missing rather than as a fifth stage, and every_status_has_a_mark pins the pairing against status_dirs so a status added later fails a test instead of quietly reading as ?. The plain text was the real cost. Detail.text was one String drawn by a Paragraph, deliberately uncoloured because an escape sequence there is drawn as literal bytes, which is 6d327df. So the block cannot arrive pre-painted. Resolved.relations is now rows, content_parts returns the body as BodyPart::Text and BodyPart::Relations with the text painted and the rows untouched, and the two renderers take it from there: content_trim paints the rows into escapes, and the board styles the same cells as spans. One builder, two painters. relation_rows decides which edges there are, what they are called and which direction leads; relation_cells decides the layout, the mark and the colours; paint_cells and span_of are the only things that differ. Cell is the unit both take, the same shape the palette uses to stop a colour existing for one renderer and not the other. reference_cells is now the one spelling of a cross reference, shared with the Campaign field. Detail.body is a ratatui Text and is the only thing measured, so last_offset and the Paragraph cannot wrap the body two ways. Detail::plain() flattens it for the suite and is cfg(test): a second representation carried beside the spans is a second thing to disagree. show carries the same mark, decided here rather than discovered later. The rows are one builder so it was free, and two views disagreeing about what a relation shows is a difference nobody can explain afterwards. That is a change to what the CLI prints, so the minor goes on the last commit of this pair. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
c437d87e9e
commit
ece201e3ab
+354
-66
@@ -539,8 +539,12 @@ pub fn format_comments_with(
|
||||
/// an edit at every call site.
|
||||
#[derive(Default)]
|
||||
pub struct Resolved {
|
||||
/// The block [`render_relations`] built, or empty for a ticket with no relations.
|
||||
pub relations: String,
|
||||
/// The relations of the ticket, both directions, from [`relations_for`]. Empty for a
|
||||
/// ticket with none at either end.
|
||||
///
|
||||
/// Rows rather than the rendered block: the CLI paints them into escapes and the
|
||||
/// board styles the same rows itself, since a paragraph is no place for an escape.
|
||||
pub relations: Vec<RelationRow>,
|
||||
/// The Campaign value as it reads, from [`reference_cell`]. Empty leaves the stored
|
||||
/// value to render as it sits, which is what a ticket in no campaign wants.
|
||||
pub campaign: String,
|
||||
@@ -555,7 +559,7 @@ pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
|
||||
/// The rule is measured on the name as displayed, in characters. It used to span the
|
||||
/// raw line, so it ran three past the heading for the `## `, and byte length over-drew
|
||||
/// anything non-ASCII.
|
||||
fn push_heading(out: &mut String, heading: &str, colored: bool) {
|
||||
fn push_heading(out: &mut Body, heading: &str, colored: bool) {
|
||||
let name = heading.strip_prefix("## ").unwrap_or(heading);
|
||||
|
||||
out.push_str(&paint(name, Color::Orange, colored));
|
||||
@@ -572,10 +576,70 @@ fn push_heading(out: &mut String, heading: &str, colored: bool) {
|
||||
///
|
||||
/// [`Resolved`] carries the parts that come from elsewhere on the board, since the
|
||||
/// body alone cannot render them.
|
||||
/// One piece of the rendered body: text as it prints, or relations still as rows.
|
||||
///
|
||||
/// The body is one string to the CLI and a run of styled lines to the board, and the
|
||||
/// only part that differs is the relations block. Splitting the body here rather than
|
||||
/// building it twice is what keeps the two views from drifting: everything outside the
|
||||
/// block is rendered once, by [`content_parts`], and the rows are handed on unpainted.
|
||||
pub enum BodyPart {
|
||||
Text(String),
|
||||
Relations(Vec<RelationRow>),
|
||||
}
|
||||
|
||||
/// The body under construction. Text accumulates into the trailing run, and a relations
|
||||
/// block closes it, so a caller pushes text and rows without tracking which it pushed
|
||||
/// last.
|
||||
#[derive(Default)]
|
||||
struct Body {
|
||||
parts: Vec<BodyPart>,
|
||||
}
|
||||
|
||||
impl Body {
|
||||
fn push_str(&mut self, text: &str) {
|
||||
match self.parts.last_mut() {
|
||||
Some(BodyPart::Text(run)) => run.push_str(text),
|
||||
_ => self.parts.push(BodyPart::Text(text.to_string())),
|
||||
}
|
||||
}
|
||||
|
||||
fn push(&mut self, c: char) {
|
||||
match self.parts.last_mut() {
|
||||
Some(BodyPart::Text(run)) => run.push(c),
|
||||
_ => self.parts.push(BodyPart::Text(c.to_string())),
|
||||
}
|
||||
}
|
||||
|
||||
fn push_relations(&mut self, rows: &[RelationRow]) {
|
||||
self.parts.push(BodyPart::Relations(rows.to_vec()));
|
||||
}
|
||||
|
||||
/// Whether the text written so far ends with `suffix`. A relations block never does,
|
||||
/// since it is not text yet.
|
||||
fn ends_with(&self, suffix: &str) -> bool {
|
||||
match self.parts.last() {
|
||||
Some(BodyPart::Text(run)) => run.ends_with(suffix),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String {
|
||||
let relations = resolved.relations.as_str();
|
||||
content_parts(content, colored, resolved)
|
||||
.iter()
|
||||
.map(|part| match part {
|
||||
BodyPart::Text(text) => text.clone(),
|
||||
BodyPart::Relations(rows) => render_relations(rows, colored),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The body rendered into its parts, with the colour decision already applied to the
|
||||
/// text and deliberately not to the relations.
|
||||
pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<BodyPart> {
|
||||
let relations = resolved.relations.as_slice();
|
||||
let lines: Vec<&str> = content.trim().lines().collect();
|
||||
let mut result = String::new();
|
||||
let mut result = Body::default();
|
||||
let mut current_section = "";
|
||||
let mut criterion = 0;
|
||||
let mut i = 0;
|
||||
@@ -598,7 +662,7 @@ pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String
|
||||
// after everything.
|
||||
if is_metadata_heading(line) && !stores_relations && !relations.is_empty() {
|
||||
push_heading(&mut result, RELATIONS.heading, colored);
|
||||
result.push_str(relations);
|
||||
result.push_relations(relations);
|
||||
result.push('\n');
|
||||
shown_relations = true;
|
||||
}
|
||||
@@ -622,7 +686,7 @@ pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String
|
||||
// holds the same edges resolved to a title, and the inverses with them.
|
||||
if line.trim_end() == RELATIONS.heading && !relations.is_empty() {
|
||||
let end = section_end(&lines, i);
|
||||
result.push_str(relations);
|
||||
result.push_relations(relations);
|
||||
// The blank line the skipped body ended with, before the next heading.
|
||||
if end < lines.len() {
|
||||
result.push('\n');
|
||||
@@ -705,10 +769,10 @@ pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String
|
||||
result.push('\n');
|
||||
}
|
||||
push_heading(&mut result, RELATIONS.heading, colored);
|
||||
result.push_str(relations);
|
||||
result.push_relations(relations);
|
||||
}
|
||||
|
||||
result
|
||||
result.parts
|
||||
}
|
||||
|
||||
/// Colour the `1.` at the head of a numbered line, leaving the rest alone.
|
||||
@@ -1640,86 +1704,222 @@ impl RelationIndex {
|
||||
/// relations block and the Campaign field, so a dangling reference is spelled one way
|
||||
/// wherever it is shown.
|
||||
pub fn reference_cell(uuid: &str, name: Option<&str>, colored: bool) -> String {
|
||||
let id = paint(short_id(uuid), Color::Red, colored);
|
||||
paint_cells(&reference_cells(uuid, name), colored)
|
||||
}
|
||||
|
||||
/// The same cross reference in cells, for a renderer that is not writing escapes.
|
||||
///
|
||||
/// The one spelling of a reference, so the relations block and the Campaign field cannot
|
||||
/// come to say a dangling one differently, and the board draws the id in the colour the
|
||||
/// guideline gives it rather than dropping every colour to stay safe.
|
||||
pub fn reference_cells(uuid: &str, name: Option<&str>) -> Vec<Cell> {
|
||||
let mut cells = vec![
|
||||
Cell::plain("("),
|
||||
Cell::colored(short_id(uuid), Color::Red),
|
||||
Cell::plain(") "),
|
||||
];
|
||||
|
||||
match name {
|
||||
Some(name) => format!("({}) {}", id, name),
|
||||
None => format!("({}) {}", id, paint("_missing_", Color::Grey, colored)),
|
||||
Some(name) => cells.push(Cell::plain(name)),
|
||||
None => cells.push(Cell::colored("_missing_", Color::Grey)),
|
||||
}
|
||||
|
||||
cells
|
||||
}
|
||||
|
||||
/// Cells as the CLI prints them: each one painted, or carried through as it stands.
|
||||
pub fn paint_cells(cells: &[Cell], colored: bool) -> String {
|
||||
cells
|
||||
.iter()
|
||||
.map(|cell| match cell.color {
|
||||
Some(color) => paint(&cell.text, color, colored),
|
||||
None => cell.text.clone(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The glyph and colour for the status of a relation's target.
|
||||
///
|
||||
/// A rising bar rather than a circle: the cards spend `\u{25cf}`, `\u{25d0}`, `\u{25cb}` and `\u{b7}` on the
|
||||
/// priority meter, and another circle here would be read as one of those. The ramp is
|
||||
/// also the meaning, backlog through done, so the shape says which status it is and the
|
||||
/// colour only says that it is one. Block Elements are the same bet every heading rule
|
||||
/// and every border on the board already makes.
|
||||
///
|
||||
/// One colour for all four, because the palette has none to spare: red is a uuid, green
|
||||
/// a title, cyan a timestamp, grey an unset value, and orange is what Status already
|
||||
/// means. Grey and `?` for a target the board does not hold, beside the `_missing_` that
|
||||
/// grey already spells.
|
||||
const STATUS_MARKS: [(&str, char); 4] = [
|
||||
("backlog", '\u{2581}'),
|
||||
("committed", '\u{2584}'),
|
||||
("reviewing", '\u{2586}'),
|
||||
("done", '\u{2588}'),
|
||||
];
|
||||
|
||||
/// The mark for a status, or the missing mark for a target the board no longer holds.
|
||||
///
|
||||
/// An unrecognised status reads as missing rather than as a stage of the flow: the value
|
||||
/// comes from the directory the ticket was found in, so it is one of the four, and
|
||||
/// guessing at a fifth would put a mark on a status nothing can act on.
|
||||
/// `every_status_has_a_mark` pins the pairing against `status_dirs`.
|
||||
pub fn status_mark(status: Option<&str>) -> (char, Color) {
|
||||
let found = status.and_then(|status| {
|
||||
STATUS_MARKS
|
||||
.iter()
|
||||
.find(|(name, _)| *name == status)
|
||||
.map(|(_, mark)| *mark)
|
||||
});
|
||||
|
||||
match found {
|
||||
Some(mark) => (mark, Color::Orange),
|
||||
None => ('?', Color::Grey),
|
||||
}
|
||||
}
|
||||
|
||||
/// A relation's target as it reads.
|
||||
fn target_cell(target: Option<&RelatedTicket>, uuid: &str, colored: bool) -> String {
|
||||
reference_cell(uuid, target.map(|ticket| ticket.title.as_str()), colored)
|
||||
/// One row of the Relations block: which relation, and what it points at.
|
||||
///
|
||||
/// The target is `None` for a uuid the board no longer holds, which is the one case that
|
||||
/// has neither a title nor a status to show.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RelationRow {
|
||||
pub label: &'static str,
|
||||
pub uuid: String,
|
||||
pub target: Option<RelationTarget>,
|
||||
}
|
||||
|
||||
/// The Relations section as it is shown, or empty when there is nothing to show.
|
||||
/// What a relation points at, once the board has been read for it.
|
||||
#[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.
|
||||
///
|
||||
/// Both directions, stored first: the relations the ticket holds, then the ones held
|
||||
/// against it, named from this end. Rendered from the index rather than from the body
|
||||
/// alone, because a bare uuid says nothing and half the relations are not in the file.
|
||||
pub fn render_relations(
|
||||
stored: &[Relation],
|
||||
index: &RelationIndex,
|
||||
uuid: &str,
|
||||
colored: bool,
|
||||
) -> String {
|
||||
let mut rows: Vec<(&'static str, String)> = stored
|
||||
/// The unit both renderers take: [`paint`] turns one into an escape sequence for the
|
||||
/// CLI, and the board turns the same one into a ratatui `Span`. A block laid out once
|
||||
/// and painted twice cannot draw two different blocks.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Cell {
|
||||
pub text: String,
|
||||
pub color: Option<Color>,
|
||||
}
|
||||
|
||||
impl Cell {
|
||||
fn plain(text: impl Into<String>) -> Self {
|
||||
Cell {
|
||||
text: text.into(),
|
||||
color: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn colored(text: impl Into<String>, color: Color) -> Self {
|
||||
Cell {
|
||||
text: text.into(),
|
||||
color: Some(color),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The relations of one ticket, both directions, in the order they are shown.
|
||||
///
|
||||
/// Stored first: the relations the ticket holds, then the ones held against it, named
|
||||
/// from this end. Read from the index rather than from the body alone, because a bare
|
||||
/// uuid says nothing and half the relations are not in the file.
|
||||
///
|
||||
/// The single builder. Everything that shows a relation goes through these rows, so the
|
||||
/// 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| {
|
||||
(
|
||||
relation.kind.label(),
|
||||
target_cell(index.get(&relation.target), &relation.target, colored),
|
||||
)
|
||||
.map(|relation| RelationRow {
|
||||
label: relation.kind.label(),
|
||||
uuid: relation.target.clone(),
|
||||
target: target_of(index.get(&relation.target)),
|
||||
})
|
||||
.collect();
|
||||
|
||||
rows.extend(index.inbound(uuid).into_iter().map(|(kind, holder)| {
|
||||
(
|
||||
kind.inverse_label(),
|
||||
target_cell(Some(holder), &holder.uuid, colored),
|
||||
)
|
||||
RelationRow {
|
||||
label: kind.inverse_label(),
|
||||
uuid: holder.uuid.clone(),
|
||||
target: target_of(Some(holder)),
|
||||
}
|
||||
}));
|
||||
|
||||
if rows.is_empty() {
|
||||
return String::new();
|
||||
}
|
||||
rows
|
||||
}
|
||||
|
||||
// Measured on the labels, which carry no colour, and padded before the target cell
|
||||
// is joined on, for the reason the metadata table is: an escape sequence counted
|
||||
// towards a width tilts the column the moment colour is on.
|
||||
/// The Relations block laid out: one row of cells per relation, or nothing to show.
|
||||
///
|
||||
/// The layout lives here rather than in each renderer, so the mark, the padding and the
|
||||
/// gutter are decided once. The labels are measured with no colour on them and padded
|
||||
/// before the target is joined, for the reason the metadata table is: an escape sequence
|
||||
/// counted towards a width tilts the column the moment colour is on.
|
||||
pub fn relation_cells(rows: &[RelationRow]) -> Vec<Vec<Cell>> {
|
||||
let width = rows
|
||||
.iter()
|
||||
.map(|(label, _)| label.chars().count())
|
||||
.map(|row| row.label.chars().count())
|
||||
.max()
|
||||
.unwrap_or(0);
|
||||
|
||||
rows.iter()
|
||||
.map(|row| {
|
||||
let (mark, 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.
|
||||
let mut cells = vec![
|
||||
Cell::plain(format!("{}{}{}", row.label, padding, COLUMN_GUTTER)),
|
||||
Cell::colored(mark.to_string(), colour),
|
||||
Cell::plain(" "),
|
||||
];
|
||||
cells.extend(reference_cells(
|
||||
&row.uuid,
|
||||
row.target.as_ref().map(|target| target.title.as_str()),
|
||||
));
|
||||
|
||||
cells
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The Relations section as the CLI prints it, or empty when there is nothing to show.
|
||||
pub fn render_relations(rows: &[RelationRow], colored: bool) -> String {
|
||||
let mut out = String::new();
|
||||
for (label, cell) in &rows {
|
||||
out.push_str(label);
|
||||
out.push_str(&" ".repeat(width - label.chars().count()));
|
||||
out.push_str(COLUMN_GUTTER);
|
||||
out.push_str(cell);
|
||||
|
||||
for row in relation_cells(rows) {
|
||||
out.push_str(&paint_cells(&row, colored));
|
||||
out.push('\n');
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
/// The rendered Relations block for one ticket, reading the board for the rest of it.
|
||||
/// The relations of the ticket in `content`, read against the board around it.
|
||||
///
|
||||
/// The colour decision is passed in rather than asked for, like everything else the
|
||||
/// body renders: the board draws the same text with colour off.
|
||||
pub fn relations_block(content: &str, worklane_dir: &Path, colored: bool) -> Result<String> {
|
||||
/// Rows rather than a rendered block: the board styles them itself, since an escape
|
||||
/// sequence in a ratatui paragraph is drawn as literal bytes.
|
||||
pub fn relations_for(content: &str, worklane_dir: &Path) -> Result<Vec<RelationRow>> {
|
||||
let title = heading_title(content);
|
||||
let stored = parse_relations(content, &title)?;
|
||||
let index = RelationIndex::load(worklane_dir)?;
|
||||
|
||||
Ok(render_relations(
|
||||
Ok(relation_rows(
|
||||
&stored,
|
||||
&index,
|
||||
&parse_ticket_field(content, "ID"),
|
||||
colored,
|
||||
))
|
||||
}
|
||||
|
||||
@@ -3202,6 +3402,19 @@ mod tests {
|
||||
}
|
||||
// --------------------------------------------------------------- relations --
|
||||
|
||||
/// One row as the block shows it, for a test about where the block goes rather than
|
||||
/// about how it was derived.
|
||||
fn row(label: &'static str, uuid: &str, title: &str, status: &str) -> RelationRow {
|
||||
RelationRow {
|
||||
label,
|
||||
uuid: uuid.to_string(),
|
||||
target: Some(RelationTarget {
|
||||
title: title.to_string(),
|
||||
status: status.to_string(),
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
const TARGET: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
||||
const SELF: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
|
||||
@@ -3327,30 +3540,105 @@ mod tests {
|
||||
]);
|
||||
let stored = vec![relation(RelationKind::RegressionOf, TARGET)];
|
||||
|
||||
// Each target marked with the status of the ticket it names: backlog for the
|
||||
// blocker, reviewing for the other one.
|
||||
assert_eq!(
|
||||
render_relations(&stored, &index, SELF, false),
|
||||
"regression of (b1b2c3d) The blocker\n\
|
||||
blocks (ccccccc) The other one\n\
|
||||
relates to (ccccccc) The other one\n"
|
||||
render_relations(&relation_rows(&stored, &index, SELF), false),
|
||||
"regression of \u{2581} (b1b2c3d) The blocker\n\
|
||||
blocks \u{2586} (ccccccc) The other one\n\
|
||||
relates to \u{2586} (ccccccc) The other one\n"
|
||||
);
|
||||
}
|
||||
|
||||
/// Every status the board holds has a mark of its own, and no two share one. Pinned
|
||||
/// against `status_dirs` rather than the four names written out here, so a status
|
||||
/// added later fails this instead of silently reading as missing.
|
||||
#[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_eq!(colour, Color::Orange, "{status} is not drawn as a status");
|
||||
assert!(seen.insert(mark), "{status} shares its mark with another status");
|
||||
}
|
||||
|
||||
assert_eq!(seen.len(), 4, "{seen:?}");
|
||||
}
|
||||
|
||||
/// A target the board does not hold has no status to show, and a value that is not
|
||||
/// one of the four is the same answer: `?` in grey, beside the grey `_missing_`.
|
||||
#[test]
|
||||
fn a_status_the_board_does_not_use_reads_as_missing() {
|
||||
assert_eq!(status_mark(None), ('?', Color::Grey));
|
||||
assert_eq!(status_mark(Some("elsewhere")), ('?', Color::Grey));
|
||||
assert_eq!(status_mark(Some("")), ('?', Color::Grey));
|
||||
}
|
||||
|
||||
/// The cards spend the circles on priority, two cells away from nothing at all, so a
|
||||
/// status drawn as one would be read as a level.
|
||||
#[test]
|
||||
fn no_status_mark_is_a_priority_glyph() {
|
||||
let levels = [1, 2, 3, 4, 5].map(|level| priority_mark(Priority::Level(level)).0);
|
||||
let priority: String = levels
|
||||
.iter()
|
||||
.copied()
|
||||
.chain([priority_mark(Priority::Unset).0])
|
||||
.collect();
|
||||
|
||||
for status in status_dirs() {
|
||||
let (mark, _) = status_mark(Some(status));
|
||||
assert!(
|
||||
!priority.contains(mark),
|
||||
"{status} is drawn with {mark:?}, which the priority meter uses"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The mark on each row is the status of the ticket that row names, not of the ticket
|
||||
/// being shown, 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("relates to", TARGET, status, status))
|
||||
.collect();
|
||||
|
||||
let rendered = render_relations(&rows, false);
|
||||
for status in status_dirs() {
|
||||
let (mark, _) = status_mark(Some(status));
|
||||
assert!(
|
||||
rendered.contains(&format!("{mark} (b1b2c3d) {status}")),
|
||||
"no {status} row marked {mark:?}:\n{rendered}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The id is kept, since it is the only thing left to go looking for, and the title
|
||||
/// is `_missing_` rather than a bare uuid pretending to be one.
|
||||
#[test]
|
||||
fn a_target_the_board_does_not_have_renders_as_missing() {
|
||||
let stored = vec![relation(RelationKind::BlockedBy, TARGET)];
|
||||
|
||||
// `?` rather than a stage of the flow: there is no status to show, and the mark
|
||||
// has to say that as plainly as `_missing_` says the title does not exist.
|
||||
assert_eq!(
|
||||
render_relations(&stored, &RelationIndex::new(Vec::new()), SELF, false),
|
||||
"blocked by (b1b2c3d) _missing_\n"
|
||||
render_relations(
|
||||
&relation_rows(&stored, &RelationIndex::new(Vec::new()), SELF),
|
||||
false
|
||||
),
|
||||
"blocked by ? (b1b2c3d) _missing_\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[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(&[], &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
|
||||
@@ -3376,10 +3664,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: "blocked by (b1b2c3d) The blocker\n".to_string(), ..Default::default() });
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: vec![row("blocked by", TARGET, "The blocker", "backlog")], ..Default::default() });
|
||||
|
||||
assert!(
|
||||
rendered.contains("Relations\n─────────\n\nblocked by (b1b2c3d) The blocker\n\nMetadata"),
|
||||
rendered.contains("Relations\n─────────\n\nblocked by \u{2581} (b1b2c3d) The blocker\n\nMetadata"),
|
||||
"{rendered:?}"
|
||||
);
|
||||
assert!(!rendered.contains(TARGET), "the bare uuid was printed: {rendered:?}");
|
||||
@@ -3391,10 +3679,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: "blocks (641e3d5) The gated one\n".to_string(), ..Default::default() });
|
||||
let rendered = content_trim(&content, false, &Resolved { relations: vec![row("blocks", SELF, "The gated one", "committed")], ..Default::default() });
|
||||
|
||||
assert!(
|
||||
rendered.contains("Body.\n\nRelations\n─────────\n\nblocks (641e3d5) The gated one\n\nMetadata"),
|
||||
rendered.contains("Body.\n\nRelations\n─────────\n\nblocks \u{2584} (641e3d5) The gated one\n\nMetadata"),
|
||||
"{rendered:?}"
|
||||
);
|
||||
}
|
||||
@@ -3403,9 +3691,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: "blocks (641e3d5) X\n".to_string(), ..Default::default() });
|
||||
let rendered = content_trim("# T\n\n## Description\nBody.\n", false, &Resolved { relations: vec![row("blocks", SELF, "X", "done")], ..Default::default() });
|
||||
|
||||
assert!(rendered.ends_with("Relations\n─────────\n\nblocks (641e3d5) X\n"), "{rendered:?}");
|
||||
assert!(rendered.ends_with("Relations\n─────────\n\nblocks \u{2588} (641e3d5) X\n"), "{rendered:?}");
|
||||
}
|
||||
|
||||
/// No block and a section holding only its placeholder: the section renders as it
|
||||
|
||||
Reference in New Issue
Block a user