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