(e4d0bb7) Colour the whole detail overlay body, not just its relations, and bump to 0.27.3

The block was the only coloured part because it arrived as rows while
everything else arrived as a painted string, and the board had to ask for
the unpainted one: an escape in a ratatui paragraph is drawn as literal
bytes.

content_parts now paints nothing. BodyPart::Text becomes
BodyPart::Cells, so content_trim is the cells through paint_cells and the
board is the same cells through span_from. push_heading, ordered_cells,
inline_cells, metadata_cells, metadata_value_cells and tag_cells replace
the painters they were. Resolved.campaign is cells too, which made
reference_cell dead at its last caller.

The colored flag still reaches content_parts and no longer means paint.
It says whether this renderer can carry a colour at all, and one thing
turns on it: **bold** gives its markers up to the colour that replaces
them, so a renderer with none has to keep them.

Color::Magenta.ansi() is \x1b[1;35m, so span_from adds the bold modifier
on the board's side, since From<Color> carries only the colour and the
same cell must not be painted two ways.

show's output is pinned byte for byte against what it printed before,
both by a fixture holding one of every painted run and by diffing the
old binary against the new one over every ticket and campaign on this
board, coloured and piped.
This commit is contained in:
Ansho Rei
2026-08-24 11:57:25 +02:00
parent 407cb14fe6
commit c2ee165108
7 changed files with 440 additions and 158 deletions
+301 -120
View File
@@ -656,9 +656,11 @@ pub struct Resolved {
/// 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
/// The Campaign value as it reads, from [`campaign_cells`]. Empty leaves the stored
/// value to render as it sits, which is what a ticket in no campaign wants.
pub campaign: String,
///
/// [`campaign_cells`]: crate::campaign::campaign_cells
pub campaign: Vec<Cell>,
}
pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
@@ -670,35 +672,32 @@ 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 Body, heading: &str, colored: bool) {
fn push_heading(out: &mut Body, heading: &str) {
let name = heading.strip_prefix("## ").unwrap_or(heading);
out.push_str(&paint(name, Color::Orange, colored));
out.push_cell(Cell::colored(name, Color::Orange));
out.push('\n');
out.push_str(&"─".repeat(name.chars().count()));
out.push('\n');
out.push('\n');
}
/// The ticket body rendered for display, with the colour decision passed in.
/// One piece of the rendered body: a run of cells, or relations still as rows.
///
/// The TUI needs the plain form: ratatui draws styled spans, and an escape sequence
/// embedded in a paragraph would be printed as literal bytes.
/// The body is one string to the CLI and a run of styled lines to the board. Neither
/// half is rendered here: a [`Cell`] carries the text and the colour it is drawn in, and
/// the renderer decides what a colour is, an escape sequence for the CLI and a ratatui
/// style for the board. That is what makes the two views one layout rather than two
/// that have to be kept in step.
///
/// [`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.
/// The relations stay rows rather than becoming cells here because their layout needs
/// the whole block at once: the label column is padded to the widest label.
pub enum BodyPart {
Text(String),
Cells(Vec<Cell>),
Relations(Vec<RelationRow>),
}
/// The body under construction. Text accumulates into the trailing run, and a relations
/// The body under construction. Cells accumulate 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)]
@@ -707,17 +706,37 @@ struct Body {
}
impl Body {
/// A run in the default foreground.
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())),
}
self.push_cell(Cell::plain(text));
}
fn push(&mut self, c: char) {
self.push_cell(Cell::plain(c.to_string()));
}
/// One run, merged into the trailing cell when it is the same colour.
///
/// Merging is not an optimisation. The board draws a span per cell, and the body is
/// pushed a character at a time in places, so without this a plain line arrives as
/// forty single-character spans for ratatui to wrap.
fn push_cell(&mut self, cell: Cell) {
if cell.text.is_empty() {
return;
}
match self.parts.last_mut() {
Some(BodyPart::Text(run)) => run.push(c),
_ => self.parts.push(BodyPart::Text(c.to_string())),
Some(BodyPart::Cells(cells)) => match cells.last_mut() {
Some(last) if last.color == cell.color => last.text.push_str(&cell.text),
_ => cells.push(cell),
},
_ => self.parts.push(BodyPart::Cells(vec![cell])),
}
}
fn push_cells(&mut self, cells: Vec<Cell>) {
for cell in cells {
self.push_cell(cell);
}
}
@@ -727,26 +746,42 @@ impl Body {
/// Whether the text written so far ends with `suffix`. A relations block never does,
/// since it is not text yet.
///
/// Over the whole trailing run rather than its last cell: a colour change starts a
/// new cell, and the question here is what the body reads like, not how it is split.
fn ends_with(&self, suffix: &str) -> bool {
match self.parts.last() {
Some(BodyPart::Text(run)) => run.ends_with(suffix),
Some(BodyPart::Cells(cells)) => {
let run: String = cells.iter().map(|cell| cell.text.as_str()).collect();
run.ends_with(suffix)
}
_ => false,
}
}
}
/// The ticket body as the CLI prints it.
///
/// [`Resolved`] carries the parts that come from elsewhere on the board, since the
/// body alone cannot render them.
pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String {
content_parts(content, colored, resolved)
.iter()
.map(|part| match part {
BodyPart::Text(text) => text.clone(),
BodyPart::Cells(cells) => paint_cells(cells, colored),
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.
/// The body laid out as cells, for a renderer to colour as it colours anything.
///
/// `colored` no longer paints anything here, and it is not the CLI's flag: it says
/// whether *this* renderer can carry a colour at all, which is the one question the
/// layout still turns on. `**bold**` and `[text](url)` give their markers up to a
/// colour, so a renderer with no colour has to keep them, or the emphasis is lost
/// rather than moved. The board passes `true`, since it styles spans; `content_trim`
/// passes the CLI's decision, so a piped `show` still reads its markers.
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();
@@ -772,24 +807,20 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
// file would have kept it, ahead of the metadata, rather than tacked on
// after everything.
if is_metadata_heading(line) && !stores_relations && !relations.is_empty() {
push_heading(&mut result, RELATIONS.heading, colored);
push_heading(&mut result, RELATIONS.heading);
result.push_relations(relations);
result.push('\n');
shown_relations = true;
}
push_heading(&mut result, section_name, colored);
push_heading(&mut result, section_name);
i += 1;
// Metadata is rendered as a block, so it is consumed here rather than
// falling through to the line-at-a-time cases below.
if is_metadata_heading(line) {
let end = section_end(&lines, i);
result.push_str(&render_metadata_table(
&lines[i..end],
colored,
&resolved.campaign,
));
result.push_cells(metadata_cells(&lines[i..end], colored, &resolved.campaign));
i = end;
}
@@ -825,7 +856,7 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
// Implementation Plan - color numbers in cyan
if current_section == "## Implementation Plan" {
result.push_str(&colorize_ordered(line, colored));
result.push_cells(ordered_cells(line));
result.push('\n');
continue;
}
@@ -837,17 +868,17 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
&& let Some((checked, text)) = checkbox(line)
{
criterion += 1;
result.push_str(&paint(&format!("{}.", criterion), Color::Cyan, colored));
result.push_cell(Cell::colored(format!("{}.", criterion), Color::Cyan));
result.push(' ');
result.push_str(&paint(if checked { "[x]" } else { "[ ]" }, Color::Grey, colored));
result.push_cell(Cell::colored(if checked { "[x]" } else { "[ ]" }, Color::Grey));
result.push(' ');
result.push_str(&colorize_inline(text, colored));
result.push_cells(inline_cells(text, colored));
result.push('\n');
continue;
}
// Regular content, with its inline markup coloured in place.
result.push_str(&colorize_inline(line, colored));
// Regular content, with its inline markup carried as cells of its own.
result.push_cells(inline_cells(line, colored));
result.push('\n');
}
@@ -857,42 +888,42 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
if !result.ends_with("\n\n") {
result.push('\n');
}
push_heading(&mut result, RELATIONS.heading, colored);
push_heading(&mut result, RELATIONS.heading);
result.push_relations(relations);
}
result.parts
}
/// Colour the `1.` at the head of a numbered line, leaving the rest alone.
/// The `1.` at the head of a numbered line as a cell of its own, the rest as it stands.
///
/// Takes the decision rather than asking for it. Asking is what put `\x1b[36m` and
/// `\x1b[0m` around every Implementation Plan number in the board's detail view,
/// which renders with colour off precisely because a paragraph is not a place an
/// escape sequence can go.
fn colorize_ordered(line: &str, colored: bool) -> String {
/// No colour flag. The cell says cyan and the renderer decides what cyan is, which is
/// what stopped this asking `should_use_colors()` and putting `\x1b[36m` around every
/// Implementation Plan number in the board's detail view.
fn ordered_cells(line: &str) -> Vec<Cell> {
if line.chars().next().is_none_or(|c| !c.is_ascii_digit()) {
return line.to_string();
return vec![Cell::plain(line)];
}
// Match "1. " pattern and color the number in cyan
let mut result = String::new();
// Match "1. " pattern and colour the number in cyan
let chars: Vec<char> = line.chars().collect();
for (i, c) in chars.iter().enumerate() {
if c.is_ascii_digit() {
// still scanning digits
} else if *c == '.' && i + 1 < chars.len() && chars[i + 1] == ' ' {
let number = &line[..i + 1];
result.push_str(&paint(number, Color::Cyan, colored));
result.push_str(&line[i + 1..]);
return result;
// Byte indexing on a char index, which holds because everything walked to
// get here is an ASCII digit or the dot itself.
return vec![
Cell::colored(&line[..i + 1], Color::Cyan),
Cell::plain(&line[i + 1..]),
];
} else {
break;
}
}
line.to_string()
vec![Cell::plain(line)]
}
/// Space between a label column and the value beside it, in the metadata table and in
@@ -930,33 +961,36 @@ fn metadata_row(line: &str) -> MetadataRow<'_> {
/// `campaign` is the resolved cell for the Campaign field, empty when there is none.
/// The file stores the full uuid, per the rule the Relations section already follows,
/// so a bare value here would be thirty-six characters saying nothing.
fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -> String {
fn metadata_value_cells(name: &str, value: &str, campaign: &[Cell]) -> Vec<Cell> {
if name == CAMPAIGN_FIELD && !campaign.is_empty() {
return campaign.to_string();
return campaign.to_vec();
}
if name == "Priority" {
// Reads as a glyph, while the file keeps storing the number.
let (glyph, colour) = priority_mark(priority_from_value(value));
return format!("{} {}", paint(glyph, colour, colored), value);
return vec![
Cell::colored(glyph, colour),
Cell::plain(format!(" {}", value)),
];
}
if is_unknown_value(value) {
return paint(value, Color::Grey, colored);
return vec![Cell::colored(value, Color::Grey)];
}
// The same word in the same colour as the label a card draws, since `tag_color` is a
// pure function of it. No mark here: the field name has already said what this is,
// and the mark is what tells a campaign from a tag on a row that holds both.
if name == CODENAME_FIELD {
return paint(value, tag_color(value), colored);
return vec![Cell::colored(value, tag_color(value))];
}
if name == "Tags" {
return paint_tags(value, colored);
return tag_cells(value);
}
value.to_string()
vec![Cell::plain(value)]
}
/// The stored tag list with each tag in its own colour.
@@ -965,25 +999,28 @@ fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -
/// holds come back unchanged. `bug, cli` and `bug,cli` are both written by hand at some
/// point, and a cell that normalised them would be the display quietly disagreeing with
/// the file it is showing.
fn paint_tags(value: &str, colored: bool) -> String {
value
.split(',')
.map(|piece| {
let tag = piece.trim();
if tag.is_empty() {
return piece.to_string();
}
fn tag_cells(value: &str) -> Vec<Cell> {
let mut cells = Vec::new();
let lead = piece.len() - piece.trim_start().len();
format!(
"{}{}{}",
&piece[..lead],
paint(tag, tag_color(tag), colored),
&piece[lead + tag.len()..]
)
})
.collect::<Vec<_>>()
.join(",")
for (index, piece) in value.split(',').enumerate() {
if index > 0 {
cells.push(Cell::plain(","));
}
let tag = piece.trim();
if tag.is_empty() {
cells.push(Cell::plain(piece));
continue;
}
let lead = piece.len() - piece.trim_start().len();
cells.push(Cell::plain(&piece[..lead]));
cells.push(Cell::colored(tag, tag_color(tag)));
cells.push(Cell::plain(&piece[lead + tag.len()..]));
}
cells.retain(|cell| !cell.text.is_empty());
cells
}
/// Render the Metadata section as two aligned columns.
@@ -991,7 +1028,7 @@ fn paint_tags(value: &str, colored: bool) -> String {
/// Taken as a block rather than a line at a time because the field column cannot be
/// sized until every name has been seen. The file is untouched by this: it goes on
/// storing the markdown list, and this is only how the list is shown.
fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> String {
fn metadata_cells(lines: &[&str], colored: bool, campaign: &[Cell]) -> Vec<Cell> {
// The heading already emits its own blank separator, so the one the template
// puts under it would otherwise open the section with a gap.
let start = lines
@@ -1012,21 +1049,23 @@ fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> Strin
.max()
.unwrap_or(0);
let mut result = String::new();
let mut result = Vec::new();
for row in &rows {
match row {
MetadataRow::Field { name, value } => {
result.push_str(&paint(name, Color::Red, colored));
result.push_str(&" ".repeat(field_width - name.chars().count()));
result.push_str(COLUMN_GUTTER);
result.push_str(&metadata_value_cell(name, value, colored, campaign));
result.push(Cell::colored(*name, Color::Red));
result.push(Cell::plain(format!(
"{}{}",
" ".repeat(field_width - name.chars().count()),
COLUMN_GUTTER
)));
result.extend(metadata_value_cells(name, value, campaign));
}
// The decision this row is rendered under, not the one the terminal
// would give: `colorize_line` asked `should_use_colors()` here, which is
// how escapes reached the board's detail view.
MetadataRow::Other(text) => result.push_str(&colorize_inline(text, colored)),
// `colored` reaches only this row, and only for the markers: a hand-written
// line is the one thing in the section that can carry inline markup.
MetadataRow::Other(text) => result.extend(inline_cells(text, colored)),
}
result.push('\n');
result.push(Cell::plain("\n"));
}
result
@@ -1059,26 +1098,27 @@ pub fn is_unknown_value(value: &str) -> bool {
trimmed == NONE || trimmed == NOT_SET
}
/// Replace `**bold**` with colour and paint `[text](url)`, or leave the line exactly
/// as it is.
/// `**bold**` and `[text](url)` split into their own cells, or the line as one cell.
///
/// Taking `enabled` rather than asking makes both paths testable, and the
/// disabled path matters: stripping the markers when there is no colour to
/// replace them with loses the emphasis altogether, which is what happens to
/// every piped `show` and to everything the opencode tools read.
/// `enabled` is the only place in the body where the renderer's colour still changes
/// the layout, and it is why [`content_parts`] still takes the flag. The bold pair
/// gives its markers up to the colour that replaces them, so a renderer with none has
/// to keep them: stripping them there loses the emphasis rather than moving it, which
/// is what a piped `show` and everything the opencode tools read would get.
///
/// One walk for both markers rather than two passes. A pass over the output of
/// another would be scanning text that already holds escape sequences, and `\x1b[36m`
/// carries an opening bracket: a link scan run afterwards would take the escape for
/// markup. Walking the source once is the only place either marker can be recognised
/// for what it is.
fn colorize_inline(line: &str, enabled: bool) -> String {
fn inline_cells(line: &str, enabled: bool) -> Vec<Cell> {
if !enabled {
return line.to_string();
return vec![Cell::plain(line)];
}
let chars: Vec<char> = line.chars().collect();
let mut result = String::new();
let mut cells: Vec<Cell> = Vec::new();
let mut plain = String::new();
let mut i = 0;
while i < chars.len() {
@@ -1088,10 +1128,11 @@ fn colorize_inline(line: &str, enabled: bool) -> String {
if is_delimiter(&chars, i)
&& let Some(close) = (i + 2..chars.len()).find(|&at| is_delimiter(&chars, at))
{
let bold: String = chars[i + 2..close].iter().collect();
// `enabled`, not `should_use_colors()`. Asking again here made the
// flag a lie: the early return above respected it and this did not.
result.push_str(&paint(&bold, Color::Magenta, enabled));
flush(&mut cells, &mut plain);
cells.push(Cell::colored(
chars[i + 2..close].iter().collect::<String>(),
Color::Magenta,
));
i = close + 2;
continue;
}
@@ -1102,17 +1143,26 @@ fn colorize_inline(line: &str, enabled: bool) -> String {
// Markers and url kept, unlike the bold pair. The url is content: a
// reader of `show` wants to see where the link goes, and the terminal
// that would make it clickable is not something worklane can count on.
let link: String = chars[i..end].iter().collect();
result.push_str(&paint(&link, Color::Cyan, enabled));
flush(&mut cells, &mut plain);
cells.push(Cell::colored(chars[i..end].iter().collect::<String>(), Color::Cyan));
i = end;
continue;
}
result.push(chars[i]);
plain.push(chars[i]);
i += 1;
}
result
flush(&mut cells, &mut plain);
cells
}
/// The plain run built so far, closed off ahead of a coloured one. An empty run pushes
/// nothing, so a line opening on a marker does not start with an empty cell.
fn flush(cells: &mut Vec<Cell>, plain: &mut String) {
if !plain.is_empty() {
cells.push(Cell::plain(std::mem::take(plain)));
}
}
fn is_delimiter(chars: &[char], at: usize) -> bool {
@@ -2163,21 +2213,16 @@ impl RelationIndex {
}
}
/// A cross reference as it reads: the short id, then the name it points at.
/// A cross reference in cells: the short id, then the name it points at.
///
/// `_missing_` rather than a bare uuid for something the board no longer holds. The id
/// is kept either way, since it is the only thing left to go looking for. Shared by the
/// 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 {
paint_cells(&reference_cells(uuid, name), colored)
}
/// The same cross reference in cells, for a renderer that is not writing escapes.
/// is kept either way, since it is the only thing left to go looking for.
///
/// 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.
/// come to say a dangling one differently, and every renderer draws the id in the colour
/// the guideline gives it rather than dropping every colour to stay safe. There was a
/// `reference_cell` beside this that painted the cells for the CLI; the Campaign field
/// was its last caller, and it now takes the cells like everything else.
pub fn reference_cells(uuid: &str, name: Option<&str>) -> Vec<Cell> {
let mut cells = vec![
Cell::plain("("),
@@ -2322,7 +2367,7 @@ pub struct Cell {
}
impl Cell {
fn plain(text: impl Into<String>) -> Self {
pub fn plain(text: impl Into<String>) -> Self {
Cell { text: text.into(), color: None }
}
@@ -3217,6 +3262,37 @@ impl Drop for Fixture {
#[cfg(test)]
mod tests {
/// One line's inline markup as a string, the shape these tests were written
/// against. `enabled` is both the marker decision and, here, the painting one,
/// which is what it was before the cells conversion split the two.
fn colorize_inline(line: &str, enabled: bool) -> String {
paint_cells(&inline_cells(line, enabled), enabled)
}
/// One metadata value as a string, the shape these tests were written against.
fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -> String {
let campaign = match campaign.is_empty() {
true => Vec::new(),
false => vec![Cell::plain(campaign)],
};
paint_cells(&metadata_value_cells(name, value, &campaign), colored)
}
/// The metadata section as a string, the shape these tests were written against.
///
/// `metadata_cells` returns cells now, one layout for both renderers, so the CLI's
/// form is `paint_cells` over them. The campaign cell is a `&str` here because that
/// is all any of these needs: one run, already resolved.
fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> String {
let campaign = match campaign.is_empty() {
true => Vec::new(),
false => vec![Cell::plain(campaign)],
};
paint_cells(&metadata_cells(lines, colored, &campaign), colored)
}
use super::*;
/// The guard removes the directory when it goes out of scope, which is what makes the
@@ -4233,6 +4309,111 @@ mod tests {
assert_eq!(rendered, "Metadata\n────────\n\nID abc\nOwner alice\n");
}
/// A body holding one of everything the renderer paints, pinned byte for byte.
///
/// The guard for extending `Cell` to the whole body, e4d0bb7: the board and the CLI
/// now share one layout, and the risk in that is the CLI's output moving to suit the
/// board. Written from what `show` printed before the conversion, so a difference is
/// a regression rather than a rewrite. Every run the guideline gives a colour is in
/// here: heading, plan number, criterion number and mark, bold, link, field name,
/// priority glyph, tag, unset value, and a hand-written line the table carries
/// through.
const EVERY_PAINTED_RUN: &str = "\
# The Title
## Description
Plain line with **bold** and a [link](http://x.test/a).
## Acceptance Criteria
- [x] First, with **bold**
- [ ] Second
## Implementation Plan
1. Step one
2. Step two
## Metadata
- **ID**: 641e3d5a-0000-0000-0000-000000000000
- **Priority**: 2
- **Tags**: bug, cli
- **Due**: _Not set_
- **Owner**: alice
- A hand-written note with **bold**
- **Status**: backlog
";
#[test]
fn show_prints_the_same_body_it_printed_before_the_cells_conversion() {
let orange = |text: &str| paint(text, Color::Orange, true);
let cyan = |text: &str| paint(text, Color::Cyan, true);
let red = |text: &str| paint(text, Color::Red, true);
let bold = |text: &str| paint(text, Color::Magenta, true);
let grey = |text: &str| paint(text, Color::Grey, true);
let expected = format!(
"{}\n───────────\n\n\nPlain line with {} and a {}.\n\n\
{}\n───────────────────\n\n\n\
{} {} First, with {}\n{} {} Second\n\n\
{}\n───────────────────\n\n\n{} Step one\n{} Step two\n\n\
{}\n────────\n\n\
{} 641e3d5a-0000-0000-0000-000000000000\n\
{} {} 2\n\
{} {}, {}\n\
{} {}\n\
{} alice\n\
- A hand-written note with {}\n\
{} backlog\n",
orange("Description"),
bold("bold"),
cyan("[link](http://x.test/a)"),
orange("Acceptance Criteria"),
cyan("1."),
grey("[x]"),
bold("bold"),
cyan("2."),
grey("[ ]"),
orange("Implementation Plan"),
cyan("1."),
cyan("2."),
orange("Metadata"),
red("ID"),
red("Priority"),
paint("●◐", Color::Red, true),
red("Tags"),
paint("bug", tag_color("bug"), true),
paint("cli", tag_color("cli"), true),
red("Due"),
grey(NOT_SET),
red("Owner"),
bold("bold"),
red("Status"),
);
assert_eq!(content_trim(EVERY_PAINTED_RUN, true, &Resolved::default()), expected);
}
/// The other half of the pin: with colour off the same body carries no escape byte
/// at all. Asserted beside the coloured form so neither can pass vacuously, the rule
/// 6d327df's guard was written under.
#[test]
fn the_same_body_with_colour_off_carries_no_escape() {
let plain = content_trim(EVERY_PAINTED_RUN, false, &Resolved::default());
assert!(!plain.contains('\x1b'), "{plain:?}");
// The markers stay, since with no colour to carry the emphasis they are the
// emphasis. That is `colorize_inline`'s disabled path, not a gap in the pin.
assert!(
plain.contains("Plain line with **bold** and a [link](http://x.test/a)."),
"{plain:?}"
);
assert!(plain.contains("1. [x] First, with **bold**"), "{plain:?}");
assert!(plain.contains("Priority ●◐ 2"), "{plain:?}");
}
#[test]
fn a_section_after_metadata_still_renders() {
let content = "# T\n\n## Metadata\n\n- **ID**: abc\n\n## Notes\n\nafter\n";