),
}
impl AnyDiv {
fn into_any_element(self) -> AnyElement {
match self {
Self::Div(div) => div.into_any_element(),
Self::Stateful(div) => div.into_any_element(),
}
}
}
impl From
for AnyDiv {
fn from(value: Div) -> Self {
Self::Div(value)
}
}
impl From
> for AnyDiv {
fn from(value: Stateful) -> Self {
Self::Stateful(value)
}
}
impl Styled for AnyDiv {
fn style(&mut self) -> &mut StyleRefinement {
match self {
Self::Div(div) => div.style(),
Self::Stateful(div) => div.style(),
}
}
}
impl ParentElement for AnyDiv {
fn extend(&mut self, elements: impl IntoIterator
- ) {
match self {
Self::Div(div) => div.extend(elements),
Self::Stateful(div) => div.extend(elements),
}
}
}
#[derive(Default)]
struct TableState {
alignments: Vec,
in_head: bool,
row_index: usize,
col_index: usize,
}
impl TableState {
fn start(&mut self, alignments: Vec) {
self.alignments = alignments;
self.in_head = false;
self.row_index = 0;
self.col_index = 0;
}
fn end(&mut self) {
self.alignments.clear();
self.in_head = false;
self.row_index = 0;
self.col_index = 0;
}
fn start_head(&mut self) {
self.in_head = true;
}
fn end_head(&mut self) {
self.in_head = false;
}
fn start_row(&mut self) {
self.col_index = 0;
}
fn end_row(&mut self) {
self.row_index += 1;
}
fn end_cell(&mut self) {
self.col_index += 1;
}
}
struct MarkdownElementBuilder {
div_stack: Vec,
rendered_lines: Vec,
pending_line: PendingLine,
rendered_links: Vec,
current_source_index: usize,
html_comment: bool,
base_text_style: TextStyle,
text_style_stack: Vec,
code_block_stack: Vec>>,
list_stack: Vec,
table: TableState,
syntax_theme: Arc,
}
#[derive(Default)]
struct PendingLine {
text: String,
runs: Vec,
source_mappings: Vec,
}
struct ListStackEntry {
bullet_index: Option,
}
impl MarkdownElementBuilder {
fn new(
container_style: &StyleRefinement,
base_text_style: TextStyle,
syntax_theme: Arc,
) -> Self {
Self {
div_stack: vec![{
let mut base_div = div();
base_div.style().refine(container_style);
base_div.debug_selector(|| "inner".into()).into()
}],
rendered_lines: Vec::new(),
pending_line: PendingLine::default(),
rendered_links: Vec::new(),
current_source_index: 0,
html_comment: false,
base_text_style,
text_style_stack: Vec::new(),
code_block_stack: Vec::new(),
list_stack: Vec::new(),
table: TableState::default(),
syntax_theme,
}
}
fn push_text_style(&mut self, style: TextStyleRefinement) {
self.text_style_stack.push(style);
}
fn text_style(&self) -> TextStyle {
let mut style = self.base_text_style.clone();
for refinement in &self.text_style_stack {
style.refine(refinement);
}
style
}
fn pop_text_style(&mut self) {
self.text_style_stack.pop();
}
fn push_div(&mut self, div: impl Into, range: &Range, markdown_end: usize) {
let mut div = div.into();
self.flush_text();
if range.start == 0 {
// Remove the top margin on the first element.
div.style().refine(&StyleRefinement {
margin: gpui::EdgesRefinement {
top: Some(Length::Definite(px(0.).into())),
left: None,
right: None,
bottom: None,
},
..Default::default()
});
}
if range.end == markdown_end {
div.style().refine(&StyleRefinement {
margin: gpui::EdgesRefinement {
top: None,
left: None,
right: None,
bottom: Some(Length::Definite(rems(0.).into())),
},
..Default::default()
});
}
self.div_stack.push(div);
}
fn push_root_block(&mut self, range: &Range, markdown_end: usize) {
self.push_div(
div().group("markdown-root-block").relative(),
range,
markdown_end,
);
self.push_div(div().pl_4(), range, markdown_end);
}
fn modify_current_div(&mut self, f: impl FnOnce(AnyDiv) -> AnyDiv) {
self.flush_text();
if let Some(div) = self.div_stack.pop() {
self.div_stack.push(f(div));
}
}
fn pop_root_block(
&mut self,
is_active: bool,
active_gutter_color: Hsla,
hovered_gutter_color: Hsla,
) {
self.pop_div();
self.modify_current_div(|el| {
el.child(
div()
.h_full()
.w(px(4.0))
.when(is_active, |this| this.bg(active_gutter_color))
.group_hover("markdown-root-block", |this| {
if is_active {
this
} else {
this.bg(hovered_gutter_color)
}
})
.rounded_xs()
.absolute()
.left_0()
.top_0(),
)
});
self.pop_div();
}
fn pop_div(&mut self) {
self.flush_text();
let div = self.div_stack.pop().unwrap().into_any_element();
self.div_stack.last_mut().unwrap().extend(iter::once(div));
}
fn push_sourced_element(&mut self, source_range: Range, element: impl Into) {
self.flush_text();
let anchor = self.render_source_anchor(source_range);
self.div_stack.last_mut().unwrap().extend([{
div()
.relative()
.child(anchor)
.child(element.into())
.into_any_element()
}]);
}
fn push_list(&mut self, bullet_index: Option) {
self.list_stack.push(ListStackEntry { bullet_index });
}
fn next_bullet_index(&mut self) -> Option {
self.list_stack.last_mut().and_then(|entry| {
let item_index = entry.bullet_index.as_mut()?;
*item_index += 1;
Some(*item_index - 1)
})
}
fn pop_list(&mut self) {
self.list_stack.pop();
}
fn push_code_block(&mut self, language: Option>) {
self.code_block_stack.push(language);
}
fn pop_code_block(&mut self) {
self.code_block_stack.pop();
}
fn push_link(&mut self, destination_url: SharedString, source_range: Range) {
self.rendered_links.push(RenderedLink {
source_range,
destination_url,
});
}
fn push_text(&mut self, text: &str, source_range: Range) {
self.pending_line.source_mappings.push(SourceMapping {
rendered_index: self.pending_line.text.len(),
source_index: source_range.start,
});
self.pending_line.text.push_str(text);
self.current_source_index = source_range.end;
if let Some(Some(language)) = self.code_block_stack.last() {
let mut offset = 0;
for (range, highlight_id) in language.highlight_text(&Rope::from(text), 0..text.len()) {
if range.start > offset {
self.pending_line
.runs
.push(self.text_style().to_run(range.start - offset));
}
let mut run_style = self.text_style();
if let Some(highlight) = self.syntax_theme.get(highlight_id).cloned() {
run_style = run_style.highlight(highlight);
}
self.pending_line.runs.push(run_style.to_run(range.len()));
offset = range.end;
}
if offset < text.len() {
self.pending_line
.runs
.push(self.text_style().to_run(text.len() - offset));
}
} else {
self.pending_line
.runs
.push(self.text_style().to_run(text.len()));
}
}
fn trim_trailing_newline(&mut self) {
if self.pending_line.text.ends_with('\n') {
self.pending_line
.text
.truncate(self.pending_line.text.len() - 1);
self.pending_line.runs.last_mut().unwrap().len -= 1;
self.current_source_index -= 1;
}
}
fn replace_pending_checkbox(&mut self, source_range: &Range) {
let trimmed = self.pending_line.text.trim();
if trimmed == "[x]" || trimmed == "[X]" || trimmed == "[ ]" {
let checked = trimmed != "[ ]";
self.pending_line = PendingLine::default();
let checkbox = Checkbox::new(
ElementId::Name(
format!("table_checkbox_{}_{}", source_range.start, source_range.end).into(),
),
if checked {
ToggleState::Selected
} else {
ToggleState::Unselected
},
)
.fill()
.visualization_only(true)
.into_any_element();
self.div_stack.last_mut().unwrap().extend([checkbox]);
}
}
fn render_source_anchor(&mut self, source_range: Range) -> AnyElement {
let mut text_style = self.base_text_style.clone();
text_style.color = Hsla::transparent_black();
let text = "\u{200B}";
let styled_text = StyledText::new(text).with_runs(vec![text_style.to_run(text.len())]);
self.rendered_lines.push(RenderedLine {
layout: styled_text.layout().clone(),
source_mappings: vec![SourceMapping {
rendered_index: 0,
source_index: source_range.start,
}],
source_end: source_range.end,
language: None,
});
div()
.absolute()
.top_0()
.left_0()
.opacity(0.)
.child(styled_text)
.into_any_element()
}
fn flush_text(&mut self) {
let line = mem::take(&mut self.pending_line);
if line.text.is_empty() {
return;
}
let text = StyledText::new(line.text).with_runs(line.runs);
self.rendered_lines.push(RenderedLine {
layout: text.layout().clone(),
source_mappings: line.source_mappings,
source_end: self.current_source_index,
language: self.code_block_stack.last().cloned().flatten(),
});
self.div_stack.last_mut().unwrap().extend([text.into_any()]);
}
fn build(mut self) -> RenderedMarkdown {
debug_assert_eq!(self.div_stack.len(), 1);
self.flush_text();
RenderedMarkdown {
element: self.div_stack.pop().unwrap().into_any_element(),
text: RenderedText {
lines: self.rendered_lines.into(),
links: self.rendered_links.into(),
},
}
}
}
struct RenderedLine {
layout: TextLayout,
source_mappings: Vec,
source_end: usize,
language: Option>,
}
impl RenderedLine {
fn rendered_index_for_source_index(&self, source_index: usize) -> usize {
if source_index >= self.source_end {
return self.layout.len();
}
let mapping = match self
.source_mappings
.binary_search_by_key(&source_index, |probe| probe.source_index)
{
Ok(ix) => &self.source_mappings[ix],
Err(ix) => &self.source_mappings[ix - 1],
};
(mapping.rendered_index + (source_index - mapping.source_index)).min(self.layout.len())
}
fn source_index_for_rendered_index(&self, rendered_index: usize) -> usize {
if rendered_index >= self.layout.len() {
return self.source_end;
}
let mapping = match self
.source_mappings
.binary_search_by_key(&rendered_index, |probe| probe.rendered_index)
{
Ok(ix) => &self.source_mappings[ix],
Err(ix) => &self.source_mappings[ix - 1],
};
mapping.source_index + (rendered_index - mapping.rendered_index)
}
/// Returns the source index for use as an exclusive range end at a word/selection boundary.
/// When the rendered index is exactly at the start of a segment with a gap from the previous
/// segment (e.g., after stripped markdown syntax like backticks), this returns the end of the
/// previous segment rather than the start of the current one.
fn source_index_for_exclusive_rendered_end(&self, rendered_index: usize) -> usize {
if rendered_index >= self.layout.len() {
return self.source_end;
}
let ix = match self
.source_mappings
.binary_search_by_key(&rendered_index, |probe| probe.rendered_index)
{
Ok(ix) => ix,
Err(ix) => {
return self.source_mappings[ix - 1].source_index
+ (rendered_index - self.source_mappings[ix - 1].rendered_index);
}
};
// Exact match at the start of a segment. Check if there's a gap from the previous segment.
if ix > 0 {
let prev_mapping = &self.source_mappings[ix - 1];
let mapping = &self.source_mappings[ix];
let prev_segment_len = mapping.rendered_index - prev_mapping.rendered_index;
let prev_source_end = prev_mapping.source_index + prev_segment_len;
if prev_source_end < mapping.source_index {
return prev_source_end;
}
}
self.source_mappings[ix].source_index
}
fn source_index_for_position(&self, position: Point) -> Result {
let line_rendered_index;
let out_of_bounds;
match self.layout.index_for_position(position) {
Ok(ix) => {
line_rendered_index = ix;
out_of_bounds = false;
}
Err(ix) => {
line_rendered_index = ix;
out_of_bounds = true;
}
};
let source_index = self.source_index_for_rendered_index(line_rendered_index);
if out_of_bounds {
Err(source_index)
} else {
Ok(source_index)
}
}
}
#[derive(Copy, Clone, Debug, Default)]
struct SourceMapping {
rendered_index: usize,
source_index: usize,
}
pub struct RenderedMarkdown {
element: AnyElement,
text: RenderedText,
}
#[derive(Clone)]
struct RenderedText {
lines: Rc<[RenderedLine]>,
links: Rc<[RenderedLink]>,
}
#[derive(Debug, Clone, Eq, PartialEq)]
struct RenderedLink {
source_range: Range,
destination_url: SharedString,
}
impl RenderedText {
fn source_index_for_position(&self, position: Point) -> Result {
let mut lines = self.lines.iter().peekable();
let mut fallback_line: Option<&RenderedLine> = None;
while let Some(line) = lines.next() {
let line_bounds = line.layout.bounds();
// Exact match: position is within bounds (handles overlapping bounds like table columns)
if line_bounds.contains(&position) {
return line.source_index_for_position(position);
}
// Track fallback for Y-coordinate based matching
if position.y <= line_bounds.bottom() && fallback_line.is_none() {
fallback_line = Some(line);
}
// Handle gap between lines
if position.y > line_bounds.bottom() {
if let Some(next_line) = lines.peek()
&& position.y < next_line.layout.bounds().top()
{
return Err(line.source_end);
}
}
}
// Fall back to Y-coordinate matched line
if let Some(line) = fallback_line {
return line.source_index_for_position(position);
}
Err(self.lines.last().map_or(0, |line| line.source_end))
}
fn position_for_source_index(&self, source_index: usize) -> Option<(Point, Pixels)> {
for line in self.lines.iter() {
let line_source_start = line.source_mappings.first().unwrap().source_index;
if source_index < line_source_start {
break;
} else if source_index > line.source_end {
continue;
} else {
let line_height = line.layout.line_height();
let rendered_index_within_line = line.rendered_index_for_source_index(source_index);
let position = line.layout.position_for_index(rendered_index_within_line)?;
return Some((position, line_height));
}
}
None
}
fn surrounding_word_range(&self, source_index: usize) -> Range {
for line in self.lines.iter() {
if source_index > line.source_end {
continue;
}
let line_rendered_start = line.source_mappings.first().unwrap().rendered_index;
let rendered_index_in_line =
line.rendered_index_for_source_index(source_index) - line_rendered_start;
let text = line.layout.text();
let scope = line.language.as_ref().map(|l| l.default_scope());
let classifier = CharClassifier::new(scope);
let mut prev_chars = text[..rendered_index_in_line].chars().rev().peekable();
let mut next_chars = text[rendered_index_in_line..].chars().peekable();
let word_kind = std::cmp::max(
prev_chars.peek().map(|&c| classifier.kind(c)),
next_chars.peek().map(|&c| classifier.kind(c)),
);
let mut start = rendered_index_in_line;
for c in prev_chars {
if Some(classifier.kind(c)) == word_kind {
start -= c.len_utf8();
} else {
break;
}
}
let mut end = rendered_index_in_line;
for c in next_chars {
if Some(classifier.kind(c)) == word_kind {
end += c.len_utf8();
} else {
break;
}
}
return line.source_index_for_rendered_index(line_rendered_start + start)
..line.source_index_for_exclusive_rendered_end(line_rendered_start + end);
}
source_index..source_index
}
fn surrounding_line_range(&self, source_index: usize) -> Range {
for line in self.lines.iter() {
if source_index > line.source_end {
continue;
}
let line_source_start = line.source_mappings.first().unwrap().source_index;
return line_source_start..line.source_end;
}
source_index..source_index
}
fn text_for_range(&self, range: Range) -> String {
let mut accumulator = String::new();
for line in self.lines.iter() {
if range.start > line.source_end {
continue;
}
let line_source_start = line.source_mappings.first().unwrap().source_index;
if range.end < line_source_start {
break;
}
let text = line.layout.text();
let start = if range.start < line_source_start {
0
} else {
line.rendered_index_for_source_index(range.start)
};
let end = if range.end > line.source_end {
line.rendered_index_for_source_index(line.source_end)
} else {
line.rendered_index_for_source_index(range.end)
}
.min(text.len());
accumulator.push_str(&text[start..end]);
accumulator.push('\n');
}
// Remove trailing newline
accumulator.pop();
accumulator
}
fn link_for_position(&self, position: Point) -> Option<&RenderedLink> {
let source_index = self.source_index_for_position(position).ok()?;
self.links
.iter()
.find(|link| link.source_range.contains(&source_index))
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpui::{TestAppContext, size};
use language::{Language, LanguageConfig, LanguageMatcher};
use std::sync::Arc;
fn ensure_theme_initialized(cx: &mut TestAppContext) {
cx.update(|cx| {
if !cx.has_global::() {
settings::init(cx);
}
if !cx.has_global::() {
theme_settings::init(theme::LoadThemes::JustBase, cx);
}
});
}
#[gpui::test]
fn test_mappings(cx: &mut TestAppContext) {
// Formatting.
assert_mappings(
&render_markdown("He*l*lo", cx),
vec![vec![(0, 0), (1, 1), (2, 3), (3, 5), (4, 6), (5, 7)]],
);
// Multiple lines.
assert_mappings(
&render_markdown("Hello\n\nWorld", cx),
vec![
vec![(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
vec![(0, 7), (1, 8), (2, 9), (3, 10), (4, 11), (5, 12)],
],
);
// Multi-byte characters.
assert_mappings(
&render_markdown("αβγ\n\nδεζ", cx),
vec![
vec![(0, 0), (2, 2), (4, 4), (6, 6)],
vec![(0, 8), (2, 10), (4, 12), (6, 14)],
],
);
// Smart quotes.
assert_mappings(&render_markdown("\"", cx), vec![vec![(0, 0), (3, 1)]]);
assert_mappings(
&render_markdown("\"hey\"", cx),
vec![vec![(0, 0), (3, 1), (4, 2), (5, 3), (6, 4), (9, 5)]],
);
// HTML Comments are ignored
assert_mappings(
&render_markdown(
"\nReturns",
cx,
),
vec![vec![
(0, 78),
(1, 79),
(2, 80),
(3, 81),
(4, 82),
(5, 83),
(6, 84),
]],
);
}
fn render_markdown(markdown: &str, cx: &mut TestAppContext) -> RenderedText {
render_markdown_with_language_registry(markdown, None, cx)
}
fn render_markdown_with_language_registry(
markdown: &str,
language_registry: Option>,
cx: &mut TestAppContext,
) -> RenderedText {
render_markdown_with_options(markdown, language_registry, MarkdownOptions::default(), cx)
}
fn render_markdown_with_options(
markdown: &str,
language_registry: Option>,
options: MarkdownOptions,
cx: &mut TestAppContext,
) -> RenderedText {
struct TestWindow;
impl Render for TestWindow {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
div()
}
}
ensure_theme_initialized(cx);
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
let markdown = cx.new(|cx| {
Markdown::new_with_options(
markdown.to_string().into(),
language_registry,
None,
options,
cx,
)
});
cx.run_until_parked();
let (rendered, _) = cx.draw(
Default::default(),
size(px(600.0), px(600.0)),
|_window, _cx| {
MarkdownElement::new(markdown, MarkdownStyle::default()).code_block_renderer(
CodeBlockRenderer::Default {
copy_button_visibility: CopyButtonVisibility::Hidden,
border: false,
},
)
},
);
rendered.text
}
#[gpui::test]
fn test_surrounding_word_range(cx: &mut TestAppContext) {
let rendered = render_markdown("Hello world tesεζ", cx);
// Test word selection for "Hello"
let word_range = rendered.surrounding_word_range(2); // Simulate click on 'l' in "Hello"
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "Hello");
// Test word selection for "world"
let word_range = rendered.surrounding_word_range(7); // Simulate click on 'o' in "world"
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "world");
// Test word selection for "tesεζ"
let word_range = rendered.surrounding_word_range(14); // Simulate click on 's' in "tesεζ"
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "tesεζ");
// Test word selection at word boundary (space)
let word_range = rendered.surrounding_word_range(5); // Simulate click on space between "Hello" and "world", expect highlighting word to the left
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "Hello");
}
#[gpui::test]
fn test_surrounding_line_range(cx: &mut TestAppContext) {
let rendered = render_markdown("First line\n\nSecond line\n\nThird lineεζ", cx);
// Test getting line range for first line
let line_range = rendered.surrounding_line_range(5); // Simulate click somewhere in first line
let selected_text = rendered.text_for_range(line_range);
assert_eq!(selected_text, "First line");
// Test getting line range for second line
let line_range = rendered.surrounding_line_range(13); // Simulate click at beginning in second line
let selected_text = rendered.text_for_range(line_range);
assert_eq!(selected_text, "Second line");
// Test getting line range for third line
let line_range = rendered.surrounding_line_range(37); // Simulate click at end of third line with multi-byte chars
let selected_text = rendered.text_for_range(line_range);
assert_eq!(selected_text, "Third lineεζ");
}
#[gpui::test]
fn test_selection_head_movement(cx: &mut TestAppContext) {
let rendered = render_markdown("Hello world test", cx);
let mut selection = Selection {
start: 5,
end: 5,
reversed: false,
pending: false,
mode: SelectMode::Character,
};
// Test forward selection
selection.set_head(10, &rendered);
assert_eq!(selection.start, 5);
assert_eq!(selection.end, 10);
assert!(!selection.reversed);
assert_eq!(selection.tail(), 5);
// Test backward selection
selection.set_head(2, &rendered);
assert_eq!(selection.start, 2);
assert_eq!(selection.end, 5);
assert!(selection.reversed);
assert_eq!(selection.tail(), 5);
// Test forward selection again from reversed state
selection.set_head(15, &rendered);
assert_eq!(selection.start, 5);
assert_eq!(selection.end, 15);
assert!(!selection.reversed);
assert_eq!(selection.tail(), 5);
}
#[gpui::test]
fn test_word_selection_drag(cx: &mut TestAppContext) {
let rendered = render_markdown("Hello world test", cx);
// Start with a simulated double-click on "world" (index 6-10)
let word_range = rendered.surrounding_word_range(7); // Click on 'o' in "world"
let mut selection = Selection {
start: word_range.start,
end: word_range.end,
reversed: false,
pending: true,
mode: SelectMode::Word(word_range),
};
// Drag forward to "test" - should expand selection to include "test"
selection.set_head(13, &rendered); // Index in "test"
assert_eq!(selection.start, 6); // Start of "world"
assert_eq!(selection.end, 16); // End of "test"
assert!(!selection.reversed);
let selected_text = rendered.text_for_range(selection.start..selection.end);
assert_eq!(selected_text, "world test");
// Drag backward to "Hello" - should expand selection to include "Hello"
selection.set_head(2, &rendered); // Index in "Hello"
assert_eq!(selection.start, 0); // Start of "Hello"
assert_eq!(selection.end, 11); // End of "world" (original selection)
assert!(selection.reversed);
let selected_text = rendered.text_for_range(selection.start..selection.end);
assert_eq!(selected_text, "Hello world");
// Drag back within original word - should revert to original selection
selection.set_head(8, &rendered); // Back within "world"
assert_eq!(selection.start, 6); // Start of "world"
assert_eq!(selection.end, 11); // End of "world"
assert!(!selection.reversed);
let selected_text = rendered.text_for_range(selection.start..selection.end);
assert_eq!(selected_text, "world");
}
#[gpui::test]
fn test_selection_with_markdown_formatting(cx: &mut TestAppContext) {
let rendered = render_markdown(
"This is **bold** text, this is *italic* text, use `code` here",
cx,
);
let word_range = rendered.surrounding_word_range(10); // Inside "bold"
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "bold");
let word_range = rendered.surrounding_word_range(32); // Inside "italic"
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "italic");
let word_range = rendered.surrounding_word_range(51); // Inside "code"
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "code");
}
#[gpui::test]
fn test_table_column_selection(cx: &mut TestAppContext) {
let rendered = render_markdown("| a | b |\n|---|---|\n| c | d |", cx);
assert!(rendered.lines.len() >= 2);
let first_bounds = rendered.lines[0].layout.bounds();
let second_bounds = rendered.lines[1].layout.bounds();
let first_index = match rendered.source_index_for_position(first_bounds.center()) {
Ok(index) | Err(index) => index,
};
let second_index = match rendered.source_index_for_position(second_bounds.center()) {
Ok(index) | Err(index) => index,
};
let first_word = rendered.text_for_range(rendered.surrounding_word_range(first_index));
let second_word = rendered.text_for_range(rendered.surrounding_word_range(second_index));
assert_eq!(first_word, "a");
assert_eq!(second_word, "b");
}
#[test]
fn test_table_checkbox_detection() {
let md = "| Done |\n|------|\n| [x] |\n| [ ] |";
let events = crate::parser::parse_markdown_with_options(md, false, false).events;
let mut in_table = false;
let mut cell_texts: Vec = Vec::new();
let mut current_cell = String::new();
for (range, event) in &events {
match event {
MarkdownEvent::Start(MarkdownTag::Table(_)) => in_table = true,
MarkdownEvent::End(MarkdownTagEnd::Table) => in_table = false,
MarkdownEvent::Start(MarkdownTag::TableCell) => current_cell.clear(),
MarkdownEvent::End(MarkdownTagEnd::TableCell) => {
if in_table {
cell_texts.push(current_cell.clone());
}
}
MarkdownEvent::Text if in_table => {
current_cell.push_str(&md[range.clone()]);
}
_ => {}
}
}
let checkbox_cells: Vec<&String> = cell_texts
.iter()
.filter(|t| {
let trimmed = t.trim();
trimmed == "[x]" || trimmed == "[X]" || trimmed == "[ ]"
})
.collect();
assert_eq!(
checkbox_cells.len(),
2,
"Expected 2 checkbox cells, got: {cell_texts:?}"
);
assert_eq!(checkbox_cells[0].trim(), "[x]");
assert_eq!(checkbox_cells[1].trim(), "[ ]");
}
#[gpui::test]
fn test_inline_code_word_selection_excludes_backticks(cx: &mut TestAppContext) {
// Test that double-clicking on inline code selects just the code content,
// not the backticks. This verifies the fix for the bug where selecting
// inline code would include the trailing backtick.
let rendered = render_markdown("use `blah` here", cx);
// Source layout: "use `blah` here"
// 0123456789...
// The inline code "blah" is at source positions 5-8 (content range 5..9)
// Click inside "blah" - should select just "blah", not "blah`"
let word_range = rendered.surrounding_word_range(6); // 'l' in "blah"
// text_for_range extracts from the rendered text (without backticks), so it
// would return "blah" even with a wrong source range. We check it anyway.
let selected_text = rendered.text_for_range(word_range.clone());
assert_eq!(selected_text, "blah");
// The source range is what matters for copy_as_markdown and selected_text,
// which extract directly from the source. With the bug, this would be 5..10
// which includes the closing backtick at position 9.
assert_eq!(word_range, 5..9);
}
#[gpui::test]
fn test_surrounding_word_range_respects_word_characters(cx: &mut TestAppContext) {
let rendered = render_markdown("foo.bar() baz", cx);
// Double clicking on 'f' in "foo" - should select just "foo"
let word_range = rendered.surrounding_word_range(0);
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "foo");
// Double clicking on 'b' in "bar" - should select just "bar"
let word_range = rendered.surrounding_word_range(4);
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "bar");
// Double clicking on 'b' in "baz" - should select "baz"
let word_range = rendered.surrounding_word_range(10);
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "baz");
// Double clicking selects word characters in code blocks
let javascript_language = Arc::new(Language::new(
LanguageConfig {
name: "JavaScript".into(),
matcher: LanguageMatcher {
path_suffixes: vec!["js".to_string()],
..Default::default()
},
word_characters: ['$', '#'].into_iter().collect(),
..Default::default()
},
None,
));
let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
language_registry.add(javascript_language);
let rendered = render_markdown_with_language_registry(
"```javascript\n$foo #bar\n```",
Some(language_registry),
cx,
);
let word_range = rendered.surrounding_word_range(14);
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "$foo");
let word_range = rendered.surrounding_word_range(19);
let selected_text = rendered.text_for_range(word_range);
assert_eq!(selected_text, "#bar");
}
#[gpui::test]
fn test_all_selection(cx: &mut TestAppContext) {
let rendered = render_markdown("Hello world\n\nThis is a test\n\nwith multiple lines", cx);
let total_length = rendered
.lines
.last()
.map(|line| line.source_end)
.unwrap_or(0);
let mut selection = Selection {
start: 0,
end: total_length,
reversed: false,
pending: true,
mode: SelectMode::All,
};
selection.set_head(5, &rendered); // Try to set head in middle
assert_eq!(selection.start, 0);
assert_eq!(selection.end, total_length);
assert!(!selection.reversed);
selection.set_head(25, &rendered); // Try to set head near end
assert_eq!(selection.start, 0);
assert_eq!(selection.end, total_length);
assert!(!selection.reversed);
let selected_text = rendered.text_for_range(selection.start..selection.end);
assert_eq!(
selected_text,
"Hello world\nThis is a test\nwith multiple lines"
);
}
fn nbsp(n: usize) -> String {
"\u{00A0}".repeat(n)
}
#[test]
fn test_escape_plain_text() {
assert_eq!(Markdown::escape("hello world"), "hello world");
assert_eq!(Markdown::escape(""), "");
assert_eq!(Markdown::escape("café ☕ naïve"), "café ☕ naïve");
}
#[test]
fn test_escape_punctuation() {
assert_eq!(Markdown::escape("hello `world`"), r"hello \`world\`");
assert_eq!(Markdown::escape("a|b"), r"a\|b");
}
#[test]
fn test_escape_leading_spaces() {
assert_eq!(Markdown::escape(" hello"), [ (4), "hello"].concat());
assert_eq!(
Markdown::escape(" | { a: string }"),
[ (4), r"\| \{ a\: string \}"].concat()
);
assert_eq!(
Markdown::escape(" first\n second"),
[ (2), "first\n\n", (2), "second"].concat()
);
assert_eq!(Markdown::escape("hello world"), "hello world");
}
#[test]
fn test_escape_leading_tabs() {
assert_eq!(Markdown::escape("\thello"), [ (4), "hello"].concat());
assert_eq!(
Markdown::escape("hello\n\t\tindented"),
["hello\n\n", (8), "indented"].concat()
);
assert_eq!(
Markdown::escape(" \t hello"),
[ (1 + 4 + 1), "hello"].concat()
);
assert_eq!(Markdown::escape("hello\tworld"), "hello\tworld");
}
#[test]
fn test_escape_newlines() {
assert_eq!(Markdown::escape("a\nb"), "a\n\nb");
assert_eq!(Markdown::escape("a\n\nb"), "a\n\n\n\nb");
assert_eq!(Markdown::escape("\nhello"), "\n\nhello");
}
#[test]
fn test_escape_multiline_diagnostic() {
assert_eq!(
Markdown::escape(" | { a: string }\n | { b: number }"),
[
(4),
r"\| \{ a\: string \}",
"\n\n",
(4),
r"\| \{ b\: number \}",
]
.concat()
);
}
fn has_code_block(markdown: &str) -> bool {
let parsed_data = parse_markdown_with_options(markdown, false, false);
parsed_data
.events
.iter()
.any(|(_, event)| matches!(event, MarkdownEvent::Start(MarkdownTag::CodeBlock { .. })))
}
#[test]
fn test_escape_output_len_matches_precomputed() {
let cases = [
"",
"hello world",
"hello `world`",
" hello",
" | { a: string }",
"\thello",
"hello\n\t\tindented",
" \t hello",
"hello\tworld",
"a\nb",
"a\n\nb",
"\nhello",
" | { a: string }\n | { b: number }",
"café ☕ naïve",
];
for input in cases {
let mut escaper = MarkdownEscaper::new();
let precomputed: usize = input.bytes().map(|b| escaper.next(b).output_len()).sum();
let mut escaper = MarkdownEscaper::new();
let mut output = String::new();
for c in input.chars() {
escaper.next(c as u8).write_to(c, &mut output);
}
assert_eq!(precomputed, output.len(), "length mismatch for {:?}", input);
}
}
#[test]
fn test_escape_prevents_code_block() {
let diagnostic = " | { a: string }";
assert!(has_code_block(diagnostic));
assert!(!has_code_block(&Markdown::escape(diagnostic)));
}
#[track_caller]
fn assert_mappings(rendered: &RenderedText, expected: Vec>) {
assert_eq!(rendered.lines.len(), expected.len(), "line count mismatch");
for (line_ix, line_mappings) in expected.into_iter().enumerate() {
let line = &rendered.lines[line_ix];
assert!(
line.source_mappings.windows(2).all(|mappings| {
mappings[0].source_index < mappings[1].source_index
&& mappings[0].rendered_index < mappings[1].rendered_index
}),
"line {} has duplicate mappings: {:?}",
line_ix,
line.source_mappings
);
for (rendered_ix, source_ix) in line_mappings {
assert_eq!(
line.source_index_for_rendered_index(rendered_ix),
source_ix,
"line {}, rendered_ix {}",
line_ix,
rendered_ix
);
assert_eq!(
line.rendered_index_for_source_index(source_ix),
rendered_ix,
"line {}, source_ix {}",
line_ix,
source_ix
);
}
}
}
}