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