Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
markdown_preview: Open Markdown links in preview and scroll to linked headings and positions (#61784)
Smit Barmase1102219f8122
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rsindex 98443eba690..25dcd06528a 100644--- a/crates/markdown/src/markdown.rs+++ b/crates/markdown/src/markdown.rs@@ -395,6 +395,8 @@ pub struct Markdown {pressed_link: Option<RenderedLink>,pressed_footnote_ref: Option<RenderedFootnoteRef>,autoscroll_request: Option<usize>,+ pending_heading_scroll: Option<SharedString>,+ pending_autoscroll: Option<usize>,active_root_block: Option<usize>,parsed_markdown: ParsedMarkdown,images_by_source_offset: HashMap<usize, Arc<Image>>,@@ -588,6 +590,8 @@ impl Markdown {pressed_link: None,pressed_footnote_ref: None,autoscroll_request: None,+ pending_heading_scroll: None,+ pending_autoscroll: None,active_root_block: None,should_reparse: false,images_by_source_offset: Default::default(),@@ -705,6 +709,14 @@ impl Markdown {self.pending_parse.is_some()}+ pub fn scroll_to_heading_when_parsed(&mut self, slug: SharedString, cx: &mut Context<Self>) {+ if self.pending_parse.is_some() || self.source.is_empty() {+ self.pending_heading_scroll = Some(slug);+ } else {+ self.scroll_to_heading(&slug, cx);+ }+ }+pub fn scroll_to_heading(&mut self, slug: &str, cx: &mut Context<Self>) -> Option<usize> {if let Some(source_index) = self.parsed_markdown.heading_slugs.get(slug).copied() {self.autoscroll_request = Some(source_index);@@ -756,7 +768,11 @@ impl Markdown {source_index: usize,cx: &mut Context<Self>,) {- self.autoscroll_request = Some(source_index);+ if self.pending_parse.is_some() {+ self.pending_autoscroll = Some(source_index);+ } else {+ self.autoscroll_request = Some(source_index);+ }cx.refresh_windows();}@@ -784,11 +800,24 @@ impl Markdown {pub fn reset(&mut self, source: SharedString, cx: &mut Context<Self>) {if &source == self.source() {+ if self.pending_parse.is_none() {+ if let Some(slug) = self.pending_heading_scroll.take() {+ self.pending_autoscroll = None;+ self.scroll_to_heading(&slug, cx);+ } else if let Some(source_index) = self.pending_autoscroll.take() {+ self.autoscroll_request = Some(source_index);+ cx.refresh_windows();+ }+ }return;}+ if !self.source.is_empty() {+ self.pending_heading_scroll = None;+ }self.source = source;self.selection = Selection::default();self.autoscroll_request = None;+ self.pending_autoscroll = None;self.pending_parse = None;self.should_reparse = false;self.search_highlights.clear();@@ -940,6 +969,8 @@ impl Markdown {if self.source.is_empty() {self.should_reparse = false;self.pending_parse.take();+ self.pending_heading_scroll = None;+ self.pending_autoscroll = None;self.parsed_markdown = ParsedMarkdown {source: self.source.clone(),..Default::default()@@ -1100,6 +1131,14 @@ impl Markdown {this.pending_parse.take();if this.should_reparse {this.parse(cx);+ } else if let Some(slug) = this.pending_heading_scroll.take()+ && let Some(source_index) =+ this.parsed_markdown.heading_slugs.get(&slug).copied()+ {+ this.pending_autoscroll = None;+ this.autoscroll_request = Some(source_index);+ } else if let Some(source_index) = this.pending_autoscroll.take() {+ this.autoscroll_request = Some(source_index);}cx.notify();cx.refresh_windows();@@ -4027,17 +4066,15 @@ impl RenderedText {fn position_for_source_index(&self, source_index: usize) -> Option<(Point<Pixels>, Pixels)> {for line in self.lines.iter() {- let line_source_start = line.source_mappings.first().unwrap().source_index;- if source_index < line_source_start {- break;- } else if source_index > line.source_end {+ if source_index > line.source_end {continue;- } else {- let line_height = line.layout.line_height();- let rendered_index_within_line = line.rendered_index_for_source_index(source_index);- let position = line.layout.position_for_index(rendered_index_within_line)?;- return Some((position, line_height));}+ 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}diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rsindex e2496ae6e46..be3a777ac62 100644--- a/crates/markdown_preview/src/markdown_preview_view.rs+++ b/crates/markdown_preview/src/markdown_preview_view.rs@@ -15,7 +15,7 @@ use gpui::{InteractiveElement, IntoElement, IsZero, Pixels, Render, Resource, RetainAllImageCache,ScrollHandle, SharedString, SharedUri, Subscription, Task, WeakEntity, Window, point, px,};-use language::LanguageRegistry;+use language::{Buffer, LanguageRegistry};use markdown::{CodeBlockRenderer, CopyButtonVisibility, Markdown, MarkdownElement, MarkdownFont,MarkdownOptions, MarkdownStyle,@@ -100,6 +100,11 @@ pub enum MarkdownPreviewEvent {SourceFileHandleChanged,}+enum PreviewLinkTarget {+ Heading(SharedString),+ Position { row: u32, column: u32 },+}+impl MarkdownPreviewView {pub fn register(workspace: &mut Workspace, _window: &mut Window, _cx: &mut Context<Workspace>) {workspace.register_action(move |workspace, _: &OpenPreview, window, cx| {@@ -195,30 +200,30 @@ impl MarkdownPreviewView {let target_buffer = editor.read(cx).buffer().read(cx).as_singleton()?;pane.items_of_type::<MarkdownPreviewView>().find(|view| {- let view_read = view.read(cx);// Only look for independent (Default mode) previews, not Follow previews.// Match by buffer entity rather than editor entity so the lookup survives// workspace restoration, where the preview's bound editor may differ from// the editor the user is currently invoking the action on even though both// wrap the same source buffer.- view_read.mode == MarkdownPreviewMode::Default- && view_read- .active_editor- .as_ref()- .is_some_and(|active_editor| {- active_editor- .editor- .read(cx)- .buffer()- .read(cx)- .as_singleton()- .as_ref()- == Some(&target_buffer)- })+ view.read(cx).mode == MarkdownPreviewMode::Default+ && view.read(cx).is_previewing(&target_buffer, cx)}).and_then(|view| pane.index_for_item(&view))}+ fn is_previewing(&self, buffer: &Entity<Buffer>, cx: &App) -> bool {+ self.active_editor.as_ref().is_some_and(|state| {+ state+ .editor+ .read(cx)+ .buffer()+ .read(cx)+ .as_singleton()+ .as_ref()+ == Some(buffer)+ })+ }+pub fn resolve_active_item_as_markdown_editor(workspace: &Workspace,cx: &mut Context<Workspace>,@@ -363,10 +368,14 @@ impl MarkdownPreviewView {}}- pub fn is_markdown_path(path: impl AsRef<Path>) -> bool {- path.as_ref().extension().is_some_and(|ext| {- ext.eq_ignore_ascii_case("md") || ext.eq_ignore_ascii_case("markdown")- })+ pub fn is_markdown_path(path: impl AsRef<Path>, languages: &Arc<LanguageRegistry>) -> bool {+ languages+ .language_for_file_path(path.as_ref())+ .is_some_and(|language_id| {+ languages+ .available_language_for_name("Markdown")+ .is_some_and(|markdown| markdown.id() == language_id)+ })}pub fn open_for_project_path(@@ -623,6 +632,47 @@ impl MarkdownPreviewView {});}+ fn navigate_to_link_target(+ &mut self,+ target: Option<PreviewLinkTarget>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ match target {+ None => {}+ Some(PreviewLinkTarget::Heading(slug)) => {+ self.markdown.update(cx, |markdown, cx| {+ markdown.scroll_to_heading_when_parsed(slug, cx);+ });+ }+ Some(PreviewLinkTarget::Position { row, column }) => {+ let Some(editor) = self+ .active_editor+ .as_ref()+ .map(|state| state.editor.clone())+ else {+ return;+ };+ let Some(source_index) =+ editor+ .read(cx)+ .buffer()+ .read(cx)+ .as_singleton()+ .map(|buffer| {+ let snapshot = buffer.read(cx).snapshot();+ let point = snapshot.point_from_external_input(row, column);+ snapshot.point_to_offset(point)+ })+ else {+ return;+ };+ Self::change_selection_to_source_index(&editor, source_index, false, window, cx);+ self.sync_preview_to_source_index(source_index, true, cx);+ }+ }+ }+fn change_selection_to_source_index(editor: &Entity<Editor>,source_index: usize,@@ -1079,6 +1129,7 @@ fn handle_url_click(SharedString::from(path_part.to_string()),fragment.map(|fragment| SharedString::from(fragment.to_string())),base_directory,+ Some(view.clone()),workspace,window,cx,@@ -1090,43 +1141,77 @@ fn open_preview_url(url: SharedString,fragment: Option<SharedString>,base_directory: Option<PathBuf>,+ source_view: Option<WeakEntity<MarkdownPreviewView>>,workspace: &WeakEntity<Workspace>,window: &mut Window,cx: &mut App,) {let decoded_path = urlencoding::decode(&url).unwrap_or_else(|_| Cow::Borrowed(&url));- // Only `://` URLs skip position handling (a scheme check would misclassify `main.rs:2`); ambiguous links like `tel:123` are tried as files first, then fall back to the URL handler.- let path_with_position = if !decoded_path.contains("://") {- if PathWithPosition::parse_str(&decoded_path).row.is_some() {- Some(decoded_path.to_string())- } else {- fragment- .as_deref()- .and_then(|fragment| fragment.strip_prefix('L'))- .and_then(source_position_from_fragment)- .map(|(row, column)| {- if column == 0 {- format!("{decoded_path}:{}", row + 1)- } else {- format!("{decoded_path}:{}:{}", row + 1, column + 1)- }+ // Only `://` URLs skip local handling (a scheme check would misclassify `main.rs:2`); ambiguous links like `tel:123` are tried as files first, then fall back to the URL handler.+ if !decoded_path.contains("://") {+ let parsed_path = PathWithPosition::parse_str(&decoded_path);+ let fragment_position = fragment+ .as_deref()+ .and_then(|fragment| fragment.strip_prefix('L'))+ .and_then(source_position_from_fragment);++ if !window.modifiers().alt+ && workspace+ .read_with(cx, |workspace, cx| {+ MarkdownPreviewView::is_markdown_path(+ &parsed_path.path,+ workspace.project().read(cx).languages(),+ )})+ .is_ok_and(|is_markdown| is_markdown)+ {+ let link_target = if let Some(row) = parsed_path.row {+ Some(PreviewLinkTarget::Position {+ row: row.saturating_sub(1),+ column: parsed_path.column.unwrap_or(1).saturating_sub(1),+ })+ } else if let Some((row, column)) = fragment_position {+ Some(PreviewLinkTarget::Position { row, column })+ } else {+ fragment.map(PreviewLinkTarget::Heading)+ };+ open_markdown_link_in_preview(+ parsed_path.path.to_string_lossy().into_owned(),+ link_target,+ decoded_path.into_owned(),+ base_directory,+ source_view,+ workspace,+ window,+ cx,+ );+ return;}- } else {- None- };- if let Some(path_with_position) = path_with_position {- open_preview_path_with_position(- path_with_position,- decoded_path.into_owned(),- base_directory,- workspace,- window,- cx,- );- return;+ let path_with_position = if parsed_path.row.is_some() {+ Some(decoded_path.to_string())+ } else {+ fragment_position.map(|(row, column)| {+ if column == 0 {+ format!("{decoded_path}:{}", row + 1)+ } else {+ format!("{decoded_path}:{}:{}", row + 1, column + 1)+ }+ })+ };++ if let Some(path_with_position) = path_with_position {+ open_preview_path_with_position(+ path_with_position,+ decoded_path.into_owned(),+ base_directory,+ workspace,+ window,+ cx,+ );+ return;+ }}if let Some(workspace) = workspace.upgrade() {@@ -1138,6 +1223,110 @@ fn open_preview_url(}}+fn find_preview_for_buffer(+ workspace: &Workspace,+ buffer: &Entity<Buffer>,+ cx: &App,+) -> Option<Entity<MarkdownPreviewView>> {+ workspace+ .items_of_type::<MarkdownPreviewView>(cx)+ .find(|view| {+ view.read(cx).mode == MarkdownPreviewMode::Default+ && view.read(cx).is_previewing(buffer, cx)+ })+}++fn open_markdown_link_in_preview(+ path: String,+ link_target: Option<PreviewLinkTarget>,+ fallback_url: String,+ base_directory: Option<PathBuf>,+ source_view: Option<WeakEntity<MarkdownPreviewView>>,+ workspace: &WeakEntity<Workspace>,+ window: &mut Window,+ cx: &mut App,+) {+ let open_target = resolve_open_target(+ workspace,+ PathMatching::Exact,+ &path,+ base_directory.as_deref(),+ cx,+ );+ let workspace = workspace.clone();+ let workspace_for_error = workspace.clone();+ let task = window.spawn(cx, async move |cx| {+ let target_path = open_target+ .await+ .filter(|open_target| open_target.is_file())+ .map(|open_target| open_target.path().path.clone());+ let Some(abs_path) = target_path else {+ workspace.update_in(cx, |workspace, window, cx| {+ workspace.open_url_or_file(&fallback_url, base_directory.as_deref(), window, cx);+ })?;+ return anyhow::Ok(());+ };++ let project = workspace.read_with(cx, |workspace, _| workspace.project().clone())?;+ let (worktree, relative_path) = project+ .update(cx, |project, cx| {+ project.find_or_create_worktree(abs_path, false, cx)+ })+ .await+ .context("resolving Markdown preview link worktree")?;+ let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id());+ let buffer = project+ .update(cx, |project, cx| {+ project.open_buffer(+ ProjectPath {+ worktree_id,+ path: relative_path,+ },+ cx,+ )+ })+ .await+ .context("opening Markdown preview link buffer")?;++ workspace.update_in(cx, |workspace, window, cx| {+ if let Some(source_view) = source_view.as_ref().and_then(|view| view.upgrade())+ && source_view.read(cx).is_previewing(&buffer, cx)+ {+ source_view.update(cx, |view, cx| {+ view.navigate_to_link_target(link_target, window, cx);+ });+ return;+ }++ if let Some(existing_view) = find_preview_for_buffer(workspace, &buffer, cx) {+ workspace.activate_item(&existing_view, true, true, window, cx);+ existing_view.update(cx, |view, cx| {+ view.navigate_to_link_target(link_target, window, cx);+ });+ return;+ }++ let editor = cx.new(|cx| {+ Editor::for_buffer(buffer, Some(workspace.project().clone()), window, cx)+ });+ let preview = MarkdownPreviewView::create_markdown_view(workspace, editor, window, cx);+ let pane = source_view+ .as_ref()+ .and_then(|view| view.upgrade())+ .and_then(|view| workspace.pane_for(&view))+ .unwrap_or_else(|| workspace.active_pane().clone());+ pane.update(cx, |pane, cx| {+ pane.add_item(Box::new(preview.clone()), true, true, None, window, cx);+ });+ preview.update(cx, |view, cx| {+ view.navigate_to_link_target(link_target, window, cx);+ });+ })?;+ anyhow::Ok(())+ });+ task.detach_and_notify_err(workspace_for_error, window, cx);+}+fn open_preview_path_with_position(path_with_position: String,fallback_path: String,@@ -1793,7 +1982,9 @@ mod tests {use buffer_diff::BufferDiff;use editor::Editor;use fs::FakeFs;- use gpui::{AppContext as _, Entity, Focusable as _, TestAppContext, WindowHandle};+ use gpui::{+ AppContext as _, Entity, Focusable as _, Modifiers, TestAppContext, WindowHandle, px,+ };use language::{Buffer, DiskState, Point};use project::Project;use serde_json::json;@@ -1845,12 +2036,13 @@ mod tests {fs.insert_tree(path!("/project"),json!({- "docs": {"guide.md": "alpha\nbeta\ngamma\n"},+ "docs": {"guide.txt": "alpha\nbeta\ngamma\n"},"src": {"main.rs": "first\nsecond\nthird\n"}}),).await;let project = Project::test(fs, [path!("/project").as_ref()], cx).await;+ register_markdown_language(&project, cx);let (multi_workspace, cx) =cx.add_window_view(|window, cx| MultiWorkspace::test_new(project, window, cx));let workspace =@@ -1862,6 +2054,7 @@ mod tests {"../src/main.rs:2:4".into(),None,Some(PathBuf::from(path!("/project/docs"))),+ None,&workspace_weak,window,cx,@@ -1888,6 +2081,7 @@ mod tests {"../src/main.rs".into(),Some("L3".into()),Some(PathBuf::from(path!("/project/docs"))),+ None,&workspace_weak,window,cx,@@ -1903,12 +2097,13 @@ mod tests {);});- // `guide.md:2` must open the sibling file at line 2 despite `guide.md:` being a valid URI scheme prefix.+ // `guide.txt:2` must open the sibling file at line 2 despite `guide.txt:` being a valid URI scheme prefix.multi_workspace.update_in(cx, |_, window, cx| {open_preview_url(- "guide.md:2".into(),+ "guide.txt:2".into(),None,Some(PathBuf::from(path!("/project/docs"))),+ None,&workspace_weak,window,cx,@@ -1920,7 +2115,7 @@ mod tests {workspace.active_item(cx).and_then(|item| item.downcast::<Editor>())- .expect("guide.md should be open in an editor")+ .expect("guide.txt should be open in an editor")});guide_editor.update_in(cx, |editor, window, cx| {let file_path = editor@@ -1929,7 +2124,7 @@ mod tests {.as_singleton().and_then(|buffer| buffer.read(cx).file().map(|file| file.path().clone())).expect("opened editor should have a file");- assert_eq!(file_path.as_ref(), rel_path("docs/guide.md"));+ assert_eq!(file_path.as_ref(), rel_path("docs/guide.txt"));let snapshot = editor.snapshot(window, cx);assert_eq!(editor.selections.newest::<Point>(&snapshot).head(),@@ -1943,6 +2138,7 @@ mod tests {"main.rs:2".into(),None,Some(PathBuf::from(path!("/project/docs"))),+ None,&workspace_weak,window,cx,@@ -1965,6 +2161,7 @@ mod tests {"tel:123".into(),None,Some(PathBuf::from(path!("/project/docs"))),+ None,&workspace_weak,window,cx,@@ -1974,6 +2171,308 @@ mod tests {assert_eq!(cx.opened_url().as_deref(), Some("tel:123"));}+ #[gpui::test]+ async fn opens_markdown_links_in_preview(cx: &mut TestAppContext) {+ init_test(cx);++ let mut notes = String::from("# Notes\n\nintro\n\n");+ for _ in 0..100 {+ notes.push_str("filler line\n\n");+ }+ notes.push_str("## Target Section\n\nfound it\n");++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/project"),+ json!({+ "notes.md": notes,+ "other.md": "# Other\n\nshort\n",+ }),+ )+ .await;+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;+ register_markdown_language(&project, cx);+ let (multi_workspace, cx) =+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project, window, cx));+ let workspace =+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());+ let workspace_weak = workspace.downgrade();++ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "notes.md".into(),+ Some("target-section".into()),+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();++ let preview = workspace.read_with(cx, |workspace, cx| {+ assert_eq!(+ workspace.items_of_type::<Editor>(cx).count(),+ 0,+ "markdown links must not open raw editors"+ );+ workspace+ .active_item(cx)+ .and_then(|item| item.downcast::<MarkdownPreviewView>())+ .expect("notes.md should open in a Markdown preview")+ });+ assert_eq!(+ preview_source_path(cx, &preview).as_ref(),+ rel_path("notes.md")+ );+ let heading_scroll_offset =+ preview.read_with(cx, |preview, _| preview.scroll_handle.offset());+ assert!(+ heading_scroll_offset.y < px(0.),+ "preview should scroll down to the linked heading, got {heading_scroll_offset:?}"+ );++ let preview_editor = preview.read_with(cx, |preview, _| {+ preview.active_editor.as_ref().unwrap().editor.clone()+ });+ preview_editor.update_in(cx, |editor, _, cx| {+ let end = editor.buffer().read(cx).snapshot(cx).len();+ editor.edit([(end..end, "\nappended\n")], cx);+ });+ cx.executor().advance_clock(Duration::from_millis(300));+ cx.run_until_parked();+ assert_eq!(+ preview.read_with(cx, |preview, _| preview.scroll_handle.offset()),+ heading_scroll_offset,+ "reparsing after an edit must not replay the consumed heading scroll"+ );++ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "notes.md".into(),+ None,+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ workspace.read_with(cx, |workspace, cx| {+ assert_eq!(+ workspace.items_of_type::<MarkdownPreviewView>(cx).count(),+ 1+ );+ assert_eq!(+ workspace.active_item(cx).map(|item| item.item_id()),+ Some(preview.entity_id())+ );+ });++ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "notes.md:105:1".into(),+ None,+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ workspace.read_with(cx, |workspace, cx| {+ assert_eq!(+ workspace.items_of_type::<Editor>(cx).count(),+ 0,+ "a position on a markdown link must not open a raw editor"+ );+ assert_eq!(+ workspace.active_item(cx).map(|item| item.item_id()),+ Some(preview.entity_id())+ );+ });+ preview_editor.update_in(cx, |editor, window, cx| {+ let snapshot = editor.snapshot(window, cx);+ assert_eq!(+ editor.selections.newest::<Point>(&snapshot).head(),+ Point::new(104, 0)+ );+ });++ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "notes.md".into(),+ Some("L3".into()),+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ workspace.read_with(cx, |workspace, cx| {+ assert_eq!(+ workspace.items_of_type::<Editor>(cx).count(),+ 0,+ "an `#L<row>` fragment on a markdown link must not open a raw editor"+ );+ assert_eq!(+ workspace.active_item(cx).map(|item| item.item_id()),+ Some(preview.entity_id())+ );+ });+ preview_editor.update_in(cx, |editor, window, cx| {+ let snapshot = editor.snapshot(window, cx);+ assert_eq!(+ editor.selections.newest::<Point>(&snapshot).head(),+ Point::new(2, 0)+ );+ });++ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "other.md".into(),+ Some("missing-heading".into()),+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ let other_preview = workspace.read_with(cx, |workspace, cx| {+ assert_eq!(+ workspace.items_of_type::<MarkdownPreviewView>(cx).count(),+ 2+ );+ workspace+ .active_item(cx)+ .and_then(|item| item.downcast::<MarkdownPreviewView>())+ .expect("other.md should open in a Markdown preview")+ });+ assert_eq!(+ preview_source_path(cx, &other_preview).as_ref(),+ rel_path("other.md")+ );+ assert_eq!(+ other_preview+ .read_with(cx, |preview, _| preview.scroll_handle.offset())+ .y,+ px(0.),+ "a dead anchor must open the document at the top"+ );++ cx.simulate_modifiers_change(Modifiers::alt());+ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "notes.md:5:3".into(),+ None,+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();+ cx.simulate_modifiers_change(Modifiers::default());++ let raw_editor = workspace.read_with(cx, |workspace, cx| {+ workspace+ .active_item(cx)+ .and_then(|item| item.downcast::<Editor>())+ .expect("alt-click should open the raw editor")+ });+ raw_editor.update_in(cx, |editor, window, cx| {+ let snapshot = editor.snapshot(window, cx);+ assert_eq!(+ editor.selections.newest::<Point>(&snapshot).head(),+ Point::new(4, 2)+ );+ });++ preview.read_with(cx, |preview, _| {+ assert_eq!(+ preview+ .active_editor+ .as_ref()+ .map(|state| state.editor.clone()),+ Some(raw_editor.clone())+ );+ });+ }++ #[gpui::test]+ async fn scrolls_position_link_in_newly_created_preview(cx: &mut TestAppContext) {+ init_test(cx);++ let mut notes = String::from("# Notes\n\nintro\n\n");+ for _ in 0..100 {+ notes.push_str("filler line\n\n");+ }+ notes.push_str("## Target Section\n\nfound it\n");++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(path!("/project"), json!({ "notes.md": notes }))+ .await;+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;+ register_markdown_language(&project, cx);+ let (multi_workspace, cx) =+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project, window, cx));+ let workspace =+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());+ let workspace_weak = workspace.downgrade();++ multi_workspace.update_in(cx, |_, window, cx| {+ open_preview_url(+ "notes.md:180:1".into(),+ None,+ Some(PathBuf::from(path!("/project"))),+ None,+ &workspace_weak,+ window,+ cx,+ );+ });+ cx.run_until_parked();++ let preview = workspace.read_with(cx, |workspace, cx| {+ assert_eq!(+ workspace.items_of_type::<Editor>(cx).count(),+ 0,+ "a position on a markdown link must not open a raw editor"+ );+ workspace+ .active_item(cx)+ .and_then(|item| item.downcast::<MarkdownPreviewView>())+ .expect("notes.md should open in a Markdown preview")+ });+ assert_eq!(+ preview_source_path(cx, &preview).as_ref(),+ rel_path("notes.md")+ );+ let preview_editor = preview.read_with(cx, |preview, _| {+ preview.active_editor.as_ref().unwrap().editor.clone()+ });+ preview_editor.update_in(cx, |editor, window, cx| {+ let snapshot = editor.snapshot(window, cx);+ assert_eq!(+ editor.selections.newest::<Point>(&snapshot).head(),+ Point::new(179, 0)+ );+ });+ let scroll_offset = preview.read_with(cx, |preview, _| preview.scroll_handle.offset());+ assert!(+ scroll_offset.y < px(0.),+ "a new preview should scroll down to the linked position, got {scroll_offset:?}"+ );+ }+#[gpui::test]async fn toggles_task_checkbox_and_saves_when_preview_is_active(cx: &mut TestAppContext) {let app_state = init_test(cx);@@ -2894,6 +3393,21 @@ mod tests {})}+ fn register_markdown_language(project: &Entity<Project>, cx: &mut TestAppContext) {+ let languages = project.read_with(cx, |project, _| project.languages().clone());+ languages.add(Arc::new(language::Language::new(+ language::LanguageConfig {+ name: "Markdown".into(),+ matcher: Arc::new(language::LanguageMatcher {+ path_suffixes: vec!["md".to_string(), "markdown".to_string()],+ ..Default::default()+ }),+ ..Default::default()+ },+ None,+ )));+ }+async fn wait_for_preview_serialization(cx: &mut TestAppContext) {cx.run_until_parked();cx.executor().advance_clock(Duration::from_millis(250));diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rsindex 6722fee9eca..670bdd40989 100644--- a/crates/project_panel/src/project_panel.rs+++ b/crates/project_panel/src/project_panel.rs@@ -1092,7 +1092,11 @@ impl ProjectPanel {let is_remote = project.is_remote();let is_collab = project.is_via_collab();let is_local = project.is_local() || project.is_via_wsl_with_host_interop(cx);- let is_markdown = !is_dir && MarkdownPreviewView::is_markdown_path(&*entry.path);+ let is_markdown = !is_dir+ && MarkdownPreviewView::is_markdown_path(+ entry.path.as_std_path(),+ project.languages(),+ );let settings = ProjectPanelSettings::get_global(cx);let visible_worktrees_count = project.visible_worktrees(cx).count();@@ -1783,7 +1787,12 @@ impl ProjectPanel {let Some((worktree, entry)) = self.selected_entry(cx) else {return;};- if !entry.is_file() || !MarkdownPreviewView::is_markdown_path(&*entry.path) {+ if !entry.is_file()+ || !MarkdownPreviewView::is_markdown_path(+ entry.path.as_std_path(),+ self.project.read(cx).languages(),+ )+ {return;}let project_path = ProjectPath {diff --git a/crates/util/src/markdown.rs b/crates/util/src/markdown.rsindex 8c45f98bf86..92c3ffedc93 100644--- a/crates/util/src/markdown.rs+++ b/crates/util/src/markdown.rs@@ -59,12 +59,12 @@ pub fn split_local_url_fragment(url: &str) -> (&str, Option<&str>) {pub fn source_position_from_fragment(fragment: &str) -> Option<(u32, u32)> {let fragment = fragment.strip_prefix('L').unwrap_or(fragment);- let (line, column) = match fragment.split_once([',', ':']) {+ let fragment = fragment+ .split_once('-')+ .map_or(fragment, |(start, _)| start);+ let (line, column) = match fragment.split_once([',', ':', 'C']) {Some((line, column)) => (line, Some(column)),- None => (- fragment.split_once('-').map_or(fragment, |(line, _)| line),- None,- ),+ None => (fragment, None),};let line = line.parse::<u32>().ok()?.checked_sub(1)?;let column = column@@ -373,6 +373,8 @@ mod tests {assert_eq!(source_position_from_fragment("33,33"), Some((32, 32)));assert_eq!(source_position_from_fragment("L42"), Some((41, 0)));assert_eq!(source_position_from_fragment("L42:7"), Some((41, 6)));+ assert_eq!(source_position_from_fragment("L3C5"), Some((2, 4)));+ assert_eq!(source_position_from_fragment("L3C5-L8C10"), Some((2, 4)));assert_eq!(source_position_from_fragment("5"), Some((4, 0)));assert_eq!(source_position_from_fragment("L10-L20"), Some((9, 0)));assert_eq!(source_position_from_fragment("heading"), None);