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