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