(25d3018) Fix the markdown link colorization branch, and bump to 0.27.2

The branch searched for a closing square bracket after the ]( sequence
instead of a closing parenthesis, so it fired only on text that was not
a link, and when it fired it pushed the matched span and dropped the
rest of the line.

Folded into colorize_bold, now colorize_inline: one walk over the source
line recognising both **bold** and [text](url). A second pass over the
first one's output would be scanning text that already holds escape
sequences, and \x1b[36m carries an opening bracket, so the link scan
would take the escape for markup. Unterminated markup of either kind
falls through to the ordinary character push, so the rest of the line
survives as literal text.

Criteria text and hand-written metadata rows get links too, since they
already went through this function. The whole span is painted, markers
and url kept: show prints to a terminal worklane cannot assume will make
a link clickable.
This commit is contained in:
Ansho Rei
2026-08-24 11:15:15 +02:00
parent 26b93f8f53
commit 108e21ad7f
4 changed files with 128 additions and 49 deletions
+122 -45
View File
@@ -841,31 +841,13 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
result.push(' ');
result.push_str(&paint(if checked { "[x]" } else { "[ ]" }, Color::Grey, colored));
result.push(' ');
result.push_str(&colorize_bold(text, colored));
result.push_str(&colorize_inline(text, colored));
result.push('\n');
continue;
}
// Standard markdown link colorization in cyan
if line.contains("[")
&& line.contains("(")
&& line.contains("]")
&& let Some(start) = line.find("[")
{
let bracket_text = &line[start..];
if let Some(end_bracket) = bracket_text.find("](") {
let link_start = start + end_bracket + 1;
if let Some(end) = line[link_start..].find(']') {
let absolute_end = link_start + end + 1;
result.push_str(&paint(&line[start..absolute_end], Color::Cyan, colored));
result.push('\n');
continue;
}
}
}
// Regular content - colorize **bold** in magenta
result.push_str(&colorize_bold(line, colored));
// Regular content, with its inline markup coloured in place.
result.push_str(&colorize_inline(line, colored));
result.push('\n');
}
@@ -1042,7 +1024,7 @@ fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> Strin
// 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_bold(text, colored)),
MetadataRow::Other(text) => result.push_str(&colorize_inline(text, colored)),
}
result.push('\n');
}
@@ -1077,13 +1059,20 @@ pub fn is_unknown_value(value: &str) -> bool {
trimmed == NONE || trimmed == NOT_SET
}
/// Replace `**bold**` with colour, or leave the line exactly as it is.
/// Replace `**bold**` with colour and paint `[text](url)`, or leave the line exactly
/// as it is.
///
/// 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.
fn colorize_bold(line: &str, enabled: bool) -> String {
///
/// 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 {
if !enabled {
return line.to_string();
}
@@ -1093,27 +1082,34 @@ fn colorize_bold(line: &str, enabled: bool) -> String {
let mut i = 0;
while i < chars.len() {
if !is_delimiter(&chars, i) {
result.push(chars[i]);
i += 1;
// Unterminated markup falls through to the push below, one character at a
// time, so the rest of the line survives as the literal text it is. The old
// link branch pushed its match and dropped everything around it.
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));
i = close + 2;
continue;
}
match (i + 2..chars.len()).find(|&at| is_delimiter(&chars, at)) {
Some(close) => {
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));
i = close + 2;
}
// Unterminated: the rest is literal. The old scan walked off the end
// here and dropped the final character.
None => {
result.extend(&chars[i..]);
return result;
}
if chars[i] == '['
&& let Some(end) = link_end(&chars, i)
{
// 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));
i = end;
continue;
}
result.push(chars[i]);
i += 1;
}
result
@@ -1123,6 +1119,22 @@ fn is_delimiter(chars: &[char], at: usize) -> bool {
chars.get(at) == Some(&'*') && chars.get(at + 1) == Some(&'*')
}
/// The index one past the end of the `[text](url)` opening at `open`, or nothing when
/// the line does not close one.
///
/// The closing parenthesis is what ends a link. The old branch looked for a second
/// square bracket there, which a well-formed link does not have, so the whole branch
/// fired only on text that was not a link at all.
fn link_end(chars: &[char], open: usize) -> Option<usize> {
let close_text = (open + 1..chars.len()).find(|&at| chars[at] == ']')?;
if chars.get(close_text + 1) != Some(&'(') {
return None;
}
let close_url = (close_text + 2..chars.len()).find(|&at| chars[at] == ')')?;
Some(close_url + 1)
}
pub const METADATA_HEADING: &str = "## Metadata";
fn is_metadata_heading(line: &str) -> bool {
@@ -4559,12 +4571,12 @@ mod tests {
#[test]
fn bold_markers_survive_when_colour_is_off() {
let line = "Some **bold** text";
assert_eq!(colorize_bold(line, false), line);
assert_eq!(colorize_inline(line, false), line);
}
#[test]
fn bold_markers_are_replaced_when_colour_is_on() {
let out = colorize_bold("Some **bold** text", true);
let out = colorize_inline("Some **bold** text", true);
assert!(out.contains("bold"), "was {out:?}");
assert!(!out.contains("**"), "markers left behind in {out:?}");
}
@@ -4573,17 +4585,82 @@ mod tests {
#[test]
fn an_unterminated_marker_keeps_the_whole_line() {
for line in ["a **bold", "**", "***", "trailing **"] {
assert_eq!(colorize_bold(line, true), line, "for {line:?}");
assert_eq!(colorize_inline(line, true), line, "for {line:?}");
}
}
#[test]
fn several_bold_runs_on_one_line_all_survive() {
let out = colorize_bold("**one** and **two** and rest", true);
let out = colorize_inline("**one** and **two** and rest", true);
assert!(out.contains("one") && out.contains("two") && out.ends_with("and rest"));
assert!(!out.contains("**"), "was {out:?}");
}
/// The old branch pushed the span it matched and dropped the rest of the line.
#[test]
fn a_link_keeps_the_text_on_either_side_of_it() {
let out = colorize_inline("see [the docs](https://x.test/y) for more", true);
assert!(out.starts_with("see "), "was {out:?}");
assert!(out.ends_with(" for more"), "was {out:?}");
assert!(out.contains("[the docs](https://x.test/y)"), "was {out:?}");
assert!(out.contains(Color::Cyan.ansi()), "not painted in {out:?}");
}
/// With no colour to carry it, the markup is the markup.
#[test]
fn a_link_survives_unchanged_when_colour_is_off() {
let line = "see [the docs](https://x.test/y) for more";
assert_eq!(colorize_inline(line, false), line);
}
/// The closing parenthesis ends a link. Looking for a second square bracket there,
/// as the old branch did, meant it fired on anything but a link.
#[test]
fn text_that_is_not_a_closed_link_is_left_alone() {
for line in [
"a [label] and (a note)",
"unterminated [text](http://x.test",
"[a][b] reference style",
"bare [",
] {
assert_eq!(colorize_inline(line, true), line, "for {line:?}");
}
}
#[test]
fn several_links_on_one_line_all_survive() {
let out = colorize_inline("[a](1) then [b](2) then end", true);
assert!(out.contains("[a](1)") && out.contains("[b](2)"), "was {out:?}");
assert!(out.ends_with(" then end"), "was {out:?}");
}
/// Both markers are recognised in the same walk, so a line does not have to pick
/// which of the two it gets.
#[test]
fn bold_and_a_link_on_one_line_are_both_coloured() {
let out = colorize_inline("**note**: read [this](http://x.test) first", true);
assert!(!out.contains("**"), "markers left behind in {out:?}");
assert!(out.contains("[this](http://x.test)"), "was {out:?}");
assert!(out.contains(Color::Magenta.ansi()), "no bold in {out:?}");
assert!(out.contains(Color::Cyan.ansi()), "no link in {out:?}");
assert!(out.ends_with(" first"), "was {out:?}");
}
/// End to end: the body a `show` prints keeps every word of a line with a link.
#[test]
fn a_body_line_with_a_link_keeps_all_of_its_text() {
let content = "# T\n\n## Description\n\nbefore [docs](http://x.test/a) after\n";
let rendered = content_trim(content, false, &Resolved::default());
assert!(
rendered.ends_with("before [docs](http://x.test/a) after\n"),
"{rendered:?}"
);
}
#[test]
fn short_id_shortens_a_full_uuid() {
assert_eq!(short_id("c230d2c6-d78a-44a5-8f5f-88fb28f84493"), "c230d2c");