1use super::wrap_map::{self, Edit as WrapEdit, Snapshot as WrapSnapshot, WrapPoint};
2use buffer::{rope, Anchor, Bias, Edit, Point, Rope, ToOffset, ToPoint as _};
3use gpui::{fonts::HighlightStyle, AppContext, ModelHandle};
4use language::{Buffer, HighlightedChunk};
5use parking_lot::Mutex;
6use std::{
7 cmp,
8 collections::HashSet,
9 iter,
10 ops::Range,
11 slice,
12 sync::{
13 atomic::{AtomicUsize, Ordering::SeqCst},
14 Arc,
15 },
16};
17use sum_tree::SumTree;
18
19pub struct BlockMap {
20 buffer: ModelHandle<Buffer>,
21 next_block_id: AtomicUsize,
22 wrap_snapshot: Mutex<WrapSnapshot>,
23 blocks: Vec<Arc<Block>>,
24 transforms: Mutex<SumTree<Transform>>,
25}
26
27pub struct BlockMapWriter<'a>(&'a mut BlockMap);
28
29pub struct BlockSnapshot {
30 wrap_snapshot: WrapSnapshot,
31 transforms: SumTree<Transform>,
32}
33
34#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
35pub struct BlockId(usize);
36
37#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
38pub struct BlockPoint(pub super::Point);
39
40#[derive(Debug)]
41struct Block {
42 id: BlockId,
43 position: Anchor,
44 text: Rope,
45 runs: Vec<(usize, HighlightStyle)>,
46 disposition: BlockDisposition,
47}
48
49#[derive(Clone)]
50pub struct BlockProperties<P, T>
51where
52 P: Clone,
53 T: Clone,
54{
55 position: P,
56 text: T,
57 runs: Vec<(usize, HighlightStyle)>,
58 disposition: BlockDisposition,
59}
60
61#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
62enum BlockDisposition {
63 Above,
64 Below,
65}
66
67#[derive(Clone, Debug)]
68struct Transform {
69 summary: TransformSummary,
70 block: Option<Arc<Block>>,
71}
72
73#[derive(Copy, Clone, Debug, Default)]
74struct TransformSummary {
75 input_rows: u32,
76 output_rows: u32,
77}
78
79pub struct HighlightedChunks<'a> {
80 transforms: sum_tree::Cursor<'a, Transform, (OutputRow, InputRow)>,
81 input_chunks: wrap_map::HighlightedChunks<'a>,
82 input_chunk: HighlightedChunk<'a>,
83 block_chunks: Option<BlockChunks<'a>>,
84 output_row: u32,
85 max_output_row: u32,
86}
87
88struct BlockChunks<'a> {
89 chunks: rope::Chunks<'a>,
90 runs: iter::Peekable<slice::Iter<'a, (usize, HighlightStyle)>>,
91 chunk: Option<&'a str>,
92 run_start: usize,
93 offset: usize,
94}
95
96#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord)]
97struct InputRow(u32);
98
99#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord)]
100struct OutputRow(u32);
101
102impl BlockMap {
103 pub fn new(buffer: ModelHandle<Buffer>, wrap_snapshot: WrapSnapshot) -> Self {
104 Self {
105 buffer,
106 next_block_id: AtomicUsize::new(0),
107 blocks: Vec::new(),
108 transforms: Mutex::new(SumTree::from_item(
109 Transform::isomorphic(wrap_snapshot.max_point().row() + 1),
110 &(),
111 )),
112 wrap_snapshot: Mutex::new(wrap_snapshot),
113 }
114 }
115
116 pub fn read(
117 &self,
118 wrap_snapshot: WrapSnapshot,
119 edits: Vec<WrapEdit>,
120 cx: &AppContext,
121 ) -> BlockSnapshot {
122 self.apply_edits(&wrap_snapshot, edits, cx);
123 *self.wrap_snapshot.lock() = wrap_snapshot.clone();
124 BlockSnapshot {
125 wrap_snapshot,
126 transforms: self.transforms.lock().clone(),
127 }
128 }
129
130 pub fn write(
131 &mut self,
132 wrap_snapshot: WrapSnapshot,
133 edits: Vec<WrapEdit>,
134 cx: &AppContext,
135 ) -> BlockMapWriter {
136 self.apply_edits(&wrap_snapshot, edits, cx);
137 *self.wrap_snapshot.lock() = wrap_snapshot;
138 BlockMapWriter(self)
139 }
140
141 fn apply_edits(&self, wrap_snapshot: &WrapSnapshot, edits: Vec<WrapEdit>, cx: &AppContext) {
142 let buffer = self.buffer.read(cx);
143 let mut transforms = self.transforms.lock();
144 let mut new_transforms = SumTree::new();
145 let mut cursor = transforms.cursor::<InputRow>();
146 let mut edits = edits.into_iter().peekable();
147 let mut last_block_ix = 0;
148 let mut blocks_in_edit = Vec::new();
149
150 while let Some(mut edit) = edits.next() {
151 new_transforms.push_tree(
152 cursor.slice(&InputRow(edit.old.start), Bias::Left, &()),
153 &(),
154 );
155
156 let transform_start = cursor.start().0;
157 edit.new.start -= edit.old.start - transform_start;
158 edit.old.start = transform_start;
159
160 loop {
161 if edit.old.end > cursor.start().0 {
162 cursor.seek(&InputRow(edit.old.end), Bias::Left, &());
163 cursor.next(&());
164 while let Some(item) = cursor.item() {
165 if item.is_isomorphic() {
166 break;
167 } else {
168 cursor.next(&());
169 }
170 }
171 let transform_end = cursor.start().0;
172 edit.new.end += transform_end - edit.old.end;
173 edit.old.end = transform_end;
174 }
175
176 if let Some(next_edit) = edits.peek() {
177 if edit.old.end >= next_edit.old.start {
178 let delta = next_edit.new.len() as i32 - next_edit.old.len() as i32;
179 edit.old.end = cmp::max(next_edit.old.end, edit.old.end);
180 edit.new.end = (edit.new.end as i32 + delta) as u32;
181 edits.next();
182 } else {
183 break;
184 }
185 } else {
186 break;
187 }
188 }
189
190 let start_anchor = buffer.anchor_before(Point::new(edit.new.start, 0));
191 let end_anchor = buffer.anchor_after(Point::new(edit.new.end, 0));
192 let start_block_ix = match self.blocks[last_block_ix..]
193 .binary_search_by(|probe| probe.position.cmp(&start_anchor, buffer).unwrap())
194 {
195 Ok(ix) | Err(ix) => last_block_ix + ix,
196 };
197 let end_block_ix = match self.blocks[start_block_ix..]
198 .binary_search_by(|probe| probe.position.cmp(&end_anchor, buffer).unwrap())
199 {
200 Ok(ix) | Err(ix) => start_block_ix + ix,
201 };
202 last_block_ix = end_block_ix;
203
204 blocks_in_edit.clear();
205 blocks_in_edit.extend(
206 self.blocks[start_block_ix..end_block_ix]
207 .iter()
208 .map(|block| (block.position.to_point(buffer).row, block)),
209 );
210 blocks_in_edit.sort_unstable_by_key(|(row, block)| (*row, block.disposition));
211
212 for (row, block) in blocks_in_edit.iter().copied() {
213 let insertion_row = if block.disposition.is_above() {
214 row
215 } else {
216 row + 1
217 };
218
219 let new_transforms_end = new_transforms.summary().input_rows;
220 if new_transforms_end < insertion_row {
221 new_transforms.push(
222 Transform::isomorphic(insertion_row - new_transforms_end),
223 &(),
224 );
225 }
226
227 new_transforms.push(Transform::block(block.clone()), &());
228 }
229
230 let new_transforms_end = new_transforms.summary().input_rows;
231 if new_transforms_end < edit.new.end {
232 new_transforms.push(
233 Transform::isomorphic(edit.new.end - new_transforms_end),
234 &(),
235 );
236 }
237 }
238 new_transforms.push_tree(cursor.suffix(&()), &());
239 drop(cursor);
240 *transforms = new_transforms;
241 }
242}
243
244impl BlockPoint {
245 fn new(row: u32, column: u32) -> Self {
246 Self(Point::new(row, column))
247 }
248}
249
250impl std::ops::Deref for BlockPoint {
251 type Target = Point;
252
253 fn deref(&self) -> &Self::Target {
254 &self.0
255 }
256}
257
258impl std::ops::DerefMut for BlockPoint {
259 fn deref_mut(&mut self) -> &mut Self::Target {
260 &mut self.0
261 }
262}
263
264impl<'a> BlockMapWriter<'a> {
265 pub fn insert<P, T>(
266 &mut self,
267 blocks: impl IntoIterator<Item = BlockProperties<P, T>>,
268 cx: &AppContext,
269 ) -> Vec<BlockId>
270 where
271 P: ToOffset + Clone,
272 T: Into<Rope> + Clone,
273 {
274 let buffer = self.0.buffer.read(cx);
275 let mut ids = Vec::new();
276 let mut edits = Vec::<Edit<u32>>::new();
277
278 for block in blocks {
279 let id = BlockId(self.0.next_block_id.fetch_add(1, SeqCst));
280 ids.push(id);
281
282 let position = buffer.anchor_before(block.position);
283 let row = position.to_point(buffer).row;
284
285 let block_ix = match self
286 .0
287 .blocks
288 .binary_search_by(|probe| probe.position.cmp(&position, buffer).unwrap())
289 {
290 Ok(ix) | Err(ix) => ix,
291 };
292 let mut text = block.text.into();
293 text.push("\n");
294 self.0.blocks.insert(
295 block_ix,
296 Arc::new(Block {
297 id,
298 position,
299 text,
300 runs: block.runs,
301 disposition: block.disposition,
302 }),
303 );
304
305 if let Err(edit_ix) = edits.binary_search_by_key(&row, |edit| edit.old.start) {
306 edits.insert(
307 edit_ix,
308 Edit {
309 old: row..(row + 1),
310 new: row..(row + 1),
311 },
312 );
313 }
314 }
315
316 self.0.apply_edits(&*self.0.wrap_snapshot.lock(), edits, cx);
317 ids
318 }
319
320 pub fn remove(&mut self, _: HashSet<BlockId>, _: &AppContext) {
321 todo!()
322 }
323}
324
325impl BlockSnapshot {
326 #[cfg(test)]
327 fn text(&mut self) -> String {
328 self.highlighted_chunks_for_rows(0..(self.max_point().0.row + 1))
329 .map(|chunk| chunk.text)
330 .collect()
331 }
332
333 pub fn highlighted_chunks_for_rows(&mut self, rows: Range<u32>) -> HighlightedChunks {
334 let mut cursor = self.transforms.cursor::<(OutputRow, InputRow)>();
335 cursor.seek(&OutputRow(rows.start), Bias::Right, &());
336 let (input_start, output_start) = cursor.start();
337 let row_overshoot = rows.start - output_start.0;
338 let input_start_row = input_start.0 + row_overshoot;
339 let input_end_row = self.to_wrap_point(BlockPoint::new(rows.end, 0)).row();
340 let input_chunks = self
341 .wrap_snapshot
342 .highlighted_chunks_for_rows(input_start_row..input_end_row);
343 HighlightedChunks {
344 input_chunks,
345 input_chunk: Default::default(),
346 block_chunks: None,
347 transforms: cursor,
348 output_row: rows.start,
349 max_output_row: rows.end,
350 }
351 }
352
353 pub fn max_point(&self) -> BlockPoint {
354 self.to_block_point(self.wrap_snapshot.max_point())
355 }
356
357 pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
358 let mut cursor = self.transforms.cursor::<(OutputRow, InputRow)>();
359 cursor.seek(&OutputRow(point.row), Bias::Right, &());
360 if let Some(transform) = cursor.item() {
361 if transform.is_isomorphic() {
362 let (output_start_row, input_start_row) = cursor.start();
363 let output_overshoot = point.row - output_start_row.0;
364 let input_point = self.wrap_snapshot.clip_point(
365 WrapPoint::new(input_start_row.0 + output_overshoot, point.column),
366 bias,
367 );
368 let input_overshoot = input_point.row() - input_start_row.0;
369 BlockPoint::new(output_start_row.0 + input_overshoot, input_point.column())
370 } else {
371 if bias == Bias::Left && cursor.start().1 .0 > 0
372 || cursor.end(&()).1 .0 == self.wrap_snapshot.max_point().row()
373 {
374 loop {
375 cursor.prev(&());
376 let transform = cursor.item().unwrap();
377 if transform.is_isomorphic() {
378 return BlockPoint::new(cursor.end(&()).0 .0 - 1, 0);
379 }
380 }
381 } else {
382 loop {
383 cursor.next(&());
384 let transform = cursor.item().unwrap();
385 if transform.is_isomorphic() {
386 return BlockPoint::new(cursor.start().0 .0, 0);
387 }
388 }
389 }
390 }
391 } else {
392 self.max_point()
393 }
394 }
395
396 pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
397 let mut cursor = self.transforms.cursor::<(InputRow, OutputRow)>();
398 cursor.seek(&InputRow(wrap_point.row()), Bias::Right, &());
399 while let Some(item) = cursor.item() {
400 if item.is_isomorphic() {
401 break;
402 }
403 cursor.next(&());
404 }
405 let (input_start, output_start) = cursor.start();
406 let row_overshoot = wrap_point.row() - input_start.0;
407 BlockPoint::new(output_start.0 + row_overshoot, wrap_point.column())
408 }
409
410 pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
411 let mut cursor = self.transforms.cursor::<(OutputRow, InputRow)>();
412 cursor.seek(&OutputRow(block_point.0.row), Bias::Right, &());
413 let (output_start, input_start) = cursor.start();
414 let row_overshoot = block_point.0.row - output_start.0;
415 WrapPoint::new(input_start.0 + row_overshoot, block_point.0.column)
416 }
417}
418
419impl Transform {
420 fn isomorphic(rows: u32) -> Self {
421 Self {
422 summary: TransformSummary {
423 input_rows: rows,
424 output_rows: rows,
425 },
426 block: None,
427 }
428 }
429
430 fn block(block: Arc<Block>) -> Self {
431 Self {
432 summary: TransformSummary {
433 input_rows: 0,
434 output_rows: block.text.summary().lines.row,
435 },
436 block: Some(block),
437 }
438 }
439
440 fn is_isomorphic(&self) -> bool {
441 self.block.is_none()
442 }
443}
444
445impl<'a> Iterator for HighlightedChunks<'a> {
446 type Item = HighlightedChunk<'a>;
447
448 fn next(&mut self) -> Option<Self::Item> {
449 if self.output_row >= self.max_output_row {
450 return None;
451 }
452
453 if let Some(block_chunks) = self.block_chunks.as_mut() {
454 if let Some(block_chunk) = block_chunks.next() {
455 self.output_row += block_chunk.text.matches('\n').count() as u32;
456 return Some(block_chunk);
457 } else {
458 self.block_chunks.take();
459 }
460 }
461
462 let transform = self.transforms.item()?;
463 if let Some(block) = transform.block.as_ref() {
464 let block_start = self.transforms.start().0 .0;
465 let block_end = self.transforms.end(&()).0 .0;
466 let start_row_in_block = self.output_row - block_start;
467 let end_row_in_block = cmp::min(self.max_output_row, block_end) - block_start;
468 self.transforms.next(&());
469 let mut block_chunks = BlockChunks::new(block, start_row_in_block..end_row_in_block);
470 if let Some(block_chunk) = block_chunks.next() {
471 self.output_row += block_chunk.text.matches('\n').count() as u32;
472 return Some(block_chunk);
473 }
474 }
475
476 if self.input_chunk.text.is_empty() {
477 self.input_chunk = self.input_chunks.next()?;
478 }
479
480 let transform_end = self.transforms.end(&()).0 .0;
481 let (prefix_rows, prefix_bytes) =
482 offset_for_row(self.input_chunk.text, transform_end - self.output_row);
483 self.output_row += prefix_rows;
484 let (prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
485 self.input_chunk.text = suffix;
486 if self.output_row == transform_end {
487 self.transforms.next(&());
488 }
489
490 Some(HighlightedChunk {
491 text: prefix,
492 ..self.input_chunk
493 })
494 }
495}
496
497impl<'a> BlockChunks<'a> {
498 fn new(block: &'a Block, row_range: Range<u32>) -> Self {
499 let point_range = Point::new(row_range.start, 0)..Point::new(row_range.end, 0);
500 let offset_range = block.text.point_to_offset(point_range.start)
501 ..block.text.point_to_offset(point_range.end);
502
503 let mut runs = block.runs.iter().peekable();
504 let mut run_start = 0;
505 while let Some((run_len, _)) = runs.peek() {
506 let run_end = run_start + run_len;
507 if run_end <= offset_range.start {
508 run_start = run_end;
509 runs.next();
510 } else {
511 break;
512 }
513 }
514
515 Self {
516 chunk: None,
517 run_start,
518 chunks: block.text.chunks_in_range(offset_range.clone()),
519 runs,
520 offset: offset_range.start,
521 }
522 }
523}
524
525impl<'a> Iterator for BlockChunks<'a> {
526 type Item = HighlightedChunk<'a>;
527
528 fn next(&mut self) -> Option<Self::Item> {
529 if self.chunk.is_none() {
530 self.chunk = self.chunks.next();
531 }
532
533 let chunk = self.chunk?;
534 let mut chunk_len = chunk.len();
535 let mut highlight_style = None;
536 if let Some((run_len, style)) = self.runs.peek() {
537 highlight_style = Some(style.clone());
538 let run_end_in_chunk = self.run_start + run_len - self.offset;
539 if run_end_in_chunk <= chunk_len {
540 chunk_len = run_end_in_chunk;
541 self.run_start += run_len;
542 self.runs.next();
543 }
544 }
545
546 self.offset += chunk_len;
547 let (chunk, suffix) = chunk.split_at(chunk_len);
548 self.chunk = if suffix.is_empty() {
549 None
550 } else {
551 Some(suffix)
552 };
553
554 Some(HighlightedChunk {
555 text: chunk,
556 highlight_id: Default::default(),
557 diagnostic: None,
558 })
559 }
560}
561
562impl sum_tree::Item for Transform {
563 type Summary = TransformSummary;
564
565 fn summary(&self) -> Self::Summary {
566 self.summary
567 }
568}
569
570impl sum_tree::Summary for TransformSummary {
571 type Context = ();
572
573 fn add_summary(&mut self, summary: &Self, _: &()) {
574 self.input_rows += summary.input_rows;
575 self.output_rows += summary.output_rows;
576 }
577}
578
579impl<'a> sum_tree::Dimension<'a, TransformSummary> for InputRow {
580 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
581 self.0 += summary.input_rows;
582 }
583}
584
585impl<'a> sum_tree::Dimension<'a, TransformSummary> for OutputRow {
586 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
587 self.0 += summary.output_rows;
588 }
589}
590
591impl BlockDisposition {
592 fn is_above(&self) -> bool {
593 matches!(self, BlockDisposition::Above)
594 }
595}
596
597// Count the number of bytes prior to a target row.
598// If the string doesn't contain the target row, return the total number of rows it does contain.
599// Otherwise return the target row itself.
600fn offset_for_row(s: &str, target_row: u32) -> (u32, usize) {
601 let mut row = 0;
602 let mut offset = 0;
603 for (ix, line) in s.split('\n').enumerate() {
604 if ix > 0 {
605 row += 1;
606 offset += 1;
607 }
608 if row as u32 >= target_row {
609 break;
610 }
611 offset += line.len();
612 }
613 (row, offset)
614}
615
616#[cfg(test)]
617mod tests {
618 use super::*;
619 use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
620 use buffer::RandomCharIter;
621 use language::Buffer;
622 use rand::prelude::*;
623 use std::env;
624
625 #[gpui::test]
626 fn test_basic_blocks(cx: &mut gpui::MutableAppContext) {
627 let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
628 let font_id = cx
629 .font_cache()
630 .select_font(family_id, &Default::default())
631 .unwrap();
632
633 let text = "aaa\nbbb\nccc\nddd\n";
634
635 let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
636 let (fold_map, folds_snapshot) = FoldMap::new(buffer.clone(), cx);
637 let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
638 let (wrap_map, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, None, cx);
639 let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot.clone());
640
641 let mut writer = block_map.write(wraps_snapshot.clone(), vec![], cx);
642 writer.insert(
643 vec![
644 BlockProperties {
645 position: Point::new(1, 0),
646 text: "BLOCK 1",
647 disposition: BlockDisposition::Above,
648 runs: vec![],
649 },
650 BlockProperties {
651 position: Point::new(1, 2),
652 text: "BLOCK 2",
653 disposition: BlockDisposition::Above,
654 runs: vec![],
655 },
656 BlockProperties {
657 position: Point::new(3, 2),
658 text: "BLOCK 3",
659 disposition: BlockDisposition::Below,
660 runs: vec![],
661 },
662 ],
663 cx,
664 );
665
666 let mut snapshot = block_map.read(wraps_snapshot, vec![], cx);
667 assert_eq!(
668 snapshot.text(),
669 "aaa\nBLOCK 1\nBLOCK 2\nbbb\nccc\nddd\nBLOCK 3\n"
670 );
671 assert_eq!(
672 snapshot.to_block_point(WrapPoint::new(1, 0)),
673 BlockPoint::new(3, 0)
674 );
675
676 // Insert a line break, separating two block decorations into separate
677 // lines.
678 buffer.update(cx, |buffer, cx| {
679 buffer.edit([Point::new(1, 1)..Point::new(1, 1)], "!!!\n", cx)
680 });
681
682 let (folds_snapshot, fold_edits) = fold_map.read(cx);
683 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
684 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
685 wrap_map.sync(tabs_snapshot, tab_edits, cx)
686 });
687 let mut snapshot = block_map.read(wraps_snapshot, wrap_edits, cx);
688 assert_eq!(
689 snapshot.text(),
690 "aaa\nBLOCK 1\nb!!!\nBLOCK 2\nbb\nccc\nddd\nBLOCK 3\n"
691 );
692 }
693
694 #[gpui::test(iterations = 100)]
695 fn test_random_blocks(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
696 let operations = env::var("OPERATIONS")
697 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
698 .unwrap_or(10);
699
700 let wrap_width = Some(rng.gen_range(0.0..=1000.0));
701 let tab_size = 1;
702 let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
703 let font_id = cx
704 .font_cache()
705 .select_font(family_id, &Default::default())
706 .unwrap();
707 let font_size = 14.0;
708
709 log::info!("Wrap width: {:?}", wrap_width);
710
711 let buffer = cx.add_model(|cx| {
712 let len = rng.gen_range(0..10);
713 let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
714 Buffer::new(0, text, cx)
715 });
716 let (fold_map, folds_snapshot) = FoldMap::new(buffer.clone(), cx);
717 let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
718 let (wrap_map, wraps_snapshot) =
719 WrapMap::new(tabs_snapshot, font_id, font_size, wrap_width, cx);
720 let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot);
721 let mut expected_blocks = Vec::new();
722
723 for _ in 0..operations {
724 match rng.gen_range(0..=100) {
725 0..=19 => {
726 let wrap_width = if rng.gen_bool(0.2) {
727 None
728 } else {
729 Some(rng.gen_range(0.0..=1000.0))
730 };
731 log::info!("Setting wrap width to {:?}", wrap_width);
732 wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
733 }
734 20..=39 => {
735 let block_count = rng.gen_range(1..=4);
736 let block_properties = (0..block_count)
737 .map(|_| {
738 let buffer = buffer.read(cx);
739 let position = buffer.anchor_before(rng.gen_range(0..=buffer.len()));
740
741 let len = rng.gen_range(0..10);
742 let text = Rope::from(
743 RandomCharIter::new(&mut rng)
744 .take(len)
745 .collect::<String>()
746 .as_str(),
747 );
748 BlockProperties {
749 position,
750 text,
751 runs: Vec::<(usize, HighlightStyle)>::new(),
752 disposition: if rng.gen() {
753 BlockDisposition::Above
754 } else {
755 BlockDisposition::Below
756 },
757 }
758 })
759 .collect::<Vec<_>>();
760
761 let (folds_snapshot, fold_edits) = fold_map.read(cx);
762 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
763 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
764 wrap_map.sync(tabs_snapshot, tab_edits, cx)
765 });
766 let mut block_map = block_map.write(wraps_snapshot, wrap_edits, cx);
767 let block_ids = block_map.insert(block_properties.clone(), cx);
768 expected_blocks.extend(block_ids.into_iter().zip(block_properties));
769 }
770 40..=59 => {
771 let block_count = rng.gen_range(1..=4.min(expected_blocks.len()));
772 let block_ids_to_remove = (0..block_count)
773 .map(|_| {
774 expected_blocks
775 .remove(rng.gen_range(0..expected_blocks.len()))
776 .0
777 })
778 .collect();
779
780 let (folds_snapshot, fold_edits) = fold_map.read(cx);
781 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
782 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
783 wrap_map.sync(tabs_snapshot, tab_edits, cx)
784 });
785 let mut block_map = block_map.write(wraps_snapshot, wrap_edits, cx);
786 block_map.remove(block_ids_to_remove, cx);
787 }
788 _ => {
789 buffer.update(cx, |buffer, _| buffer.randomly_edit(&mut rng, 5));
790 }
791 }
792
793 let (folds_snapshot, fold_edits) = fold_map.read(cx);
794 let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
795 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
796 wrap_map.sync(tabs_snapshot, tab_edits, cx)
797 });
798 let mut blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, cx);
799 assert_eq!(
800 blocks_snapshot.transforms.summary().input_rows,
801 wraps_snapshot.max_point().row() + 1
802 );
803
804 let buffer = buffer.read(cx);
805 let mut sorted_blocks = expected_blocks
806 .iter()
807 .cloned()
808 .map(|(_, block)| BlockProperties {
809 position: block.position.to_point(buffer),
810 text: block.text,
811 runs: block.runs,
812 disposition: block.disposition,
813 })
814 .collect::<Vec<_>>();
815 sorted_blocks.sort_unstable_by_key(|block| (block.position.row, block.disposition));
816 let mut sorted_blocks = sorted_blocks.into_iter().peekable();
817
818 let mut expected_text = String::new();
819 let input_text = wraps_snapshot.text();
820 for (row, input_line) in input_text.split('\n').enumerate() {
821 let row = row as u32;
822 if row > 0 {
823 expected_text.push('\n');
824 }
825
826 while let Some(block) = sorted_blocks.peek() {
827 if block.position.row == row && block.disposition == BlockDisposition::Above {
828 expected_text.extend(block.text.chunks());
829 expected_text.push('\n');
830 sorted_blocks.next();
831 } else {
832 break;
833 }
834 }
835
836 expected_text.push_str(input_line);
837
838 while let Some(block) = sorted_blocks.peek() {
839 if block.position.row == row && block.disposition == BlockDisposition::Below {
840 expected_text.push('\n');
841 expected_text.extend(block.text.chunks());
842 sorted_blocks.next();
843 } else {
844 break;
845 }
846 }
847 }
848
849 assert_eq!(blocks_snapshot.text(), expected_text);
850 }
851 }
852}