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