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