Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
108e21ad7f | ||
|
|
26b93f8f53 | ||
|
|
7126138d46 |
@@ -398,7 +398,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_bold` 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. `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 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
|
||||
@@ -415,6 +415,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- Priority ramp → brightred (1), red (2), orange (3), cyan (4), grey (5). Green is deliberately absent: it means title
|
||||
- Relation kind mark → brightred `×` blocked by and blocks, cyan `→` relates to, orange `←` regression of and regressed by. A small ramp inside one column, the way the priority meter is: the mark says which kind of edge the row is, so none of these three is a colour standing in for the uuid or the title beside it. Brightred on the cross rather than red, because the id one cell to its right is red and the two would blend. It is the colour and the glyph a held-up card already carries, which is the point: one vocabulary for blocking
|
||||
- Relation status mark → grey `○` backlog, orange `◐` committed, cyan `◐` reviewing, green `●` done, grey `?` for a target the board does not hold. The second ramp in that column: the shape says how far the target has got and the colour tells the two middle stages apart, since both are half circles. **Green is here and deliberately absent from the priority ramp**, where it would sit on a whole line and read as a title; on a one-cell mark with no title behind it, it is the obvious colour for finished and nothing else wants it. Orange keeps the meaning it already has, Status, and grey keeps unset for the one row with no status to show
|
||||
- Markdown link → cyan, markers and url kept. Not a new meaning for the colour: the plan numbers, the criterion numbers and the `relates to` mark are already cyan inside a rendered body, and a link is the same kind of thing, a pointer the reader may follow rather than a value. The url is not hidden behind the text the way a renderer would hide it, because `show` prints to a terminal worklane cannot assume will make it clickable, and a link whose target cannot be read is worse than a long line
|
||||
- Chrome → grey. The footer's key names, a rendered `[ ]`, and the overlay's page indicator. Not a new slot: grey already means "what a reader skips", which is the other half of the unset-value meaning, and none of these is a value. The indicator in orange would read as the title it faces across the overlay, in cyan as a timestamp, and in the priority ramp's colours as a level
|
||||
- Campaign label → its codename through `tag_color`, bold, marked `~`. The colour is what groups a campaign across the cards that carry it, which is exactly what a tag's colour is for, and one word is one colour in every view because `tag_color` is a pure function of it. The mark and the bold are what tell it from a tag on a row that holds both: the mark is not `#`, or the row would read as a list of tags with a stranger in it, and not `@`, which reads as a person on every board anyone has used. `Codename` in a metadata table takes the colour without the mark, since the field name has already said what it is
|
||||
- Campaign label with no codename → grey. The label is then the short id, and grey keeps a reserved meaning off a `TAG_COLORS` slot in the one case where it would land on one: red is the uuid's everywhere else, and grey already means what a reader skips, which is what a campaign with no codename has to say for itself
|
||||
@@ -426,7 +427,8 @@ 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_bold`, `content_trim_colored`) handle markdown formatting. `colorize_line` is gone: it was a `pub` alias for `colorize_bold` with one caller, and the only thing it added was asking the terminal
|
||||
- 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 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
|
||||
@@ -454,12 +456,12 @@ and this file is for what someone changing worklane's own code needs.
|
||||
### Version Bumps
|
||||
- Before every commit, decide whether the change warrants a version bump in `Cargo.toml`
|
||||
- Always ask the user to confirm the bump and its kind before making it — never bump silently, and never skip the question because the answer looks obvious
|
||||
- **`make patch`, `make minor` and `make major` do the mechanics**, run after the commit is in: each bumps `Cargo.toml` and the `worklane` entry in `Cargo.lock`, appends `, and bump to <version>` to the commit's subject, folds the bump into that commit, and tags it. Bumping by hand is how a version comes to be left untagged, which is what the one action is for. It refuses on a dirty tree, on an already-tagged `HEAD` and on a `HEAD` that is already pushed, since each of those makes the amend lose work, orphan a tag or need a force push
|
||||
- Pre-1.0, so: patch for fixes and internal changes, minor for a new command, flag or changed output, major only for a deliberate 1.0
|
||||
- **Changed output means the CLI's output.** That is the surface scripts and agents read, so a changed listing, message or exit code is a minor. A change to what the board draws is a patch however visible it is, since nothing consumes the frame. See The Board View
|
||||
- **Settling output that shipped one version ago is a patch**, not a second minor. 0.15.1 changed the relation mark 0.15.0 had just introduced, and 0.15.2 added the status mark beside it: the minor was the arrival of a marked relations block, and settling what it marks belongs to that. Three minors in an hour would tell anyone reading the tags that there were three features
|
||||
- No bump for docs-only, tests-only or `--fixup` commits
|
||||
- When one body of work spans several commits, bump once on the final commit rather than on each
|
||||
- Bump `Cargo.toml` and the `worklane` entry in `Cargo.lock` together, in the commit that carries the bump
|
||||
- Every bump gets a matching annotated tag, `v<version>`, on the bump commit — a bumped version is never left untagged
|
||||
- Tag locally only; never push a tag unless asked
|
||||
- `worklane --version` reports the crate version alongside the build sha, so the bump is what makes one release distinguishable from another
|
||||
|
||||
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.27.0"
|
||||
version = "0.27.2"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.27.0"
|
||||
version = "0.27.2"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
# Release helpers.
|
||||
#
|
||||
# `make patch|minor|major` bumps the version in Cargo.toml and Cargo.lock, folds
|
||||
# that bump into the last commit, and tags it. Everything is one action so a
|
||||
# release cannot end up half-done: no version bump left untagged, no tag without
|
||||
# a bump.
|
||||
|
||||
.PHONY: help patch minor major version release install
|
||||
|
||||
help:
|
||||
@echo "make patch bump $(CURRENT) -> next patch, amend into HEAD, tag"
|
||||
@echo "make minor bump $(CURRENT) -> next minor, amend into HEAD, tag"
|
||||
@echo "make major bump $(CURRENT) -> next major, amend into HEAD, tag"
|
||||
@echo "make version print the current version"
|
||||
@echo "make install cargo install --path . && worklane install-skill"
|
||||
|
||||
# Read from the [package] table of Cargo.toml, which is the version the binary
|
||||
# reports through `--version`, so it is the single source of truth. The name is
|
||||
# what finds this crate's own entry in Cargo.lock.
|
||||
PACKAGE = $(shell awk -F'"' '/^\[package\]/{p=1;next} /^\[/{p=0} p && /^name *= *"/{print $$2; exit}' Cargo.toml)
|
||||
CURRENT = $(shell awk -F'"' '/^\[package\]/{p=1;next} /^\[/{p=0} p && /^version *= *"/{print $$2; exit}' Cargo.toml)
|
||||
|
||||
# 1 appends ", and bump to <version>" to the amended commit's subject; empty
|
||||
# leaves the message alone.
|
||||
AMEND_SUBJECT = 1
|
||||
|
||||
version:
|
||||
@echo $(CURRENT)
|
||||
|
||||
patch: BUMP = patch
|
||||
minor: BUMP = minor
|
||||
major: BUMP = major
|
||||
patch minor major: release
|
||||
|
||||
# A release rewrites the last commit, so refuse anything that would make that
|
||||
# rewrite lose work or orphan a tag.
|
||||
release:
|
||||
@set -e; \
|
||||
if ! git rev-parse -q --verify HEAD >/dev/null 2>&1; then \
|
||||
echo "error: no commits yet, so there is no commit to fold a version bump into. Commit first." >&2; \
|
||||
exit 1; \
|
||||
fi; \
|
||||
if [ -n "$$(git status --porcelain)" ]; then \
|
||||
echo "error: working tree is dirty. Commit or stash first, and decide whether that work belongs in this version:" >&2; \
|
||||
git status --short >&2; \
|
||||
exit 1; \
|
||||
fi; \
|
||||
if [ -n "$$(git tag --points-at HEAD)" ]; then \
|
||||
echo "error: HEAD is already tagged $$(git tag --points-at HEAD | paste -sd' '). Amending it would leave that tag on an orphaned commit. Commit something first." >&2; \
|
||||
exit 1; \
|
||||
fi; \
|
||||
if upstream=$$(git rev-parse --abbrev-ref --symbolic-full-name '@{u}' 2>/dev/null) && \
|
||||
git merge-base --is-ancestor HEAD "$$upstream" 2>/dev/null; then \
|
||||
echo "error: HEAD is already pushed to $$upstream. Amending it would need a force push. Commit something first." >&2; \
|
||||
exit 1; \
|
||||
fi; \
|
||||
current="$(CURRENT)"; \
|
||||
if [ -z "$$current" ]; then echo "error: no version found in the [package] table of Cargo.toml" >&2; exit 1; fi; \
|
||||
new=$$(echo "$$current" | awk -F. -v kind=$(BUMP) '{ \
|
||||
if (NF != 3) exit 1; \
|
||||
if (kind == "patch") printf "%d.%d.%d\n", $$1, $$2, $$3 + 1; \
|
||||
else if (kind == "minor") printf "%d.%d.0\n", $$1, $$2 + 1; \
|
||||
else printf "%d.0.0\n", $$1 + 1 }'); \
|
||||
if [ -z "$$new" ]; then echo "error: cannot bump version '$$current': expected major.minor.patch" >&2; exit 1; fi; \
|
||||
if git rev-parse -q --verify "refs/tags/v$$new" >/dev/null; then \
|
||||
echo "error: tag v$$new already exists" >&2; exit 1; \
|
||||
fi; \
|
||||
awk -v v="$$new" '/^\[package\]/{p=1} /^\[/ && !/^\[package\]/{p=0} p && /^version *= *"/{sub(/"[^"]*"/, "\"" v "\"")} {print}' Cargo.toml > Cargo.toml.bump; \
|
||||
mv Cargo.toml.bump Cargo.toml; \
|
||||
git add Cargo.toml; \
|
||||
if [ -f Cargo.lock ] && git ls-files --error-unmatch Cargo.lock >/dev/null 2>&1; then \
|
||||
awk -v v="$$new" -v pkg="$(PACKAGE)" '$$0 == "name = \"" pkg "\""{f=1} f && /^version = "/{sub(/"[^"]*"/, "\"" v "\""); f=0} {print}' Cargo.lock > Cargo.lock.bump; \
|
||||
mv Cargo.lock.bump Cargo.lock; \
|
||||
git add Cargo.lock; \
|
||||
fi; \
|
||||
if [ -n "$(AMEND_SUBJECT)" ]; then \
|
||||
subject=$$(git log -1 --format=%s | sed -E 's/, and bump to [0-9]+\.[0-9]+\.[0-9]+$$//'); \
|
||||
body=$$(git log -1 --format=%b); \
|
||||
if [ -n "$$body" ]; then \
|
||||
git commit --quiet --amend -m "$$subject, and bump to $$new" -m "$$body"; \
|
||||
else \
|
||||
git commit --quiet --amend -m "$$subject, and bump to $$new"; \
|
||||
fi; \
|
||||
else \
|
||||
git commit --quiet --amend --no-edit; \
|
||||
fi; \
|
||||
git tag -a "v$$new" -m "v$$new"; \
|
||||
echo "$$current -> $$new, tagged v$$new on $$(git rev-parse --short HEAD) ($$(git log -1 --format=%s))"
|
||||
|
||||
install:
|
||||
cargo install --path .
|
||||
worklane install-skill
|
||||
@@ -78,3 +78,20 @@ Whether a truncated pipe reports 141 or 0 depends on the size of the output, not
|
||||
the command. A pipe holds 64 KiB, so a listing that fits lands in the buffer whole
|
||||
and the writer never learns the reader left, giving 0. Only output past that gets far
|
||||
enough to be cut off. Either way nothing is printed to stderr.
|
||||
|
||||
## Releasing
|
||||
|
||||
```sh
|
||||
make patch # 0.27.1 -> next patch
|
||||
make minor # 0.27.1 -> next minor
|
||||
make major # 0.27.1 -> next major
|
||||
```
|
||||
|
||||
Each bumps `Cargo.toml` and `Cargo.lock`, folds that bump into the last commit, and tags it
|
||||
`v<version>`. One action, so no bump is left untagged and no tag lands without a bump. In this repo
|
||||
it also appends `, and bump to <version>` to the commit's subject, the way the release commits
|
||||
before it read.
|
||||
|
||||
It refuses to run when the working tree is dirty, when `HEAD` is already tagged, or when `HEAD` is
|
||||
already pushed. The first asks you to decide whether that work belongs in the version; the other two
|
||||
mean the amend would orphan a tag or need a force push.
|
||||
|
||||
+5
-1
@@ -248,7 +248,11 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
// The way in to the campaign picker, like `/` is to the search prompt: from
|
||||
// the next keypress on `picker_key` above has the keyboard. Free of every
|
||||
// other binding, and `ctrl-c` is matched above this so quitting still wins.
|
||||
KeyCode::Char('c') => board.open_picker(),
|
||||
KeyCode::Char('c') => board.open_picker(tui::PickerKind::Campaign, screen),
|
||||
// The other axis the board is cut along, and the one `ls --tag` has
|
||||
// answered since 2f3796e. Free of every other binding: `tab` is its own
|
||||
// key code, not this letter.
|
||||
KeyCode::Char('t') => board.open_picker(tui::PickerKind::Tag, screen),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
+10
@@ -163,6 +163,16 @@ impl TagIndex {
|
||||
self.tags.keys().map(String::as_str)
|
||||
}
|
||||
|
||||
/// What a tag means, whole, or `None` for a tag the file does not declare.
|
||||
///
|
||||
/// The raw section, paragraphs and all, where [`Self::summary`] is the one line a
|
||||
/// listing has room for. `Some("")` is a tag declared with nothing said about it, which
|
||||
/// the caller has to tell apart from `None`: the board draws the two in different
|
||||
/// sections.
|
||||
pub fn annotation(&self, tag: &str) -> Option<&str> {
|
||||
self.tags.get(tag).map(String::as_str)
|
||||
}
|
||||
|
||||
/// The opening line of what a tag means, or `None` for a tag the file does not declare.
|
||||
///
|
||||
/// The cut to one line lives here rather than on the parse, the way
|
||||
|
||||
+997
-156
File diff suppressed because it is too large
Load Diff
+122
-45
@@ -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");
|
||||
|
||||
Reference in New Issue
Block a user