Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
markdown: Improve selection copying to always yield valid markdown (#60657)
Smit Barmase8f907c5ee1ab
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex fe8b7b29233..08646698120 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -7402,7 +7402,7 @@ impl ThreadView {block.markdown()}};- md.map_or(false, |m| m.read(cx).selected_text().is_some())+ md.map_or(false, |m| m.read(cx).has_selection())})}).unwrap_or(false);diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rsindex 69f5aa32083..a4651e5d7e5 100644--- a/crates/markdown/src/markdown.rs+++ b/crates/markdown/src/markdown.rs@@ -2,6 +2,7 @@ pub mod html;mod mermaid;pub mod parser;mod path_range;+mod selection;use base64::Engine as _;use futures::FutureExt as _;@@ -808,12 +809,15 @@ impl Markdown {output.into()}- pub fn selected_text(&self) -> Option<String> {+ pub fn has_selection(&self) -> bool {+ self.selection.end > self.selection.start+ }++ pub fn selected_source(&self) -> Option<&str> {if self.selection.end <= self.selection.start {- None- } else {- Some(self.source[self.selection.start..self.selection.end].to_string())+ return None;}+ self.source.get(self.selection.start..self.selection.end)}pub fn set_search_highlights(@@ -873,7 +877,9 @@ impl Markdown {if self.selection.end <= self.selection.start {return;}- let text = self.source[self.selection.start..self.selection.end].to_string();+ let text = self+ .parsed_markdown+ .rebalanced_markdown_for_selection(self.selection.start..self.selection.end);cx.write_to_clipboard(ClipboardItem::new_string(text));}@@ -884,8 +890,10 @@ impl Markdown {) {let range = self.selection.start..self.selection.end;if range.end > range.start {- self.context_menu_selected_markdown =- Some(SharedString::new(&self.source[range.clone()]));+ self.context_menu_selected_markdown = Some(SharedString::new(+ self.parsed_markdown+ .rebalanced_markdown_for_selection(range.clone()),+ ));self.context_menu_selected_text = rendered_text.map(|text| text.text_for_range(range)).map(SharedString::new)@@ -910,8 +918,9 @@ impl Markdown {self.context_menu_selected_text.as_ref()}- /// Returns the raw markdown source that was selected when the most recent- /// context menu invocation happened.+ /// Returns the markdown that was selected when the most recent context+ /// menu invocation happened, rebalanced via+ /// [`ParsedMarkdown::rebalanced_markdown_for_selection`].pub fn context_menu_selected_markdown(&self) -> Option<&SharedString> {self.context_menu_selected_markdown.as_ref()}@@ -1207,6 +1216,21 @@ impl ParsedMarkdown {Some(partition.saturating_sub(1))}++ /// Extracts the markdown source for a selection, rebalancing inline+ /// delimiters (`**`, backticks, link syntax, etc.) so partial selections of+ /// styled spans stay well-formed.+ ///+ /// With an exception of a single inline code span, which is returned as plain+ /// text, since copying a command or identifier is the dominant use case there.+ pub fn rebalanced_markdown_for_selection(&self, selection: Range<usize>) -> String {+ selection::rebalanced_markdown_for_selection(+ &self.source,+ &self.events,+ &self.root_block_starts,+ selection,+ )+ }}pub enum AutoscrollBehavior {diff --git a/crates/markdown/src/selection.rs b/crates/markdown/src/selection.rsnew file mode 100644index 00000000000..9e7851b549b--- /dev/null+++ b/crates/markdown/src/selection.rs@@ -0,0 +1,598 @@+use crate::parser::{MarkdownEvent, MarkdownTag, MarkdownTagEnd};+use std::ops::Range;++struct InlineSpan {+ range: Range<usize>,+ content: Range<usize>,+ is_code: bool,+}++impl InlineSpan {+ fn opening<'a>(&self, source: &'a str) -> &'a str {+ source+ .get(self.range.start..self.content.start)+ .unwrap_or("")+ }++ fn closing<'a>(&self, source: &'a str) -> &'a str {+ source.get(self.content.end..self.range.end).unwrap_or("")+ }+}++fn is_inline_span_tag(tag: &MarkdownTag) -> bool {+ matches!(+ tag,+ MarkdownTag::Emphasis+ | MarkdownTag::Strong+ | MarkdownTag::Strikethrough+ | MarkdownTag::Superscript+ | MarkdownTag::Subscript+ | MarkdownTag::Link { .. }+ )+}++fn is_inline_span_tag_end(tag: &MarkdownTagEnd) -> bool {+ matches!(+ tag,+ MarkdownTagEnd::Emphasis+ | MarkdownTagEnd::Strong+ | MarkdownTagEnd::Strikethrough+ | MarkdownTagEnd::Superscript+ | MarkdownTagEnd::Subscript+ | MarkdownTagEnd::Link+ )+}++fn inline_code_full_range(source: &str, content: &Range<usize>) -> Range<usize> {+ let opening_ticks = source[..content.start]+ .bytes()+ .rev()+ .take_while(|&byte| byte == b'`')+ .count();+ let closing_ticks = source[content.end..]+ .bytes()+ .take_while(|&byte| byte == b'`')+ .count();+ let ticks = opening_ticks.min(closing_ticks);+ content.start - ticks..content.end + ticks+}++fn collect_inline_spans(source: &str, events: &[(Range<usize>, MarkdownEvent)]) -> Vec<InlineSpan> {+ fn note_child(stack: &mut [(Range<usize>, Option<Range<usize>>)], child: &Range<usize>) {+ for (_, content) in stack.iter_mut() {+ match content {+ Some(content) => content.end = content.end.max(child.end),+ None => *content = Some(child.clone()),+ }+ }+ }++ let mut spans = Vec::new();+ let mut stack: Vec<(Range<usize>, Option<Range<usize>>)> = Vec::new();+ for (event_range, event) in events {+ match event {+ MarkdownEvent::Start(tag) if is_inline_span_tag(tag) => {+ note_child(&mut stack, event_range);+ stack.push((event_range.clone(), None));+ }+ MarkdownEvent::End(tag) if is_inline_span_tag_end(tag) => {+ if let Some((range, content)) = stack.pop() {+ let content = content.unwrap_or(range.clone());+ spans.push(InlineSpan {+ range,+ content,+ is_code: false,+ });+ }+ note_child(&mut stack, event_range);+ }+ MarkdownEvent::Code | MarkdownEvent::SubstitutedCode(_) => {+ let range = inline_code_full_range(source, event_range);+ note_child(&mut stack, &range);+ spans.push(InlineSpan {+ range,+ content: event_range.clone(),+ is_code: true,+ });+ }+ _ => note_child(&mut stack, event_range),+ }+ }+ spans+}++pub(crate) fn rebalanced_markdown_for_selection(+ source: &str,+ events: &[(Range<usize>, MarkdownEvent)],+ root_block_starts: &[usize],+ selection: Range<usize>,+) -> String {+ let Some(selection) = snap_to_char_boundaries(source, selection) else {+ return String::new();+ };++ let (start_events, end_events) = boundary_block_events(events, root_block_starts, &selection);+ let mut spans = collect_inline_spans(source, start_events);+ spans.extend(collect_inline_spans(source, end_events));++ let Some(selection) = snap_out_of_delimiters(&spans, selection) else {+ return String::new();+ };++ if selection_is_only_inside_code_spans(&spans, &selection) {+ return source[selection].to_string();+ }++ rebalance_delimiters(source, &spans, &selection)+}++/// Returns the events of the root blocks containing each selection boundary.+/// The second slice is empty when both boundaries share a block.+fn boundary_block_events<'a>(+ events: &'a [(Range<usize>, MarkdownEvent)],+ root_block_starts: &[usize],+ selection: &Range<usize>,+) -> (+ &'a [(Range<usize>, MarkdownEvent)],+ &'a [(Range<usize>, MarkdownEvent)],+) {+ if root_block_starts.is_empty() {+ return (events, &[]);+ }+ let start_block = root_block_index(root_block_starts, selection.start);+ let end_block = root_block_index(root_block_starts, selection.end);+ let start_events = root_block_events(events, root_block_starts, start_block);+ if end_block == start_block {+ (start_events, &[])+ } else {+ (+ start_events,+ root_block_events(events, root_block_starts, end_block),+ )+ }+}++fn root_block_index(root_block_starts: &[usize], offset: usize) -> usize {+ root_block_starts+ .partition_point(|block_start| *block_start <= offset)+ .saturating_sub(1)+}++fn root_block_events<'a>(+ events: &'a [(Range<usize>, MarkdownEvent)],+ root_block_starts: &[usize],+ block: usize,+) -> &'a [(Range<usize>, MarkdownEvent)] {+ let Some(&block_start) = root_block_starts.get(block) else {+ return events;+ };+ let start = events.partition_point(|(range, _)| range.start < block_start);+ let end = match root_block_starts.get(block + 1) {+ Some(&next_block_start) => {+ events.partition_point(|(range, _)| range.start < next_block_start)+ }+ None => events.len(),+ };+ events.get(start..end).unwrap_or(events)+}++fn snap_to_char_boundaries(source: &str, selection: Range<usize>) -> Option<Range<usize>> {+ let mut start = selection.start.min(source.len());+ let mut end = selection.end.min(source.len());+ if start >= end {+ return None;+ }+ while start > 0 && !source.is_char_boundary(start) {+ start -= 1;+ }+ while end < source.len() && !source.is_char_boundary(end) {+ end += 1;+ }+ Some(start..end)+}++/// Shrinks selection boundaries that fall inside delimiter syntax (`**`,+/// etc.) so no delimiter is left half-selected:+///+/// - an end in `**bold*|*` snaps back to `**bold|**`+/// - a start in `*|*bold**` snaps forward to `**|bold**`+///+/// This repeats until stable, since snapping can land inside a nested span's+/// delimiter. Returns `None` if the selection becomes empty.+fn snap_out_of_delimiters(spans: &[InlineSpan], selection: Range<usize>) -> Option<Range<usize>> {+ let mut start = selection.start;+ let mut end = selection.end;+ loop {+ let mut changed = false;+ for span in spans {+ if end > span.range.start && end <= span.content.start {+ end = span.range.start;+ changed = true;+ } else if end > span.content.end && end <= span.range.end {+ end = span.content.end;+ changed = true;+ }+ if start >= span.range.start && start < span.content.start {+ start = span.content.start;+ changed = true;+ } else if start >= span.content.end && start < span.range.end {+ start = span.range.end;+ changed = true;+ }+ }+ if !changed {+ break;+ }+ }+ (start < end).then(|| start..end)+}++fn selection_is_only_inside_code_spans(spans: &[InlineSpan], selection: &Range<usize>) -> bool {+ let contains = |span: &InlineSpan| {+ span.content.start <= selection.start && selection.end <= span.content.end+ };+ spans.iter().any(|span| span.is_code && contains(span))+ && !spans.iter().any(|span| !span.is_code && contains(span))+}++/// Re-adds delimiters cut off by the selection so the result is well-formed+/// markdown:+///+/// - selecting `old te` in `**bold text**` yields `**old te**`+/// - nested spans are reopened outermost first: selecting `alic` in+/// `**bold _italic_**` yields `**_alic_**`+fn rebalance_delimiters(source: &str, spans: &[InlineSpan], selection: &Range<usize>) -> String {+ let nesting_order = |a: &&InlineSpan, b: &&InlineSpan| {+ a.range+ .start+ .cmp(&b.range.start)+ .then(b.range.end.cmp(&a.range.end))+ };++ let mut open_at_start = spans+ .iter()+ .filter(|span| span.content.start <= selection.start && selection.start < span.content.end)+ .collect::<Vec<_>>();+ open_at_start.sort_by(nesting_order);++ let mut open_at_end = spans+ .iter()+ .filter(|span| span.content.start < selection.end && selection.end <= span.content.end)+ .collect::<Vec<_>>();+ open_at_end.sort_by(nesting_order);++ let mut result = String::new();+ for span in &open_at_start {+ result.push_str(span.opening(source));+ }+ result.push_str(&source[selection.clone()]);+ for span in open_at_end.iter().rev() {+ result.push_str(span.closing(source));+ }++ result+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::parser::parse_markdown_with_options;+ use util::test::marked_text_ranges;++ fn markdown_for(source: &str, selection: Range<usize>) -> String {+ let parsed = parse_markdown_with_options(source, false, false, false);+ rebalanced_markdown_for_selection(+ source,+ &parsed.events,+ &parsed.root_block_starts,+ selection,+ )+ }++ fn markdown_for_marked(marked_source: &str) -> String {+ let (source, selection) = marked_range(marked_source);+ markdown_for(&source, selection)+ }++ #[track_caller]+ fn assert_marked_selection(marked_source: &str, expected: &str) {+ assert_eq!(+ markdown_for_marked(marked_source),+ expected,+ "source: {marked_source:?}"+ );+ }++ #[track_caller]+ fn marked_range(marked_source: &str) -> (String, Range<usize>) {+ let (source, ranges) = marked_text_ranges(marked_source, false);+ match ranges.as_slice() {+ [selection] => (source, selection.clone()),+ _ => panic!("expected exactly one «» range in marked source"),+ }+ }++ fn inline_spans(source: &str) -> Vec<InlineSpan> {+ let parsed = parse_markdown_with_options(source, false, false, false);+ collect_inline_spans(source, &parsed.events)+ }++ #[track_caller]+ fn assert_snapped(marked_selection: &str, marked_expected: Option<&str>, message: &str) {+ let (source, selection) = marked_range(marked_selection);+ let expected = marked_expected.map(|marked_expected| {+ let (expected_source, range) = marked_range(marked_expected);+ assert_eq!(+ expected_source, source,+ "expected must be marked on the same source"+ );+ range+ });+ assert_eq!(+ snap_out_of_delimiters(&inline_spans(&source), selection),+ expected,+ "{message}"+ );+ }++ #[test]+ fn test_snap_out_of_delimiters() {+ assert_snapped(+ "**«bold»** rest",+ Some("**«bold»** rest"),+ "boundaries already in content must be untouched",+ );+ assert_snapped(+ "*«*bold»** rest",+ Some("**«bold»** rest"),+ "a start in the opening delimiter must advance into the content",+ );+ assert_snapped(+ "**«bold*»* rest",+ Some("**«bold»** rest"),+ "an end in the closing delimiter must retreat to the content end",+ );+ assert_snapped(+ "**bold*«* rest»",+ Some("**bold**« rest»"),+ "a start in the closing delimiter must advance past the whole span",+ );+ assert_snapped(+ "«*»*bold** rest",+ None,+ "an end in the opening delimiter must retreat to before the span",+ );+ assert_snapped(+ "**bold«**» rest",+ None,+ "a selection covering only delimiter text must collapse",+ );+ }++ #[test]+ fn test_snap_out_of_delimiters_cascades_through_nested_spans() {+ assert_snapped(+ "**`«code`*»*",+ Some("**`«code»`**"),+ "an end inside bold's closing `**` first snaps to code's closing \+ backtick, so it must cascade into the code content",+ );+ }++ #[test]+ fn test_snap_to_char_boundaries() {+ // `√` occupies bytes 1..4.+ let source = "a√b";+ assert_eq!(+ snap_to_char_boundaries(source, 0..5),+ Some(0..5),+ "boundaries already on char boundaries must be untouched"+ );+ assert_eq!(+ snap_to_char_boundaries(source, 0..2),+ Some(0..4),+ "an end mid-character must expand forward to keep the character"+ );+ assert_eq!(+ snap_to_char_boundaries(source, 2..5),+ Some(1..5),+ "a start mid-character must expand backward to keep the character"+ );+ assert_eq!(+ snap_to_char_boundaries(source, 2..3),+ Some(1..4),+ "a selection entirely inside a character must cover the whole character"+ );+ assert_eq!(+ snap_to_char_boundaries(source, 2..10),+ Some(1..5),+ "an end past the source must clamp to its length"+ );+ assert_eq!(+ snap_to_char_boundaries(source, 2..2),+ None,+ "an empty selection must collapse, even mid-character"+ );+ assert_eq!(+ snap_to_char_boundaries(source, 5..10),+ None,+ "a selection entirely past the source must collapse"+ );+ assert_eq!(+ snap_to_char_boundaries(source, Range { start: 4, end: 2 }),+ None,+ "a reversed selection must collapse"+ );+ }++ fn selection_is_plain(marked_source: &str) -> bool {+ let (source, selection) = marked_range(marked_source);+ selection_is_only_inside_code_spans(&inline_spans(&source), &selection)+ }++ #[test]+ fn test_selection_is_only_inside_code_spans() {+ assert!(+ selection_is_plain("run `«cargo» test` now"),+ "a selection fully inside the code span's content must be plain"+ );+ assert!(+ !selection_is_plain("«run `cargo» test` now"),+ "a selection reaching outside the code span must not be plain"+ );+ assert!(+ !selection_is_plain("**`«code»`**"),+ "code nested in bold must not be plain: the bold span also contains it"+ );+ }++ #[test]+ fn test_markdown_for_selection_balances_inline_spans() {+ assert_marked_selection("This is **«bold»** text in a sentence.", "**bold**");+ assert_marked_selection("This is **«bold**» text in a sentence.", "**bold**");+ assert_marked_selection("Th«is is **bo»ld** text in a sentence.", "is is **bo**");++ assert_marked_selection("This is *«italic»* text in a sentence.", "*italic*");+ assert_marked_selection("This is *it«al»ic* text in a sentence.", "*al*");++ assert_marked_selection("T«his is `cod»e` all `in one` sentence.", "his is `cod`");+ assert_marked_selection(+ "This is `c«ode` all `in o»ne` sentence.",+ "`ode` all `in o`",+ );+ assert_marked_selection(+ "This is `«code` all `in one»` sentence.",+ "`code` all `in one`",+ );+ assert_marked_selection(+ "This is `«code` all `in one`» sentence.",+ "`code` all `in one`",+ );++ // Special case for single inline code blocks+ assert_marked_selection("This is `«code»` all `in one` sentence.", "code");+ assert_marked_selection("This is `«code`» all `in one` sentence.", "code");+ assert_marked_selection("This is `c«od»e` all `in one` sentence.", "od");+ }++ #[test]+ fn test_markdown_for_selection_nested_spans() {+ assert_marked_selection("**bo«ld wi»th `code` inside**", "**ld wi**");+ assert_marked_selection("**bold with `c«od»e` inside**", "**`od`**");+ assert_marked_selection("**bold with `«code»` inside**", "**`code`**");+ assert_marked_selection(+ "**«bold with `code` inside»**",+ "**bold with `code` inside**",+ );+ assert_marked_selection(+ "«**bold with `code` inside**»",+ "**bold with `code` inside**",+ );+ }++ #[test]+ fn test_markdown_for_selection_links() {+ assert_marked_selection(+ "[Visit Rust's we«bsite»](https://rust.org)",+ "[bsite](https://rust.org)",+ );+ assert_marked_selection(+ "[«Visit Rust's website»](https://rust.org)",+ "[Visit Rust's website](https://rust.org)",+ );+ assert_marked_selection("visit https://«example».com now", "example");+ }++ #[test]+ fn test_markdown_for_selection_scopes_to_boundary_blocks() {+ assert_marked_selection(+ "**bo«ld one**\n\nmiddle `x`\n\n*ita»lic two*",+ "**ld one**\n\nmiddle `x`\n\n*ita*",+ );+ assert_marked_selection("**bold** first\n\nsecond *ita«li»c* here", "*li*");+ assert_marked_selection("one\n«\ntwo»", "\ntwo");+ assert_marked_selection("**one*«*\n\ntw»o", "\n\ntw");+ }++ #[test]+ fn test_root_block_index() {+ let starts = [2, 10, 20];+ assert_eq!(+ root_block_index(&starts, 0),+ 0,+ "an offset before the first block start must clamp to the first block"+ );+ assert_eq!(root_block_index(&starts, 2), 0);+ assert_eq!(root_block_index(&starts, 9), 0);+ assert_eq!(root_block_index(&starts, 10), 1);+ assert_eq!(root_block_index(&starts, 19), 1);+ assert_eq!(root_block_index(&starts, 20), 2);+ assert_eq!(+ root_block_index(&starts, 100),+ 2,+ "an offset past the last block start must clamp to the last block"+ );+ }++ #[test]+ fn test_root_block_events_slices_each_block() {+ let source = "first **a**\n\nsecond `b`\n\nthird *c*";+ let parsed = parse_markdown_with_options(source, false, false, false);+ let events = parsed.events.as_slice();+ let starts = parsed.root_block_starts.as_slice();+ assert_eq!(starts, &[0, 13, 25]);++ let mut sliced_events = Vec::new();+ for block in 0..starts.len() {+ let slice = root_block_events(events, starts, block);+ assert!(!slice.is_empty(), "block {block} must have events");+ let block_end = starts.get(block + 1).copied().unwrap_or(source.len());+ for (range, event) in slice {+ assert!(+ (starts[block]..block_end).contains(&range.start),+ "event {event:?} at {range:?} must start within block {block}"+ );+ }+ sliced_events.extend_from_slice(slice);+ }+ assert_eq!(+ sliced_events, events,+ "the per-block slices must partition all events in order"+ );++ assert_eq!(+ root_block_events(events, starts, starts.len()),+ events,+ "an out-of-range block index must fall back to all events"+ );+ }++ #[test]+ fn test_markdown_for_selection_plain_text_and_blocks() {+ assert_eq!(+ markdown_for_marked("some «text»"),+ "text",+ "plain text must be unchanged"+ );+ assert_eq!(+ markdown_for_marked("«para one\n\n- item **bold**\n- item two»"),+ "para one\n\n- item **bold**\n- item two",+ "selections spanning multiple blocks must keep interior syntax as-is"+ );+ assert_eq!(+ markdown_for_marked("```rust\n«let x = 1;»\n```"),+ "let x = 1;",+ "a selection inside a fenced code block must stay plain"+ );+ assert_eq!(+ markdown_for("abc", 2..100),+ "c",+ "out-of-bounds ends must be clamped"+ );+ assert_eq!(+ markdown_for("abc", Range { start: 3, end: 2 }),+ "",+ "inverted ranges must yield an empty string"+ );+ }+}diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rsindex db6c1a80786..81349a59f3b 100644--- a/crates/markdown_preview/src/markdown_preview_view.rs+++ b/crates/markdown_preview/src/markdown_preview_view.rs@@ -1385,7 +1385,11 @@ impl SearchableItem for MarkdownPreviewView {_window: &mut Window,cx: &mut Context<Self>,) -> String {- self.markdown.read(cx).selected_text().unwrap_or_default()+ self.markdown+ .read(cx)+ .selected_source()+ .unwrap_or_default()+ .to_string()}fn activate_match(