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.rsindex 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 = "";+ 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 = "[](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  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.rsindex 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.rsindex 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) {