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