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