Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Markdown preview visible find matches (#62280)

Warya Wayne9bb4787949ee
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 2c622018a82..458485733ca 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -933,6 +933,14 @@ impl Markdown {
&self.source
}
+ pub fn non_rendered_source_ranges(&self) -> Vec<Range<usize>> {
+ if self.source != self.parsed_markdown.source {
+ return Vec::new();
+ }
+
+ self.parsed_markdown.non_rendered_source_ranges()
+ }
+
pub fn first_code_block_language(&self) -> Option<Arc<Language>> {
self.parsed_markdown.events.iter().find_map(|(_, event)| {
let MarkdownEvent::Start(MarkdownTag::CodeBlock { kind, .. }) = event else {
@@ -1217,6 +1225,7 @@ impl Markdown {
mermaid_diagrams: BTreeMap::default(),
heading_slugs: HashMap::default(),
footnote_definitions: HashMap::default(),
+ link_definition_spans: Arc::default(),
},
Default::default(),
);
@@ -1236,6 +1245,7 @@ impl Markdown {
let metadata_blocks = parsed.metadata_blocks;
let heading_slugs = parsed.heading_slugs;
let footnote_definitions = parsed.footnote_definitions;
+ let link_definition_spans = parsed.link_definition_spans;
let mermaid_diagrams = if should_render_mermaid_diagrams {
extract_mermaid_diagrams(&source, &events)
} else {
@@ -1305,6 +1315,7 @@ impl Markdown {
mermaid_diagrams,
heading_slugs,
footnote_definitions,
+ link_definition_spans: Arc::from(link_definition_spans),
},
images_by_source_offset,
)
@@ -1451,6 +1462,7 @@ pub struct ParsedMarkdown {
pub(crate) mermaid_diagrams: BTreeMap<usize, ParsedMarkdownMermaidDiagram>,
pub heading_slugs: HashMap<SharedString, usize>,
pub footnote_definitions: HashMap<SharedString, usize>,
+ pub(crate) link_definition_spans: Arc<[Range<usize>]>,
}
impl ParsedMarkdown {
@@ -1466,6 +1478,74 @@ impl ParsedMarkdown {
&self.root_block_starts
}
+ fn non_rendered_source_ranges(&self) -> Vec<Range<usize>> {
+ let mut ranges = Vec::new();
+ let mut active_link = None;
+ let mut active_image: Option<Range<usize>> = None;
+
+ for (event_range, event) in self.events.iter() {
+ // An image renders as an image, so nothing between its start and end is text on
+ // screen - not the alt text, and not the destination. Skipping these events also
+ // keeps the alt text from advancing the enclosing link's cursor, which would
+ // otherwise carve it out of the link's non-rendered span.
+ if let Some(image_range) = &active_image {
+ if matches!(event, MarkdownEvent::End(MarkdownTagEnd::Image))
+ && event_range.end >= image_range.end
+ {
+ active_image = None;
+ }
+ continue;
+ }
+
+ match event {
+ MarkdownEvent::Start(MarkdownTag::Image { .. }) => {
+ active_image = Some(event_range.clone());
+ if active_link.is_none() {
+ ranges.push(event_range.clone());
+ }
+ }
+ MarkdownEvent::Start(MarkdownTag::Link { .. }) => {
+ active_link = Some((event_range.clone(), event_range.start));
+ }
+ MarkdownEvent::Text
+ | MarkdownEvent::SubstitutedText(_)
+ | MarkdownEvent::Code
+ | MarkdownEvent::SubstitutedCode(_) => {
+ let Some((link_range, cursor)) = active_link.as_mut() else {
+ continue;
+ };
+ let visible_start = event_range.start.max(link_range.start);
+ let visible_end = event_range.end.min(link_range.end);
+ if visible_start > *cursor {
+ ranges.push(*cursor..visible_start);
+ }
+ *cursor = (*cursor).max(visible_end);
+ }
+ MarkdownEvent::End(MarkdownTagEnd::Link) => {
+ if let Some((link_range, cursor)) = active_link.take()
+ && cursor < link_range.end
+ {
+ ranges.push(cursor..link_range.end);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ ranges.extend(self.link_definition_spans.iter().cloned());
+ // Callers binary search these ranges, which requires them to be sorted and disjoint.
+ ranges.sort_by_key(|range| range.start);
+ ranges.dedup_by(|next, previous| {
+ if next.start <= previous.end {
+ previous.end = previous.end.max(next.end);
+ true
+ } else {
+ false
+ }
+ });
+ ranges
+ }
+
pub fn root_block_for_source_index(&self, source_index: usize) -> Option<usize> {
if self.root_block_starts.is_empty() {
return None;
@@ -4836,6 +4916,88 @@ mod tests {
});
}
+ #[gpui::test]
+ fn test_non_rendered_source_ranges(cx: &mut TestAppContext) {
+ let source = "[@octocat](https://github.com/octocat) https://github.com/octocat";
+ let markdown = cx.new(|cx| Markdown::new(source.into(), None, None, cx));
+ cx.run_until_parked();
+
+ assert_eq!(
+ markdown.read_with(cx, |markdown, _| markdown.non_rendered_source_ranges()),
+ vec![0..1, 9..38]
+ );
+ }
+
+ #[gpui::test]
+ fn test_non_rendered_source_ranges_for_reference_definitions(cx: &mut TestAppContext) {
+ let source = "[@octocat][octocat]\n\n[octocat]: https://github.com/octocat";
+ let markdown = cx.new(|cx| Markdown::new(source.into(), None, None, cx));
+ cx.run_until_parked();
+
+ assert_eq!(
+ markdown.read_with(cx, |markdown, _| markdown.non_rendered_source_ranges()),
+ vec![0..1, 9..19, 21..58]
+ );
+ }
+
+ #[gpui::test]
+ fn test_non_rendered_source_ranges_for_images(cx: &mut TestAppContext) {
+ let source = "![alt](https://example.com/img.png \"title\")";
+ let markdown = cx.new(|cx| Markdown::new(source.into(), None, None, cx));
+ cx.run_until_parked();
+
+ assert_eq!(
+ markdown.read_with(cx, |markdown, _| markdown.non_rendered_source_ranges()),
+ vec![0..source.len()]
+ );
+ }
+
+ #[gpui::test]
+ fn test_non_rendered_source_ranges_for_linked_images(cx: &mut TestAppContext) {
+ let source = "[![alt](https://example.com/img.png)](https://example.com/dest)";
+ let markdown = cx.new(|cx| Markdown::new(source.into(), None, None, cx));
+ cx.run_until_parked();
+
+ assert_eq!(
+ markdown.read_with(cx, |markdown, _| markdown.non_rendered_source_ranges()),
+ vec![0..source.len()]
+ );
+ }
+
+ #[gpui::test]
+ fn test_non_rendered_source_ranges_for_image_between_link_text(cx: &mut TestAppContext) {
+ let source = "[before ![alt](https://example.com/img.png) after](https://example.com/dest)";
+ let markdown = cx.new(|cx| Markdown::new(source.into(), None, None, cx));
+ cx.run_until_parked();
+
+ let ranges = markdown.read_with(cx, |markdown, _| markdown.non_rendered_source_ranges());
+ assert_eq!(ranges, vec![0..1, 8..43, 49..source.len()]);
+ assert_eq!(&source[1..8], "before ");
+ assert_eq!(&source[43..49], " after");
+ }
+
+ #[gpui::test]
+ fn test_non_rendered_source_ranges_are_empty_while_parsing(cx: &mut TestAppContext) {
+ let markdown =
+ cx.new(|cx| Markdown::new("[a](https://example.com)".into(), None, None, cx));
+ cx.run_until_parked();
+
+ markdown.update(cx, |markdown, cx| {
+ markdown.reset("[bb](https://example.com)".into(), cx);
+ assert!(markdown.is_parsing());
+ assert_eq!(
+ markdown.non_rendered_source_ranges(),
+ Vec::<Range<usize>>::new()
+ );
+ });
+
+ cx.run_until_parked();
+ markdown.update(cx, |markdown, _| {
+ assert!(!markdown.is_parsing());
+ assert_eq!(markdown.non_rendered_source_ranges(), vec![0..1, 3..25]);
+ });
+ }
+
#[gpui::test]
fn test_wrapped_code_block_has_no_scroll_handle(cx: &mut TestAppContext) {
let markdown =
diff --git a/crates/markdown/src/parser.rs b/crates/markdown/src/parser.rs
index fc9256d5aba..a7117228084 100644
--- a/crates/markdown/src/parser.rs
+++ b/crates/markdown/src/parser.rs
@@ -40,6 +40,9 @@ pub(crate) struct ParsedMarkdownData {
pub metadata_blocks: BTreeMap<usize, ParsedMetadataBlock>,
pub heading_slugs: HashMap<SharedString, usize>,
pub footnote_definitions: HashMap<SharedString, usize>,
+ /// Source spans of link reference definitions (`[id]: https://example.com`), which are
+ /// consumed by the parser and never appear in any event range.
+ pub link_definition_spans: Vec<Range<usize>>,
}
#[derive(Clone, Debug, PartialEq)]
@@ -250,9 +253,14 @@ pub(crate) fn parse_markdown_with_options(
} else {
PARSE_OPTIONS
};
- let mut parser = Parser::new_ext(text, parse_options)
- .into_offset_iter()
- .peekable();
+ let parser = Parser::new_ext(text, parse_options);
+ let mut link_definition_spans = parser
+ .reference_definitions()
+ .iter()
+ .map(|(_, definition)| definition.span.clone())
+ .collect::<Vec<_>>();
+ link_definition_spans.sort_by_key(|span| span.start);
+ let mut parser = parser.into_offset_iter().peekable();
while let Some((pulldown_event, range)) = parser.next() {
if within_metadata && !parse_metadata_blocks {
if let pulldown_cmark::Event::End(pulldown_cmark::TagEnd::MetadataBlock(_)) =
@@ -677,6 +685,7 @@ pub(crate) fn parse_markdown_with_options(
metadata_blocks,
heading_slugs,
footnote_definitions,
+ link_definition_spans,
}
}
diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rs
index d6946a877a6..48b8085234e 100644
--- a/crates/markdown_preview/src/markdown_preview_view.rs
+++ b/crates/markdown_preview/src/markdown_preview_view.rs
@@ -68,6 +68,9 @@ pub struct MarkdownPreviewView {
pending_update_task: Option<Task<Result<()>>>,
hovered_url: Option<SharedString>,
mode: MarkdownPreviewMode,
+ /// Search results depend on the parsed markdown, which lags behind the source while a
+ /// background parse is in flight. Tracked so matches can be invalidated once it lands.
+ markdown_parse_pending: bool,
}
#[derive(Clone, Copy, Debug, PartialEq)]
@@ -309,8 +312,13 @@ impl MarkdownPreviewView {
workspace: workspace.clone(),
_markdown_subscription: cx.observe(
&markdown,
- |this: &mut Self, _: Entity<Markdown>, cx| {
+ |this: &mut Self, markdown: Entity<Markdown>, cx| {
this.sync_active_root_block(cx);
+ let is_parsing = markdown.read(cx).is_parsing();
+ if this.markdown_parse_pending && !is_parsing {
+ cx.emit(SearchEvent::MatchesInvalidated);
+ }
+ this.markdown_parse_pending = is_parsing;
},
),
markdown,
@@ -321,6 +329,7 @@ impl MarkdownPreviewView {
pending_update_task: None,
hovered_url: None,
mode,
+ markdown_parse_pending: false,
};
this.set_editor(active_editor, window, cx);
@@ -587,6 +596,7 @@ impl MarkdownPreviewView {
view.markdown.update(cx, |markdown, cx| {
markdown.reset(contents, cx);
});
+ view.markdown_parse_pending = view.markdown.read(cx).is_parsing();
view.sync_preview_to_source_index(selection_start, should_reveal_selection, cx);
cx.emit(SearchEvent::MatchesInvalidated);
}
@@ -1869,8 +1879,12 @@ impl SearchableItem for MarkdownPreviewView {
_window: &mut Window,
cx: &mut Context<Self>,
) -> Task<Vec<Self::Match>> {
- let source = self.markdown.read(cx).source().to_string();
- cx.background_spawn(async move { query.search_str(&source) })
+ let markdown = self.markdown.read(cx);
+ let source = markdown.source().to_string();
+ let non_rendered_ranges = markdown.non_rendered_source_ranges();
+ cx.background_spawn(async move {
+ filter_non_rendered_matches(query.search_str(&source), &non_rendered_ranges)
+ })
}
fn active_match_index(
@@ -1906,6 +1920,25 @@ impl SearchableItem for MarkdownPreviewView {
}
}
+/// `non_rendered_ranges` must be sorted by start and disjoint, as returned by
+/// [`Markdown::non_rendered_source_ranges`]. Matches may arrive in any order.
+fn filter_non_rendered_matches(
+ matches: Vec<Range<usize>>,
+ non_rendered_ranges: &[Range<usize>],
+) -> Vec<Range<usize>> {
+ matches
+ .into_iter()
+ .filter(|match_range| {
+ let candidate =
+ non_rendered_ranges.partition_point(|range| range.end <= match_range.start);
+
+ !non_rendered_ranges
+ .get(candidate)
+ .is_some_and(|range| range.start < match_range.end)
+ })
+ .collect()
+}
+
impl SerializableItem for MarkdownPreviewView {
fn serialized_item_kind() -> &'static str {
"MarkdownPreviewView"
@@ -2079,7 +2112,28 @@ mod tests {
AppState, ItemId, MultiWorkspace, SaveIntent, Workspace, WorkspaceId, open_paths,
};
- use super::{MarkdownPreviewView, open_preview_url};
+ use super::{MarkdownPreviewView, filter_non_rendered_matches, open_preview_url};
+
+ #[test]
+ fn filters_matches_in_non_rendered_link_source() {
+ let matches = vec![1..9, 30..37, 58..65];
+ let non_rendered_ranges = vec![0..1, 9..38];
+
+ assert_eq!(
+ filter_non_rendered_matches(matches, &non_rendered_ranges),
+ vec![1..9, 58..65]
+ );
+ }
+
+ #[test]
+ fn filters_matches_regardless_of_match_order() {
+ let non_rendered_ranges = vec![0..1, 9..38];
+
+ assert_eq!(
+ filter_non_rendered_matches(vec![58..65, 1..9, 30..37], &non_rendered_ranges),
+ vec![58..65, 1..9]
+ );
+ }
#[gpui::test]
fn resolves_workspace_absolute_preview_image_path_and_rejects_missing(cx: &mut App) {