1use super::{
2 wrap_map::{self, WrapEdit, WrapPoint, WrapSnapshot},
3 Highlights,
4};
5use crate::{EditorStyle, GutterDimensions};
6use collections::{Bound, HashMap, HashSet};
7use gpui::{AnyElement, Pixels, WindowContext};
8use language::{BufferSnapshot, Chunk, Patch, Point};
9use multi_buffer::{Anchor, ExcerptId, ExcerptRange, MultiBufferRow, ToPoint as _};
10use parking_lot::Mutex;
11use std::{
12 cell::RefCell,
13 cmp::{self, Ordering},
14 fmt::Debug,
15 ops::{Deref, DerefMut, Range, RangeBounds},
16 sync::{
17 atomic::{AtomicUsize, Ordering::SeqCst},
18 Arc,
19 },
20};
21use sum_tree::{Bias, SumTree};
22use text::Edit;
23
24const NEWLINES: &[u8] = &[b'\n'; u8::MAX as usize];
25
26/// Tracks custom blocks such as diagnostics that should be displayed within buffer.
27///
28/// See the [`display_map` module documentation](crate::display_map) for more information.
29pub struct BlockMap {
30 next_block_id: AtomicUsize,
31 wrap_snapshot: RefCell<WrapSnapshot>,
32 blocks: Vec<Arc<Block>>,
33 transforms: RefCell<SumTree<Transform>>,
34 show_excerpt_controls: bool,
35 buffer_header_height: u8,
36 excerpt_header_height: u8,
37 excerpt_footer_height: u8,
38}
39
40pub struct BlockMapWriter<'a>(&'a mut BlockMap);
41
42#[derive(Clone)]
43pub struct BlockSnapshot {
44 wrap_snapshot: WrapSnapshot,
45 transforms: SumTree<Transform>,
46}
47
48#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
49pub struct BlockId(usize);
50
51#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
52pub struct BlockPoint(pub Point);
53
54#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
55pub struct BlockRow(pub(super) u32);
56
57#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
58struct WrapRow(u32);
59
60pub type RenderBlock = Box<dyn Send + Fn(&mut BlockContext) -> AnyElement>;
61
62pub struct Block {
63 id: BlockId,
64 position: Anchor,
65 height: u8,
66 style: BlockStyle,
67 render: Mutex<RenderBlock>,
68 disposition: BlockDisposition,
69}
70
71pub struct BlockProperties<P> {
72 pub position: P,
73 pub height: u8,
74 pub style: BlockStyle,
75 pub render: Box<dyn Send + Fn(&mut BlockContext) -> AnyElement>,
76 pub disposition: BlockDisposition,
77}
78
79#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
80pub enum BlockStyle {
81 Fixed,
82 Flex,
83 Sticky,
84}
85
86pub struct BlockContext<'a, 'b> {
87 pub context: &'b mut WindowContext<'a>,
88 pub anchor_x: Pixels,
89 pub max_width: Pixels,
90 pub gutter_dimensions: &'b GutterDimensions,
91 pub em_width: Pixels,
92 pub line_height: Pixels,
93 pub block_id: usize,
94 pub editor_style: &'b EditorStyle,
95}
96
97/// Whether the block should be considered above or below the anchor line
98#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
99pub enum BlockDisposition {
100 Above,
101 Below,
102}
103
104#[derive(Clone, Debug)]
105struct Transform {
106 summary: TransformSummary,
107 block: Option<TransformBlock>,
108}
109
110pub(crate) enum BlockType {
111 Custom(BlockId),
112 Header,
113 Footer,
114}
115
116pub(crate) trait BlockLike {
117 fn block_type(&self) -> BlockType;
118 fn disposition(&self) -> BlockDisposition;
119}
120
121#[allow(clippy::large_enum_variant)]
122#[derive(Clone)]
123pub enum TransformBlock {
124 Custom(Arc<Block>),
125 ExcerptHeader {
126 id: ExcerptId,
127 buffer: BufferSnapshot,
128 range: ExcerptRange<text::Anchor>,
129 height: u8,
130 starts_new_buffer: bool,
131 show_excerpt_controls: bool,
132 },
133 ExcerptFooter {
134 id: ExcerptId,
135 disposition: BlockDisposition,
136 height: u8,
137 },
138}
139
140impl BlockLike for TransformBlock {
141 fn block_type(&self) -> BlockType {
142 match self {
143 TransformBlock::Custom(block) => BlockType::Custom(block.id),
144 TransformBlock::ExcerptHeader { .. } => BlockType::Header,
145 TransformBlock::ExcerptFooter { .. } => BlockType::Footer,
146 }
147 }
148
149 fn disposition(&self) -> BlockDisposition {
150 self.disposition()
151 }
152}
153
154impl TransformBlock {
155 fn disposition(&self) -> BlockDisposition {
156 match self {
157 TransformBlock::Custom(block) => block.disposition,
158 TransformBlock::ExcerptHeader { .. } => BlockDisposition::Above,
159 TransformBlock::ExcerptFooter { disposition, .. } => *disposition,
160 }
161 }
162
163 pub fn height(&self) -> u8 {
164 match self {
165 TransformBlock::Custom(block) => block.height,
166 TransformBlock::ExcerptHeader { height, .. } => *height,
167 TransformBlock::ExcerptFooter { height, .. } => *height,
168 }
169 }
170}
171
172impl Debug for TransformBlock {
173 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
174 match self {
175 Self::Custom(block) => f.debug_struct("Custom").field("block", block).finish(),
176 Self::ExcerptHeader {
177 buffer,
178 starts_new_buffer,
179 id,
180 ..
181 } => f
182 .debug_struct("ExcerptHeader")
183 .field("id", &id)
184 .field("path", &buffer.file().map(|f| f.path()))
185 .field("starts_new_buffer", &starts_new_buffer)
186 .finish(),
187 TransformBlock::ExcerptFooter {
188 id, disposition, ..
189 } => f
190 .debug_struct("ExcerptFooter")
191 .field("id", &id)
192 .field("disposition", &disposition)
193 .finish(),
194 }
195 }
196}
197
198#[derive(Clone, Debug, Default)]
199struct TransformSummary {
200 input_rows: u32,
201 output_rows: u32,
202}
203
204pub struct BlockChunks<'a> {
205 transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
206 input_chunks: wrap_map::WrapChunks<'a>,
207 input_chunk: Chunk<'a>,
208 output_row: u32,
209 max_output_row: u32,
210}
211
212#[derive(Clone)]
213pub struct BlockBufferRows<'a> {
214 transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
215 input_buffer_rows: wrap_map::WrapBufferRows<'a>,
216 output_row: BlockRow,
217 started: bool,
218}
219
220impl BlockMap {
221 pub fn new(
222 wrap_snapshot: WrapSnapshot,
223 show_excerpt_controls: bool,
224 buffer_header_height: u8,
225 excerpt_header_height: u8,
226 excerpt_footer_height: u8,
227 ) -> Self {
228 let row_count = wrap_snapshot.max_point().row() + 1;
229 let map = Self {
230 next_block_id: AtomicUsize::new(0),
231 blocks: Vec::new(),
232 transforms: RefCell::new(SumTree::from_item(Transform::isomorphic(row_count), &())),
233 wrap_snapshot: RefCell::new(wrap_snapshot.clone()),
234 show_excerpt_controls,
235 buffer_header_height,
236 excerpt_header_height,
237 excerpt_footer_height,
238 };
239 map.sync(
240 &wrap_snapshot,
241 Patch::new(vec![Edit {
242 old: 0..row_count,
243 new: 0..row_count,
244 }]),
245 );
246 map
247 }
248
249 pub fn read(&self, wrap_snapshot: WrapSnapshot, edits: Patch<u32>) -> BlockSnapshot {
250 self.sync(&wrap_snapshot, edits);
251 *self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
252 BlockSnapshot {
253 wrap_snapshot,
254 transforms: self.transforms.borrow().clone(),
255 }
256 }
257
258 pub fn write(&mut self, wrap_snapshot: WrapSnapshot, edits: Patch<u32>) -> BlockMapWriter {
259 self.sync(&wrap_snapshot, edits);
260 *self.wrap_snapshot.borrow_mut() = wrap_snapshot;
261 BlockMapWriter(self)
262 }
263
264 fn sync(&self, wrap_snapshot: &WrapSnapshot, mut edits: Patch<u32>) {
265 let buffer = wrap_snapshot.buffer_snapshot();
266
267 // Handle changing the last excerpt if it is empty.
268 if buffer.trailing_excerpt_update_count()
269 != self
270 .wrap_snapshot
271 .borrow()
272 .buffer_snapshot()
273 .trailing_excerpt_update_count()
274 {
275 let max_point = wrap_snapshot.max_point();
276 let edit_start = wrap_snapshot.prev_row_boundary(max_point);
277 let edit_end = max_point.row() + 1;
278 edits = edits.compose([WrapEdit {
279 old: edit_start..edit_end,
280 new: edit_start..edit_end,
281 }]);
282 }
283
284 let edits = edits.into_inner();
285 if edits.is_empty() {
286 return;
287 }
288
289 let mut transforms = self.transforms.borrow_mut();
290 let mut new_transforms = SumTree::new();
291 let old_row_count = transforms.summary().input_rows;
292 let new_row_count = wrap_snapshot.max_point().row() + 1;
293 let mut cursor = transforms.cursor::<WrapRow>();
294 let mut last_block_ix = 0;
295 let mut blocks_in_edit = Vec::new();
296 let mut edits = edits.into_iter().peekable();
297
298 while let Some(edit) = edits.next() {
299 // Preserve any old transforms that precede this edit.
300 let old_start = WrapRow(edit.old.start);
301 let new_start = WrapRow(edit.new.start);
302 new_transforms.append(cursor.slice(&old_start, Bias::Left, &()), &());
303 if let Some(transform) = cursor.item() {
304 if transform.is_isomorphic() && old_start == cursor.end(&()) {
305 new_transforms.push(transform.clone(), &());
306 cursor.next(&());
307 while let Some(transform) = cursor.item() {
308 if transform
309 .block
310 .as_ref()
311 .map_or(false, |b| b.disposition().is_below())
312 {
313 new_transforms.push(transform.clone(), &());
314 cursor.next(&());
315 } else {
316 break;
317 }
318 }
319 }
320 }
321
322 // Preserve any portion of an old transform that precedes this edit.
323 let extent_before_edit = old_start.0 - cursor.start().0;
324 push_isomorphic(&mut new_transforms, extent_before_edit);
325
326 // Skip over any old transforms that intersect this edit.
327 let mut old_end = WrapRow(edit.old.end);
328 let mut new_end = WrapRow(edit.new.end);
329 cursor.seek(&old_end, Bias::Left, &());
330 cursor.next(&());
331 if old_end == *cursor.start() {
332 while let Some(transform) = cursor.item() {
333 if transform
334 .block
335 .as_ref()
336 .map_or(false, |b| b.disposition().is_below())
337 {
338 cursor.next(&());
339 } else {
340 break;
341 }
342 }
343 }
344
345 // Combine this edit with any subsequent edits that intersect the same transform.
346 while let Some(next_edit) = edits.peek() {
347 if next_edit.old.start <= cursor.start().0 {
348 old_end = WrapRow(next_edit.old.end);
349 new_end = WrapRow(next_edit.new.end);
350 cursor.seek(&old_end, Bias::Left, &());
351 cursor.next(&());
352 if old_end == *cursor.start() {
353 while let Some(transform) = cursor.item() {
354 if transform
355 .block
356 .as_ref()
357 .map_or(false, |b| b.disposition().is_below())
358 {
359 cursor.next(&());
360 } else {
361 break;
362 }
363 }
364 }
365 edits.next();
366 } else {
367 break;
368 }
369 }
370
371 // Find the blocks within this edited region.
372 let new_buffer_start =
373 wrap_snapshot.to_point(WrapPoint::new(new_start.0, 0), Bias::Left);
374 let start_bound = Bound::Included(new_buffer_start);
375 let start_block_ix = match self.blocks[last_block_ix..].binary_search_by(|probe| {
376 probe
377 .position
378 .to_point(buffer)
379 .cmp(&new_buffer_start)
380 .then(Ordering::Greater)
381 }) {
382 Ok(ix) | Err(ix) => last_block_ix + ix,
383 };
384
385 let end_bound;
386 let end_block_ix = if new_end.0 > wrap_snapshot.max_point().row() {
387 end_bound = Bound::Unbounded;
388 self.blocks.len()
389 } else {
390 let new_buffer_end =
391 wrap_snapshot.to_point(WrapPoint::new(new_end.0, 0), Bias::Left);
392 end_bound = Bound::Excluded(new_buffer_end);
393 match self.blocks[start_block_ix..].binary_search_by(|probe| {
394 probe
395 .position
396 .to_point(buffer)
397 .cmp(&new_buffer_end)
398 .then(Ordering::Greater)
399 }) {
400 Ok(ix) | Err(ix) => start_block_ix + ix,
401 }
402 };
403 last_block_ix = end_block_ix;
404
405 debug_assert!(blocks_in_edit.is_empty());
406 blocks_in_edit.extend(
407 self.blocks[start_block_ix..end_block_ix]
408 .iter()
409 .map(|block| {
410 let mut position = block.position.to_point(buffer);
411 match block.disposition {
412 BlockDisposition::Above => position.column = 0,
413 BlockDisposition::Below => {
414 position.column = buffer.line_len(MultiBufferRow(position.row))
415 }
416 }
417 let position = wrap_snapshot.make_wrap_point(position, Bias::Left);
418 (position.row(), TransformBlock::Custom(block.clone()))
419 }),
420 );
421
422 if buffer.show_headers() {
423 blocks_in_edit.extend(BlockMap::header_blocks(
424 self.show_excerpt_controls,
425 self.excerpt_footer_height,
426 self.buffer_header_height,
427 self.excerpt_header_height,
428 buffer,
429 (start_bound, end_bound),
430 wrap_snapshot,
431 ));
432 }
433
434 BlockMap::sort_blocks(&mut blocks_in_edit);
435
436 // For each of these blocks, insert a new isomorphic transform preceding the block,
437 // and then insert the block itself.
438 for (block_row, block) in blocks_in_edit.drain(..) {
439 let insertion_row = match block.disposition() {
440 BlockDisposition::Above => block_row,
441 BlockDisposition::Below => block_row + 1,
442 };
443 let extent_before_block = insertion_row - new_transforms.summary().input_rows;
444 push_isomorphic(&mut new_transforms, extent_before_block);
445 new_transforms.push(Transform::block(block), &());
446 }
447
448 old_end = WrapRow(old_end.0.min(old_row_count));
449 new_end = WrapRow(new_end.0.min(new_row_count));
450
451 // Insert an isomorphic transform after the final block.
452 let extent_after_last_block = new_end.0 - new_transforms.summary().input_rows;
453 push_isomorphic(&mut new_transforms, extent_after_last_block);
454
455 // Preserve any portion of the old transform after this edit.
456 let extent_after_edit = cursor.start().0 - old_end.0;
457 push_isomorphic(&mut new_transforms, extent_after_edit);
458 }
459
460 new_transforms.append(cursor.suffix(&()), &());
461 debug_assert_eq!(
462 new_transforms.summary().input_rows,
463 wrap_snapshot.max_point().row() + 1
464 );
465
466 drop(cursor);
467 *transforms = new_transforms;
468 }
469
470 pub fn replace_renderers(&mut self, mut renderers: HashMap<BlockId, RenderBlock>) {
471 for block in &mut self.blocks {
472 if let Some(render) = renderers.remove(&block.id) {
473 *block.render.lock() = render;
474 }
475 }
476 }
477
478 pub fn show_excerpt_controls(&self) -> bool {
479 self.show_excerpt_controls
480 }
481
482 pub fn header_blocks<'a, 'b: 'a, 'c: 'a + 'b, R, T>(
483 show_excerpt_controls: bool,
484 excerpt_footer_height: u8,
485 buffer_header_height: u8,
486 excerpt_header_height: u8,
487 buffer: &'b multi_buffer::MultiBufferSnapshot,
488 range: R,
489 wrap_snapshot: &'c WrapSnapshot,
490 ) -> impl Iterator<Item = (u32, TransformBlock)> + 'b
491 where
492 R: RangeBounds<T>,
493 T: multi_buffer::ToOffset,
494 {
495 buffer
496 .excerpt_boundaries_in_range(range)
497 .flat_map(move |excerpt_boundary| {
498 let wrap_row = wrap_snapshot
499 .make_wrap_point(Point::new(excerpt_boundary.row.0, 0), Bias::Left)
500 .row();
501
502 [
503 show_excerpt_controls
504 .then(|| {
505 excerpt_boundary.prev.as_ref().map(|prev| {
506 (
507 wrap_row,
508 TransformBlock::ExcerptFooter {
509 id: prev.id,
510 height: excerpt_footer_height,
511 disposition: if excerpt_boundary.next.is_some() {
512 BlockDisposition::Above
513 } else {
514 BlockDisposition::Below
515 },
516 },
517 )
518 })
519 })
520 .flatten(),
521 excerpt_boundary.next.map(|next| {
522 let starts_new_buffer = excerpt_boundary
523 .prev
524 .map_or(true, |prev| prev.buffer_id != next.buffer_id);
525
526 (
527 wrap_row,
528 TransformBlock::ExcerptHeader {
529 id: next.id,
530 buffer: next.buffer,
531 range: next.range,
532 height: if starts_new_buffer {
533 buffer_header_height
534 } else {
535 excerpt_header_height
536 },
537 starts_new_buffer,
538 show_excerpt_controls,
539 },
540 )
541 }),
542 ]
543 })
544 .flatten()
545 }
546
547 pub(crate) fn sort_blocks<B: BlockLike>(blocks: &mut Vec<(u32, B)>) {
548 // Place excerpt headers and footers above custom blocks on the same row
549 blocks.sort_unstable_by(|(row_a, block_a), (row_b, block_b)| {
550 row_a.cmp(row_b).then_with(|| {
551 block_a
552 .disposition()
553 .cmp(&block_b.disposition())
554 .then_with(|| match ((block_a.block_type()), (block_b.block_type())) {
555 (BlockType::Footer, BlockType::Footer) => Ordering::Equal,
556 (BlockType::Footer, _) => Ordering::Less,
557 (_, BlockType::Footer) => Ordering::Greater,
558 (BlockType::Header, BlockType::Header) => Ordering::Equal,
559 (BlockType::Header, _) => Ordering::Less,
560 (_, BlockType::Header) => Ordering::Greater,
561 (BlockType::Custom(a_id), BlockType::Custom(b_id)) => a_id.cmp(&b_id),
562 })
563 })
564 });
565 }
566}
567
568fn push_isomorphic(tree: &mut SumTree<Transform>, rows: u32) {
569 if rows == 0 {
570 return;
571 }
572
573 let mut extent = Some(rows);
574 tree.update_last(
575 |last_transform| {
576 if last_transform.is_isomorphic() {
577 let extent = extent.take().unwrap();
578 last_transform.summary.input_rows += extent;
579 last_transform.summary.output_rows += extent;
580 }
581 },
582 &(),
583 );
584 if let Some(extent) = extent {
585 tree.push(Transform::isomorphic(extent), &());
586 }
587}
588
589impl BlockPoint {
590 pub fn new(row: u32, column: u32) -> Self {
591 Self(Point::new(row, column))
592 }
593}
594
595impl Deref for BlockPoint {
596 type Target = Point;
597
598 fn deref(&self) -> &Self::Target {
599 &self.0
600 }
601}
602
603impl std::ops::DerefMut for BlockPoint {
604 fn deref_mut(&mut self) -> &mut Self::Target {
605 &mut self.0
606 }
607}
608
609impl<'a> BlockMapWriter<'a> {
610 pub fn insert(
611 &mut self,
612 blocks: impl IntoIterator<Item = BlockProperties<Anchor>>,
613 ) -> Vec<BlockId> {
614 let mut ids = Vec::new();
615 let mut edits = Patch::default();
616 let wrap_snapshot = &*self.0.wrap_snapshot.borrow();
617 let buffer = wrap_snapshot.buffer_snapshot();
618
619 for block in blocks {
620 let id = BlockId(self.0.next_block_id.fetch_add(1, SeqCst));
621 ids.push(id);
622
623 let position = block.position;
624 let point = position.to_point(buffer);
625 let wrap_row = wrap_snapshot
626 .make_wrap_point(Point::new(point.row, 0), Bias::Left)
627 .row();
628 let start_row = wrap_snapshot.prev_row_boundary(WrapPoint::new(wrap_row, 0));
629 let end_row = wrap_snapshot
630 .next_row_boundary(WrapPoint::new(wrap_row, 0))
631 .unwrap_or(wrap_snapshot.max_point().row() + 1);
632
633 let block_ix = match self
634 .0
635 .blocks
636 .binary_search_by(|probe| probe.position.cmp(&position, buffer))
637 {
638 Ok(ix) | Err(ix) => ix,
639 };
640 self.0.blocks.insert(
641 block_ix,
642 Arc::new(Block {
643 id,
644 position,
645 height: block.height,
646 render: Mutex::new(block.render),
647 disposition: block.disposition,
648 style: block.style,
649 }),
650 );
651
652 edits = edits.compose([Edit {
653 old: start_row..end_row,
654 new: start_row..end_row,
655 }]);
656 }
657
658 self.0.sync(wrap_snapshot, edits);
659 ids
660 }
661
662 pub fn replace(&mut self, mut heights_and_renderers: HashMap<BlockId, (u8, RenderBlock)>) {
663 let wrap_snapshot = &*self.0.wrap_snapshot.borrow();
664 let buffer = wrap_snapshot.buffer_snapshot();
665 let mut edits = Patch::default();
666 let mut last_block_buffer_row = None;
667
668 for block in &mut self.0.blocks {
669 if let Some((new_height, render)) = heights_and_renderers.remove(&block.id) {
670 if block.height != new_height {
671 let new_block = Block {
672 id: block.id,
673 position: block.position,
674 height: new_height,
675 style: block.style,
676 render: Mutex::new(render),
677 disposition: block.disposition,
678 };
679 *block = Arc::new(new_block);
680
681 let buffer_row = block.position.to_point(buffer).row;
682 if last_block_buffer_row != Some(buffer_row) {
683 last_block_buffer_row = Some(buffer_row);
684 let wrap_row = wrap_snapshot
685 .make_wrap_point(Point::new(buffer_row, 0), Bias::Left)
686 .row();
687 let start_row =
688 wrap_snapshot.prev_row_boundary(WrapPoint::new(wrap_row, 0));
689 let end_row = wrap_snapshot
690 .next_row_boundary(WrapPoint::new(wrap_row, 0))
691 .unwrap_or(wrap_snapshot.max_point().row() + 1);
692 edits.push(Edit {
693 old: start_row..end_row,
694 new: start_row..end_row,
695 })
696 }
697 }
698 }
699 }
700
701 self.0.sync(wrap_snapshot, edits);
702 }
703
704 pub fn remove(&mut self, block_ids: HashSet<BlockId>) {
705 let wrap_snapshot = &*self.0.wrap_snapshot.borrow();
706 let buffer = wrap_snapshot.buffer_snapshot();
707 let mut edits = Patch::default();
708 let mut last_block_buffer_row = None;
709 self.0.blocks.retain(|block| {
710 if block_ids.contains(&block.id) {
711 let buffer_row = block.position.to_point(buffer).row;
712 if last_block_buffer_row != Some(buffer_row) {
713 last_block_buffer_row = Some(buffer_row);
714 let wrap_row = wrap_snapshot
715 .make_wrap_point(Point::new(buffer_row, 0), Bias::Left)
716 .row();
717 let start_row = wrap_snapshot.prev_row_boundary(WrapPoint::new(wrap_row, 0));
718 let end_row = wrap_snapshot
719 .next_row_boundary(WrapPoint::new(wrap_row, 0))
720 .unwrap_or(wrap_snapshot.max_point().row() + 1);
721 edits.push(Edit {
722 old: start_row..end_row,
723 new: start_row..end_row,
724 })
725 }
726 false
727 } else {
728 true
729 }
730 });
731 self.0.sync(wrap_snapshot, edits);
732 }
733}
734
735impl BlockSnapshot {
736 #[cfg(test)]
737 pub fn text(&self) -> String {
738 self.chunks(
739 0..self.transforms.summary().output_rows,
740 false,
741 Highlights::default(),
742 )
743 .map(|chunk| chunk.text)
744 .collect()
745 }
746
747 pub(crate) fn chunks<'a>(
748 &'a self,
749 rows: Range<u32>,
750 language_aware: bool,
751 highlights: Highlights<'a>,
752 ) -> BlockChunks<'a> {
753 let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
754 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
755 let input_end = {
756 cursor.seek(&BlockRow(rows.end), Bias::Right, &());
757 let overshoot = if cursor
758 .item()
759 .map_or(false, |transform| transform.is_isomorphic())
760 {
761 rows.end - cursor.start().0 .0
762 } else {
763 0
764 };
765 cursor.start().1 .0 + overshoot
766 };
767 let input_start = {
768 cursor.seek(&BlockRow(rows.start), Bias::Right, &());
769 let overshoot = if cursor
770 .item()
771 .map_or(false, |transform| transform.is_isomorphic())
772 {
773 rows.start - cursor.start().0 .0
774 } else {
775 0
776 };
777 cursor.start().1 .0 + overshoot
778 };
779 BlockChunks {
780 input_chunks: self.wrap_snapshot.chunks(
781 input_start..input_end,
782 language_aware,
783 highlights,
784 ),
785 input_chunk: Default::default(),
786 transforms: cursor,
787 output_row: rows.start,
788 max_output_row,
789 }
790 }
791
792 pub(super) fn buffer_rows(&self, start_row: BlockRow) -> BlockBufferRows {
793 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
794 cursor.seek(&start_row, Bias::Right, &());
795 let (output_start, input_start) = cursor.start();
796 let overshoot = if cursor.item().map_or(false, |t| t.is_isomorphic()) {
797 start_row.0 - output_start.0
798 } else {
799 0
800 };
801 let input_start_row = input_start.0 + overshoot;
802 BlockBufferRows {
803 transforms: cursor,
804 input_buffer_rows: self.wrap_snapshot.buffer_rows(input_start_row),
805 output_row: start_row,
806 started: false,
807 }
808 }
809
810 pub fn blocks_in_range(
811 &self,
812 rows: Range<u32>,
813 ) -> impl Iterator<Item = (u32, &TransformBlock)> {
814 let mut cursor = self.transforms.cursor::<BlockRow>();
815 cursor.seek(&BlockRow(rows.start), Bias::Right, &());
816 std::iter::from_fn(move || {
817 while let Some(transform) = cursor.item() {
818 let start_row = cursor.start().0;
819 if start_row >= rows.end {
820 break;
821 }
822 if let Some(block) = &transform.block {
823 cursor.next(&());
824 return Some((start_row, block));
825 } else {
826 cursor.next(&());
827 }
828 }
829 None
830 })
831 }
832
833 pub fn max_point(&self) -> BlockPoint {
834 let row = self.transforms.summary().output_rows - 1;
835 BlockPoint::new(row, self.line_len(BlockRow(row)))
836 }
837
838 pub fn longest_row(&self) -> u32 {
839 let input_row = self.wrap_snapshot.longest_row();
840 self.to_block_point(WrapPoint::new(input_row, 0)).row
841 }
842
843 pub(super) fn line_len(&self, row: BlockRow) -> u32 {
844 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
845 cursor.seek(&BlockRow(row.0), Bias::Right, &());
846 if let Some(transform) = cursor.item() {
847 let (output_start, input_start) = cursor.start();
848 let overshoot = row.0 - output_start.0;
849 if transform.block.is_some() {
850 0
851 } else {
852 self.wrap_snapshot.line_len(input_start.0 + overshoot)
853 }
854 } else {
855 panic!("row out of range");
856 }
857 }
858
859 pub(super) fn is_block_line(&self, row: BlockRow) -> bool {
860 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
861 cursor.seek(&row, Bias::Right, &());
862 cursor.item().map_or(false, |t| t.block.is_some())
863 }
864
865 pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
866 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
867 cursor.seek(&BlockRow(point.row), Bias::Right, &());
868
869 let max_input_row = WrapRow(self.transforms.summary().input_rows);
870 let mut search_left =
871 (bias == Bias::Left && cursor.start().1 .0 > 0) || cursor.end(&()).1 == max_input_row;
872 let mut reversed = false;
873
874 loop {
875 if let Some(transform) = cursor.item() {
876 if transform.is_isomorphic() {
877 let (output_start_row, input_start_row) = cursor.start();
878 let (output_end_row, input_end_row) = cursor.end(&());
879 let output_start = Point::new(output_start_row.0, 0);
880 let input_start = Point::new(input_start_row.0, 0);
881 let input_end = Point::new(input_end_row.0, 0);
882 let input_point = if point.row >= output_end_row.0 {
883 let line_len = self.wrap_snapshot.line_len(input_end_row.0 - 1);
884 self.wrap_snapshot
885 .clip_point(WrapPoint::new(input_end_row.0 - 1, line_len), bias)
886 } else {
887 let output_overshoot = point.0.saturating_sub(output_start);
888 self.wrap_snapshot
889 .clip_point(WrapPoint(input_start + output_overshoot), bias)
890 };
891
892 if (input_start..input_end).contains(&input_point.0) {
893 let input_overshoot = input_point.0.saturating_sub(input_start);
894 return BlockPoint(output_start + input_overshoot);
895 }
896 }
897
898 if search_left {
899 cursor.prev(&());
900 } else {
901 cursor.next(&());
902 }
903 } else if reversed {
904 return self.max_point();
905 } else {
906 reversed = true;
907 search_left = !search_left;
908 cursor.seek(&BlockRow(point.row), Bias::Right, &());
909 }
910 }
911 }
912
913 pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
914 let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
915 cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
916 if let Some(transform) = cursor.item() {
917 debug_assert!(transform.is_isomorphic());
918 } else {
919 return self.max_point();
920 }
921
922 let (input_start_row, output_start_row) = cursor.start();
923 let input_start = Point::new(input_start_row.0, 0);
924 let output_start = Point::new(output_start_row.0, 0);
925 let input_overshoot = wrap_point.0 - input_start;
926 BlockPoint(output_start + input_overshoot)
927 }
928
929 pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
930 let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
931 cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
932 if let Some(transform) = cursor.item() {
933 match transform.block.as_ref().map(|b| b.disposition()) {
934 Some(BlockDisposition::Above) => WrapPoint::new(cursor.start().1 .0, 0),
935 Some(BlockDisposition::Below) => {
936 let wrap_row = cursor.start().1 .0 - 1;
937 WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
938 }
939 None => {
940 let overshoot = block_point.row - cursor.start().0 .0;
941 let wrap_row = cursor.start().1 .0 + overshoot;
942 WrapPoint::new(wrap_row, block_point.column)
943 }
944 }
945 } else {
946 self.wrap_snapshot.max_point()
947 }
948 }
949}
950
951impl Transform {
952 fn isomorphic(rows: u32) -> Self {
953 Self {
954 summary: TransformSummary {
955 input_rows: rows,
956 output_rows: rows,
957 },
958 block: None,
959 }
960 }
961
962 fn block(block: TransformBlock) -> Self {
963 Self {
964 summary: TransformSummary {
965 input_rows: 0,
966 output_rows: block.height() as u32,
967 },
968 block: Some(block),
969 }
970 }
971
972 fn is_isomorphic(&self) -> bool {
973 self.block.is_none()
974 }
975}
976
977impl<'a> Iterator for BlockChunks<'a> {
978 type Item = Chunk<'a>;
979
980 fn next(&mut self) -> Option<Self::Item> {
981 if self.output_row >= self.max_output_row {
982 return None;
983 }
984
985 let transform = self.transforms.item()?;
986 if transform.block.is_some() {
987 let block_start = self.transforms.start().0 .0;
988 let mut block_end = self.transforms.end(&()).0 .0;
989 self.transforms.next(&());
990 if self.transforms.item().is_none() {
991 block_end -= 1;
992 }
993
994 let start_in_block = self.output_row - block_start;
995 let end_in_block = cmp::min(self.max_output_row, block_end) - block_start;
996 let line_count = end_in_block - start_in_block;
997 self.output_row += line_count;
998
999 return Some(Chunk {
1000 text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..line_count as usize]) },
1001 ..Default::default()
1002 });
1003 }
1004
1005 if self.input_chunk.text.is_empty() {
1006 if let Some(input_chunk) = self.input_chunks.next() {
1007 self.input_chunk = input_chunk;
1008 } else {
1009 self.output_row += 1;
1010 if self.output_row < self.max_output_row {
1011 self.transforms.next(&());
1012 return Some(Chunk {
1013 text: "\n",
1014 ..Default::default()
1015 });
1016 } else {
1017 return None;
1018 }
1019 }
1020 }
1021
1022 let transform_end = self.transforms.end(&()).0 .0;
1023 let (prefix_rows, prefix_bytes) =
1024 offset_for_row(self.input_chunk.text, transform_end - self.output_row);
1025 self.output_row += prefix_rows;
1026 let (prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
1027 self.input_chunk.text = suffix;
1028 if self.output_row == transform_end {
1029 self.transforms.next(&());
1030 }
1031
1032 Some(Chunk {
1033 text: prefix,
1034 ..self.input_chunk.clone()
1035 })
1036 }
1037}
1038
1039impl<'a> Iterator for BlockBufferRows<'a> {
1040 type Item = Option<BlockRow>;
1041
1042 fn next(&mut self) -> Option<Self::Item> {
1043 if self.started {
1044 self.output_row.0 += 1;
1045 } else {
1046 self.started = true;
1047 }
1048
1049 if self.output_row.0 >= self.transforms.end(&()).0 .0 {
1050 self.transforms.next(&());
1051 }
1052
1053 let transform = self.transforms.item()?;
1054 if transform.block.is_some() {
1055 Some(None)
1056 } else {
1057 Some(self.input_buffer_rows.next().unwrap().map(BlockRow))
1058 }
1059 }
1060}
1061
1062impl sum_tree::Item for Transform {
1063 type Summary = TransformSummary;
1064
1065 fn summary(&self) -> Self::Summary {
1066 self.summary.clone()
1067 }
1068}
1069
1070impl sum_tree::Summary for TransformSummary {
1071 type Context = ();
1072
1073 fn add_summary(&mut self, summary: &Self, _: &()) {
1074 self.input_rows += summary.input_rows;
1075 self.output_rows += summary.output_rows;
1076 }
1077}
1078
1079impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
1080 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
1081 self.0 += summary.input_rows;
1082 }
1083}
1084
1085impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockRow {
1086 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
1087 self.0 += summary.output_rows;
1088 }
1089}
1090
1091impl BlockDisposition {
1092 fn is_below(&self) -> bool {
1093 matches!(self, BlockDisposition::Below)
1094 }
1095}
1096
1097impl<'a> Deref for BlockContext<'a, '_> {
1098 type Target = WindowContext<'a>;
1099
1100 fn deref(&self) -> &Self::Target {
1101 self.context
1102 }
1103}
1104
1105impl DerefMut for BlockContext<'_, '_> {
1106 fn deref_mut(&mut self) -> &mut Self::Target {
1107 self.context
1108 }
1109}
1110
1111impl Block {
1112 pub fn render(&self, cx: &mut BlockContext) -> AnyElement {
1113 self.render.lock()(cx)
1114 }
1115
1116 pub fn position(&self) -> &Anchor {
1117 &self.position
1118 }
1119
1120 pub fn style(&self) -> BlockStyle {
1121 self.style
1122 }
1123}
1124
1125impl Debug for Block {
1126 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1127 f.debug_struct("Block")
1128 .field("id", &self.id)
1129 .field("position", &self.position)
1130 .field("disposition", &self.disposition)
1131 .finish()
1132 }
1133}
1134
1135// Count the number of bytes prior to a target point. If the string doesn't contain the target
1136// point, return its total extent. Otherwise return the target point itself.
1137fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
1138 let mut row = 0;
1139 let mut offset = 0;
1140 for (ix, line) in s.split('\n').enumerate() {
1141 if ix > 0 {
1142 row += 1;
1143 offset += 1;
1144 }
1145 if row >= target {
1146 break;
1147 }
1148 offset += line.len();
1149 }
1150 (row, offset)
1151}
1152
1153#[cfg(test)]
1154mod tests {
1155 use std::env;
1156
1157 use super::*;
1158 use crate::display_map::inlay_map::InlayMap;
1159 use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
1160 use gpui::{div, font, px, Element};
1161 use multi_buffer::MultiBuffer;
1162 use rand::prelude::*;
1163 use settings::SettingsStore;
1164 use util::RandomCharIter;
1165
1166 #[gpui::test]
1167 fn test_offset_for_row() {
1168 assert_eq!(offset_for_row("", 0), (0, 0));
1169 assert_eq!(offset_for_row("", 1), (0, 0));
1170 assert_eq!(offset_for_row("abcd", 0), (0, 0));
1171 assert_eq!(offset_for_row("abcd", 1), (0, 4));
1172 assert_eq!(offset_for_row("\n", 0), (0, 0));
1173 assert_eq!(offset_for_row("\n", 1), (1, 1));
1174 assert_eq!(offset_for_row("abc\ndef\nghi", 0), (0, 0));
1175 assert_eq!(offset_for_row("abc\ndef\nghi", 1), (1, 4));
1176 assert_eq!(offset_for_row("abc\ndef\nghi", 2), (2, 8));
1177 assert_eq!(offset_for_row("abc\ndef\nghi", 3), (2, 11));
1178 }
1179
1180 #[gpui::test]
1181 fn test_basic_blocks(cx: &mut gpui::TestAppContext) {
1182 cx.update(|cx| init_test(cx));
1183
1184 let text = "aaa\nbbb\nccc\nddd";
1185
1186 let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
1187 let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
1188 let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
1189 let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1190 let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
1191 let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
1192 let (wrap_map, wraps_snapshot) =
1193 cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
1194 let mut block_map = BlockMap::new(wraps_snapshot.clone(), true, 1, 1, 1);
1195
1196 let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
1197 let block_ids = writer.insert(vec![
1198 BlockProperties {
1199 style: BlockStyle::Fixed,
1200 position: buffer_snapshot.anchor_after(Point::new(1, 0)),
1201 height: 1,
1202 disposition: BlockDisposition::Above,
1203 render: Box::new(|_| div().into_any()),
1204 },
1205 BlockProperties {
1206 style: BlockStyle::Fixed,
1207 position: buffer_snapshot.anchor_after(Point::new(1, 2)),
1208 height: 2,
1209 disposition: BlockDisposition::Above,
1210 render: Box::new(|_| div().into_any()),
1211 },
1212 BlockProperties {
1213 style: BlockStyle::Fixed,
1214 position: buffer_snapshot.anchor_after(Point::new(3, 3)),
1215 height: 3,
1216 disposition: BlockDisposition::Below,
1217 render: Box::new(|_| div().into_any()),
1218 },
1219 ]);
1220
1221 let snapshot = block_map.read(wraps_snapshot, Default::default());
1222 assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
1223
1224 let blocks = snapshot
1225 .blocks_in_range(0..8)
1226 .map(|(start_row, block)| {
1227 let block = block.as_custom().unwrap();
1228 (start_row..start_row + block.height as u32, block.id)
1229 })
1230 .collect::<Vec<_>>();
1231
1232 // When multiple blocks are on the same line, the newer blocks appear first.
1233 assert_eq!(
1234 blocks,
1235 &[
1236 (1..2, block_ids[0]),
1237 (2..4, block_ids[1]),
1238 (7..10, block_ids[2]),
1239 ]
1240 );
1241
1242 assert_eq!(
1243 snapshot.to_block_point(WrapPoint::new(0, 3)),
1244 BlockPoint::new(0, 3)
1245 );
1246 assert_eq!(
1247 snapshot.to_block_point(WrapPoint::new(1, 0)),
1248 BlockPoint::new(4, 0)
1249 );
1250 assert_eq!(
1251 snapshot.to_block_point(WrapPoint::new(3, 3)),
1252 BlockPoint::new(6, 3)
1253 );
1254
1255 assert_eq!(
1256 snapshot.to_wrap_point(BlockPoint::new(0, 3)),
1257 WrapPoint::new(0, 3)
1258 );
1259 assert_eq!(
1260 snapshot.to_wrap_point(BlockPoint::new(1, 0)),
1261 WrapPoint::new(1, 0)
1262 );
1263 assert_eq!(
1264 snapshot.to_wrap_point(BlockPoint::new(3, 0)),
1265 WrapPoint::new(1, 0)
1266 );
1267 assert_eq!(
1268 snapshot.to_wrap_point(BlockPoint::new(7, 0)),
1269 WrapPoint::new(3, 3)
1270 );
1271
1272 assert_eq!(
1273 snapshot.clip_point(BlockPoint::new(1, 0), Bias::Left),
1274 BlockPoint::new(0, 3)
1275 );
1276 assert_eq!(
1277 snapshot.clip_point(BlockPoint::new(1, 0), Bias::Right),
1278 BlockPoint::new(4, 0)
1279 );
1280 assert_eq!(
1281 snapshot.clip_point(BlockPoint::new(1, 1), Bias::Left),
1282 BlockPoint::new(0, 3)
1283 );
1284 assert_eq!(
1285 snapshot.clip_point(BlockPoint::new(1, 1), Bias::Right),
1286 BlockPoint::new(4, 0)
1287 );
1288 assert_eq!(
1289 snapshot.clip_point(BlockPoint::new(4, 0), Bias::Left),
1290 BlockPoint::new(4, 0)
1291 );
1292 assert_eq!(
1293 snapshot.clip_point(BlockPoint::new(4, 0), Bias::Right),
1294 BlockPoint::new(4, 0)
1295 );
1296 assert_eq!(
1297 snapshot.clip_point(BlockPoint::new(6, 3), Bias::Left),
1298 BlockPoint::new(6, 3)
1299 );
1300 assert_eq!(
1301 snapshot.clip_point(BlockPoint::new(6, 3), Bias::Right),
1302 BlockPoint::new(6, 3)
1303 );
1304 assert_eq!(
1305 snapshot.clip_point(BlockPoint::new(7, 0), Bias::Left),
1306 BlockPoint::new(6, 3)
1307 );
1308 assert_eq!(
1309 snapshot.clip_point(BlockPoint::new(7, 0), Bias::Right),
1310 BlockPoint::new(6, 3)
1311 );
1312
1313 assert_eq!(
1314 snapshot
1315 .buffer_rows(BlockRow(0))
1316 .map(|row| row.map(|r| r.0))
1317 .collect::<Vec<_>>(),
1318 &[
1319 Some(0),
1320 None,
1321 None,
1322 None,
1323 Some(1),
1324 Some(2),
1325 Some(3),
1326 None,
1327 None,
1328 None
1329 ]
1330 );
1331
1332 // Insert a line break, separating two block decorations into separate lines.
1333 let buffer_snapshot = buffer.update(cx, |buffer, cx| {
1334 buffer.edit([(Point::new(1, 1)..Point::new(1, 1), "!!!\n")], None, cx);
1335 buffer.snapshot(cx)
1336 });
1337
1338 let (inlay_snapshot, inlay_edits) =
1339 inlay_map.sync(buffer_snapshot, subscription.consume().into_inner());
1340 let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1341 let (tab_snapshot, tab_edits) =
1342 tab_map.sync(fold_snapshot, fold_edits, 4.try_into().unwrap());
1343 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1344 wrap_map.sync(tab_snapshot, tab_edits, cx)
1345 });
1346 let snapshot = block_map.read(wraps_snapshot, wrap_edits);
1347 assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
1348 }
1349
1350 #[gpui::test]
1351 fn test_replace_with_heights(cx: &mut gpui::TestAppContext) {
1352 let _update = cx.update(|cx| init_test(cx));
1353
1354 let text = "aaa\nbbb\nccc\nddd";
1355
1356 let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
1357 let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
1358 let _subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
1359 let (_inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1360 let (_fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
1361 let (_tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
1362 let (_wrap_map, wraps_snapshot) =
1363 cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
1364 let mut block_map = BlockMap::new(wraps_snapshot.clone(), false, 1, 1, 0);
1365
1366 let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
1367 let block_ids = writer.insert(vec![
1368 BlockProperties {
1369 style: BlockStyle::Fixed,
1370 position: buffer_snapshot.anchor_after(Point::new(1, 0)),
1371 height: 1,
1372 disposition: BlockDisposition::Above,
1373 render: Box::new(|_| div().into_any()),
1374 },
1375 BlockProperties {
1376 style: BlockStyle::Fixed,
1377 position: buffer_snapshot.anchor_after(Point::new(1, 2)),
1378 height: 2,
1379 disposition: BlockDisposition::Above,
1380 render: Box::new(|_| div().into_any()),
1381 },
1382 BlockProperties {
1383 style: BlockStyle::Fixed,
1384 position: buffer_snapshot.anchor_after(Point::new(3, 3)),
1385 height: 3,
1386 disposition: BlockDisposition::Below,
1387 render: Box::new(|_| div().into_any()),
1388 },
1389 ]);
1390
1391 {
1392 let snapshot = block_map.read(wraps_snapshot.clone(), Default::default());
1393 assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
1394
1395 let mut block_map_writer = block_map.write(wraps_snapshot.clone(), Default::default());
1396
1397 let mut hash_map = HashMap::default();
1398 let render: RenderBlock = Box::new(|_| div().into_any());
1399 hash_map.insert(block_ids[0], (2_u8, render));
1400 block_map_writer.replace(hash_map);
1401 let snapshot = block_map.read(wraps_snapshot.clone(), Default::default());
1402 assert_eq!(snapshot.text(), "aaa\n\n\n\n\nbbb\nccc\nddd\n\n\n");
1403 }
1404
1405 {
1406 let mut block_map_writer = block_map.write(wraps_snapshot.clone(), Default::default());
1407
1408 let mut hash_map = HashMap::default();
1409 let render: RenderBlock = Box::new(|_| div().into_any());
1410 hash_map.insert(block_ids[0], (1_u8, render));
1411 block_map_writer.replace(hash_map);
1412
1413 let snapshot = block_map.read(wraps_snapshot.clone(), Default::default());
1414 assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
1415 }
1416
1417 {
1418 let mut block_map_writer = block_map.write(wraps_snapshot.clone(), Default::default());
1419
1420 let mut hash_map = HashMap::default();
1421 let render: RenderBlock = Box::new(|_| div().into_any());
1422 hash_map.insert(block_ids[0], (0_u8, render));
1423 block_map_writer.replace(hash_map);
1424
1425 let snapshot = block_map.read(wraps_snapshot.clone(), Default::default());
1426 assert_eq!(snapshot.text(), "aaa\n\n\nbbb\nccc\nddd\n\n\n");
1427 }
1428
1429 {
1430 let mut block_map_writer = block_map.write(wraps_snapshot.clone(), Default::default());
1431
1432 let mut hash_map = HashMap::default();
1433 let render: RenderBlock = Box::new(|_| div().into_any());
1434 hash_map.insert(block_ids[0], (3_u8, render));
1435 block_map_writer.replace(hash_map);
1436
1437 let snapshot = block_map.read(wraps_snapshot.clone(), Default::default());
1438 assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
1439 }
1440
1441 {
1442 let mut block_map_writer = block_map.write(wraps_snapshot.clone(), Default::default());
1443
1444 let mut hash_map = HashMap::default();
1445 let render: RenderBlock = Box::new(|_| div().into_any());
1446 hash_map.insert(block_ids[0], (3_u8, render));
1447 block_map_writer.replace(hash_map);
1448
1449 let snapshot = block_map.read(wraps_snapshot.clone(), Default::default());
1450 // Same height as before, should remain the same
1451 assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
1452 }
1453 }
1454
1455 #[gpui::test]
1456 fn test_blocks_on_wrapped_lines(cx: &mut gpui::TestAppContext) {
1457 cx.update(|cx| init_test(cx));
1458
1459 let _font_id = cx.text_system().font_id(&font("Helvetica")).unwrap();
1460
1461 let text = "one two three\nfour five six\nseven eight";
1462
1463 let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
1464 let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
1465 let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1466 let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
1467 let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
1468 let (_, wraps_snapshot) = cx.update(|cx| {
1469 WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), Some(px(60.)), cx)
1470 });
1471 let mut block_map = BlockMap::new(wraps_snapshot.clone(), true, 1, 1, 0);
1472
1473 let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
1474 writer.insert(vec![
1475 BlockProperties {
1476 style: BlockStyle::Fixed,
1477 position: buffer_snapshot.anchor_after(Point::new(1, 12)),
1478 disposition: BlockDisposition::Above,
1479 render: Box::new(|_| div().into_any()),
1480 height: 1,
1481 },
1482 BlockProperties {
1483 style: BlockStyle::Fixed,
1484 position: buffer_snapshot.anchor_after(Point::new(1, 1)),
1485 disposition: BlockDisposition::Below,
1486 render: Box::new(|_| div().into_any()),
1487 height: 1,
1488 },
1489 ]);
1490
1491 // Blocks with an 'above' disposition go above their corresponding buffer line.
1492 // Blocks with a 'below' disposition go below their corresponding buffer line.
1493 let snapshot = block_map.read(wraps_snapshot, Default::default());
1494 assert_eq!(
1495 snapshot.text(),
1496 "one two \nthree\n\nfour five \nsix\n\nseven \neight"
1497 );
1498 }
1499
1500 #[gpui::test(iterations = 100)]
1501 fn test_random_blocks(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
1502 cx.update(|cx| init_test(cx));
1503
1504 let operations = env::var("OPERATIONS")
1505 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1506 .unwrap_or(10);
1507
1508 let wrap_width = if rng.gen_bool(0.2) {
1509 None
1510 } else {
1511 Some(px(rng.gen_range(0.0..=100.0)))
1512 };
1513 let tab_size = 1.try_into().unwrap();
1514 let font_size = px(14.0);
1515 let buffer_start_header_height = rng.gen_range(1..=5);
1516 let excerpt_header_height = rng.gen_range(1..=5);
1517 let excerpt_footer_height = rng.gen_range(1..=5);
1518
1519 log::info!("Wrap width: {:?}", wrap_width);
1520 log::info!("Excerpt Header Height: {:?}", excerpt_header_height);
1521 log::info!("Excerpt Footer Height: {:?}", excerpt_footer_height);
1522
1523 let buffer = if rng.gen() {
1524 let len = rng.gen_range(0..10);
1525 let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
1526 log::info!("initial buffer text: {:?}", text);
1527 cx.update(|cx| MultiBuffer::build_simple(&text, cx))
1528 } else {
1529 cx.update(|cx| MultiBuffer::build_random(&mut rng, cx))
1530 };
1531
1532 let mut buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
1533 let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1534 let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
1535 let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
1536 let (wrap_map, wraps_snapshot) = cx
1537 .update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), font_size, wrap_width, cx));
1538 let mut block_map = BlockMap::new(
1539 wraps_snapshot,
1540 true,
1541 buffer_start_header_height,
1542 excerpt_header_height,
1543 excerpt_footer_height,
1544 );
1545 let mut custom_blocks = Vec::new();
1546
1547 for _ in 0..operations {
1548 let mut buffer_edits = Vec::new();
1549 match rng.gen_range(0..=100) {
1550 0..=19 => {
1551 let wrap_width = if rng.gen_bool(0.2) {
1552 None
1553 } else {
1554 Some(px(rng.gen_range(0.0..=100.0)))
1555 };
1556 log::info!("Setting wrap width to {:?}", wrap_width);
1557 wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1558 }
1559 20..=39 => {
1560 let block_count = rng.gen_range(1..=5);
1561 let block_properties = (0..block_count)
1562 .map(|_| {
1563 let buffer = cx.update(|cx| buffer.read(cx).read(cx).clone());
1564 let position = buffer.anchor_after(
1565 buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Left),
1566 );
1567
1568 let disposition = if rng.gen() {
1569 BlockDisposition::Above
1570 } else {
1571 BlockDisposition::Below
1572 };
1573 let height = rng.gen_range(1..5);
1574 log::info!(
1575 "inserting block {:?} {:?} with height {}",
1576 disposition,
1577 position.to_point(&buffer),
1578 height
1579 );
1580 BlockProperties {
1581 style: BlockStyle::Fixed,
1582 position,
1583 height,
1584 disposition,
1585 render: Box::new(|_| div().into_any()),
1586 }
1587 })
1588 .collect::<Vec<_>>();
1589
1590 let (inlay_snapshot, inlay_edits) =
1591 inlay_map.sync(buffer_snapshot.clone(), vec![]);
1592 let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1593 let (tab_snapshot, tab_edits) =
1594 tab_map.sync(fold_snapshot, fold_edits, tab_size);
1595 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1596 wrap_map.sync(tab_snapshot, tab_edits, cx)
1597 });
1598 let mut block_map = block_map.write(wraps_snapshot, wrap_edits);
1599 let block_ids =
1600 block_map.insert(block_properties.iter().map(|props| BlockProperties {
1601 position: props.position,
1602 height: props.height,
1603 style: props.style,
1604 render: Box::new(|_| div().into_any()),
1605 disposition: props.disposition,
1606 }));
1607 for (block_id, props) in block_ids.into_iter().zip(block_properties) {
1608 custom_blocks.push((block_id, props));
1609 }
1610 }
1611 40..=59 if !custom_blocks.is_empty() => {
1612 let block_count = rng.gen_range(1..=4.min(custom_blocks.len()));
1613 let block_ids_to_remove = (0..block_count)
1614 .map(|_| {
1615 custom_blocks
1616 .remove(rng.gen_range(0..custom_blocks.len()))
1617 .0
1618 })
1619 .collect();
1620
1621 let (inlay_snapshot, inlay_edits) =
1622 inlay_map.sync(buffer_snapshot.clone(), vec![]);
1623 let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1624 let (tab_snapshot, tab_edits) =
1625 tab_map.sync(fold_snapshot, fold_edits, tab_size);
1626 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1627 wrap_map.sync(tab_snapshot, tab_edits, cx)
1628 });
1629 let mut block_map = block_map.write(wraps_snapshot, wrap_edits);
1630 block_map.remove(block_ids_to_remove);
1631 }
1632 _ => {
1633 buffer.update(cx, |buffer, cx| {
1634 let mutation_count = rng.gen_range(1..=5);
1635 let subscription = buffer.subscribe();
1636 buffer.randomly_mutate(&mut rng, mutation_count, cx);
1637 buffer_snapshot = buffer.snapshot(cx);
1638 buffer_edits.extend(subscription.consume());
1639 log::info!("buffer text: {:?}", buffer_snapshot.text());
1640 });
1641 }
1642 }
1643
1644 let (inlay_snapshot, inlay_edits) =
1645 inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
1646 let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1647 let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
1648 let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1649 wrap_map.sync(tab_snapshot, tab_edits, cx)
1650 });
1651 let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits);
1652 assert_eq!(
1653 blocks_snapshot.transforms.summary().input_rows,
1654 wraps_snapshot.max_point().row() + 1
1655 );
1656 log::info!("blocks text: {:?}", blocks_snapshot.text());
1657
1658 let mut expected_blocks = Vec::new();
1659 expected_blocks.extend(custom_blocks.iter().map(|(id, block)| {
1660 let mut position = block.position.to_point(&buffer_snapshot);
1661 match block.disposition {
1662 BlockDisposition::Above => {
1663 position.column = 0;
1664 }
1665 BlockDisposition::Below => {
1666 position.column = buffer_snapshot.line_len(MultiBufferRow(position.row));
1667 }
1668 };
1669 let row = wraps_snapshot.make_wrap_point(position, Bias::Left).row();
1670 (
1671 row,
1672 ExpectedBlock::Custom {
1673 disposition: block.disposition,
1674 id: *id,
1675 height: block.height,
1676 },
1677 )
1678 }));
1679
1680 // Note that this needs to be synced with the related section in BlockMap::sync
1681 expected_blocks.extend(
1682 BlockMap::header_blocks(
1683 true,
1684 excerpt_footer_height,
1685 buffer_start_header_height,
1686 excerpt_header_height,
1687 &buffer_snapshot,
1688 0..,
1689 &wraps_snapshot,
1690 )
1691 .map(|(row, block)| (row, block.into())),
1692 );
1693
1694 BlockMap::sort_blocks(&mut expected_blocks);
1695
1696 let mut sorted_blocks_iter = expected_blocks.into_iter().peekable();
1697
1698 let input_buffer_rows = buffer_snapshot
1699 .buffer_rows(MultiBufferRow(0))
1700 .collect::<Vec<_>>();
1701 let mut expected_buffer_rows = Vec::new();
1702 let mut expected_text = String::new();
1703 let mut expected_block_positions = Vec::new();
1704 let input_text = wraps_snapshot.text();
1705 for (row, input_line) in input_text.split('\n').enumerate() {
1706 let row = row as u32;
1707 if row > 0 {
1708 expected_text.push('\n');
1709 }
1710
1711 let buffer_row = input_buffer_rows[wraps_snapshot
1712 .to_point(WrapPoint::new(row, 0), Bias::Left)
1713 .row as usize];
1714
1715 while let Some((block_row, block)) = sorted_blocks_iter.peek() {
1716 if *block_row == row && block.disposition() == BlockDisposition::Above {
1717 let (_, block) = sorted_blocks_iter.next().unwrap();
1718 let height = block.height() as usize;
1719 expected_block_positions
1720 .push((expected_text.matches('\n').count() as u32, block));
1721 let text = "\n".repeat(height);
1722 expected_text.push_str(&text);
1723 for _ in 0..height {
1724 expected_buffer_rows.push(None);
1725 }
1726 } else {
1727 break;
1728 }
1729 }
1730
1731 let soft_wrapped = wraps_snapshot.to_tab_point(WrapPoint::new(row, 0)).column() > 0;
1732 expected_buffer_rows.push(if soft_wrapped { None } else { buffer_row });
1733 expected_text.push_str(input_line);
1734
1735 while let Some((block_row, block)) = sorted_blocks_iter.peek() {
1736 if *block_row == row && block.disposition() == BlockDisposition::Below {
1737 let (_, block) = sorted_blocks_iter.next().unwrap();
1738 let height = block.height() as usize;
1739 expected_block_positions
1740 .push((expected_text.matches('\n').count() as u32 + 1, block));
1741 let text = "\n".repeat(height);
1742 expected_text.push_str(&text);
1743 for _ in 0..height {
1744 expected_buffer_rows.push(None);
1745 }
1746 } else {
1747 break;
1748 }
1749 }
1750 }
1751
1752 let expected_lines = expected_text.split('\n').collect::<Vec<_>>();
1753 let expected_row_count = expected_lines.len();
1754 for start_row in 0..expected_row_count {
1755 let expected_text = expected_lines[start_row..].join("\n");
1756 let actual_text = blocks_snapshot
1757 .chunks(
1758 start_row as u32..blocks_snapshot.max_point().row + 1,
1759 false,
1760 Highlights::default(),
1761 )
1762 .map(|chunk| chunk.text)
1763 .collect::<String>();
1764 assert_eq!(
1765 actual_text, expected_text,
1766 "incorrect text starting from row {}",
1767 start_row
1768 );
1769 assert_eq!(
1770 blocks_snapshot
1771 .buffer_rows(BlockRow(start_row as u32))
1772 .map(|row| row.map(|r| r.0))
1773 .collect::<Vec<_>>(),
1774 &expected_buffer_rows[start_row..]
1775 );
1776 }
1777
1778 assert_eq!(
1779 blocks_snapshot
1780 .blocks_in_range(0..(expected_row_count as u32))
1781 .map(|(row, block)| (row, block.clone().into()))
1782 .collect::<Vec<_>>(),
1783 expected_block_positions
1784 );
1785
1786 let mut expected_longest_rows = Vec::new();
1787 let mut longest_line_len = -1_isize;
1788 for (row, line) in expected_lines.iter().enumerate() {
1789 let row = row as u32;
1790
1791 assert_eq!(
1792 blocks_snapshot.line_len(BlockRow(row)),
1793 line.len() as u32,
1794 "invalid line len for row {}",
1795 row
1796 );
1797
1798 let line_char_count = line.chars().count() as isize;
1799 match line_char_count.cmp(&longest_line_len) {
1800 Ordering::Less => {}
1801 Ordering::Equal => expected_longest_rows.push(row),
1802 Ordering::Greater => {
1803 longest_line_len = line_char_count;
1804 expected_longest_rows.clear();
1805 expected_longest_rows.push(row);
1806 }
1807 }
1808 }
1809
1810 let longest_row = blocks_snapshot.longest_row();
1811 assert!(
1812 expected_longest_rows.contains(&longest_row),
1813 "incorrect longest row {}. expected {:?} with length {}",
1814 longest_row,
1815 expected_longest_rows,
1816 longest_line_len,
1817 );
1818
1819 for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
1820 let wrap_point = WrapPoint::new(row, 0);
1821 let block_point = blocks_snapshot.to_block_point(wrap_point);
1822 assert_eq!(blocks_snapshot.to_wrap_point(block_point), wrap_point);
1823 }
1824
1825 let mut block_point = BlockPoint::new(0, 0);
1826 for c in expected_text.chars() {
1827 let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
1828 let left_buffer_point = blocks_snapshot.to_point(left_point, Bias::Left);
1829 assert_eq!(
1830 blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(left_point)),
1831 left_point
1832 );
1833 assert_eq!(
1834 left_buffer_point,
1835 buffer_snapshot.clip_point(left_buffer_point, Bias::Right),
1836 "{:?} is not valid in buffer coordinates",
1837 left_point
1838 );
1839
1840 let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
1841 let right_buffer_point = blocks_snapshot.to_point(right_point, Bias::Right);
1842 assert_eq!(
1843 blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(right_point)),
1844 right_point
1845 );
1846 assert_eq!(
1847 right_buffer_point,
1848 buffer_snapshot.clip_point(right_buffer_point, Bias::Left),
1849 "{:?} is not valid in buffer coordinates",
1850 right_point
1851 );
1852
1853 if c == '\n' {
1854 block_point.0 += Point::new(1, 0);
1855 } else {
1856 block_point.column += c.len_utf8() as u32;
1857 }
1858 }
1859 }
1860
1861 #[derive(Debug, Eq, PartialEq)]
1862 enum ExpectedBlock {
1863 ExcerptHeader {
1864 height: u8,
1865 starts_new_buffer: bool,
1866 },
1867 ExcerptFooter {
1868 height: u8,
1869 disposition: BlockDisposition,
1870 },
1871 Custom {
1872 disposition: BlockDisposition,
1873 id: BlockId,
1874 height: u8,
1875 },
1876 }
1877
1878 impl BlockLike for ExpectedBlock {
1879 fn block_type(&self) -> BlockType {
1880 match self {
1881 ExpectedBlock::Custom { id, .. } => BlockType::Custom(*id),
1882 ExpectedBlock::ExcerptHeader { .. } => BlockType::Header,
1883 ExpectedBlock::ExcerptFooter { .. } => BlockType::Footer,
1884 }
1885 }
1886
1887 fn disposition(&self) -> BlockDisposition {
1888 self.disposition()
1889 }
1890 }
1891
1892 impl ExpectedBlock {
1893 fn height(&self) -> u8 {
1894 match self {
1895 ExpectedBlock::ExcerptHeader { height, .. } => *height,
1896 ExpectedBlock::Custom { height, .. } => *height,
1897 ExpectedBlock::ExcerptFooter { height, .. } => *height,
1898 }
1899 }
1900
1901 fn disposition(&self) -> BlockDisposition {
1902 match self {
1903 ExpectedBlock::ExcerptHeader { .. } => BlockDisposition::Above,
1904 ExpectedBlock::Custom { disposition, .. } => *disposition,
1905 ExpectedBlock::ExcerptFooter { disposition, .. } => *disposition,
1906 }
1907 }
1908 }
1909
1910 impl From<TransformBlock> for ExpectedBlock {
1911 fn from(block: TransformBlock) -> Self {
1912 match block {
1913 TransformBlock::Custom(block) => ExpectedBlock::Custom {
1914 id: block.id,
1915 disposition: block.disposition,
1916 height: block.height,
1917 },
1918 TransformBlock::ExcerptHeader {
1919 height,
1920 starts_new_buffer,
1921 ..
1922 } => ExpectedBlock::ExcerptHeader {
1923 height,
1924 starts_new_buffer,
1925 },
1926 TransformBlock::ExcerptFooter {
1927 height,
1928 disposition,
1929 ..
1930 } => ExpectedBlock::ExcerptFooter {
1931 height,
1932 disposition,
1933 },
1934 }
1935 }
1936 }
1937 }
1938
1939 fn init_test(cx: &mut gpui::AppContext) {
1940 let settings = SettingsStore::test(cx);
1941 cx.set_global(settings);
1942 theme::init(theme::LoadThemes::JustBase, cx);
1943 }
1944
1945 impl TransformBlock {
1946 fn as_custom(&self) -> Option<&Block> {
1947 match self {
1948 TransformBlock::Custom(block) => Some(block),
1949 TransformBlock::ExcerptHeader { .. } => None,
1950 TransformBlock::ExcerptFooter { .. } => None,
1951 }
1952 }
1953 }
1954
1955 impl BlockSnapshot {
1956 fn to_point(&self, point: BlockPoint, bias: Bias) -> Point {
1957 self.wrap_snapshot.to_point(self.to_wrap_point(point), bias)
1958 }
1959 }
1960}