(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:
@@ -175,7 +175,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **A campaign's state is derived, never stored.** Open until every member is done, computed by `Standing` from the members. A `Status` field on the campaign would be the same state in two places, and the two would disagree the moment a member moved. It is also why there is no `campaign mv` and no forward-only ruleset beside `mv`'s
|
||||
- **A campaign with no members is neither open nor done.** `Standing::state()` returns `None` there, and both callers print `no members`. Calling it done would make a container nothing has been filed against the most complete thing on the board; calling it open would claim work that does not exist
|
||||
- **Membership is one field on the member**, `Campaign` in the ticket Metadata, written only by `assign`. The member list is deliberately *not* on the campaign: that would put membership in two places, and would make one file that every assignment edits, which is contended the moment two agents share a board. So `add` has no `--campaign` and `set` has no `--campaign`, the same rule as Owner and Status
|
||||
- **The full uuid is stored and the title is resolved for display**, as the Relations section already does. `reference_cell` is shared between the two, so a dangling campaign and a dangling relation target are both spelled `_missing_` rather than each inventing a spelling
|
||||
- **The full uuid is stored and the title is resolved for display**, as the Relations section already does. `reference_cells` is shared between the two, so a dangling campaign and a dangling relation target are both spelled `_missing_` rather than each inventing a spelling
|
||||
- **`add` does not write the field.** Every ticket written before campaigns existed has none, so the insertion path has to exist regardless; leaving it out of `add` means one path that is always exercised rather than two. Same reasoning as the Relations section
|
||||
- `set_or_insert_metadata_field()` is the upsert, and `METADATA_ORDER` is its anchor list, the way `SECTION_ORDER` is `ensure_section`'s. Campaign is placed before Status, so Status stays last where every file already keeps it. A file with no `## Metadata` heading is an **error, not an insertion**: per 641e3d5 such a file has no fields at all, and writing one above the prose would invent a shape nothing reads
|
||||
- **The four tiers are `resolve_in()`, shared by tickets and campaigns.** A campaign is addressed exactly the way a ticket is, and a second resolver would be a second copy of the precedence rules to keep in step. `Found.dir` is the status for a ticket and empty for a campaign, which is what makes the ambiguity listing drop the bracket for one
|
||||
@@ -242,7 +242,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **`the_count_is_read_when_the_items_are_collected_and_not_per_draw` takes the comments directory away after the board is built**, and is paired with `a_comment_added_after_the_board_was_built_reaches_the_card_on_reload`, because a count that never asks the filesystem again would pass the first test by never changing. The digest already moves when a comment lands, so the reload is what recounts
|
||||
- **A card names its campaign on the label row, before the tags, in bold.** `labels_line` draws both, `CAMPAIGN_MARK` (`~`) for the campaign and `#` for a tag, and the campaign takes the row's width first: two cards in one campaign is what a reader looking for a campaign is looking for, and the tags are the context around it. So a row too narrow for both drops the tags whole and keeps the campaign, the order `corner_line` and `project_label` already follow, and a campaign the row will not hold at all goes whole too. A ticket in neither spends no row, so **a ticket in no campaign renders exactly as it did before campaigns reached the card**
|
||||
- **`Card::campaign` is a resolved `Cell`, not a uuid**, settled at reload the way `project` and `blocked` are. `TicketItem::campaign` already carries the uuid off the pass that builds the card; the name is in another directory, so `columns_of` reads `CampaignIndex` once per project and hands it to every card. Never per draw, the rule `criteria` and `tags` already hold. The merge carries the resolved cell rather than looking it up again, for the reason it carries `blocked`: a campaign is addressed inside one `.worklane`, so a merged lookup could answer one project's uuid with another project's campaign
|
||||
- **A campaign the board does not hold labels nothing**, the answer `mark_blocked` gives a dangling blocker. `campaign_cell` renders that case as `_missing_` because a metadata table is a place to report a dangling reference; a card is not
|
||||
- **A campaign the board does not hold labels nothing**, the answer `mark_blocked` gives a dangling blocker. `campaign_cells` renders that case as `_missing_` because a metadata table is a place to report a dangling reference; a card is not
|
||||
- **`c` opens the campaign picker, and taking a campaign filters the tab's columns to its members.** Not a fifth tab: a campaign groups across the flow, so the shape of the answer is the four statuses with fewer cards in them, which is what `campaign show` already answers the question in. Every column is kept, empty ones included. The filter is applied in `reload`, where the columns are built, so nothing downstream has to ask whether a campaign is selected — the board simply holds fewer cards, and `first_match`, `done_count` and the copy key all keep working unchanged
|
||||
- **`Tab::campaign` is a uuid on the tab, not on the `Board`.** A campaign belongs to one `.worklane`, so a filter carried onto another project's tab would empty it and say nothing about why. It is looked up by uuid rather than held as an index, and a selection whose campaign has left the board is cleared by `reload` rather than left filtering the board to nothing
|
||||
- **The frame above the columns has two heights, and `Chrome` is what every measurement takes.** `Chrome::campaign` is an `Option<FrameSize>`, not a bool: `None` for a tab showing the whole board, and `Collapsed` or `Expanded` for one filtered to a campaign, because both heights have to be measured the same way by everything that measures the board. `frame_rows` grew a row, so the two bools that decide the geometry became one `Chrome`, copied from `Board::chrome`: adjacent same-typed parameters are what the Rust Style rule warns about, and the draw and `follow_selection` have to measure one answer or a keypress scrolls against a board the next frame does not draw. The row indices are named (`TAB_ROW`, `CAMPAIGN_ROW`, `BOARD_ROW`, `FOOTER_ROW`), since an index written out by hand goes on meaning what it used to
|
||||
@@ -328,7 +328,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
### The Relations Block
|
||||
- **One builder, two painters.** `relation_rows` decides which edges there are, what they are called and which direction comes first; `relation_cells` decides the layout, the mark and the colours; `paint_cells` turns cells into escapes for the CLI and `span_of` turns the same cells into ratatui spans for the board. Two builders producing one block in two shapes is a pair free to disagree about ordering or padding, which is what this shape exists to prevent
|
||||
- **`Cell` is the unit both renderers take**: a run of text and the colour it is drawn in, `None` for the default foreground. The same trick as the palette itself, where `Color::ansi()` and `From<Color> for ratatui::style::Color` keep one colour from existing for one renderer and not the other
|
||||
- **`reference_cells` is the one spelling of a cross reference**, and `reference_cell` is it painted. The relations block and the Campaign field both go through it, so a dangling reference reads the same way wherever it is shown
|
||||
- **`reference_cells` is the one spelling of a cross reference.** The relations block and the Campaign field both go through it, so a dangling reference reads the same way wherever it is shown. There was a `reference_cell` beside it that painted the cells for the CLI; once the whole body became cells the Campaign field stopped needing a string and it was the last caller, so it is gone
|
||||
- **A row 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 and one glyph could not answer both: which rows hold this ticket up, and whether the ones that do are finished
|
||||
- The status went through one bad shape first. It was a rising bar, `▁▄▆█`, as the only mark, which read as an undifferentiated column of blocks and left the kind to five long words that blur when a ticket carries several. Then the kind took the column alone and the status was lost. Both, in that order, is the answer
|
||||
- **Both directions of a kind carry one mark.** `blocked by` and `blocks` are the same edge read from two ends, and the label is what says which end you are on. `both_directions_of_a_kind_carry_one_mark` pins it
|
||||
@@ -340,11 +340,15 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **Committed and reviewing are told apart by colour alone**, both being `◐`, so a pipe cannot tell them apart: `should_use_colors` is false and both read as under way. Accepted, because `●` and `○` are the two answers usually wanted and `show` on the target settles the rest, and `assets/SKILL.md` says so outright rather than leaving an agent to infer it. Do not fix this by giving one of them a colour that means something else
|
||||
- `RelationTarget` carries the title and the status in one `Option`, because they come from the same lookup and are absent together. It was taken out when the mark keyed on the kind alone and put back one commit later, which is the cost of a field nothing reads: correct at the time, and churn either way
|
||||
- **`show` and the board carry the same mark**, decided rather than left to be discovered: the rows are one builder, so giving the CLI the mark cost nothing, and two views disagreeing about what a relation shows would be the kind of difference nobody can explain later. That makes it a change to what the CLI prints, so it is a minor
|
||||
- **`Resolved.relations` is rows, not a rendered block.** That is what lets the board style them: an escape sequence in a ratatui paragraph is drawn as literal bytes (6d327df), so the block cannot arrive pre-painted. `content_parts` hands the text through already painted and the rows through untouched, which is the asymmetry the two renderers need
|
||||
- **`BodyPart` splits the body rather than building it twice.** Everything outside the relations block is rendered once, by `content_parts`; `content_trim` is that with the rows painted, and the board is that with the rows styled. `Body` is the accumulator, so a caller pushes text and rows without tracking which it pushed last
|
||||
- **`Resolved.relations` is rows, not a rendered block, and `Resolved.campaign` is cells for the same reason.** An escape sequence in a ratatui paragraph is drawn as literal bytes (6d327df), so nothing in `Resolved` can arrive pre-painted. This was the asymmetry the two renderers needed while the rest of the body was a painted string; there is no asymmetry left, since `content_parts` paints nothing at all
|
||||
- **`BodyPart` splits the body rather than building it twice.** It is `Cells` or `Relations`: everything outside the block is laid out once, by `content_parts`, and `content_trim` is that run through `paint_cells` while the board is the same cells run through `span_from`. `Body` is the accumulator, so a caller pushes cells and rows without tracking which it pushed last, and it merges a run into the trailing cell when the colour matches, because the board draws a span per cell and the body is pushed a character at a time in places
|
||||
- **`Detail.body` is a `Text`, and it is the only thing measured.** `last_offset` and the `Paragraph` both take it, so the clamp cannot wrap the body differently from the draw. `Detail::plain()` flattens it for the suite and is `#[cfg(test)]`: a second representation carried alongside the spans is a second thing to disagree
|
||||
- `detail_body` closes a line only where the text says, so a part that does not end on a newline runs on into the next one. The seam between text and rows is wherever the body put it rather than wherever a part happened to end
|
||||
- **The relations block is the only coloured part of the overlay body, and that is a decision, not an oversight.** The headings, the plan numbers, the criteria marks, the bold runs and the grey unset values are all painted by `show` and all flat on the board. The block earned its colour because it is where a reader compares several references at once, and because it was already data rather than prose: it arrives as rows for the status mark, so styling it cost nothing extra. Colouring the rest means giving every painted run in `content_parts` the `Cell` treatment, which is a much larger change with no reader's question behind it, and it is its own ticket. Do not paint one more section here without taking that on: two coloured sections and five plain ones reads as a bug, where one clearly does not
|
||||
- `detail_body` closes a line only where the text says, so a part that does not end on a newline runs on into the next one. The seam between text and rows is wherever the body put it rather than wherever a part happened to end. It now splits **per cell** rather than per part, since a `Cells` part holds many runs and a newline can fall inside any of them
|
||||
- **The whole overlay body is coloured now, and `content_parts` paints nothing.** The block used to be the only coloured part, because it arrived as rows while everything else arrived as a painted string; e4d0bb7 gave the rest the same `Cell` treatment. So the headings, the plan numbers, the criteria numbers and marks, the bold runs, the field names, the priority glyph, the tags and the grey unset values are one layout that `show` paints and the board styles. Do not reintroduce a `paint` call in `content_parts`: the flat overlay was exactly that, a renderer forced to ask for the unpainted string because the painted one held escapes
|
||||
- **`colored` still reaches `content_parts`, and it 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 or the emphasis is lost rather than moved. The board passes `true`, `content_trim` passes the CLI's decision, and a piped `show` still reads its markers. Nothing else in the body consults it
|
||||
- **Magenta means bold, and `span_from` is where the board learns that.** `Color::Magenta.ansi()` is `\x1b[1;35m`, so the CLI draws every bold run bold as well as magenta, and `From<Color>` can carry only the colour. Without the modifier added on the board's side the same cell would be painted two ways, which is the one thing the shared layout exists to prevent
|
||||
- **The conversion is pinned from both ends.** `show_prints_the_same_body_it_printed_before_the_cells_conversion` holds a body with one of every painted run and asserts the CLI's output byte for byte, written from what it printed before the change, so the risk in sharing a layout, the CLI's output drifting to suit the board, fails the suite. `the_whole_body_is_styled_in_the_overlay_and_no_escape_reached_it` is the other end and is paired the way the guideline demands: a renderer that dropped every colour passes the absence, and one that went back to painting strings passes the presence
|
||||
- **The comments block is still flat, and it is the last piece that is.** `format_comments_with` is a string the board appends after the body rather than part of what `content_parts` lays out, so it was outside e4d0bb7. Its own ticket
|
||||
|
||||
### Finding the Board
|
||||
- **`find_worklane_dir` classifies the entry before it follows it.** `exists()` follows a link, so a `.worklane` that was a dangling symlink answered the same as no `.worklane` at all: the walk carried on up the tree and the first board above the project became the one every write landed in, silently. `classify` reads `symlink_metadata` first and answers one of four, `Absent`, `Board`, `Dangling` or `NotADirectory`, and **`Absent` is the only one the walk carries on from**. A `.worklane` that is there but unusable is this project's board and is reported, not handed upward
|
||||
@@ -399,7 +403,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
### Color and Output
|
||||
- Use `color_text()` for coloured output — it respects `should_use_colors()` (terminal detection), and `paint()` is the same with the decision passed in
|
||||
- **`color_text()` is for the CLI's own printing only. Anything reachable from `content_trim` takes the decision as an argument and calls `paint()`**, because the board renders with colour off and an escape sequence in a ratatui paragraph is drawn as literal bytes. `nothing_the_body_renders_asks_the_terminal_for_the_colour_decision` scans this file and fails on a new caller; the allowlist is `ambiguous`, which builds a failed-search message for stderr
|
||||
- A function that takes an `enabled` flag must use it all the way down. `colorize_inline` honoured its flag on the early return and then asked `should_use_colors()` for the bold run, which made the flag a lie in half the function
|
||||
- A function that takes an `enabled` flag must use it all the way down. The inline pass honoured its flag on the early return and then asked `should_use_colors()` for the bold run, which made the flag a lie in half the function. The better answer, where it fits, is to take no flag: `ordered_cells` and `metadata_value_cells` return the colour rather than a decision about it
|
||||
- **A test that asserts an absence has to be paired with one that asserts the presence.** The guard for this, an assert that the detail view holds no escape byte, could not fail: a test binary has no tty, so `should_use_colors()` was false and the leaking branch was never taken. The pair is now `content_trim(.., false)` has no escape and `content_trim(.., true)` still colours, which pins the flag as the only thing that decides
|
||||
- **The palette is the `Color` enum, not a string.** `Color::ansi()` gives the CLI its SGR sequence and `From<Color> for ratatui::style::Color` gives the TUI its equivalent, so a colour that exists for one renderer and not the other is a compile error. The stringly-typed version needed a test for exactly that, and a missing entry silently produced an empty prefix, which is how `magenta` came to be undefined
|
||||
- Reset color with `\x1b[0m` after colored text
|
||||
@@ -428,9 +432,9 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- Grey is indexed colour 8 in the 256-colour form, not SGR 90 or 37. Both of those failed on a real palette: 90 leans on the bright-black slot and 37 can sit on top of the default foreground. `\x1b[38;5;8m` is byte for byte what crossterm emits for ratatui's `Color::DarkGray`, the grey frig and pantop use for dimmed rows
|
||||
|
||||
### Code Organization
|
||||
- Colorization functions (`colorize_ordered`, `colorize_inline`, `content_trim_colored`) handle markdown formatting. `colorize_line` is gone: it was a `pub` alias for the bold pass with one caller, and the only thing it added was asking the terminal
|
||||
- **`colorize_inline` walks the line once for both inline markers**, `**bold**` and `[text](url)`, rather than running one pass over the output of the other. A second pass 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. The source is the only string in which either marker means what it says. It was `colorize_bold` while links lived in a branch of their own in `content_parts`; that branch is gone, which is also what gives the criteria text and the metadata `Other` rows their links, since those already went through this function
|
||||
- `show` renders the Metadata section as a two column table via `render_metadata_table`, not line by line. Column width is measured on the raw field names in characters and padding is applied before anything is styled: measuring a coloured string counts its escapes towards its width. `paint()` is `color_text()` with the colour decision passed in, which is what lets a test render both ways in one process
|
||||
- The body's painters return cells, not strings: `ordered_cells`, `inline_cells`, `metadata_cells`, `metadata_value_cells`, `tag_cells` and `push_heading`. `content_trim_colored` is the CLI entry point and `paint_cells` is the only thing that writes an escape. `colorize_line` is gone: it was a `pub` alias for the bold pass with one caller, and the only thing it added was asking the terminal
|
||||
- **`inline_cells` walks the line once for both inline markers**, `**bold**` and `[text](url)`, rather than running one pass over the output of the other. A second pass 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. The source is the only string in which either marker means what it says. It was `colorize_bold` while links lived in a branch of their own in `content_parts`; that branch is gone, which is also what gives the criteria text and the metadata `Other` rows their links, since those already went through this function
|
||||
- `show` renders the Metadata section as a two column table via `metadata_cells`, not line by line. Column width is measured on the raw field names in characters and the padding goes into a cell of its own, so nothing is ever measured with a colour on it: measuring a painted string counts its escapes towards its width. `paint()` is `color_text()` with the colour decision passed in, which is what lets a test render both ways in one process
|
||||
- The title is printed once, by `cmd_show`. `content_trim_colored` skips the `# ` heading in the file content
|
||||
- Rules under headings are measured on the displayed name in characters, never on the raw line or in bytes
|
||||
- `resolve_ticket()` scans all status directories — it's the single source for ticket lookup by UUID prefix, title, or filename
|
||||
|
||||
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.27.2"
|
||||
version = "0.27.3"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.27.2"
|
||||
version = "0.27.3"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
+5
-5
@@ -173,22 +173,22 @@ impl CampaignIndex {
|
||||
/// target does, rather than as the bare value the file stores: the value is a full
|
||||
/// uuid, so showing it raw is thirty-six characters that say nothing about what is
|
||||
/// gone.
|
||||
pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> String {
|
||||
pub fn campaign_cells(content: &str, index: &CampaignIndex) -> Vec<Cell> {
|
||||
let Some(uuid) = parse_campaign(content) else {
|
||||
return String::new();
|
||||
return Vec::new();
|
||||
};
|
||||
|
||||
reference_cell(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()), colored)
|
||||
reference_cells(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()))
|
||||
}
|
||||
|
||||
/// The parts [`content_trim`] cannot render from the ticket file alone.
|
||||
///
|
||||
/// Both halves read the tree beside the ticket, so they are gathered in one place
|
||||
/// rather than at each call site.
|
||||
pub fn resolved_for(content: &str, worklane_dir: &Path, colored: bool) -> Result<Resolved> {
|
||||
pub fn resolved_for(content: &str, worklane_dir: &Path) -> Result<Resolved> {
|
||||
Ok(Resolved {
|
||||
relations: relations_for(content, worklane_dir)?,
|
||||
campaign: campaign_cell(content, &CampaignIndex::load(worklane_dir)?, colored),
|
||||
campaign: campaign_cells(content, &CampaignIndex::load(worklane_dir)?),
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -443,7 +443,7 @@ pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
let ticket_uuid = parse_ticket_field(&content, "ID");
|
||||
// Read before anything is printed, so a board that cannot be read fails instead of
|
||||
// half printing a ticket.
|
||||
let resolved = resolved_for(&content, worklane_dir, should_use_colors())?;
|
||||
let resolved = resolved_for(&content, worklane_dir)?;
|
||||
|
||||
// The only title in the output: content_trim_colored used to print it a second
|
||||
// time from the file content. Green per the colour guideline, and the rule is
|
||||
|
||||
+116
-19
@@ -1902,7 +1902,7 @@ fn detail_of(card: &Card) -> Detail {
|
||||
// read of one small directory beside it, for the same reason `show` pays it: the
|
||||
// field stores a uuid, and a card that displayed one raw would say nothing.
|
||||
let resolved = worklane_dir
|
||||
.and_then(|dir| crate::campaign::resolved_for(&content, dir, false).ok())
|
||||
.and_then(|dir| crate::campaign::resolved_for(&content, dir).ok())
|
||||
.unwrap_or_default();
|
||||
let comments = match worklane_dir {
|
||||
Some(worklane_dir) => {
|
||||
@@ -1911,10 +1911,16 @@ fn detail_of(card: &Card) -> Detail {
|
||||
None => Vec::new(),
|
||||
};
|
||||
|
||||
// Colour off for the text, which is what keeps escapes out of the paragraph, and the
|
||||
// relations arrive as rows so the board can style them itself.
|
||||
let mut parts = content_parts(&content, false, &resolved);
|
||||
parts.push(BodyPart::Text(format!("\n{}", format_comments_with(&comments, false))));
|
||||
// Colour on, and nothing here is painted: the body arrives as cells and the
|
||||
// relations as rows, and `detail_body` turns both into styled spans. An escape
|
||||
// sequence never enters, which is what a ratatui paragraph would draw as literal
|
||||
// bytes. The comments are still flat, being a string the board appends rather than
|
||||
// part of the rendered body.
|
||||
let mut parts = content_parts(&content, true, &resolved);
|
||||
parts.push(BodyPart::Cells(vec![Cell::plain(format!(
|
||||
"\n{}",
|
||||
format_comments_with(&comments, false)
|
||||
))]));
|
||||
|
||||
Detail {
|
||||
title: ticket.title.clone(),
|
||||
@@ -1936,17 +1942,19 @@ fn detail_body(parts: &[BodyPart]) -> Text<'static> {
|
||||
|
||||
for part in parts {
|
||||
match part {
|
||||
BodyPart::Text(text) => {
|
||||
let mut rest = text.as_str();
|
||||
while let Some((line, tail)) = rest.split_once('\n') {
|
||||
if !line.is_empty() {
|
||||
open.push(Span::raw(line.to_string()));
|
||||
BodyPart::Cells(cells) => {
|
||||
for cell in cells {
|
||||
let mut rest = cell.text.as_str();
|
||||
while let Some((line, tail)) = rest.split_once('\n') {
|
||||
if !line.is_empty() {
|
||||
open.push(span_from(line, cell.color));
|
||||
}
|
||||
lines.push(Line::from(std::mem::take(&mut open)));
|
||||
rest = tail;
|
||||
}
|
||||
if !rest.is_empty() {
|
||||
open.push(span_from(rest, cell.color));
|
||||
}
|
||||
lines.push(Line::from(std::mem::take(&mut open)));
|
||||
rest = tail;
|
||||
}
|
||||
if !rest.is_empty() {
|
||||
open.push(Span::raw(rest.to_string()));
|
||||
}
|
||||
}
|
||||
// One line each, from the same cells `render_relations` paints, so the block
|
||||
@@ -1972,10 +1980,26 @@ fn detail_body(parts: &[BodyPart]) -> Text<'static> {
|
||||
/// The other half of `paint_cells`, which is the CLI's. `From<Color>` is what makes the
|
||||
/// two agree about what the colour is.
|
||||
fn span_of(cell: Cell) -> Span<'static> {
|
||||
match cell.color {
|
||||
Some(color) => Span::styled(cell.text, Style::default().fg(color.into())),
|
||||
None => Span::raw(cell.text),
|
||||
span_from(cell.text, cell.color)
|
||||
}
|
||||
|
||||
/// The same, for a renderer holding the two halves of a cell rather than the cell.
|
||||
///
|
||||
/// The bold on magenta is not a flourish. `Color::Magenta.ansi()` is `\x1b[1;35m`, so
|
||||
/// the CLI draws every bold run bold as well as magenta, and a board that dropped the
|
||||
/// modifier would be painting the same cell differently from the CLI. The colour is the
|
||||
/// only thing `From<Color>` can carry, so the attribute has to be added on this side.
|
||||
fn span_from(text: impl Into<String>, color: Option<Color>) -> Span<'static> {
|
||||
let Some(color) = color else {
|
||||
return Span::raw(text.into());
|
||||
};
|
||||
|
||||
let mut style = Style::default().fg(color.into());
|
||||
if color == Color::Magenta {
|
||||
style = style.add_modifier(Modifier::BOLD);
|
||||
}
|
||||
|
||||
Span::styled(text.into(), style)
|
||||
}
|
||||
|
||||
/// The four columns of one board, with each card's campaign already named.
|
||||
@@ -2189,7 +2213,7 @@ fn retain_campaign(mut columns: Vec<Column>, campaign: Option<&str>) -> Vec<Colu
|
||||
|
||||
/// The label for the campaign a ticket names, or nothing when it names none.
|
||||
///
|
||||
/// Nothing, too, for a uuid the index does not hold. `campaign_cell` renders that case as
|
||||
/// Nothing, too, for a uuid the index does not hold. `campaign_cells` renders that case as
|
||||
/// `_missing_` because a metadata table is a place to report a dangling reference; a card
|
||||
/// is not, and the answer here is the one `mark_blocked` gives a blocker nobody holds.
|
||||
fn campaign_of(ticket: &TicketItem, campaigns: &CampaignIndex) -> Option<Cell> {
|
||||
@@ -6658,6 +6682,79 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
/// Every painted run in the body reaches the overlay as a style, e4d0bb7.
|
||||
///
|
||||
/// The block was the only coloured part of the body; the rest was flat because
|
||||
/// `content_parts` painted into a string and the board had to ask for the unpainted
|
||||
/// one. It hands out cells now, so the CLI paints them and the board styles them,
|
||||
/// and there is one layout behind both.
|
||||
///
|
||||
/// Paired the way the guideline demands, and both halves are load bearing here: a
|
||||
/// renderer that dropped every colour would pass the absence, and one that went back
|
||||
/// to painting strings would pass the presence.
|
||||
#[test]
|
||||
fn the_whole_body_is_styled_in_the_overlay_and_no_escape_reached_it() {
|
||||
let dir = board_dir();
|
||||
let uuid = "11111111-0000-4000-8000-000000000000";
|
||||
std::fs::write(
|
||||
dir.join("backlog").join(format!("{uuid}_a-painted-one.md")),
|
||||
format!(
|
||||
"# A painted one\n\n## Description\n\nA line with **emphasis** in it.\n\n\
|
||||
## Acceptance Criteria\n\n- [ ] Something\n\n\
|
||||
## Implementation Plan\n\n1. A step\n\n\
|
||||
## Metadata\n\n- **ID**: {uuid}\n- **Due**: _Not set_\n\
|
||||
- **Tags**: bug\n- **Status**: backlog\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let mut board = one_board(&dir);
|
||||
board.toggle_detail();
|
||||
let detail = board.detail.as_ref().expect("no detail");
|
||||
|
||||
// One run per colour the guideline gives the body, each asked for by name so a
|
||||
// run that goes flat names itself in the failure.
|
||||
let heading = body_line(detail, "Description");
|
||||
assert_eq!(span_color(&heading, "Description"), Some(Color::Orange.into()));
|
||||
|
||||
let emphasis = body_line(detail, "emphasis");
|
||||
assert_eq!(span_color(&emphasis, "emphasis"), Some(Color::Magenta.into()));
|
||||
|
||||
let criterion = body_line(detail, "Something");
|
||||
assert_eq!(span_color(&criterion, "1."), Some(Color::Cyan.into()));
|
||||
assert_eq!(span_color(&criterion, "[ ]"), Some(Color::Grey.into()));
|
||||
|
||||
let step = body_line(detail, "A step");
|
||||
assert_eq!(span_color(&step, "1."), Some(Color::Cyan.into()));
|
||||
|
||||
let due = body_line(detail, "_Not set_");
|
||||
assert_eq!(span_color(&due, "Due"), Some(Color::Red.into()));
|
||||
assert_eq!(span_color(&due, "_Not set_"), Some(Color::Grey.into()));
|
||||
|
||||
let tags = body_line(detail, "bug");
|
||||
assert_eq!(span_color(&tags, "bug"), Some(tag_color("bug").into()));
|
||||
|
||||
// `Color::Magenta.ansi()` is `\x1b[1;35m`, so the CLI draws a bold run bold as
|
||||
// well as magenta. The board has to add the modifier itself, since `From<Color>`
|
||||
// carries only the colour.
|
||||
let bold = emphasis
|
||||
.spans
|
||||
.iter()
|
||||
.find(|span| span.content.as_ref() == "emphasis")
|
||||
.expect("no emphasis span");
|
||||
assert!(
|
||||
bold.style.add_modifier.contains(Modifier::BOLD),
|
||||
"the bold run is magenta but not bold: {bold:?}"
|
||||
);
|
||||
|
||||
// The other half: none of that arrived as bytes.
|
||||
assert!(
|
||||
!detail.plain().contains('\x1b'),
|
||||
"escapes reached the body: {:?}",
|
||||
detail.plain()
|
||||
);
|
||||
}
|
||||
|
||||
/// A target the board no longer holds keeps the id, which is the only thing left to
|
||||
/// go looking for, and says `_missing_` in the grey that means an unset value. The
|
||||
/// colour must not turn a gap into something that reads like a real target.
|
||||
|
||||
+301
-120
@@ -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";
|
||||
|
||||
Reference in New Issue
Block a user