//! The rich text composer: Markdown styled live as you type.
//!
//! The text stays plain Markdown (that is what gets sent); only its styling
//! changes. Headings and `**strong**` turn bold, `*emphasis*` italic, code
//! sits on a faint well, quotes and fenced blocks are muted, list markers,
//! links and a leading `/command` or `$skill` are tinted, and the syntax
//! characters themselves fade back.
//!
//! gpui-base only paints highlighter runs in its code-editor layout, so the
//! rich composer is an [`EditorState`] dressed as the plain composer: no
//! gutter, folding, indent guides, auto-closing or smart indent, soft wrap on,
//! and [`MarkdownInput`] grows it from two to twelve rows the way
//! `TextareaState::auto_grow` does. [`MarkdownHighlighter`] supplies the runs.
//!
//! ```ignore
//! let composer = cx.new(|cx| {
//! markdown_input::composer_state(EditorState::new(window, cx), rich)
//! .submit_on_enter(true)
//! .placeholder("Ask for changes")
//! });
//! // render: MarkdownInput::new(&composer)
//! // toggle: markdown_input::enable(&composer, on, cx)
//! ```
use std::{cell::Cell, ops::Range, rc::Rc};
use gpui_kit::component::input::{
self, Editor, EditorState, FoldRange, HighlightStyleResolver, InputEdit, InputHighlighter,
InputHighlighterFactory, Rope, RopeExt as _,
};
use gpui_kit::component::native_menu::NativeMenu;
use gpui_kit::*;
use crate::ui::metal::{self, Palette};
/// What a byte of Markdown is, as bit flags; a byte can be several at once
/// (bold inside a heading, a delimiter of inline code).
mod flag {
pub const HEADING: u16 = 1 << 0;
pub const STRONG: u16 = 1 << 1;
pub const EMPHASIS: u16 = 1 << 2;
/// Inline code, delimiters included.
pub const CODE: u16 = 1 << 3;
/// A line inside a fenced code block.
pub const CODE_BLOCK: u16 = 1 << 4;
/// The opening or closing line of a fence.
pub const FENCE: u16 = 1 << 5;
/// Text inside a block quote.
pub const QUOTE: u16 = 1 << 6;
/// A list bullet, number or task box.
pub const LIST_MARKER: u16 = 1 << 7;
pub const LINK_TEXT: u16 = 1 << 8;
pub const LINK_URL: u16 = 1 << 9;
/// A leading `/command` or `$skill`.
pub const COMMAND: u16 = 1 << 10;
/// Markdown syntax: `#`, `**`, `` ` ``, `>`, brackets, escapes.
pub const SYNTAX: u16 = 1 << 11;
}
/// A styled run of the document: a byte range and its [`flag`]s.
type Span = (Range<usize>, u16);
thread_local! {
/// The theme the composer paints with. [`InputHighlighter::styles`]
/// gets no `App`, so [`MarkdownInput`] records the palette here on every
/// render, ahead of the editor's paint in the same frame. One theme is
/// active app-wide, so one cell serves every composer.
static PALETTE: Cell<Option<&'static Palette>> = const { Cell::new(None) };
}
fn active_palette() -> &'static Palette {
PALETTE.with(Cell::get).unwrap_or(&metal::BONE)
}
/// Turns Markdown into highlight runs for an [`EditorState`].
///
/// Every edit rescans the whole document. A hand-written line scanner gets
/// through a few hundred lines in microseconds, and a full rescan keeps fenced
/// blocks right however an edit opens or closes them.
#[derive(Default)]
pub struct MarkdownHighlighter {
/// Styled runs over the whole document, ordered and non-overlapping.
/// Unstyled text has no entry.
spans: Vec<Span>,
}
impl MarkdownHighlighter {
pub fn new() -> Self {
Self::default()
}
fn rescan(&mut self, text: &str) {
self.spans = scan(text);
}
/// The highlight runs for `range`, styled with `palette`.
fn styles_with(&self, range: &Range<usize>, palette: &Palette) -> Vec<(Range<usize>, HighlightStyle)> {
let mut runs = Vec::new();
let mut at = range.start;
let first = self.spans.partition_point(|(span, _)| span.end <= range.start);
for (span, flags) in &self.spans[first..] {
if span.start >= range.end {
break;
}
let start = span.start.max(range.start);
let end = span.end.min(range.end);
if start > at {
runs.push((at..start, HighlightStyle::default()));
}
runs.push((start..end, style_for(*flags, palette)));
at = end;
}
if at < range.end {
runs.push((at..range.end, HighlightStyle::default()));
}
runs
}
}
impl InputHighlighter for MarkdownHighlighter {
fn language(&self) -> SharedString {
"markdown".into()
}
fn update(
&mut self,
_edit: Option<InputEdit>,
text: &Rope,
_folding: bool,
_window: &mut Window,
cx: &mut Context<EditorState>,
) {
PALETTE.with(|cell| cell.set(Some(metal::palette(cx))));
self.rescan(&text.to_string());
}
fn update_batch(
&mut self,
edits: &[(InputEdit, Rope)],
_folding: bool,
_window: &mut Window,
_cx: &mut Context<EditorState>,
) {
// Only the text after the last edit matters to a full rescan.
if let Some((_, text)) = edits.last() {
self.rescan(&text.to_string());
}
}
fn styles(
&self,
range: &Range<usize>,
_resolver: &dyn HighlightStyleResolver,
) -> Vec<(Range<usize>, HighlightStyle)> {
// The resolver is gpui-component's syntax theme, which the `Editor`
// element re-installs on every render, so the colors come from the
// MetalUI palette instead.
self.styles_with(range, active_palette())
}
fn fold_ranges(&self, _text: &Rope) -> Vec<FoldRange> {
Vec::new()
}
}
/// The highlighter factory for an [`EditorState`]: Markdown when `on`, plain
/// text otherwise. Installing a factory (even the plain one) also keeps
/// gpui-component's tree-sitter factory out.
pub fn highlighter_factory(on: bool) -> InputHighlighterFactory {
if on {
Rc::new(|_| Some(Box::new(MarkdownHighlighter::new()) as Box<dyn InputHighlighter>))
} else {
Rc::new(|_| None)
}
}
/// Dresses a fresh [`EditorState`] as the composer: no line numbers, gutter,
/// folding or indent guides, no bracket pairing or smart indent, no search
/// panel or scrolling past the end, soft wrap on, and Markdown styling when
/// `rich`. Chain `submit_on_enter` and `placeholder` after it as for a
/// `TextareaState`, and render it with [`MarkdownInput`].
pub fn composer_state(state: EditorState, rich: bool) -> EditorState {
let mut state = state
.line_number(false)
.folding(false)
.indent_guides(false)
.auto_close(false)
.smart_indent(false)
.soft_wrap(true)
.searchable(false)
.scroll_beyond_last_line(Some(0));
state.ensure_highlighter_factory(highlighter_factory(rich));
state
}
/// Turns Markdown styling on or off, live.
pub fn enable(state: &Entity<EditorState>, on: bool, cx: &mut App) {
state.update(cx, |state, cx| state.set_highlighter_factory(highlighter_factory(on), cx));
}
/// Vertical padding the input puts around its text: gpui-component's
/// `Size::Medium.input_py()`, the same as the plain composer's.
const PADDING_Y: f32 = 8.;
/// How much further right an editor starts its text than a textarea: it pads
/// 6px instead of 10px, plus a 6px gap where the line numbers would end.
const EDITOR_INDENT: f32 = 2.;
/// Renders a [`composer_state`] editor as the plain composer would render its
/// `Textarea`: borderless, in the UI font at the textarea's size and leading,
/// growing with its content between `rows` (default 2 to 12).
#[derive(IntoElement)]
pub struct MarkdownInput {
state: Entity<EditorState>,
min_rows: usize,
max_rows: usize,
}
impl MarkdownInput {
pub fn new(state: &Entity<EditorState>) -> Self {
Self { state: state.clone(), min_rows: 2, max_rows: 12 }
}
/// Grow with the content from `min` through `max` rows.
pub fn rows(mut self, min: usize, max: usize) -> Self {
self.min_rows = min.max(1);
self.max_rows = max.max(self.min_rows);
self
}
}
impl RenderOnce for MarkdownInput {
fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
PALETTE.with(|cell| cell.set(Some(metal::palette(cx))));
let (min, max) = (self.min_rows, self.max_rows);
let state = self.state.read(cx);
let line_height = state.line_height().unwrap_or_else(|| rems(1.25).to_pixels(window.rem_size()));
let rows = content_rows(state).unwrap_or(min).clamp(min, max);
// The rows above come from the last layout. Once this frame has laid
// the text out, measure again and redraw if the content grew or shrank.
let entity = self.state.clone();
window.on_next_frame(move |_, cx| {
let measured = content_rows(entity.read(cx)).map(|now| now.clamp(min, max));
if measured.is_some_and(|now| now != rows) {
cx.notify(entity.entity_id());
}
});
let menu_state = self.state.clone();
Editor::new(&self.state)
.appearance(false)
.h(line_height * rows as f32 + px(PADDING_Y * 2.))
.context_menu(move |menu, window, cx| {
// The builder runs while the editor is mid-update, where
// reading its state panics, so the real menu waits a tick
// and the empty one returned here shows nothing.
let state = menu_state.clone();
window.defer(cx, move |window, cx| {
let position = window.mouse_position();
context_menu(&state, NativeMenu::new(), cx).show(position, window, cx);
});
menu
})
.font_family(metal::SANS)
.text_size(rems(0.875))
.line_height(rems(1.25))
.ml(px(-EDITOR_INDENT))
}
}
/// The plain text menu. The editor's own adds code navigation entries.
fn context_menu(state: &Entity<EditorState>, menu: NativeMenu, cx: &App) -> NativeMenu {
let state = state.read(cx);
let editable = state.is_editable();
let selected = !state.selected_range().is_empty();
menu.menu_with_disabled("Cut", !(editable && selected), Box::new(input::Cut))
.menu_with_disabled("Copy", !selected, Box::new(input::Copy))
.menu_with_disabled("Paste", !editable, Box::new(input::Paste))
.separator()
.menu("Select All", Box::new(input::SelectAll))
}
/// How many rows the editor's text takes up, soft wraps included, from its
/// last layout. `None` before the first layout.
///
/// The laid-out lines are measured exactly; lines scrolled out of view count
/// one row each, which only ever undercounts, so growing converges in a frame
/// or two.
fn content_rows(state: &EditorState) -> Option<usize> {
let line_height = state.line_height()?;
let text = state.text();
let lines = text.lines_len().max(1);
let visible = state.visible_row_range()?;
let visible = visible.start.min(lines)..visible.end.min(lines);
if visible.is_empty() {
return None;
}
let start = text.line_start_offset(visible.start);
let end = text.line_end_offset(visible.end - 1);
let top = state.range_to_bounds(&(start..start))?.top();
let bottom = state.range_to_bounds(&(end..end))?.bottom();
let measured = ((bottom - top) / line_height).round().max(1.) as usize;
Some(measured + lines - visible.len())
}
fn style_for(flags: u16, p: &Palette) -> HighlightStyle {
let mut style = HighlightStyle::default();
if flags & (flag::HEADING | flag::STRONG) != 0 {
style.font_weight = Some(FontWeight::BOLD);
}
if flags & flag::EMPHASIS != 0 {
// Geist ships no italic face, and GPUI on Linux does not slant one,
// so emphasis also gets a softer ink to stay visible.
style.font_style = Some(FontStyle::Italic);
style.color = Some(p.ink2);
}
if flags & flag::QUOTE != 0 {
style.color = Some(p.ink2);
}
if flags & flag::LIST_MARKER != 0 {
style.color = Some(p.amber_ink);
}
if flags & flag::COMMAND != 0 {
style.color = Some(p.green_ink);
style.font_weight = Some(FontWeight::MEDIUM);
}
if flags & flag::LINK_TEXT != 0 {
style.color = Some(p.blue_ink);
style.underline =
Some(UnderlineStyle { thickness: px(1.), color: Some(p.blue_ink.opacity(0.5)), wavy: false });
}
if flags & flag::LINK_URL != 0 {
style.color = Some(p.ink3);
}
if flags & flag::CODE != 0 {
style.color = Some(p.ink2);
style.background_color = Some(p.well_top);
}
if flags & flag::SYNTAX != 0 {
style.color = Some(p.ink3);
}
if flags & flag::CODE_BLOCK != 0 {
style.color = Some(p.ink2);
style.font_weight = None;
style.font_style = None;
}
if flags & flag::FENCE != 0 {
style.color = Some(p.ink3);
}
style
}
// ---------------------------------------------------------------------------
// The scanner
// ---------------------------------------------------------------------------
/// An open code fence: its character and length.
#[derive(Clone, Copy)]
struct Fence {
ch: u8,
len: usize,
}
/// Scans `text` into styled runs: ordered, non-overlapping, on UTF-8 char
/// boundaries, unstyled text left out.
fn scan(text: &str) -> Vec<Span> {
let mut spans = Vec::new();
let mut fence = None;
let mut leading = true;
let mut flags = Vec::new();
let mut literal = Vec::new();
let mut offset = 0;
for raw in text.split('\n') {
let line = raw.strip_suffix('\r').unwrap_or(raw);
flags.clear();
flags.resize(line.len(), 0u16);
literal.clear();
literal.resize(line.len(), false);
// The message is sent trimmed, so its first non-blank line leads.
let leads = leading && !line.trim().is_empty();
scan_line(line, &mut fence, leads, &mut flags, &mut literal);
leading &= !leads;
push_runs(&mut spans, offset, &flags);
offset += raw.len() + 1;
}
spans
}
/// Appends the runs of equal, non-zero flags in one line.
fn push_runs(spans: &mut Vec<Span>, offset: usize, flags: &[u16]) {
let mut start = 0;
while start < flags.len() {
let value = flags[start];
let mut end = start + 1;
while end < flags.len() && flags[end] == value {
end += 1;
}
if value != 0 {
spans.push((offset + start..offset + end, value));
}
start = end;
}
}
fn mark(flags: &mut [u16], range: Range<usize>, value: u16) {
for slot in &mut flags[range] {
*slot |= value;
}
}
fn indent_of(bytes: &[u8], from: usize) -> usize {
bytes[from..].iter().take_while(|&&b| b == b' ' || b == b'\t').count()
}
fn scan_line(line: &str, fence: &mut Option<Fence>, leads: bool, flags: &mut [u16], literal: &mut [bool]) {
let bytes = line.as_bytes();
let len = bytes.len();
if let Some(open) = *fence {
if closes_fence(bytes, open) {
*fence = None;
mark(flags, 0..len, flag::FENCE);
} else {
mark(flags, 0..len, flag::CODE_BLOCK);
}
return;
}
if let Some(open) = opens_fence(bytes) {
*fence = Some(open);
mark(flags, 0..len, flag::FENCE);
return;
}
let mut pos = 0;
if leads && let Some(end) = leading_command(bytes) {
let start = indent_of(bytes, 0);
mark(flags, start..end, flag::COMMAND);
inline(line, end..len, flags, literal);
return;
}
// Block quotes, nested or not: `>` markers, each with one optional space.
loop {
let at = pos + indent_of(bytes, pos);
if at - pos <= 3 && bytes.get(at) == Some(&b'>') {
mark(flags, at..len, flag::QUOTE);
mark(flags, at..at + 1, flag::SYNTAX);
pos = at + 1;
if bytes.get(pos) == Some(&b' ') {
pos += 1;
}
} else {
break;
}
}
if is_thematic_break(&bytes[pos..]) {
mark(flags, pos..len, flag::SYNTAX);
return;
}
// ATX heading: up to three spaces, one to six `#`, then a space or the end.
let at = pos + indent_of(bytes, pos);
let hashes = bytes[at..].iter().take_while(|&&b| b == b'#').count();
if at - pos <= 3
&& (1..=6).contains(&hashes)
&& matches!(bytes.get(at + hashes), None | Some(b' ' | b'\t'))
{
mark(flags, at..len, flag::HEADING);
mark(flags, at..at + hashes, flag::SYNTAX);
// An optional closing run of `#` after a space.
let trimmed = line.trim_end().len();
let closing = bytes[..trimmed].iter().rev().take_while(|&&b| b == b'#').count();
let mut content_end = trimmed;
if closing > 0 && trimmed - closing > at + hashes && matches!(bytes[trimmed - closing - 1], b' ' | b'\t') {
content_end = trimmed - closing;
mark(flags, content_end..trimmed, flag::SYNTAX);
}
inline(line, (at + hashes).min(content_end)..content_end, flags, literal);
return;
}
// List item: a bullet or a number, then a space or the end, then
// optionally a task box.
let mut content = pos;
if let Some(marker_end) = list_marker(bytes, at) {
mark(flags, at..marker_end, flag::LIST_MARKER);
content = marker_end;
let box_at = marker_end + indent_of(bytes, marker_end);
if box_at > marker_end
&& let [b'[', b' ' | b'x' | b'X', b']', ..] = &bytes[box_at..]
&& matches!(bytes.get(box_at + 3), None | Some(b' ' | b'\t'))
{
mark(flags, box_at..box_at + 3, flag::LIST_MARKER);
content = box_at + 3;
}
}
inline(line, content..len, flags, literal);
}
/// An opening fence: three or more backticks or tildes, at any indent (fences
/// inside list items are indented). A backtick fence's info string can't hold
/// a backtick, or it's inline code.
fn opens_fence(bytes: &[u8]) -> Option<Fence> {
let at = indent_of(bytes, 0);
let ch = *bytes.get(at)?;
if ch != b'`' && ch != b'~' {
return None;
}
let len = bytes[at..].iter().take_while(|&&b| b == ch).count();
if len < 3 || (ch == b'`' && bytes[at + len..].contains(&b'`')) {
return None;
}
Some(Fence { ch, len })
}
/// A closing fence: at least as long as the opening one, nothing after it.
fn closes_fence(bytes: &[u8], open: Fence) -> bool {
let at = indent_of(bytes, 0);
let len = bytes[at..].iter().take_while(|&&b| b == open.ch).count();
len >= open.len && bytes[at + len..].iter().all(|b| b.is_ascii_whitespace())
}
/// `---`, `***` or `___`, optionally spaced out.
fn is_thematic_break(bytes: &[u8]) -> bool {
let mut ch = None;
let mut count = 0;
for &b in bytes {
match b {
b' ' | b'\t' => {}
b'-' | b'*' | b'_' if ch.is_none_or(|c| c == b) => {
ch = Some(b);
count += 1;
}
_ => return false,
}
}
count >= 3
}
/// The end of a list marker starting at `at`: `-`, `*` or `+`, or up to nine
/// digits and `.` or `)`, followed by a space or the end of the line.
fn list_marker(bytes: &[u8], at: usize) -> Option<usize> {
let end = match *bytes.get(at)? {
b'-' | b'*' | b'+' => at + 1,
b'0'..=b'9' => {
let digits = bytes[at..].iter().take_while(|b| b.is_ascii_digit()).count();
if digits > 9 || !matches!(bytes.get(at + digits), Some(b'.' | b')')) {
return None;
}
at + digits + 1
}
_ => return None,
};
matches!(bytes.get(end), None | Some(b' ' | b'\t')).then_some(end)
}
/// The end of a `/command` or `$skill` at the start of the line.
fn leading_command(bytes: &[u8]) -> Option<usize> {
let at = indent_of(bytes, 0);
let sigil = *bytes.get(at)?;
if sigil != b'/' && sigil != b'$' {
return None;
}
let name = bytes[at + 1..]
.iter()
.take_while(|&&b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-' | b':' | b'.'))
.count();
let first = *bytes.get(at + 1)?;
let starts_well = if sigil == b'$' { first.is_ascii_alphabetic() } else { first.is_ascii_alphanumeric() };
let end = at + 1 + name;
(name > 0 && starts_well && matches!(bytes.get(end), None | Some(b' ' | b'\t'))).then_some(end)
}
/// Marks inline Markdown in `range` of `line`: escapes, code spans, links,
/// bare URLs and emphasis, in that order of precedence. `literal` collects
/// bytes that later passes must not read as syntax.
fn inline(line: &str, range: Range<usize>, flags: &mut [u16], literal: &mut [bool]) {
let bytes = line.as_bytes();
let Range { start, end } = range;
// Escapes and code spans, left to right as CommonMark reads them.
let mut i = start;
while i < end {
match bytes[i] {
b'\\' if i + 1 < end && bytes[i + 1].is_ascii_punctuation() => {
mark(flags, i..i + 1, flag::SYNTAX);
literal[i] = true;
literal[i + 1] = true;
i += 2;
}
b'`' => {
let run = run_len(bytes, i, end, b'`');
if let Some(close) = find_backtick_run(bytes, i + run, end, run) {
mark(flags, i..close + run, flag::CODE);
mark(flags, i..i + run, flag::SYNTAX);
mark(flags, close..close + run, flag::SYNTAX);
literal[i..close + run].fill(true);
i = close + run;
} else {
literal[i..i + run].fill(true);
i += run;
}
}
_ => i += 1,
}
}
links(line, start..end, flags, literal);
bare_urls(line, start..end, flags, literal);
emphasis(line, start..end, flags, literal);
}
fn run_len(bytes: &[u8], at: usize, end: usize, ch: u8) -> usize {
bytes[at..end].iter().take_while(|&&b| b == ch).count()
}
/// The start of the next run of exactly `len` backticks in `from..end`.
fn find_backtick_run(bytes: &[u8], from: usize, end: usize, len: usize) -> Option<usize> {
let mut i = from;
while i < end {
if bytes[i] == b'`' {
let run = run_len(bytes, i, end, b'`');
if run == len {
return Some(i);
}
i += run;
} else {
i += 1;
}
}
None
}
/// `[text](url)` and ``.
fn links(line: &str, range: Range<usize>, flags: &mut [u16], literal: &mut [bool]) {
let bytes = line.as_bytes();
let Range { start, end } = range;
let mut i = start;
while i < end {
if bytes[i] != b'[' || literal[i] {
i += 1;
continue;
}
let Some(close) = matching(bytes, literal, i, end, b'[', b']') else {
i += 1;
continue;
};
let Some(paren_close) = (bytes.get(close + 1) == Some(&b'('))
.then(|| matching(bytes, literal, close + 1, end, b'(', b')'))
.flatten()
else {
i += 1;
continue;
};
let open = if i > start && bytes[i - 1] == b'!' && !literal[i - 1] { i - 1 } else { i };
mark(flags, i + 1..close, flag::LINK_TEXT);
mark(flags, close + 2..paren_close, flag::LINK_URL);
mark(flags, open..i + 1, flag::SYNTAX);
mark(flags, close..close + 2, flag::SYNTAX);
mark(flags, paren_close..paren_close + 1, flag::SYNTAX);
for at in [i, close, close + 1, paren_close] {
literal[at] = true;
}
literal[open] = true;
literal[close + 2..paren_close].fill(true);
i = paren_close + 1;
}
}
/// The index of the bracket closing the one at `open`, skipping literal bytes.
fn matching(bytes: &[u8], literal: &[bool], open: usize, end: usize, left: u8, right: u8) -> Option<usize> {
let mut depth = 0usize;
for i in open..end {
if literal[i] && i != open {
continue;
}
if bytes[i] == left {
depth += 1;
} else if bytes[i] == right {
depth -= 1;
if depth == 0 {
return Some(i);
}
}
}
None
}
/// `http://` and `https://` URLs written out in the text.
fn bare_urls(line: &str, range: Range<usize>, flags: &mut [u16], literal: &mut [bool]) {
let bytes = line.as_bytes();
let mut search = range.start;
while let Some(found) = line[search..range.end].find("http") {
let at = search + found;
let rest = &line[at..range.end];
let scheme = if rest.starts_with("https://") {
8
} else if rest.starts_with("http://") {
7
} else {
search = at + 4;
continue;
};
let word_start = at == range.start || matches!(bytes[at - 1], b' ' | b'\t' | b'(' | b'<' | b'"' | b'\'');
if !word_start || literal[at] {
search = at + scheme;
continue;
}
let mut end = at + rest.find(|c: char| c.is_whitespace() || c == '<' || c == '>').unwrap_or(rest.len());
while end > at + scheme && matches!(bytes[end - 1], b'.' | b',' | b':' | b';' | b'!' | b'?' | b')' | b'\'' | b'"') {
end -= 1;
}
if end > at + scheme {
mark(flags, at..end, flag::LINK_TEXT);
literal[at..end].fill(true);
}
search = end.max(at + scheme);
}
}
/// A run of `*` or `_` that may open or close emphasis.
struct Delimiter {
ch: u8,
/// Where the run's unused delimiters start.
start: usize,
/// How many are left unused.
len: usize,
original_len: usize,
can_open: bool,
can_close: bool,
}
fn is_punctuation(c: char) -> bool {
c.is_ascii_punctuation() || (!c.is_alphanumeric() && !c.is_whitespace() && !c.is_control())
}
/// `*emphasis*`, `_emphasis_`, `**strong**` and `__strong__`, matched with
/// CommonMark's delimiter-run rules (flanking, intraword `_`, rule of three).
fn emphasis(line: &str, range: Range<usize>, flags: &mut [u16], literal: &[bool]) {
let bytes = line.as_bytes();
let mut runs: Vec<Delimiter> = Vec::new();
let mut i = range.start;
while i < range.end {
let ch = bytes[i];
if (ch != b'*' && ch != b'_') || literal[i] {
i += 1;
continue;
}
let mut len = 1;
while i + len < range.end && bytes[i + len] == ch && !literal[i + len] {
len += 1;
}
let before = line[..i].chars().next_back().unwrap_or(' ');
let after = line[i + len..].chars().next().unwrap_or(' ');
let left = !after.is_whitespace()
&& (!is_punctuation(after) || before.is_whitespace() || is_punctuation(before));
let right = !before.is_whitespace()
&& (!is_punctuation(before) || after.is_whitespace() || is_punctuation(after));
let (can_open, can_close) = if ch == b'*' {
(left, right)
} else {
(left && (!right || is_punctuation(before)), right && (!left || is_punctuation(after)))
};
if can_open || can_close {
runs.push(Delimiter { ch, start: i, len, original_len: len, can_open, can_close });
}
i += len;
}
for closer in 0..runs.len() {
if !runs[closer].can_close {
continue;
}
while runs[closer].len > 0 {
let opener = (0..closer).rev().find(|&o| {
let (o, c) = (&runs[o], &runs[closer]);
let odd_match = (o.can_close || c.can_open)
&& (o.original_len + c.original_len) % 3 == 0
&& !(o.original_len % 3 == 0 && c.original_len % 3 == 0);
o.ch == c.ch && o.can_open && o.len > 0 && !odd_match
});
let Some(opener) = opener else { break };
let used = if runs[opener].len >= 2 && runs[closer].len >= 2 { 2 } else { 1 };
let open_end = runs[opener].start + runs[opener].len;
let close_start = runs[closer].start;
mark(flags, open_end - used..open_end, flag::SYNTAX);
mark(flags, close_start..close_start + used, flag::SYNTAX);
mark(flags, open_end..close_start, if used == 2 { flag::STRONG } else { flag::EMPHASIS });
runs[opener].len -= used;
runs[closer].start += used;
runs[closer].len -= used;
for between in &mut runs[opener + 1..closer] {
between.len = 0;
}
}
}
}
#[cfg(test)]
mod tests {
// Not `super::*`: GPUI's glob exports its own `test` attribute.
use std::ops::Range;
use gpui_kit::{FontWeight, HighlightStyle};
use super::{MarkdownHighlighter, flag, metal, scan};
/// The flags of the bytes covered by `needle`'s first occurrence, which
/// must all agree.
fn flags_of(text: &str, needle: &str) -> u16 {
let at = text.find(needle).unwrap_or_else(|| panic!("{needle:?} not in {text:?}"));
flags_at(text, at..at + needle.len())
}
fn flags_at(text: &str, range: Range<usize>) -> u16 {
let spans = scan(text);
let value = |offset: usize| {
spans.iter().find(|(span, _)| span.contains(&offset)).map_or(0, |(_, flags)| *flags)
};
let first = value(range.start);
for offset in range.clone() {
assert_eq!(value(offset), first, "mixed flags in {:?} of {text:?}", &text[range.clone()]);
}
first
}
fn assert_well_formed(text: &str) {
let spans = scan(text);
let mut last = 0;
for (span, flags) in &spans {
assert!(span.start >= last && span.start < span.end, "{spans:?}");
assert!(*flags != 0);
assert!(text.is_char_boundary(span.start) && text.is_char_boundary(span.end), "{span:?}");
assert!(span.end <= text.len());
last = span.end;
}
}
/// `styles` must cover any requested range exactly, in order.
fn assert_covers(text: &str, range: Range<usize>) {
let mut highlighter = MarkdownHighlighter::new();
highlighter.rescan(text);
let runs = highlighter.styles_with(&range, &metal::BONE);
let mut at = range.start;
for (run, _) in &runs {
assert_eq!(run.start, at, "gap or overlap in {runs:?}");
assert!(run.end > run.start, "empty run in {runs:?}");
assert!(text.is_char_boundary(run.start) && text.is_char_boundary(run.end));
at = run.end;
}
assert_eq!(at, range.end, "runs end early: {runs:?}");
}
#[test]
fn headings() {
let text = "# Title\n###### Six\n####### seven\n#hashtag\n## Closed ##";
assert_eq!(flags_of(text, "#"), flag::HEADING | flag::SYNTAX);
assert_eq!(flags_of(text, "Title"), flag::HEADING);
assert_eq!(flags_of(text, "Six"), flag::HEADING);
assert_eq!(flags_of(text, "seven"), 0);
assert_eq!(flags_of(text, "#hashtag"), 0);
assert_eq!(flags_of(text, "Closed"), flag::HEADING);
let closing = text.rfind("##").unwrap();
assert_eq!(flags_at(text, closing..closing + 2), flag::HEADING | flag::SYNTAX);
assert_eq!(flags_of("# **Bold** head", "Bold"), flag::HEADING | flag::STRONG);
}
#[test]
fn emphasis_and_strong() {
let text = "a *one* b **two** c _three_ d __four__ e ***five***";
assert_eq!(flags_of(text, "one"), flag::EMPHASIS);
assert_eq!(flags_of(text, "two"), flag::STRONG);
assert_eq!(flags_of(text, "three"), flag::EMPHASIS);
assert_eq!(flags_of(text, "four"), flag::STRONG);
assert_eq!(flags_of(text, "five"), flag::STRONG | flag::EMPHASIS);
assert_eq!(flags_of(text, "**"), flag::SYNTAX);
assert_eq!(flags_of(text, " b "), 0);
}
#[test]
fn emphasis_that_is_not() {
// Intraword underscores, spaced-out stars and unclosed runs stay text.
for text in ["snake_case_name", "2 * 3 * 4", "a **b", "* not a list*either", "x__y__z"] {
let spans = scan(text);
assert!(spans.iter().all(|(_, flags)| flags & (flag::EMPHASIS | flag::STRONG) == 0), "{text:?}: {spans:?}");
}
// Stars inside a word still do.
assert_eq!(flags_of("un*frigging*believable", "frigging"), flag::EMPHASIS);
}
#[test]
fn nested_emphasis() {
let text = "**bold *both* bold**";
assert_eq!(flags_of(text, "both"), flag::STRONG | flag::EMPHASIS);
assert_eq!(flags_of(text, "bold "), flag::STRONG);
}
#[test]
fn inline_code() {
let text = "run `cargo *test*` now and ``a ` b``";
assert_eq!(flags_of(text, "cargo *test*"), flag::CODE);
assert_eq!(flags_of(text, "`"), flag::CODE | flag::SYNTAX);
assert_eq!(flags_of(text, "a ` b"), flag::CODE);
assert_eq!(flags_of(text, " now "), 0);
// An unmatched backtick is just a backtick.
assert_eq!(scan("a ` b"), vec![]);
}
#[test]
fn escapes() {
let text = r"\*not emphasis\* and \`not code\`";
assert_eq!(flags_of(text, "not emphasis"), 0);
assert_eq!(flags_of(text, "not code"), 0);
assert_eq!(flags_at(text, 0..1), flag::SYNTAX);
}
/// The flags of line `n`, which must agree across it.
fn line_flags(text: &str, n: usize) -> u16 {
let start: usize = text.split('\n').take(n).map(|line| line.len() + 1).sum();
let line = text.split('\n').nth(n).unwrap();
flags_at(text, start..start + line.len())
}
#[test]
fn fences_span_lines() {
let text = "before\n```rust\nlet x = *y*;\n# not a heading\n```\nafter *em*";
assert_eq!(line_flags(text, 0), 0);
assert_eq!(line_flags(text, 1), flag::FENCE);
assert_eq!(line_flags(text, 2), flag::CODE_BLOCK);
assert_eq!(line_flags(text, 3), flag::CODE_BLOCK);
assert_eq!(line_flags(text, 4), flag::FENCE);
assert_eq!(flags_of(text, "em"), flag::EMPHASIS);
}
#[test]
fn fences_need_a_matching_close() {
// A shorter run or another character doesn't close; an unclosed fence
// runs to the end, as it does on GitHub.
let text = "~~~~\n~~~\n```\nstill code\n~~~~~\nout";
assert_eq!(line_flags(text, 0), flag::FENCE);
assert_eq!(line_flags(text, 1), flag::CODE_BLOCK);
assert_eq!(line_flags(text, 2), flag::CODE_BLOCK);
assert_eq!(line_flags(text, 3), flag::CODE_BLOCK);
assert_eq!(line_flags(text, 4), flag::FENCE);
assert_eq!(line_flags(text, 5), 0);
assert_eq!(line_flags("```\nopen\nto the end", 2), flag::CODE_BLOCK);
// Backticks in the info string make it inline code, not a fence.
assert_eq!(flags_of("```a``` b", "b"), 0);
assert_eq!(flags_of("```a``` b", "a"), flag::CODE);
// Indented fences count, as inside list items.
assert_eq!(flags_of("1. step\n ```\n code\n ```\nout", "code"), flag::CODE_BLOCK);
assert_eq!(flags_of("1. step\n ```\n code\n ```\nout", "out"), 0);
}
#[test]
fn quotes_lists_and_rules() {
let text = "> quoted *em*";
assert_eq!(flags_of(text, ">"), flag::QUOTE | flag::SYNTAX);
assert_eq!(flags_of(text, "quoted"), flag::QUOTE);
assert_eq!(flags_of(text, "em"), flag::QUOTE | flag::EMPHASIS);
for (text, marker) in
[("- item", "-"), ("* star", "*"), ("+ plus", "+"), ("12. twelve", "12."), ("3) three", "3)"), (" - nested", "-")]
{
assert_eq!(flags_of(text, marker), flag::LIST_MARKER, "{text:?}");
assert_eq!(flags_at(text, text.len() - 3..text.len()), 0, "{text:?}");
}
assert_eq!(flags_of("- [x] done", "[x]"), flag::LIST_MARKER);
assert_eq!(flags_of("- [x] done", "done"), 0);
assert_eq!(flags_of("---", "---"), flag::SYNTAX);
assert_eq!(flags_of("* * *", "* * *"), flag::SYNTAX);
assert_eq!(flags_of("-not", "-not"), 0);
assert_eq!(flags_of("1.5 times", "1.5"), 0);
assert_eq!(flags_of("> - nested", "-"), flag::QUOTE | flag::LIST_MARKER);
}
#[test]
fn links_and_urls() {
let text = "see [the docs](https://x.dev/a_b_c) and  or https://t3.chat/x.";
assert_eq!(flags_of(text, "the docs"), flag::LINK_TEXT);
assert_eq!(flags_of(text, "https://x.dev/a_b_c"), flag::LINK_URL);
assert_eq!(flags_of(text, "]("), flag::SYNTAX);
assert_eq!(flags_of(text, "![") , flag::SYNTAX);
assert_eq!(flags_of(text, "https://t3.chat/x"), flag::LINK_TEXT);
assert_eq!(flags_at(text, text.len() - 1..text.len()), 0);
assert_eq!(flags_of("[not a link] (x)", "not a link"), 0);
}
#[test]
fn leading_commands() {
assert_eq!(flags_of("/review this *now*", "/review"), flag::COMMAND);
assert_eq!(flags_of("/review this *now*", "now"), flag::EMPHASIS);
assert_eq!(flags_of("\n $deploy-prod please", "$deploy-prod"), flag::COMMAND);
assert_eq!(flags_of("/plugin:cmd", "/plugin:cmd"), flag::COMMAND);
// Not leading, a path, or a price: plain text.
assert_eq!(flags_of("hi\n/review", "/review"), 0);
assert_eq!(flags_of("/home/joni is mine", "/home"), 0);
assert_eq!(flags_of("$5 please", "$5"), 0);
}
#[test]
fn unicode_text() {
let text = "# Grüße 👋\n**fett** und *kursiv* — `naïve`\n> ünïcödé [lïnk](ü)\n日本語の*強調*です";
assert_well_formed(text);
assert_eq!(flags_of(text, "Grüße 👋"), flag::HEADING);
assert_eq!(flags_of(text, "fett"), flag::STRONG);
assert_eq!(flags_of(text, "kursiv"), flag::EMPHASIS);
assert_eq!(flags_of(text, "naïve"), flag::CODE);
assert_eq!(flags_of(text, "lïnk"), flag::QUOTE | flag::LINK_TEXT);
assert_eq!(flags_of(text, "強調"), flag::EMPHASIS);
for end in (0..=text.len()).filter(|&i| text.is_char_boundary(i)) {
assert_covers(text, 0..end);
assert_covers(text, end..text.len());
}
}
#[test]
fn styles_cover_every_line_range() {
let text = "# H\n\n- a **b** `c`\r\n```\nx\n```\n> q [l](u)\n__u__ *e* ~ end";
assert_well_formed(text);
let mut starts = vec![0];
starts.extend(text.match_indices('\n').map(|(i, _)| i + 1));
starts.push(text.len());
for (i, &start) in starts.iter().enumerate() {
for &end in &starts[i..] {
assert_covers(text, start..end);
}
}
assert_covers("", 0..0);
assert!(MarkdownHighlighter::new().styles_with(&(0..0), &metal::BONE).is_empty());
}
#[test]
fn crlf_lines() {
let text = "**a**\r\n# b\r\n";
assert_well_formed(text);
assert_eq!(flags_of(text, "a"), flag::STRONG);
assert_eq!(flags_of(text, "b"), flag::HEADING);
assert_eq!(flags_of(text, "\r"), 0);
}
#[test]
fn styles_follow_flags() {
let mut highlighter = MarkdownHighlighter::new();
let text = "**b** `c`";
highlighter.rescan(text);
let runs = highlighter.styles_with(&(0..text.len()), &metal::GRAPHITE);
let style_at = |offset: usize| runs.iter().find(|(run, _)| run.contains(&offset)).unwrap().1;
assert_eq!(style_at(2).font_weight, Some(FontWeight::BOLD));
assert_eq!(style_at(0).color, Some(metal::GRAPHITE.ink3));
assert_eq!(style_at(7).background_color, Some(metal::GRAPHITE.well_top));
assert_eq!(style_at(5), HighlightStyle::default());
}
#[test]
fn a_few_hundred_lines_scan_fast() {
let block = "# Heading\nSome *text* with **bold**, `code` and [a link](https://x.y).\n- item one\n```\nfn main() {}\n```\n> quote\n";
let text = block.repeat(100);
let started = std::time::Instant::now();
for _ in 0..10 {
assert!(!scan(&text).is_empty());
}
assert!(started.elapsed() < std::time::Duration::from_millis(200), "{:?}", started.elapsed());
}
}