From 1d0354592bebfe250457ff89e63ab48ec8e3f624 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9B=B7=E7=94=B5=E8=8A=BD=E8=A1=A3?= Date: Wed, 14 Oct 2026 13:14:49 -0400 Subject: [PATCH] documents: format always reads apart; read cutoff back to 128 KiB The format command never parses on the UI thread; refusals past the size checks come by event. The document's at-once read returns to 128 KiB, so a visual opening between the cutoffs starts at the top. Timing test takes web_time::Instant. Co-Authored-By: Claude Opus 5.5 (1M context) --- AGENTS.md | 2 +- src/documents/document/format/apply.rs | 10 +---- src/documents/document/mod.rs | 2 +- src/documents/document/tests/format.rs | 56 +++++++++++++++++--------- src/documents/document/tests/place.rs | 8 ++++ 5 files changed, 50 insertions(+), 28 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 45e93c9..203c2f6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -13,7 +13,7 @@ Ely GPUI Component. A component library for GPUI, in light and dark. - Web views: `wry` 0.57 (Apache-2.0 OR MIT, default features off, macOS only) lays a child WKWebView over the window. - Terminal: `alacritty_terminal` 0.26 (Apache-2.0, default features off, native only) for the grid, its parser and the pseudo-terminal; `futures` carries its events. `vte` 0.15 (Apache-2.0 OR MIT), the parser it re-exports, reads `AnsiText`'s codes alone, so colored output builds for wasm32. - Diffs: `similar` 3.2 (Apache-2.0) for line and word diffs and three-way merges; its `unicode` feature splits words at punctuation. -- Markdown: `markdown` 1.0.0 (markdown-rs, MIT) reads GitHub's flavor and math into a syntax tree with byte positions for `MarkdownRenderer`, `MarkdownEditor`, the highlights, block ranges and outline. `MarkdownRenderer` draws display math through `typography::Latex`, a ```` ```mermaid ```` block through `documents::Diagram`, and pictures from the owner's folder (`base`) or `data:` addresses (`base64` 0.22, MIT OR Apache-2.0); web pictures stay unloaded. Inline math shows as TeX: gpui text carries no inline pictures. Inline it reads as Typora's defaults: `:shortcode:` turns to its emoji as GitHub reads it (the `emojis` crate's names, GitHub's today, so `:cricket:` is the insect; read after escapes and references, so `\:smile:` turns too; inside an autolink or `` it stays text; within one DOM text node, which filtered tags do not split, the first `:name:`-shaped run decides for all: blank text or a space before it turns every shortcode, else none, so `x:smile: :smile:` stays), inline HTML's `u`, `b`/`strong`, `i`/`em`, `s`/`del`/`strike`, `code`/`kbd`, `mark`, `br` and `a href` draw as what they mean GFM's filtered tags (`script`, `style`, `title`, `textarea`, `iframe`, `xmp`, `noembed`, `noframes`, `plaintext`) show as text, and other tags, hyphenated names too, vanish, leaving their text; a tag's name runs to white space or `/`, as HTML5 reads it; attribute values split on ASCII whitespace alone and decode as HTML decodes them; each Markdown container is the element GitHub writes (`em`, `strong`, `del`, `a`), on one stack with the tags and repaired as HTML5 repairs: an end tag closes the innermost element of its name and all above it, of which only formatting elements (`a`, `b`, `code`, `em`, `i`, `s`, `strike`, `strong`, `u`) reopen, a new `a` ends the open one and an `a` without `href` links nothing; other tags are not tracked, and `
` breaks as `
` does; and a footnote reference is its number in superscript, numbered by first reference, as its definition is; one `~` still strikes. At the root, blocks read as GitHub shows them: a quote whose first line is plain text reading `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]` or `[!CAUTION]` in any case, after escapes and references, spaces and tabs around it, with more after it, is an alert under its title (Important in the palette's violet, `syntax.keyword`, read at 4.5:1); a paragraph that is `[toc]` alone, as Typora reads it, lists every heading by depth, and a press on one reveals it as a link press does (`MarkdownDocument`'s `reveal`), the heading found where `CodeEditor` anchors carried it through each edit since the read, gone if an edit or an undo took it, and a secondary press acts on press, since a block writing back moves the list; front matter shows in a box without its fences; an HTML block shows its text with the inline tags above, white space collapsed and owed as a browser lays it, block elements breaking lines and closing what opened inside them, HTML5's start tags ending an open `p`, `fieldset` and `menu` too, and an `li` start an `li`, a `dd` or `dt` start either, as HTML5 ends them, comments dropped, the filtered tags shown as text, and an unclosed tag dropping the rest; a rule is a 2px `border_strong` line; bullets go •, ◦, ▪ by list depth, ordered lists counted. Exports read a tree as the drawing does through `MarkdownReader` (`block` gives its `MarkdownBlock`s, `inline` its text, `note` and `label` its footnotes, `headings` the `[toc]` list), one fresh stack per paragraph, heading or cell. `MarkdownDocument` holds a whole file in one `CodeEditor` (text and undo, colored by `CodeEditor::highlighter` with `markdown_highlights`): visual draws the file's top-level blocks in a gpui `list`, a pressed block opening as its source in a `TextInput` whose typing is the document's text at once and whose write-back is one undo step; source is the editor; preview draws without presses. A written-back block, a mode switch or a new text is read at once up to 16 KiB, longer ones on the background executor; typing in source or split reads 300 ms after the last key, off the main thread (markdown-rs grows with the square of its nodes, not its bytes: in release, 128 KiB of one-letter paragraphs takes 1.7 s, 16 KiB 42 ms, while 128 KiB of prose takes 20 ms). Texts past `LARGEST_READ` (2 MiB) are never read: no blocks, no outline. A new read keeps the list's blocks alike at both ends. One caret serves every mode: the editor's selection, which a written-back block moves; `set_caret` and `set_top_line` set caret and view apart; a top line asked (numbered, so a late frame callback finishes only its own ask; new text places it again, clamped to the text as it then is) waits for the read, lands on its block, then a frame later at its share of the block's height; `reveal` is such an ask with the caret at its line; a switch between source and the list keeps the top line, one between visual and preview keeps the list's scroll as it is. A block opens only when the read is of the text as it is now. A pressed block keeps its identity across the write-back of the one before it, and opens with the caret on the pressed character: each drawn piece keeps its written span and how it decodes (Markdown's escapes and references for text, as markdown-rs decodes them, autolink text as written, HTML's references for an HTML block's runs, none for code spans but a table cell's `\|`, cut as CommonMark cuts their end spaces), and is matched from its end, an equal character first, a drawn space next against a line end, decoded or not, so quote marks and indents at a line's start are never taken for text and an alert's text reads past its marker; text before an emoji lands at its piece's start; code, front matter, a link definition and an HTML block's runs read back line for line, LF, CRLF and CR alike, each drawn line ending its written one, a tab cut to spaces landing on the tab; a block's drawn positions count from its own start, so an edit before it keeps it alike. A secondary press opens nothing, an empty document's open on focus included: it writes back an open block, refuses the press if that changed the pressed block's kind, text or drawing (a definition's new address too), moves the caret there and emits `DocumentEvent::Pointed`, whose `DocumentTarget` names the block's kind, a link's or picture's address, and whether it lies in a table or code. `MarkdownDocument::format` toggles an `InlineFormat` at the selection as Typora's toggle does: inside that style it comes off; a selection is wrapped, its end spaces left out and the same style it partly covers taken in; a caret takes its word, or an empty pair between stop characters or on a blank line; `Clear` takes every inline mark off the blocks it touches, inline math's `$`, footnote brackets and escape backslashes too, an autolink's kept as written; code, math, HTML and front matter refuse, as does an end inside a node's marks or a link address, or a selection crossing a block, a link or another mark (`FormatRefusal`); past 16 KiB the toggle reads off the UI thread, one at a time (another refuses as `Busy`), and lands only if text and selection are unchanged and preview is not shown, a refusal met there coming as `DocumentEvent::FormatRefused`; past the largest read it refuses; in an open block it edits the field, which stays open, and joins its one write-back step. Blocks are Tab stops that Enter or Space opens; preview takes no presses, undo or redo. `CodeEditor` keeps at most 64 MiB of undo and redo text, dropping the oldest undo and then the farthest redo after every record, composition, undo and redo. `BlockData::from_markdown` and its export still read with `pulldown-cmark` 0.13 (MIT, default features off); it adds GitHub's alerts, a callout's form, and reads each field's inline Markdown from the source by offset, as written. +- Markdown: `markdown` 1.0.0 (markdown-rs, MIT) reads GitHub's flavor and math into a syntax tree with byte positions for `MarkdownRenderer`, `MarkdownEditor`, the highlights, block ranges and outline. `MarkdownRenderer` draws display math through `typography::Latex`, a ```` ```mermaid ```` block through `documents::Diagram`, and pictures from the owner's folder (`base`) or `data:` addresses (`base64` 0.22, MIT OR Apache-2.0); web pictures stay unloaded. Inline math shows as TeX: gpui text carries no inline pictures. Inline it reads as Typora's defaults: `:shortcode:` turns to its emoji as GitHub reads it (the `emojis` crate's names, GitHub's today, so `:cricket:` is the insect; read after escapes and references, so `\:smile:` turns too; inside an autolink or `` it stays text; within one DOM text node, which filtered tags do not split, the first `:name:`-shaped run decides for all: blank text or a space before it turns every shortcode, else none, so `x:smile: :smile:` stays), inline HTML's `u`, `b`/`strong`, `i`/`em`, `s`/`del`/`strike`, `code`/`kbd`, `mark`, `br` and `a href` draw as what they mean GFM's filtered tags (`script`, `style`, `title`, `textarea`, `iframe`, `xmp`, `noembed`, `noframes`, `plaintext`) show as text, and other tags, hyphenated names too, vanish, leaving their text; a tag's name runs to white space or `/`, as HTML5 reads it; attribute values split on ASCII whitespace alone and decode as HTML decodes them; each Markdown container is the element GitHub writes (`em`, `strong`, `del`, `a`), on one stack with the tags and repaired as HTML5 repairs: an end tag closes the innermost element of its name and all above it, of which only formatting elements (`a`, `b`, `code`, `em`, `i`, `s`, `strike`, `strong`, `u`) reopen, a new `a` ends the open one and an `a` without `href` links nothing; other tags are not tracked, and `
` breaks as `
` does; and a footnote reference is its number in superscript, numbered by first reference, as its definition is; one `~` still strikes. At the root, blocks read as GitHub shows them: a quote whose first line is plain text reading `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]` or `[!CAUTION]` in any case, after escapes and references, spaces and tabs around it, with more after it, is an alert under its title (Important in the palette's violet, `syntax.keyword`, read at 4.5:1); a paragraph that is `[toc]` alone, as Typora reads it, lists every heading by depth, and a press on one reveals it as a link press does (`MarkdownDocument`'s `reveal`), the heading found where `CodeEditor` anchors carried it through each edit since the read, gone if an edit or an undo took it, and a secondary press acts on press, since a block writing back moves the list; front matter shows in a box without its fences; an HTML block shows its text with the inline tags above, white space collapsed and owed as a browser lays it, block elements breaking lines and closing what opened inside them, HTML5's start tags ending an open `p`, `fieldset` and `menu` too, and an `li` start an `li`, a `dd` or `dt` start either, as HTML5 ends them, comments dropped, the filtered tags shown as text, and an unclosed tag dropping the rest; a rule is a 2px `border_strong` line; bullets go •, ◦, ▪ by list depth, ordered lists counted. Exports read a tree as the drawing does through `MarkdownReader` (`block` gives its `MarkdownBlock`s, `inline` its text, `note` and `label` its footnotes, `headings` the `[toc]` list), one fresh stack per paragraph, heading or cell. `MarkdownDocument` holds a whole file in one `CodeEditor` (text and undo, colored by `CodeEditor::highlighter` with `markdown_highlights`): visual draws the file's top-level blocks in a gpui `list`, a pressed block opening as its source in a `TextInput` whose typing is the document's text at once and whose write-back is one undo step; source is the editor; preview draws without presses. A written-back block, a mode switch or a new text is read at once up to 128 KiB, longer ones on the background executor; typing in source or split reads 300 ms after the last key, off the main thread (markdown-rs grows with the square of its nodes, not its bytes: in release, 128 KiB of one-letter paragraphs takes 1.7 s, 16 KiB 42 ms, while 128 KiB of prose takes 20 ms; a block-heavy text under the cutoff can still hold the UI thread past 100 ms, a known limit). Texts past `LARGEST_READ` (2 MiB) are never read: no blocks, no outline. A new read keeps the list's blocks alike at both ends. One caret serves every mode: the editor's selection, which a written-back block moves; `set_caret` and `set_top_line` set caret and view apart; a top line asked (numbered, so a late frame callback finishes only its own ask; new text places it again, clamped to the text as it then is) waits for the read, lands on its block, then a frame later at its share of the block's height; `reveal` is such an ask with the caret at its line; a switch between source and the list keeps the top line, one between visual and preview keeps the list's scroll as it is. A block opens only when the read is of the text as it is now. A pressed block keeps its identity across the write-back of the one before it, and opens with the caret on the pressed character: each drawn piece keeps its written span and how it decodes (Markdown's escapes and references for text, as markdown-rs decodes them, autolink text as written, HTML's references for an HTML block's runs, none for code spans but a table cell's `\|`, cut as CommonMark cuts their end spaces), and is matched from its end, an equal character first, a drawn space next against a line end, decoded or not, so quote marks and indents at a line's start are never taken for text and an alert's text reads past its marker; text before an emoji lands at its piece's start; code, front matter, a link definition and an HTML block's runs read back line for line, LF, CRLF and CR alike, each drawn line ending its written one, a tab cut to spaces landing on the tab; a block's drawn positions count from its own start, so an edit before it keeps it alike. A secondary press opens nothing, an empty document's open on focus included: it writes back an open block, refuses the press if that changed the pressed block's kind, text or drawing (a definition's new address too), moves the caret there and emits `DocumentEvent::Pointed`, whose `DocumentTarget` names the block's kind, a link's or picture's address, and whether it lies in a table or code. `MarkdownDocument::format` toggles an `InlineFormat` at the selection as Typora's toggle does: inside that style it comes off; a selection is wrapped, its end spaces left out and the same style it partly covers taken in; a caret takes its word, or an empty pair between stop characters or on a blank line; `Clear` takes every inline mark off the blocks it touches, inline math's `$`, footnote brackets and escape backslashes too, an autolink's kept as written; code, math, HTML and front matter refuse, as does an end inside a node's marks or a link address, or a selection crossing a block, a link or another mark (`FormatRefusal`); the toggle always reads off the UI thread, one at a time (another refuses as `Busy`), and lands only if text and selection are unchanged and preview is not shown, a refusal met there coming as `DocumentEvent::FormatRefused`; past the largest read it refuses; in an open block it edits the field, which stays open, and joins its one write-back step. Blocks are Tab stops that Enter or Space opens; preview takes no presses, undo or redo. `CodeEditor` keeps at most 64 MiB of undo and redo text, dropping the oldest undo and then the farthest redo after every record, composition, undo and redo. `BlockData::from_markdown` and its export still read with `pulldown-cmark` 0.13 (MIT, default features off); it adds GitHub's alerts, a callout's form, and reads each field's inline Markdown from the source by offset, as written. - Pictures: `image` 0.25 (MIT OR Apache-2.0), the crate gpui decodes with, default features off; it turns decoded frames and rims map tiles. - Math and diagrams: RaTeX 0.1.14 (`ratex-parser`, `ratex-layout`, `ratex-svg` with `embed-fonts`, `ratex-types`; MIT, KaTeX's fonts OFL) typesets `Latex` to SVG with outlined glyphs; `mermaid-rs-renderer` 0.3.1 (MIT, default features off) draws `Diagram`. Both go through gpui's `SvgRenderer` at the window's scale, loaded as gpui assets off the main thread; `usvg` 0.46, gpui's own, reads a diagram's size. A RaTeX or Mermaid panic on parsed input becomes the element's error. Each element holds its picture through `primitives::held`: a new source, or the element leaving the window, removes the old asset from gpui's cache and drops its image from the atlas after the frame. - Maps: Natural Earth's 110m countries (public domain). `assets/maps/countries.geojson`, trimmed by `scripts/countries.py` to an ISO code, a name and positions to 0.01°, backs `maps::WorldMap`; the gallery's tiles are cut from the same file, z0 to z3, by `scripts/tiles.py` with Pillow. diff --git a/src/documents/document/format/apply.rs b/src/documents/document/format/apply.rs index e99b9a0..dcc1613 100644 --- a/src/documents/document/format/apply.rs +++ b/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, DocumentEvent, LARGEST_READ, MarkdownDocument}, + document::{DocumentEvent, LARGEST_READ, MarkdownDocument}, modes::joint, }; @@ -15,7 +15,7 @@ use crate::documents::{ type Snapshot = (String, usize, Range); impl MarkdownDocument { - /// `format` at the selection; long texts refuse by event. + /// `format` at the selection, read apart; refusals by event. pub fn format( &mut self, format: InlineFormat, @@ -36,12 +36,6 @@ impl MarkdownDocument { 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:?}"); - })?; - return self.apply(format, change, &full, offset, cx); - } log::info!( "markdown document: format {format:?} reads {} bytes apart", full.len() diff --git a/src/documents/document/mod.rs b/src/documents/document/mod.rs index ea100f9..96b836c 100644 --- a/src/documents/document/mod.rs +++ b/src/documents/document/mod.rs @@ -41,7 +41,7 @@ use crate::{ }; /// Texts this long parse at once; longer ones elsewhere. -const AT_ONCE: usize = 16 << 10; +const AT_ONCE: usize = 128 << 10; /// Longer texts are never read: source alone. pub const LARGEST_READ: usize = 2 << 20; diff --git a/src/documents/document/tests/format.rs b/src/documents/document/tests/format.rs index 2af5aee..ad9903c 100644 --- a/src/documents/document/tests/format.rs +++ b/src/documents/document/tests/format.rs @@ -1,15 +1,15 @@ //! Inline formats toggle as Typora's (R4.6). -use std::{cell::RefCell, rc::Rc, time::Instant}; +use std::{cell::RefCell, rc::Rc}; use gpui::{Entity, Modifiers, TestAppContext, VisualTestContext}; use markdown::mdast::Node; +use web_time::Instant; use super::{open, opened, press, text}; use crate::documents::{ DocumentEvent, FormatRefusal, InlineFormat, LARGEST_READ, MarkdownDocument, MarkdownMode, document::{ - AT_ONCE, format::{toggle, toggle_tree}, visual, }, @@ -145,6 +145,7 @@ fn an_open_block_stays_open_and_undoes_as_one_step(cx: &mut TestAppContext) { .format(InlineFormat::Strong, cx) .expect("formatted"); }); + cx.run_until_parked(); assert_eq!( opened(&document, cx), "alpha **beta**", @@ -172,6 +173,7 @@ fn the_source_takes_a_format_as_one_step(cx: &mut TestAppContext) { .update(cx, |editor, cx| editor.select(std::iter::once(2..2), cx)); document.format(InlineFormat::Code, cx).expect("formatted"); }); + cx.run_until_parked(); assert_eq!(text(&document, cx), "`alpha` beta\n"); document.update(cx, |document, cx| { document.editor.update(cx, |editor, cx| editor.undo(cx)); @@ -221,8 +223,8 @@ fn underline_comes_off_past_other_tags() { assert_eq!(ok("a b‸c d", Underline), "a b‸c d"); } -/// A source document of one long word, caret at 1. -fn long(cx: &mut TestAppContext, len: usize) -> (Entity, &mut VisualTestContext) { +/// A source document of one word, caret at 1. +fn word(cx: &mut TestAppContext, len: usize) -> (Entity, &mut VisualTestContext) { let (document, cx) = open(&"x".repeat(len), MarkdownMode::Source, cx); document.update(cx, |document, cx| { document @@ -233,8 +235,8 @@ fn long(cx: &mut TestAppContext, len: usize) -> (Entity, &mut } #[gpui::test] -fn a_long_text_formats_once_read_apart(cx: &mut TestAppContext) { - let (document, cx) = long(cx, AT_ONCE + 1); +fn a_format_reads_apart(cx: &mut TestAppContext) { + let (document, cx) = word(cx, 64); document.update(cx, |document, cx| { document.format(InlineFormat::Strong, cx).expect("taken") }); @@ -248,7 +250,7 @@ fn a_long_text_formats_once_read_apart(cx: &mut TestAppContext) { #[gpui::test] fn many_short_paragraphs_format_apart(cx: &mut TestAppContext) { - let source = "a\n\n".repeat(AT_ONCE / 3 + 1); + let source = "a\n\n".repeat(100); let (document, cx) = open(&source, MarkdownMode::Source, cx); document.update(cx, |document, cx| { document @@ -262,8 +264,8 @@ fn many_short_paragraphs_format_apart(cx: &mut TestAppContext) { } #[gpui::test] -fn a_long_format_lapses_when_the_text_moves(cx: &mut TestAppContext) { - let (document, cx) = long(cx, AT_ONCE + 1); +fn a_format_lapses_when_the_text_moves(cx: &mut TestAppContext) { + let (document, cx) = word(cx, 64); document.update(cx, |document, cx| { document.format(InlineFormat::Strong, cx).expect("taken"); document @@ -296,8 +298,8 @@ fn refusals( } #[gpui::test] -fn a_long_lapse_comes_by_event(cx: &mut TestAppContext) { - let (document, cx) = long(cx, AT_ONCE + 1); +fn a_lapse_comes_by_event(cx: &mut TestAppContext) { + let (document, cx) = word(cx, 64); let heard = refusals(&document, cx); document.update(cx, |document, cx| { document.format(InlineFormat::Strong, cx).expect("taken"); @@ -351,8 +353,8 @@ fn many_paragraphs_format_in_linear_time() { } #[gpui::test] -fn a_second_long_format_refuses_while_one_runs(cx: &mut TestAppContext) { - let (document, cx) = long(cx, AT_ONCE + 1); +fn a_second_format_refuses_while_one_runs(cx: &mut TestAppContext) { + let (document, cx) = word(cx, 64); let second = document.update(cx, |document, cx| { document.format(InlineFormat::Strong, cx).expect("taken"); document.format(InlineFormat::Emphasis, cx) @@ -372,8 +374,8 @@ fn a_second_long_format_refuses_while_one_runs(cx: &mut TestAppContext) { } #[gpui::test] -fn a_long_refusal_comes_by_event(cx: &mut TestAppContext) { - let source = format!("`code` {}", "x".repeat(AT_ONCE)); +fn a_refusal_comes_by_event(cx: &mut TestAppContext) { + let source = format!("`code` {}", "x".repeat(64)); let (document, cx) = open(&source, MarkdownMode::Source, cx); let heard = refusals(&document, cx); let taken = document.update(cx, |document, cx| { @@ -389,8 +391,8 @@ fn a_long_refusal_comes_by_event(cx: &mut TestAppContext) { } #[gpui::test] -fn a_long_format_drops_once_preview_shows(cx: &mut TestAppContext) { - let (document, cx) = long(cx, AT_ONCE + 1); +fn a_format_drops_once_preview_shows(cx: &mut TestAppContext) { + let (document, cx) = word(cx, 64); let heard = refusals(&document, cx); document.update_in(cx, |document, window, cx| { document.format(InlineFormat::Strong, cx).expect("taken"); @@ -403,7 +405,25 @@ fn a_long_format_drops_once_preview_shows(cx: &mut TestAppContext) { #[gpui::test] fn a_text_past_the_largest_read_refuses(cx: &mut TestAppContext) { - let (document, cx) = long(cx, LARGEST_READ + 1); + let (document, cx) = word(cx, LARGEST_READ + 1); let refused = document.update(cx, |document, cx| document.format(InlineFormat::Strong, cx)); assert_eq!(refused, Err(FormatRefusal::TooLong)); } + +#[gpui::test] +fn a_visual_format_reads_apart(cx: &mut TestAppContext) { + let (document, cx) = open("word\n\nmore\n", MarkdownMode::Visual, cx); + document.update(cx, |document, cx| { + document + .editor + .update(cx, |editor, cx| editor.select(std::iter::once(1..1), cx)); + document.format(InlineFormat::Strong, cx).expect("taken"); + }); + assert_eq!( + text(&document, cx), + "word\n\nmore\n", + "not on the UI thread" + ); + cx.run_until_parked(); + assert_eq!(text(&document, cx), "**word**\n\nmore\n"); +} diff --git a/src/documents/document/tests/place.rs b/src/documents/document/tests/place.rs index 965f39d..828a75b 100644 --- a/src/documents/document/tests/place.rs +++ b/src/documents/document/tests/place.rs @@ -229,3 +229,11 @@ fn the_selection_reads_in_source_and_in_an_open_block(cx: &mut TestAppContext) { "words" ); } + +#[gpui::test] +fn a_visual_opening_starts_at_the_top(cx: &mut TestAppContext) { + let source = format!("alpha beta\n\n{}", "x".repeat(20000)); + let (document, cx) = open(&source, MarkdownMode::Visual, cx); + cx.run_until_parked(); + assert_eq!(landed(&document, cx), 0); +}