documents: format checks nested marks, reports late refusals, reads small texts at once

Unwrapping a style now runs the crossing check on the found node, so an
end in a nested link address or strike mark refuses. Clear keeps an
autolink's backslashes. Block lookups use a sorted search, so the walk
grows linearly. A long format refuses a second one as Busy and reports
refusals, a changed text and a shown preview through FormatRefused.
markdown-rs grows with the square of its nodes, so texts read at once
only up to 16 KiB.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

src/documents/document/format.rs

@@ -41,6 +41,10 @@ pub enum FormatRefusal {
     Across,
     /// Past the largest read: source alone.
     TooLong,
+    /// A long format still runs.
+    Busy,
+    /// The text changed before a long format finished.
+    Changed,
 }
 
 /// The edits and the selection after them.
@@ -60,7 +64,7 @@ fn content(node: &Node) -> Range<usize> {
     }
 }
 
-/// Room for text: a cell inside its pipes, end spaces too.
+/// Room for text: inside a cell's pipes, trailing spaces too.
 fn room(node: &Node, text: &str) -> Range<usize> {
     let inner = match node {
         Node::TableCell(_) => {
@@ -76,6 +80,12 @@ fn room(node: &Node, text: &str) -> Range<usize> {
     inner.start..inner.end + spaces
 }
 
+/// Which of `sorted`, disjoint spans, holds `inner`.
+pub(super) fn holder(sorted: &[Range<usize>], inner: &Range<usize>) -> Option<usize> {
+    let at = sorted.partition_point(|span| span.start <= inner.start);
+    (at > 0 && inner.end <= sorted[at - 1].end).then(|| at - 1)
+}
+
 fn block(node: &Node) -> bool {
     matches!(
         node,
@@ -151,11 +161,12 @@ fn verbatim(
     selection: &Range<usize>,
     format: InlineFormat,
 ) -> Result<(), FormatRefusal> {
-    let blocks: Vec<Range<usize>> = nodes
+    let mut blocks: Vec<Range<usize>> = nodes
         .iter()
         .filter(|node| block(node))
         .map(|node| span(node))
         .collect();
+    blocks.sort_by_key(|block| block.start);
     for node in nodes {
         let whole = span(node);
         let touches = |edge: bool| {
@@ -166,9 +177,6 @@ fn verbatim(
                     false => whole.start < at && at < whole.end,
                 })
         };
-        let inline = blocks
-            .iter()
-            .any(|block| block.start <= whole.start && whole.end <= block.end);
         // Clear takes a block's inline code and tags too.
         let held = format != InlineFormat::Clear && touches(false);
         let why = match node {
@@ -177,7 +185,11 @@ fn verbatim(
             Node::Yaml(_) | Node::Toml(_) if touches(true) => FormatRefusal::FrontMatter,
             Node::InlineCode(_) if format != InlineFormat::Code && held => FormatRefusal::Code,
             Node::InlineMath(_) if held => FormatRefusal::Math,
-            Node::Html(_) if (inline && held) || (!inline && touches(true)) => FormatRefusal::Html,
+            Node::Html(_) => match holder(&blocks, &whole).is_some() {
+                true if held => FormatRefusal::Html,
+                false if touches(true) => FormatRefusal::Html,
+                _ => continue,
+            },
             _ => continue,
         };
         return Err(why);
@@ -222,9 +234,18 @@ pub(super) fn toggle(
     selection: Range<usize>,
     format: InlineFormat,
 ) -> Result<Change, FormatRefusal> {
-    let root = file_tree(text);
+    toggle_tree(text, &file_tree(text), selection, format)
+}
+
+/// `toggle` on `root`, the tree `text` parses to.
+pub(super) fn toggle_tree(
+    text: &str,
+    root: &Node,
+    selection: Range<usize>,
+    format: InlineFormat,
+) -> Result<Change, FormatRefusal> {
     let mut nodes = Vec::new();
-    walk(&root, &mut nodes);
+    walk(root, &mut nodes);
     verbatim(&nodes, &selection, format)?;
     if format == InlineFormat::Clear {
         return clear::clear(text, &nodes, selection);
@@ -248,6 +269,7 @@ pub(super) fn toggle(
         .filter(|node| styled(format, node) && holds(node))
         .min_by_key(|node| span(node).len());
     if let Some(node) = found {
+        crossed(text, &nodes, &span(node), s, e, format)?;
         return Ok(unwrap(
             span(node),
             marks(node, text).expect("a styled node has marks"),
@@ -283,6 +305,7 @@ pub(super) fn toggle(
     if format == InlineFormat::Underline
         && let Some(tags) = underline(&nodes, &within, s, e)
     {
+        crossed(text, &nodes, &(tags[0].start..tags[1].end), s, e, format)?;
         return Ok(unwrap(tags[0].start..tags[1].end, tags));
     }
     if s != e {

src/documents/document/format/apply.rs

@@ -7,7 +7,7 @@ use gpui::{AppContext as _, Context};
 use super::{Change, FormatRefusal, InlineFormat, toggle};
 use crate::documents::{
     MarkdownMode,
-    document::{AT_ONCE, LARGEST_READ, MarkdownDocument},
+    document::{AT_ONCE, DocumentEvent, LARGEST_READ, MarkdownDocument},
     modes::joint,
 };
 
@@ -15,9 +15,7 @@ use crate::documents::{
 type Snapshot = (String, usize, Range<usize>);
 
 impl MarkdownDocument {
-    /// `format` at the selection, Typora's way, or why not.
-    ///
-    /// Long texts toggle off the UI thread; refusals then log.
+    /// `format` at the selection; long texts refuse by event.
     pub fn format(
         &mut self,
         format: InlineFormat,
@@ -34,6 +32,10 @@ impl MarkdownDocument {
             );
             return Err(FormatRefusal::TooLong);
         }
+        if self.formatting {
+            log::info!("markdown document: format {format:?} refused: one runs");
+            return Err(FormatRefusal::Busy);
+        }
         if full.len() <= AT_ONCE {
             let change = toggle(&full, selection, format).inspect_err(|why| {
                 log::info!("markdown document: format {format:?} refused: {why:?}");
@@ -45,26 +47,31 @@ impl MarkdownDocument {
             full.len()
         );
         let taken = (full.clone(), offset, selection.clone());
-        self._formatting = Some(cx.spawn(async move |document, cx| {
+        self.formatting = true;
+        cx.spawn(async move |document, cx| {
             let change = cx
                 .background_spawn(async move { toggle(&full, selection, format) })
                 .await;
             document
                 .update(cx, |document, cx| {
-                    if document.snapshot(cx) != taken {
-                        return log::warn!("markdown document: format {format:?} lapsed");
-                    }
-                    match change {
-                        // Apply logs its own refusal.
-                        Ok(change) => document.apply(format, change, &taken.0, taken.1, cx).ok(),
-                        Err(why) => {
-                            log::info!("markdown document: format {format:?} refused: {why:?}");
-                            None
-                        }
+                    document.formatting = false;
+                    let done = if document.mode == MarkdownMode::Preview {
+                        Err(FormatRefusal::Preview)
+                    } else if document.snapshot(cx) != taken {
+                        Err(FormatRefusal::Changed)
+                    } else {
+                        change.and_then(|change| {
+                            document.apply(format, change, &taken.0, taken.1, cx)
+                        })
                     };
+                    if let Err(why) = done {
+                        log::info!("markdown document: format {format:?} refused: {why:?}");
+                        cx.emit(DocumentEvent::FormatRefused(why));
+                    }
                 })
                 .ok();
-        }));
+        })
+        .detach();
         Ok(())
     }
 

src/documents/document/format/clear.rs

@@ -4,7 +4,7 @@ use std::ops::Range;
 
 use markdown::mdast::Node;
 
-use super::{Change, FormatRefusal, after, block, cut, marks, room};
+use super::{Change, FormatRefusal, after, block, cut, holder, marks, room};
 use crate::documents::{markdown::span, tree::inside};
 
 /// The backslashes of escapes in a text node's span.
@@ -25,10 +25,12 @@ fn escapes(text: &str, whole: Range<usize>) -> Vec<Range<usize>> {
 }
 
 /// A node's inline marks, as Typora's `.md-meta`.
-fn meta(node: &Node, text: &str) -> Vec<Range<usize>> {
+fn meta(node: &Node, text: &str, autolinks: &[Range<usize>]) -> Vec<Range<usize>> {
     let whole = span(node);
     match node {
         Node::Html(_) => vec![whole],
+        // Autolink text keeps its backslashes.
+        Node::Text(_) if holder(autolinks, &whole).is_some() => Vec::new(),
         Node::Text(_) => escapes(text, whole),
         Node::InlineMath(_) => {
             let inner = inside(text, whole.clone(), '$');
@@ -45,7 +47,7 @@ pub(super) fn clear(
     nodes: &[&Node],
     selection: Range<usize>,
 ) -> Result<Change, FormatRefusal> {
-    let blocks: Vec<Range<usize>> = (nodes.iter())
+    let mut blocks: Vec<Range<usize>> = (nodes.iter())
         .filter(|node| block(node))
         .map(|node| room(node, text))
         .filter(|range| range.start <= selection.end && selection.start <= range.end)
@@ -53,25 +55,29 @@ pub(super) fn clear(
     if blocks.is_empty() {
         return Err(FormatRefusal::Outside);
     }
-    let held = |hole: &Range<usize>| {
-        blocks
-            .iter()
-            .any(|block| block.start <= hole.start && hole.end <= block.end)
-    };
-    let mut holes: Vec<Range<usize>> = (nodes.iter())
-        .flat_map(|node| meta(node, text))
-        .filter(|hole| !hole.is_empty() && held(hole))
-        .collect();
-    holes.sort_by_key(|hole| hole.start);
-    let edits = (blocks.iter())
-        .filter_map(|block| {
-            let inside: Vec<Range<usize>> = (holes.iter())
-                .filter(|hole| block.start <= hole.start && hole.end <= block.end)
-                .cloned()
-                .collect();
-            (!inside.is_empty()).then(|| (block.clone(), cut(text, block.clone(), &inside)))
-        })
+    blocks.sort_by_key(|block| block.start);
+    let mut autolinks: Vec<Range<usize>> = (nodes.iter())
+        .filter(|node| matches!(node, Node::Link(_)))
+        .map(|node| span(node))
+        .filter(|whole| !text[whole.clone()].starts_with('['))
         .collect();
+    autolinks.sort_by_key(|link| link.start);
+    let mut inside: Vec<Vec<Range<usize>>> = vec![Vec::new(); blocks.len()];
+    for hole in (nodes.iter()).flat_map(|node| meta(node, text, &autolinks)) {
+        if let Some(at) = holder(&blocks, &hole).filter(|_| !hole.is_empty()) {
+            inside[at].push(hole);
+        }
+    }
+    let mut holes = Vec::new();
+    let mut edits = Vec::new();
+    for (block, mut cuts) in blocks.into_iter().zip(inside) {
+        if cuts.is_empty() {
+            continue;
+        }
+        cuts.sort_by_key(|hole| hole.start);
+        edits.push((block.clone(), cut(text, block, &cuts)));
+        holes.extend(cuts);
+    }
     Ok((
         edits,
         after(selection.start, &holes)..after(selection.end, &holes),

src/documents/document/mod.rs

@@ -41,7 +41,7 @@ use crate::{
 };
 
 /// Texts this long parse at once; longer ones elsewhere.
-const AT_ONCE: usize = 128 << 10;
+const AT_ONCE: usize = 16 << 10;
 
 /// Longer texts are never read: source alone.
 pub const LARGEST_READ: usize = 2 << 20;
@@ -58,6 +58,8 @@ pub enum DocumentEvent {
     Parsed,
     /// A secondary press moved the caret onto this.
     Pointed(DocumentTarget),
+    /// A long format, accepted, did not happen.
+    FormatRefused(FormatRefusal),
 }
 
 /// A top line asked, numbered so late callbacks know theirs.
@@ -87,7 +89,7 @@ pub struct MarkdownDocument {
     /// Text changes counted; a read of an older one lapses.
     edits: u64,
     _parsing: Option<Task<()>>,
-    _formatting: Option<Task<()>>,
+    formatting: bool,
     list: ListState,
     open: Option<Open>,
     /// A top line asked for, until the view holds it.
@@ -159,7 +161,7 @@ impl MarkdownDocument {
             parsed: Arc::default(),
             edits: 0,
             _parsing: None,
-            _formatting: None,
+            formatting: false,
             list: ListState::new(1, ListAlignment::Top, overdraw),
             open: None,
             top: None,

src/documents/document/tests/format.rs

@@ -1,11 +1,19 @@
 //! Inline formats toggle as Typora's (R4.6).
 
+use std::{cell::RefCell, rc::Rc, time::Instant};
+
 use gpui::{Entity, Modifiers, TestAppContext, VisualTestContext};
+use markdown::mdast::Node;
 
 use super::{open, opened, press, text};
 use crate::documents::{
-    FormatRefusal, InlineFormat, LARGEST_READ, MarkdownDocument, MarkdownMode,
-    document::{AT_ONCE, format::toggle, visual},
+    DocumentEvent, FormatRefusal, InlineFormat, LARGEST_READ, MarkdownDocument, MarkdownMode,
+    document::{
+        AT_ONCE,
+        format::{toggle, toggle_tree},
+        visual,
+    },
+    markdown::file_tree,
 };
 
 /// `marked` toggled: `‸` is the caret, `⟨…⟩` the selection.
@@ -238,6 +246,21 @@ fn a_long_text_formats_once_read_apart(cx: &mut TestAppContext) {
     assert!(text(&document, cx).starts_with("**x"));
 }
 
+#[gpui::test]
+fn many_short_paragraphs_format_apart(cx: &mut TestAppContext) {
+    let source = "a\n\n".repeat(AT_ONCE / 3 + 1);
+    let (document, cx) = open(&source, MarkdownMode::Source, cx);
+    document.update(cx, |document, cx| {
+        document
+            .editor
+            .update(cx, |editor, cx| editor.select(std::iter::once(0..1), cx));
+        document.format(InlineFormat::Strong, cx).expect("taken");
+    });
+    assert_eq!(text(&document, cx), source, "not on the UI thread");
+    cx.run_until_parked();
+    assert!(text(&document, cx).starts_with("**a**\n\na"));
+}
+
 #[gpui::test]
 fn a_long_format_lapses_when_the_text_moves(cx: &mut TestAppContext) {
     let (document, cx) = long(cx, AT_ONCE + 1);
@@ -254,6 +277,130 @@ fn a_long_format_lapses_when_the_text_moves(cx: &mut TestAppContext) {
     );
 }
 
+/// The refusals a document sends by event.
+fn refusals(
+    document: &Entity<MarkdownDocument>,
+    cx: &mut VisualTestContext,
+) -> Rc<RefCell<Vec<FormatRefusal>>> {
+    let heard = Rc::new(RefCell::new(Vec::new()));
+    let kept = heard.clone();
+    cx.update(|_, cx| {
+        cx.subscribe(document, move |_, event: &DocumentEvent, _| {
+            if let DocumentEvent::FormatRefused(why) = event {
+                kept.borrow_mut().push(*why);
+            }
+        })
+        .detach()
+    });
+    heard
+}
+
+#[gpui::test]
+fn a_long_lapse_comes_by_event(cx: &mut TestAppContext) {
+    let (document, cx) = long(cx, AT_ONCE + 1);
+    let heard = refusals(&document, cx);
+    document.update(cx, |document, cx| {
+        document.format(InlineFormat::Strong, cx).expect("taken");
+        document
+            .editor
+            .update(cx, |editor, cx| editor.edit([(0..0, "y".to_string())], cx));
+    });
+    cx.run_until_parked();
+    assert_eq!(*heard.borrow(), [FormatRefusal::Changed]);
+}
+
+#[test]
+fn an_unwrap_refuses_an_end_in_nested_marks() {
+    use InlineFormat::*;
+    let across = Err(FormatRefusal::Across);
+    assert_eq!(toggled("**[a](ht‸tps://x)**", Strong), across);
+    assert_eq!(toggled("**~~a~‸~**", Strong), across);
+    assert_eq!(toggled("<u>[a](ht‸tps://x)</u>", Underline), across);
+    assert_eq!(toggled("**a *b⟨* c⟩**", Strong), across);
+}
+
+#[test]
+fn clear_keeps_an_autolink_backslash() {
+    assert_eq!(
+        ok(r"a‸ <https://x/\*>", InlineFormat::Clear),
+        r"a‸ https://x/\*"
+    );
+}
+
+/// The walk past the parse, on `n` then `4n` repeats.
+fn linear(unit: &str, run: impl Fn(&str, &Node)) {
+    let time = |n: usize| {
+        let text = unit.repeat(n);
+        let root = file_tree(&text);
+        let start = Instant::now();
+        run(&text, &root);
+        start.elapsed()
+    };
+    let (small, large) = (time(4000), time(16000));
+    assert!(large < small * 8, "{small:?} then {large:?}");
+}
+
+#[test]
+fn many_paragraphs_format_in_linear_time() {
+    linear("a\n\n", |text, root| {
+        toggle_tree(text, root, 0..1, InlineFormat::Strong).expect("toggled");
+    });
+    linear("**a**\n\n", |text, root| {
+        toggle_tree(text, root, 0..text.len(), InlineFormat::Clear).expect("cleared");
+    });
+}
+
+#[gpui::test]
+fn a_second_long_format_refuses_while_one_runs(cx: &mut TestAppContext) {
+    let (document, cx) = long(cx, AT_ONCE + 1);
+    let second = document.update(cx, |document, cx| {
+        document.format(InlineFormat::Strong, cx).expect("taken");
+        document.format(InlineFormat::Emphasis, cx)
+    });
+    assert_eq!(second, Err(FormatRefusal::Busy));
+    cx.run_until_parked();
+    document.update(cx, |document, cx| {
+        document.format(InlineFormat::Emphasis, cx).expect("taken")
+    });
+    cx.run_until_parked();
+    assert!(text(&document, cx).starts_with("***x"));
+    document.update(cx, |document, cx| {
+        document.editor.update(cx, |editor, cx| editor.undo(cx));
+    });
+    assert!(text(&document, cx).starts_with("**x"));
+    assert!(!text(&document, cx).starts_with("***"));
+}
+
+#[gpui::test]
+fn a_long_refusal_comes_by_event(cx: &mut TestAppContext) {
+    let source = format!("`code` {}", "x".repeat(AT_ONCE));
+    let (document, cx) = open(&source, MarkdownMode::Source, cx);
+    let heard = refusals(&document, cx);
+    let taken = document.update(cx, |document, cx| {
+        document
+            .editor
+            .update(cx, |editor, cx| editor.select(std::iter::once(2..2), cx));
+        document.format(InlineFormat::Strong, cx)
+    });
+    assert_eq!(taken, Ok(()));
+    cx.run_until_parked();
+    assert_eq!(*heard.borrow(), [FormatRefusal::Code]);
+    assert_eq!(text(&document, cx), source);
+}
+
+#[gpui::test]
+fn a_long_format_drops_once_preview_shows(cx: &mut TestAppContext) {
+    let (document, cx) = long(cx, AT_ONCE + 1);
+    let heard = refusals(&document, cx);
+    document.update_in(cx, |document, window, cx| {
+        document.format(InlineFormat::Strong, cx).expect("taken");
+        document.set_mode(MarkdownMode::Preview, window, cx);
+    });
+    cx.run_until_parked();
+    assert!(text(&document, cx).starts_with("xx"));
+    assert_eq!(*heard.borrow(), [FormatRefusal::Preview]);
+}
+
 #[gpui::test]
 fn a_text_past_the_largest_read_refuses(cx: &mut TestAppContext) {
     let (document, cx) = long(cx, LARGEST_READ + 1);