),
}
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;
}
fn current_cell_alignment(&self) -> Option {
if self.alignments.is_empty() {
return None;
}
if self.in_head {
return Some(Alignment::Center);
}
self.alignments.get(self.col_index).copied()
}
}
fn alignment_to_text_align(alignment: Alignment) -> Option {
match alignment {
Alignment::Left => Some(TextAlign::Left),
Alignment::Center => Some(TextAlign::Center),
Alignment::Right => Some(TextAlign::Right),
Alignment::None => None,
}
}
struct MetadataCellStyle {
row_index: usize,
is_key: bool,
}
struct MarkdownElementBuilder {
div_stack: Vec,
rendered_lines: Vec,
pending_line: PendingLine,
rendered_links: Vec,
rendered_image_links: Vec,
rendered_footnote_refs: Vec,
current_source_index: usize,
html_comment: bool,
rendered_footnote_separator: bool,
base_text_style: TextStyle,
text_style_stack: Vec,
code_block_stack: Vec>>,
link_depth: usize,
list_stack: Vec,
table: TableState,
syntax_theme: Arc,
}
struct DivStackEntry {
div: AnyDiv,
line_break_mode: LineBreakMode,
}
#[derive(Clone, Copy, Eq, PartialEq)]
enum LineBreakMode {
TextLayout,
FlexWrap,
}
impl DivStackEntry {
fn new(div: impl Into) -> Self {
Self {
div: div.into(),
line_break_mode: LineBreakMode::TextLayout,
}
}
}
#[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);
DivStackEntry::new(base_div.debug_selector(|| "inner".into()))
}],
rendered_lines: Vec::new(),
pending_line: PendingLine::default(),
rendered_links: Vec::new(),
rendered_image_links: Vec::new(),
rendered_footnote_refs: Vec::new(),
current_source_index: 0,
html_comment: false,
rendered_footnote_separator: false,
base_text_style,
text_style_stack: Vec::new(),
code_block_stack: Vec::new(),
link_depth: 0,
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(DivStackEntry::new(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 push_image_child(&mut self, child: impl IntoElement) {
self.modify_current_div(|el| el.flex().flex_row().flex_wrap().items_start());
self.div_stack.last_mut().unwrap().line_break_mode = LineBreakMode::FlexWrap;
self.append_child(child.into_any_element());
}
fn push_line_break(&mut self, source_range: Range) {
if self.uses_flex_line_breaks() {
self.modify_current_div(|el| el.child(div().w_full().h_0()));
} else {
self.push_text("\n", source_range);
}
}
fn push_soft_break(&mut self, source_range: Range) {
// A soft break right after an item in flex wrap container would otherwise
// render as a stray leading space before the next wrapped item.
if self.uses_flex_line_breaks() && self.pending_line.text.is_empty() {
return;
}
self.push_text(" ", source_range);
}
fn append_child(&mut self, child: AnyElement) {
self.div_stack.last_mut().unwrap().div.extend([child]);
}
fn uses_flex_line_breaks(&self) -> bool {
self.div_stack
.last()
.is_some_and(|entry| entry.line_break_mode == LineBreakMode::FlexWrap)
}
fn modify_current_div(&mut self, f: impl FnOnce(AnyDiv) -> AnyDiv) {
self.flush_text();
if let Some(mut entry) = self.div_stack.pop() {
entry.div = f(entry.div);
self.div_stack.push(entry);
}
}
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().div.into_any_element();
self.append_child(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.append_child(
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_image_link(
&mut self,
destination_url: SharedString,
bounds: Rc>>>,
) {
self.rendered_image_links.push(RenderedImageLink {
bounds,
destination_url,
});
}
fn push_footnote_ref(&mut self, label: SharedString, source_range: Range) {
self.rendered_footnote_refs.push(RenderedFootnoteRef {
source_range,
label,
});
}
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;
// Compute the base text style once
let text_style = self.text_style();
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(text_style.to_run(range.start - offset));
}
let run_len = range.len();
if let Some(highlight) = self.syntax_theme.get(highlight_id).cloned() {
self.pending_line
.runs
.push(text_style.clone().highlight(highlight).to_run(run_len));
} else {
self.pending_line.runs.push(text_style.to_run(run_len));
}
offset = range.end;
}
if offset < text.len() {
self.pending_line
.runs
.push(text_style.to_run(text.len() - offset));
}
} else {
self.pending_line.runs.push(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, on_toggle: Option) {
let text = &self.pending_line.text;
let trimmed = text.trim();
if trimmed != "[x]" && trimmed != "[X]" && trimmed != "[ ]" {
return;
}
let checked = trimmed != "[ ]";
let leading_ws = text.len() - text.trim_start().len();
let marker_rendered = leading_ws..leading_ws + trimmed.len();
let marker_source = self
.source_range_for_rendered(&marker_rendered)
.expect("pending checkbox text must have source mappings");
self.pending_line = PendingLine::default();
let toggle_state = if checked {
ToggleState::Selected
} else {
ToggleState::Unselected
};
let checkbox = Checkbox::new(
ElementId::Name(
format!(
"table_checkbox_{}_{}",
marker_source.start, marker_source.end
)
.into(),
),
toggle_state,
)
.fill();
let checkbox = if let Some(on_toggle) = on_toggle {
checkbox
.on_click(move |_state, window, cx| {
on_toggle(marker_source.clone(), !checked, window, cx);
})
.into_any_element()
} else {
checkbox.visualization_only(true).into_any_element()
};
let mut checkbox_container = h_flex().w_full();
checkbox_container = match self.text_style().text_align {
TextAlign::Left => checkbox_container.justify_start(),
TextAlign::Center => checkbox_container.justify_center(),
TextAlign::Right => checkbox_container.justify_end(),
};
self.append_child(checkbox_container.child(checkbox).into_any_element());
}
fn source_range_for_rendered(&self, rendered: &Range) -> Option> {
source_range_for_rendered(&self.pending_line.source_mappings, rendered)
}
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,
text_align: TextAlign::Left,
});
div()
.absolute()
.top_0()
.left_0()
.opacity(0.)
.child(styled_text)
.into_any_element()
}
fn flush_text(&mut self) {
let text_align = self.text_style().text_align;
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(),
text_align,
});
self.append_child(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().div.into_any_element(),
text: RenderedText {
lines: self.rendered_lines.into(),
links: self.rendered_links.into(),
image_links: self.rendered_image_links.into(),
footnote_refs: self.rendered_footnote_refs.into(),
},
}
}
}
struct RenderedLine {
layout: TextLayout,
source_mappings: Vec,
source_end: usize,
language: Option>,
text_align: TextAlign,
}
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 alignment_offset_for_segment(
&self,
available_width: Pixels,
segment_start_x: Pixels,
segment_end_x: Pixels,
) -> Pixels {
let segment_width = segment_end_x - segment_start_x;
match self.text_align {
TextAlign::Left => px(0.),
TextAlign::Center => ((available_width - segment_width) / 2.).max(px(0.)),
TextAlign::Right => (available_width - segment_width).max(px(0.)),
}
}
fn source_index_for_position(&self, position: Point) -> Result {
let adjusted_position = maybe!({
if self.text_align == TextAlign::Left {
return None;
}
let Some(wrapped_line) = self.layout.line_layout_for_index(0) else {
return None;
};
let bounds = self.layout.bounds();
let line_height = self.layout.line_height();
let relative_y = (position.y - bounds.top()).max(px(0.));
let wrapped_row_ix = (relative_y / line_height) as usize;
let boundaries = wrapped_line.wrap_boundaries();
let segment_start_x = if wrapped_row_ix == 0 {
px(0.)
} else {
boundaries
.get(wrapped_row_ix - 1)
.map(|b| {
wrapped_line.unwrapped_layout.runs[b.run_ix].glyphs[b.glyph_ix]
.position
.x
})
.unwrap_or(px(0.))
};
let segment_end_x = boundaries
.get(wrapped_row_ix)
.map(|b| {
wrapped_line.unwrapped_layout.runs[b.run_ix].glyphs[b.glyph_ix]
.position
.x
})
.unwrap_or(wrapped_line.unwrapped_layout.width);
let alignment_offset = self.alignment_offset_for_segment(
bounds.size.width,
segment_start_x,
segment_end_x,
);
Some(point(position.x - alignment_offset, position.y))
})
.unwrap_or(position);
let line_rendered_index;
let out_of_bounds;
match self.layout.index_for_position(adjusted_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,
}
fn source_range_for_rendered(
mappings: &[SourceMapping],
rendered: &Range,
) -> Option> {
if rendered.start >= rendered.end {
return None;
}
let start = source_index_for_rendered(mappings, rendered.start)?;
let end = source_index_for_rendered(mappings, rendered.end - 1)? + 1;
Some(start..end)
}
fn source_index_for_rendered(mappings: &[SourceMapping], rendered_index: usize) -> Option {
let mut last: Option<&SourceMapping> = None;
for mapping in mappings {
if mapping.rendered_index <= rendered_index {
last = Some(mapping);
} else {
break;
}
}
last.map(|m| m.source_index + (rendered_index - m.rendered_index))
}
pub struct RenderedMarkdown {
element: AnyElement,
text: RenderedText,
}
#[derive(Clone)]
struct RenderedText {
lines: Rc<[RenderedLine]>,
links: Rc<[RenderedLink]>,
image_links: Rc<[RenderedImageLink]>,
footnote_refs: Rc<[RenderedFootnoteRef]>,
}
struct WrappedLineSegment {
start: usize,
end: usize,
row_top: Pixels,
layout: Arc,
}
#[derive(Debug, Clone, Eq, PartialEq)]
struct RenderedLink {
source_range: Range,
destination_url: SharedString,
}
#[derive(Clone)]
struct RenderedImageLink {
// Populated once the image's `canvas` overlay is painted; images aren't part of the
// text layout, so their hit-test region can't be derived from a source range.
bounds: Rc>>>,
destination_url: SharedString,
}
#[derive(Debug, Clone, Eq, PartialEq)]
struct RenderedFootnoteRef {
source_range: Range,
label: SharedString,
}
impl RenderedText {
fn bounds_for_source_range(&self, range: Range) -> Vec> {
self.bounds_for_sorted_source_ranges([(0, range)])
.into_iter()
.map(|(_, bounds)| bounds)
.collect()
}
fn bounds_for_sorted_source_ranges(
&self,
ranges: impl IntoIterator
- )>,
) -> Vec<(usize, Bounds)> {
let ranges = ranges.into_iter().collect::>();
let mut all_bounds = Vec::new();
let mut first_possible_range_ix = 0;
for line in self.lines.iter() {
let line_source_start = line.source_mappings.first().unwrap().source_index;
while ranges
.get(first_possible_range_ix)
.is_some_and(|(_, range)| range.end <= line_source_start)
{
first_possible_range_ix += 1;
}
let Some((_, first_possible_range)) = ranges.get(first_possible_range_ix) else {
break;
};
if first_possible_range.start >= line.source_end {
continue;
}
let wrapped_line_segments = Self::wrapped_line_segments(line);
if wrapped_line_segments.is_empty() {
continue;
}
let mut range_ix = first_possible_range_ix;
while let Some((highlight_ix, range)) = ranges.get(range_ix) {
if range.start >= line.source_end {
break;
}
Self::push_bounds_for_line_source_range(
&mut all_bounds,
*highlight_ix,
line,
&wrapped_line_segments,
range.start.max(line_source_start)..range.end.min(line.source_end),
);
range_ix += 1;
}
}
all_bounds
}
fn wrapped_line_segments(line: &RenderedLine) -> SmallVec<[WrappedLineSegment; 1]> {
let layout = &line.layout;
let line_height = layout.line_height();
let mut row_top = layout.bounds().top();
let mut wrapped_line_start = 0;
let mut segments = SmallVec::new();
for wrapped_line in layout.line_layouts() {
let wrapped_line_end = wrapped_line_start + wrapped_line.len();
let wrapped_line_height = wrapped_line.size(line_height).height;
segments.push(WrappedLineSegment {
start: wrapped_line_start,
end: wrapped_line_end,
row_top,
layout: wrapped_line,
});
row_top += wrapped_line_height;
wrapped_line_start = wrapped_line_end + 1;
}
segments
}
fn push_bounds_for_line_source_range(
all_bounds: &mut Vec<(usize, Bounds)>,
highlight_ix: usize,
line: &RenderedLine,
wrapped_line_segments: &[WrappedLineSegment],
range: Range,
) {
if range.start >= range.end {
return;
}
let layout = &line.layout;
let line_bounds = layout.bounds();
let line_height = layout.line_height();
let rendered_start = line.rendered_index_for_source_index(range.start);
let rendered_end = line.rendered_index_for_source_index(range.end);
for wrapped_line_segment in wrapped_line_segments {
if wrapped_line_segment.start >= rendered_end {
break;
}
if wrapped_line_segment.end <= rendered_start {
continue;
}
let wrapped_line = &wrapped_line_segment.layout;
let unwrapped_layout = &wrapped_line.unwrapped_layout;
let wrapped_line_start = wrapped_line_segment.start;
let wrapped_line_end = wrapped_line_segment.end;
let mut row_top = wrapped_line_segment.row_top;
let row_ends = wrapped_line
.wrap_boundaries()
.iter()
.map(|wrap_boundary| {
let glyph =
&unwrapped_layout.runs[wrap_boundary.run_ix].glyphs[wrap_boundary.glyph_ix];
(wrapped_line_start + glyph.index, glyph.position.x)
})
.chain([(wrapped_line_end, unwrapped_layout.width)]);
let mut row_start = wrapped_line_start;
let mut row_start_x = Pixels::ZERO;
for (row_end, row_end_x) in row_ends {
let selection_start = rendered_start.max(row_start);
let selection_end = rendered_end.min(row_end);
if selection_start < selection_end {
let alignment_offset = line.alignment_offset_for_segment(
line_bounds.size.width,
row_start_x,
row_end_x,
);
let x_for_index = |index| {
line_bounds.left()
+ alignment_offset
+ unwrapped_layout.x_for_index(index - wrapped_line_start)
- row_start_x
};
all_bounds.push((
highlight_ix,
Bounds::from_corners(
point(x_for_index(selection_start), row_top),
point(x_for_index(selection_end), row_top + line_height),
),
));
}
row_start = row_end;
row_start_x = row_end_x;
row_top += line_height;
}
}
}
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() {
if source_index > line.source_end {
continue;
}
let line_source_start = line.source_mappings.first().unwrap().source_index;
let source_index = source_index.max(line_source_start);
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_source_index(&self, source_index: usize) -> Option<&RenderedLink> {
self.links
.iter()
.find(|link| link.source_range.contains(&source_index))
}
fn image_link_for_position(&self, position: Point) -> Option<&RenderedImageLink> {
self.image_links.iter().find(|image| {
image
.bounds
.get()
.is_some_and(|bounds| bounds.contains(&position))
})
}
fn footnote_ref_for_source_index(&self, source_index: usize) -> Option<&RenderedFootnoteRef> {
self.footnote_refs
.iter()
.find(|fref| fref.source_range.contains(&source_index))
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpui::{RenderImage, TestAppContext, UpdateGlobal, size};
use language::{Language, LanguageConfig, LanguageMatcher};
use std::cell::RefCell;
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
struct TestWindow;
impl Render for TestWindow {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
div()
}
}
struct MarkdownTestView {
markdown: Entity,
style: MarkdownStyle,
code_span_link: Option,
rendered_text: Rc>>,
}
impl Render for MarkdownTestView {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
let mut markdown_element =
MarkdownElement::new(self.markdown.clone(), self.style.clone());
if let Some(code_span_link) = self.code_span_link.clone() {
markdown_element =
markdown_element.on_code_span_link(move |text, cx| code_span_link(text, cx));
}
CapturingMarkdownElement {
markdown_element: markdown_element.code_block_renderer(
CodeBlockRenderer::Default {
copy_button_visibility: CopyButtonVisibility::Hidden,
wrap_button_visibility: WrapButtonVisibility::Hidden,
border: false,
},
),
rendered_text: self.rendered_text.clone(),
}
}
}
struct CapturingMarkdownElement {
markdown_element: MarkdownElement,
rendered_text: Rc>>,
}
impl IntoElement for CapturingMarkdownElement {
type Element = Self;
fn into_element(self) -> Self::Element {
self
}
}
impl Element for CapturingMarkdownElement {
type RequestLayoutState = RenderedMarkdown;
type PrepaintState = Hitbox;
fn id(&self) -> Option {
self.markdown_element.id()
}
fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
self.markdown_element.source_location()
}
fn request_layout(
&mut self,
id: Option<&GlobalElementId>,
inspector_id: Option<&gpui::InspectorElementId>,
window: &mut Window,
cx: &mut App,
) -> (gpui::LayoutId, Self::RequestLayoutState) {
self.markdown_element
.request_layout(id, inspector_id, window, cx)
}
fn prepaint(
&mut self,
id: Option<&GlobalElementId>,
inspector_id: Option<&gpui::InspectorElementId>,
bounds: Bounds,
rendered_markdown: &mut Self::RequestLayoutState,
window: &mut Window,
cx: &mut App,
) -> Self::PrepaintState {
self.markdown_element
.prepaint(id, inspector_id, bounds, rendered_markdown, window, cx)
}
fn paint(
&mut self,
id: Option<&GlobalElementId>,
inspector_id: Option<&gpui::InspectorElementId>,
bounds: Bounds,
rendered_markdown: &mut Self::RequestLayoutState,
hitbox: &mut Self::PrepaintState,
window: &mut Window,
cx: &mut App,
) {
self.markdown_element.paint(
id,
inspector_id,
bounds,
rendered_markdown,
hitbox,
window,
cx,
);
*self.rendered_text.borrow_mut() = Some(rendered_markdown.text.clone());
}
}
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);
}
});
}
fn render_markdown_entity_in_view(
markdown: Entity,
style: MarkdownStyle,
code_span_link: Option,
cx: &mut TestAppContext,
) -> RenderedText {
let rendered_text = Rc::new(RefCell::new(None));
let (_, cx) = cx.add_window_view({
let rendered_text = rendered_text.clone();
move |_, _| MarkdownTestView {
markdown,
style,
code_span_link,
rendered_text,
}
});
cx.run_until_parked();
rendered_text
.borrow()
.clone()
.expect("markdown should be rendered in the test view")
}
#[gpui::test]
fn test_code_block_controls_are_unique_across_markdown_entities(cx: &mut TestAppContext) {
struct TestWindow;
impl Render for TestWindow {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
div()
}
}
struct TestMarkdowns {
first_markdown: Entity,
second_markdown: Entity,
}
impl Render for TestMarkdowns {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
div()
.child(MarkdownElement::new(
self.first_markdown.clone(),
MarkdownStyle::default(),
))
.child(MarkdownElement::new(
self.second_markdown.clone(),
MarkdownStyle::default(),
))
}
}
ensure_theme_initialized(cx);
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
let markdown = "```sh\necho hello\n```";
let first_markdown = cx.new(|cx| Markdown::new(markdown.into(), None, None, cx));
let second_markdown = cx.new(|cx| Markdown::new(markdown.into(), None, None, cx));
cx.run_until_parked();
cx.draw(Default::default(), size(px(600.0), px(600.0)), |_, cx| {
cx.new(|_| TestMarkdowns {
first_markdown: first_markdown.clone(),
second_markdown: second_markdown.clone(),
})
.into_any_element()
});
}
#[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)
}
#[gpui::test]
fn test_active_search_highlight_uses_match_index(cx: &mut TestAppContext) {
let markdown = cx.new(|cx| Markdown::new("zero one two".into(), None, None, cx));
markdown.update(cx, |markdown, cx| {
markdown.set_search_highlights(vec![0..4, 5..8, 9..12], Some(0), cx);
assert_eq!(markdown.search_highlights(), &[0..4, 5..8, 9..12]);
assert_eq!(markdown.active_search_highlight(), Some(0));
markdown.set_active_search_highlight(Some(1), cx);
assert_eq!(markdown.active_search_highlight(), Some(1));
markdown.set_active_search_highlight(Some(2), cx);
assert_eq!(markdown.active_search_highlight(), Some(2));
markdown.set_active_search_highlight(Some(3), cx);
assert_eq!(markdown.active_search_highlight(), None);
});
}
#[gpui::test]
fn test_wrapped_code_block_has_no_scroll_handle(cx: &mut TestAppContext) {
let markdown =
cx.new(|cx| Markdown::new("```rust\nlet value = 1;\n```".into(), None, None, cx));
markdown.update(cx, |markdown, _| {
assert!(markdown.code_block_scroll_handle(0).is_some());
markdown.toggle_code_block_wrap(0);
assert!(markdown.code_block_scroll_handle(0).is_none());
markdown.toggle_code_block_wrap(0);
assert!(markdown.code_block_scroll_handle(0).is_some());
});
}
#[gpui::test]
fn test_frontmatter_renders_without_delimiters(cx: &mut TestAppContext) {
let rendered = render_markdown_with_options(
"---\ntitle: Post\n---\nBody",
None,
MarkdownOptions {
render_metadata_blocks: true,
..Default::default()
},
cx,
);
assert_eq!(rendered.text_for_range(0..24), "title\nPost\nBody");
}
#[gpui::test]
fn test_frontmatter_falls_back_to_code_block_for_nested_yaml(cx: &mut TestAppContext) {
let rendered = render_markdown_with_options(
"---\ntags:\n - zed\n---\nBody",
None,
MarkdownOptions {
render_metadata_blocks: true,
..Default::default()
},
cx,
);
assert_eq!(rendered.text_for_range(0..26), "tags:\n - zed\nBody");
}
fn render_markdown_with_code_span_link(
markdown: &str,
callback: impl Fn(&str, &App) -> Option + 'static,
cx: &mut TestAppContext,
) -> RenderedText {
render_markdown_with_code_span_link_style(markdown, MarkdownStyle::default(), callback, cx)
}
fn render_markdown_with_code_span_link_style(
markdown: &str,
style: MarkdownStyle,
callback: impl Fn(&str, &App) -> Option + 'static,
cx: &mut TestAppContext,
) -> RenderedText {
ensure_theme_initialized(cx);
let markdown = cx.new(|cx| Markdown::new(markdown.to_string().into(), None, None, cx));
cx.run_until_parked();
render_markdown_entity_in_view(markdown, style, Some(Arc::new(callback)), 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 {
ensure_theme_initialized(cx);
let markdown = cx.new(|cx| {
Markdown::new_with_options(
markdown.to_string().into(),
language_registry,
None,
options,
cx,
)
});
cx.run_until_parked();
render_markdown_entity_in_view(markdown, MarkdownStyle::default(), None, cx)
}
fn render_markdown_with_image_resolver(
markdown: &str,
options: MarkdownOptions,
resolver: impl Fn(&str) -> Option + 'static,
cx: &mut TestAppContext,
) -> RenderedText {
ensure_theme_initialized(cx);
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
let markdown = cx.new(|cx| {
Markdown::new_with_options(markdown.to_string().into(), None, 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())
.image_resolver(resolver)
.code_block_renderer(CodeBlockRenderer::Default {
copy_button_visibility: CopyButtonVisibility::Hidden,
wrap_button_visibility: WrapButtonVisibility::Hidden,
border: false,
})
},
);
rendered.text
}
fn test_image(cx: &mut TestAppContext) -> Arc {
cx.update(|cx| {
cx.svg_renderer()
.render_single_frame(
br#""#,
1.0,
)
.expect("test svg should render")
})
}
#[gpui::test]
fn test_soft_break_keeps_space_in_paragraph_with_image(cx: &mut TestAppContext) {
let image = test_image(cx);
let rendered = render_markdown_with_image_resolver(
"Here is an image  and more text\nthat continues",
MarkdownOptions::default(),
move |_| Some(ImageSource::Render(image.clone())),
cx,
);
let text: String = rendered
.lines
.iter()
.map(|line| line.layout.wrapped_text())
.collect();
assert!(
text.contains("more text that continues"),
"soft break in an image paragraph should still separate words with a space; got: {text:?}"
);
assert!(
!text.contains("textthat"),
"soft break between words must not be dropped; got: {text:?}"
);
}
#[gpui::test]
fn test_soft_break_after_image_does_not_insert_leading_space(cx: &mut TestAppContext) {
let image = test_image(cx);
let rendered = render_markdown_with_image_resolver(
"\ncaption",
MarkdownOptions::default(),
move |_| Some(ImageSource::Render(image.clone())),
cx,
);
let text: String = rendered
.lines
.iter()
.map(|line| line.layout.wrapped_text())
.collect();
assert_eq!(
text, "caption",
"a soft break after an image should not insert leading whitespace before caption text; got: {text:?}"
);
}
#[gpui::test]
fn test_break_between_images_does_not_inject_leading_space(cx: &mut TestAppContext) {
let image = test_image(cx);
let rendered = render_markdown_with_image_resolver(
"\n
\n",
MarkdownOptions {
parse_html: true,
..Default::default()
},
move |_| Some(ImageSource::Render(image.clone())),
cx,
);
let stray_whitespace_line = rendered.lines.iter().find_map(|line| {
let text = line.layout.wrapped_text();
(!text.is_empty() && text.trim().is_empty()).then_some(text)
});
assert!(
stray_whitespace_line.is_none(),
"soft break after a
between images must not render a stray space \
before the wrapped image; got whitespace-only line: {stray_whitespace_line:?}"
);
}
#[gpui::test]
fn test_break_in_tight_list_item_after_image_item_is_newline(cx: &mut TestAppContext) {
let image = test_image(cx);
let rendered = render_markdown_with_image_resolver(
"- \n- first
second",
MarkdownOptions {
parse_html: true,
..Default::default()
},
move |_| Some(ImageSource::Render(image.clone())),
cx,
);
let text: String = rendered
.lines
.iter()
.map(|line| line.layout.wrapped_text())
.collect();
assert!(
text.contains("first\nsecond"),
"break in a text-only tight list item should render as a newline; got: {text:?}"
);
}
#[gpui::test]
fn test_hard_style_soft_break_after_image_moves_caption_to_next_row(cx: &mut TestAppContext) {
ensure_theme_initialized(cx);
let image = test_image(cx);
let markdown_source = "\ncaption";
let caption_range = markdown_source.len() - "caption".len()..markdown_source.len();
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
let markdown = cx.new(|cx| {
Markdown::new_with_options(
markdown_source.to_string().into(),
None,
None,
MarkdownOptions::default(),
cx,
)
});
cx.run_until_parked();
let mut caption_top = |soft_break_as_hard_break: bool| {
let mut style = MarkdownStyle::default();
style.soft_break_as_hard_break = soft_break_as_hard_break;
let image = image.clone();
let (rendered, _) = cx.draw(
Default::default(),
size(px(600.0), px(600.0)),
|_window, _cx| {
MarkdownElement::new(markdown.clone(), style)
.image_resolver(move |_| Some(ImageSource::Render(image.clone())))
.code_block_renderer(CodeBlockRenderer::Default {
copy_button_visibility: CopyButtonVisibility::Hidden,
wrap_button_visibility: WrapButtonVisibility::Hidden,
border: false,
})
},
);
rendered
.text
.bounds_for_source_range(caption_range.clone())
.into_iter()
.next()
.expect("caption should have text bounds")
.top()
};
let caption_top_with_break = caption_top(true);
let caption_top_without_break = caption_top(false);
assert!(
caption_top_with_break > caption_top_without_break,
"caption should render below the image for hard-style soft breaks; \
top with break: {caption_top_with_break:?}, top without break: {caption_top_without_break:?}"
);
}
#[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_state_current_cell_alignment_centers_headers() {
let mut table = TableState::default();
table.start(vec![Alignment::Left, Alignment::Right, Alignment::None]);
table.start_head();
for _ in 0..3 {
assert_eq!(table.current_cell_alignment(), Some(Alignment::Center));
table.end_cell();
}
table.end_head();
table.start_row();
assert_eq!(table.current_cell_alignment(), Some(Alignment::Left));
table.end_cell();
assert_eq!(table.current_cell_alignment(), Some(Alignment::Right));
table.end_cell();
assert_eq!(table.current_cell_alignment(), Some(Alignment::None));
table.end_cell();
table.end_row();
table.end();
assert_eq!(table.current_cell_alignment(), None);
}
#[test]
fn test_table_state_current_cell_alignment_outside_table() {
let table = TableState::default();
assert_eq!(table.current_cell_alignment(), None);
}
#[test]
fn test_table_checkbox_detection() {
let md = "| Done |\n|------|\n| [x] |\n| [ ] |";
let events = crate::parser::parse_markdown_with_options(md, false, 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(), "[ ]");
}
#[test]
fn test_table_checkbox_marker_source_range() {
let md = "| Done |\n|------|\n| [x] |\n| [ ] |";
let events = crate::parser::parse_markdown_with_options(md, false, false, false).events;
let mut in_cell = false;
let mut pending_text = String::new();
let mut mappings: Vec = Vec::new();
let mut cell_ranges: Vec> = Vec::new();
for (range, event) in &events {
match event {
MarkdownEvent::Start(MarkdownTag::TableCell) => {
in_cell = true;
pending_text.clear();
mappings.clear();
}
MarkdownEvent::End(MarkdownTagEnd::TableCell) => {
if in_cell {
let trimmed = pending_text.trim();
if trimmed == "[x]" || trimmed == "[X]" || trimmed == "[ ]" {
let leading = pending_text.len() - pending_text.trim_start().len();
let rendered = leading..leading + trimmed.len();
let marker_source = source_range_for_rendered(&mappings, &rendered)
.expect("marker source range");
cell_ranges.push(marker_source);
}
}
in_cell = false;
}
MarkdownEvent::Text if in_cell => {
mappings.push(SourceMapping {
rendered_index: pending_text.len(),
source_index: range.start,
});
pending_text.push_str(&md[range.clone()]);
}
_ => {}
}
}
assert_eq!(cell_ranges.len(), 2);
for marker_range in &cell_ranges {
let slice = &md[marker_range.clone()];
assert!(
slice == "[x]" || slice == "[X]" || slice == "[ ]",
"expected `[x]`/`[X]`/`[ ]`, got {slice:?} at {marker_range:?}"
);
}
}
#[gpui::test]
fn test_escaped_pipes_in_inline_code_inside_tables(cx: &mut TestAppContext) {
let markdown = "\
| Pattern | What it does |
| --- | --- |
| `^echo(\\s\\|$)` | command pattern |
| `a\\|b` | alternation |
| `(a\\|b)` | grouped alternation |
| `a\\|\\|b` | empty middle alternative |";
let rendered = render_markdown(markdown, cx);
let text = rendered.text_for_range(0..markdown.len());
assert_eq!(
text,
"Pattern\n\
What it does\n\
^echo(\\s|$)\n\
command pattern\n\
a|b\n\
alternation\n\
(a|b)\n\
grouped alternation\n\
a||b\n\
empty middle alternative"
);
}
#[test]
fn test_source_range_for_rendered_handles_split_chunks() {
let mappings = vec![
SourceMapping {
rendered_index: 0,
source_index: 20,
},
SourceMapping {
rendered_index: 1,
source_index: 21,
},
SourceMapping {
rendered_index: 2,
source_index: 22,
},
];
let range = source_range_for_rendered(&mappings, &(0..3)).unwrap();
assert_eq!(range, 20..23);
let range = source_range_for_rendered(&mappings, &(1..2)).unwrap();
assert_eq!(range, 21..22);
assert_eq!(source_range_for_rendered(&mappings, &(2..2)), None);
}
#[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()
})
.into(),
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()
);
}
#[test]
fn test_escape_non_ascii() {
// Cyrillic characters should not have backslashes added before them,
// but ASCII punctuation should still be escaped.
assert_eq!(Markdown::escape("Привет, мир"), r"Привет\, мир");
// Test with markdown special characters mixed in
assert_eq!(Markdown::escape("Привет, *мир*"), r"Привет\, \*мир\*");
// Test with the exact example from the issue (single quotes are also ASCII punctuation)
assert_eq!(
Markdown::escape("Отсутствует пробел справа от ','"),
r"Отсутствует пробел справа от \'\,\'"
);
// Test more non-ASCII scripts
assert_eq!(
Markdown::escape("こんにちは *world*"),
r"こんにちは \*world\*"
);
assert_eq!(Markdown::escape("العربيّة [link]"), r"العربيّة \[link\]");
assert_eq!(Markdown::escape("Ελληνικά _text_"), r"Ελληνικά \_text\_");
assert_eq!(Markdown::escape("עברית `code`"), r"עברית \`code\`");
// Non-ASCII followed by ASCII punctuation
assert_eq!(Markdown::escape("Test: тест"), r"Test\: тест");
}
fn has_code_block(markdown: &str) -> bool {
let parsed_data = parse_markdown_with_options(markdown, false, 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.chars().map(|c| escaper.next(c).output_len(c)).sum();
let mut escaper = MarkdownEscaper::new();
let mut output = String::new();
for c in input.chars() {
escaper.next(c).write_to(c, &mut output);
}
assert_eq!(precomputed, output.len(), "length mismatch for {:?}", input);
}
}
#[gpui::test]
fn test_inline_br_renders_as_line_break(cx: &mut TestAppContext) {
let options = MarkdownOptions {
parse_html: true,
..Default::default()
};
for br in ["
", "
", "
"] {
let md = format!("first{br}second");
let rendered = render_markdown_with_options(&md, None, options, cx);
let text: String = rendered
.lines
.iter()
.map(|line| line.layout.wrapped_text())
.collect();
assert!(
!text.contains(br),
"{br} should not appear as literal text; got: {text:?}"
);
assert!(
text.contains("first\nsecond"),
"{br} should produce a newline between 'first' and 'second'; got: {text:?}"
);
}
}
#[gpui::test]
fn test_hard_break_in_text_paragraph_after_paragraph(cx: &mut TestAppContext) {
let options = MarkdownOptions {
parse_html: true,
..Default::default()
};
let rendered =
render_markdown_with_options("para one\n\nfirst
second", None, options, cx);
let all_text: String = rendered
.lines
.iter()
.map(|line| line.layout.wrapped_text())
.collect::>()
.join("\n");
assert!(
all_text.contains("first") && all_text.contains("second"),
"both sides of
should be present; got: {all_text:?}"
);
assert!(
!all_text.contains("
"),
"
should not appear as literal text; got: {all_text:?}"
);
}
#[test]
fn test_escape_prevents_code_block() {
let diagnostic = " | { a: string }";
assert!(has_code_block(diagnostic));
assert!(!has_code_block(&Markdown::escape(diagnostic)));
}
#[gpui::test]
fn test_link_detected_for_source_index(cx: &mut TestAppContext) {
let rendered = render_markdown("[Click here](https://example.com)", cx);
assert_eq!(rendered.links.len(), 1);
assert_eq!(rendered.links[0].destination_url, "https://example.com");
// Source index 1 ('C' in "Click") is inside the link's source range
let link = rendered.link_for_source_index(1);
assert!(link.is_some());
assert_eq!(link.unwrap().destination_url, "https://example.com");
// A source index past the end of the link range returns None
let past_end = rendered.links[0].source_range.end;
assert!(rendered.link_for_source_index(past_end).is_none());
}
#[gpui::test]
fn test_link_for_source_index_ignores_plain_text(cx: &mut TestAppContext) {
let rendered = render_markdown("Hello world", cx);
assert!(rendered.links.is_empty());
assert!(rendered.link_for_source_index(0).is_none());
assert!(rendered.link_for_source_index(5).is_none());
}
#[gpui::test]
fn test_code_span_link_detected_for_source_index(cx: &mut TestAppContext) {
let source = "see `foo.rs` for details";
let rendered = render_markdown_with_code_span_link(
source,
|text, _cx| (text == "foo.rs").then(|| "file:///tmp/foo.rs".into()),
cx,
);
assert_eq!(rendered.links.len(), 1);
assert_eq!(rendered.links[0].destination_url, "file:///tmp/foo.rs");
let code_index = source.find("foo.rs").unwrap();
let link = rendered.link_for_source_index(code_index);
assert!(link.is_some());
assert_eq!(link.unwrap().destination_url, "file:///tmp/foo.rs");
assert!(
rendered
.link_for_source_index(source.find("see").unwrap())
.is_none()
);
}
#[gpui::test]
fn test_code_span_link_receives_decoded_inline_code(cx: &mut TestAppContext) {
let source = r"| Pattern |
| --- |
| `a\|b` |";
let rendered = render_markdown_with_code_span_link(
source,
|text, _cx| (text == "a|b").then(|| "file:///tmp/a-or-b".into()),
cx,
);
assert_eq!(rendered.links.len(), 1);
assert_eq!(rendered.links[0].destination_url, "file:///tmp/a-or-b");
}
#[gpui::test]
fn test_code_span_link_ignores_code_when_mouse_interaction_is_prevented(
cx: &mut TestAppContext,
) {
let callback_count = Arc::new(AtomicUsize::new(0));
let rendered = render_markdown_with_code_span_link_style(
"see `foo.rs` for details",
MarkdownStyle {
prevent_mouse_interaction: true,
..MarkdownStyle::default()
},
{
let callback_count = callback_count.clone();
move |text, _cx| {
callback_count.fetch_add(1, Ordering::Relaxed);
(text == "foo.rs").then(|| "file:///tmp/foo.rs".into())
}
},
cx,
);
assert!(rendered.links.is_empty());
assert_eq!(callback_count.load(Ordering::Relaxed), 0);
}
#[gpui::test]
fn test_code_span_link_ignores_code_without_callback(cx: &mut TestAppContext) {
let rendered = render_markdown("see `foo.rs` for details", cx);
assert!(rendered.links.is_empty());
}
#[gpui::test]
fn test_code_span_link_ignores_code_inside_markdown_link(cx: &mut TestAppContext) {
let source = "see [`foo.rs`](https://example.com) for details";
let rendered = render_markdown_with_code_span_link(
source,
|text, _cx| (text == "foo.rs").then(|| "file:///tmp/foo.rs".into()),
cx,
);
assert_eq!(rendered.links.len(), 1);
assert_eq!(rendered.links[0].destination_url, "https://example.com");
}
#[gpui::test]
fn test_context_menu_link_initial_state(cx: &mut TestAppContext) {
ensure_theme_initialized(cx);
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
let markdown =
cx.new(|cx| Markdown::new("Hello [world](https://example.com)".into(), None, None, cx));
cx.run_until_parked();
cx.update(|_window, cx| {
assert!(markdown.read(cx).context_menu_link().is_none());
});
}
#[gpui::test]
fn test_url_hover_callback(cx: &mut TestAppContext) {
struct HoverTestView {
markdown: Entity,
hovered_urls: Rc>>>,
}
impl Render for HoverTestView {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
let hovered_urls = self.hovered_urls.clone();
div().size_full().child(
MarkdownElement::new(self.markdown.clone(), MarkdownStyle::default())
.on_url_hover(move |url, _, _| {
hovered_urls.borrow_mut().push(url);
}),
)
}
}
ensure_theme_initialized(cx);
let hovered_urls = Rc::new(RefCell::new(Vec::new()));
let (_, cx) = cx.add_window_view({
let hovered_urls = hovered_urls.clone();
move |_, cx| HoverTestView {
markdown: cx
.new(|cx| Markdown::new("[link](https://example.com)".into(), None, None, cx)),
hovered_urls,
}
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(8.), px(8.)), None, gpui::Modifiers::default());
assert_eq!(
hovered_urls.borrow().last().cloned().flatten().as_deref(),
Some("https://example.com")
);
cx.simulate_mouse_move(point(px(500.), px(500.)), None, gpui::Modifiers::default());
assert_eq!(hovered_urls.borrow().last(), Some(&None));
}
#[gpui::test]
fn test_url_hover_callback_for_linked_image(cx: &mut TestAppContext) {
struct HoverTestView {
markdown: Entity,
hovered_urls: Rc>>>,
}
impl Render for HoverTestView {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
let hovered_urls = self.hovered_urls.clone();
div().size_full().child(
MarkdownElement::new(self.markdown.clone(), MarkdownStyle::default())
.image_resolver(|_| Some(loaded_image_source()))
.on_url_hover(move |url, _, _| {
hovered_urls.borrow_mut().push(url);
}),
)
}
}
ensure_theme_initialized(cx);
let hovered_urls = Rc::new(RefCell::new(Vec::new()));
let (_, cx) = cx.add_window_view({
let hovered_urls = hovered_urls.clone();
move |_, cx| HoverTestView {
markdown: cx.new(|cx| {
Markdown::new(
"[](https://example.com)".into(),
None,
None,
cx,
)
}),
hovered_urls,
}
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(4.), px(4.)), None, gpui::Modifiers::default());
assert_eq!(
hovered_urls.borrow().last().cloned().flatten().as_deref(),
Some("https://example.com")
);
cx.simulate_mouse_move(point(px(8.), px(8.)), None, gpui::Modifiers::default());
assert_eq!(
hovered_urls.borrow().last().cloned().flatten().as_deref(),
Some("https://example.com")
);
cx.simulate_mouse_move(point(px(500.), px(500.)), None, gpui::Modifiers::default());
assert_eq!(hovered_urls.borrow().last(), Some(&None));
}
#[gpui::test]
fn test_capture_for_context_menu(cx: &mut TestAppContext) {
ensure_theme_initialized(cx);
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
let markdown = cx.new(|cx| Markdown::new("some text".into(), None, None, cx));
cx.run_until_parked();
// Simulates right-clicking on a link, with "text" selected
let url: SharedString = "https://example.com".into();
markdown.update(cx, |md, _cx| {
md.selection.start = 5;
md.selection.end = 9;
md.capture_for_context_menu(Some(url.clone()), None);
});
cx.update(|_window, cx| {
let markdown = markdown.read(cx);
assert_eq!(
markdown.context_menu_link().map(SharedString::as_ref),
Some("https://example.com")
);
assert_eq!(
markdown
.context_menu_selected_markdown()
.map(SharedString::as_ref),
Some("text")
);
assert_eq!(
markdown
.context_menu_selected_text()
.map(SharedString::as_ref),
Some("text")
);
});
// Simulates right-clicking on plain text with no selection — everything is cleared
markdown.update(cx, |md, _cx| {
md.selection.start = 0;
md.selection.end = 0;
md.capture_for_context_menu(None, None);
});
cx.update(|_window, cx| {
let markdown = markdown.read(cx);
assert!(markdown.context_menu_link().is_none());
assert!(markdown.context_menu_selected_markdown().is_none());
assert!(markdown.context_menu_selected_text().is_none());
});
}
#[gpui::test]
fn test_preview_body_font_size_is_rem_based(cx: &mut TestAppContext) {
ensure_theme_initialized(cx);
let (_, cx) = cx.add_window_view(|_, _| TestWindow);
cx.update(|window, cx| {
let style = MarkdownStyle::themed(MarkdownFont::Preview, window, cx);
assert!(
matches!(style.base_text_style.font_size, AbsoluteLength::Rems(_)),
"preview body font size must be rem-based, got {:?}",
style.base_text_style.font_size
);
assert!(
matches!(
style.container_style.text.font_size,
Some(AbsoluteLength::Rems(_))
),
"preview container font size must be rem-based, got {:?}",
style.container_style.text.font_size
);
});
}
fn failing_image_source() -> ImageSource {
ImageSource::Custom(Arc::new(|_, _| {
Some(Err(gpui::ImageCacheError::Asset(
"failed to load image".into(),
)))
}))
}
fn loaded_image_source() -> ImageSource {
let buffer = image::ImageBuffer::from_pixel(16, 16, image::Rgba([0, 0, 0, 255]));
ImageSource::Render(Arc::new(gpui::RenderImage::new(SmallVec::from_elem(
image::Frame::new(buffer),
1,
))))
}
fn open_markdown_image_test_window<'a>(
source: &str,
image_source: ImageSource,
cx: &'a mut TestAppContext,
) -> &'a mut gpui::VisualTestContext {
struct ImageTestView {
markdown: Entity,
image_source: ImageSource,
}
impl Render for ImageTestView {
fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement {
let image_source = self.image_source.clone();
div().size_full().child(
MarkdownElement::new(self.markdown.clone(), MarkdownStyle::default())
.image_resolver(move |_| Some(image_source.clone())),
)
}
}
ensure_theme_initialized(cx);
let source = source.to_string();
let (_, cx) = cx.add_window_view(|_, cx| ImageTestView {
markdown: cx.new(|cx| Markdown::new(source.into(), None, None, cx)),
image_source,
});
cx.run_until_parked();
cx
}
#[gpui::test]
fn test_clicking_image_fallback_opens_image_url(cx: &mut TestAppContext) {
let cx = open_markdown_image_test_window(
"",
failing_image_source(),
cx,
);
cx.simulate_click(point(px(8.), px(8.)), gpui::Modifiers::default());
assert_eq!(
cx.opened_url(),
Some("https://example.com/image.png".to_string())
);
}
#[gpui::test]
fn test_clicking_image_fallback_inside_link_opens_link_url(cx: &mut TestAppContext) {
let cx = open_markdown_image_test_window(
"[](https://example.com/link)",
failing_image_source(),
cx,
);
cx.simulate_click(point(px(8.), px(8.)), gpui::Modifiers::default());
assert_eq!(
cx.opened_url(),
Some("https://example.com/link".to_string())
);
}
#[gpui::test]
fn test_clicking_loaded_image_inside_link_opens_link_url(cx: &mut TestAppContext) {
let cx = open_markdown_image_test_window(
"[](https://example.com/link)",
loaded_image_source(),
cx,
);
cx.simulate_click(point(px(8.), px(8.)), gpui::Modifiers::default());
assert_eq!(
cx.opened_url(),
Some("https://example.com/link".to_string())
);
}
#[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
);
}
}
}
#[gpui::test]
fn test_bounds_for_source_range_skips_gaps_between_rendered_lines(cx: &mut TestAppContext) {
let source = "First\n\nSecond";
let rendered = render_markdown(source, cx);
let highlight_bounds = rendered.bounds_for_source_range(0..source.len());
assert_eq!(highlight_bounds.len(), rendered.lines.len());
for (line, highlight_bounds) in rendered.lines.iter().zip(highlight_bounds.iter()) {
let line_bounds = line.layout.bounds();
assert_eq!(highlight_bounds.top(), line_bounds.top());
assert_eq!(
highlight_bounds.bottom(),
line_bounds.top() + line.layout.line_height()
);
}
}
#[gpui::test]
fn test_bounds_for_source_range_returns_one_bound_per_soft_wrap_row(cx: &mut TestAppContext) {
let sentence = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, \
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
let source = [sentence, sentence, sentence, sentence].join(" ");
let rendered = render_markdown(&source, cx);
let line = &rendered.lines[0];
let line_bounds = line.layout.bounds();
let line_height = line.layout.line_height();
let wrapped_line = line.layout.line_layout_for_index(0).unwrap();
let visual_row_count = wrapped_line.wrap_boundaries().len() + 1;
let highlight_bounds = rendered.bounds_for_source_range(0..source.len());
assert_eq!(highlight_bounds.len(), visual_row_count);
let mut row_top = line_bounds.top();
for (row_index, row_bounds) in highlight_bounds.iter().enumerate() {
assert_eq!(row_bounds.top(), row_top);
assert_eq!(row_bounds.bottom(), row_top + line_height);
assert!(
row_bounds.size.width > Pixels::ZERO,
"row {row_index} should have a non-empty highlight"
);
row_top += line_height;
}
}
#[gpui::test]
fn test_heading_font_sizes_are_distinct(cx: &mut TestAppContext) {
let rendered = render_markdown("# H1\n\n## H2\n\n### H3\n\nBody text", cx);
assert!(
rendered.lines.len() >= 4,
"expected at least 4 rendered lines, got {}",
rendered.lines.len()
);
let h1_line_height = rendered.lines[0].layout.line_height();
let h2_line_height = rendered.lines[1].layout.line_height();
let h3_line_height = rendered.lines[2].layout.line_height();
let body_line_height = rendered.lines[3].layout.line_height();
assert!(
h1_line_height > h2_line_height,
"H1 line height ({h1_line_height:?}) should be greater than H2 ({h2_line_height:?})"
);
assert!(
h2_line_height > h3_line_height,
"H2 line height ({h2_line_height:?}) should be greater than H3 ({h3_line_height:?})"
);
assert!(
h3_line_height > body_line_height,
"H3 line height ({h3_line_height:?}) should be greater than body text ({body_line_height:?})"
);
}
#[gpui::test]
fn test_ui_zoom_does_not_affect_markdown_preview(cx: &mut TestAppContext) {
ensure_theme_initialized(cx);
cx.update(|cx| {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
settings.theme.ui_font_size = Some(16.0.into());
settings.theme.markdown_preview_font_size = None;
});
});
});
cx.run_until_parked();
cx.update(|cx| {
let before = ThemeSettings::get_global(cx).markdown_preview_font_size(cx);
assert_eq!(before, px(16.0));
theme_settings::adjust_ui_font_size(cx, |size| size + px(3.0));
assert_eq!(ThemeSettings::get_global(cx).ui_font_size(cx), px(19.0));
assert_eq!(
ThemeSettings::get_global(cx).markdown_preview_font_size(cx),
before
);
});
}
#[gpui::test]
fn test_markdown_preview_follows_ui_font_size_setting_when_unset(cx: &mut TestAppContext) {
ensure_theme_initialized(cx);
cx.update(|cx| {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
settings.theme.ui_font_size = Some(20.0.into());
settings.theme.markdown_preview_font_size = None;
});
});
});
cx.run_until_parked();
cx.update(|cx| {
assert_eq!(
ThemeSettings::get_global(cx).markdown_preview_font_size(cx),
px(20.0)
);
});
cx.update(|cx| {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
settings.theme.ui_font_size = Some(24.0.into());
});
});
});
cx.run_until_parked();
cx.update(|cx| {
assert_eq!(
ThemeSettings::get_global(cx).markdown_preview_font_size(cx),
px(24.0)
);
});
}
}