1use super::{
2 buffer::{AnchorRangeExt, TextSummary},
3 Anchor, Buffer, Point, ToOffset,
4};
5use buffer::HighlightId;
6use gpui::{AppContext, ModelHandle};
7use parking_lot::Mutex;
8use std::{
9 cmp::{self, Ordering},
10 iter, mem,
11 ops::Range,
12 sync::atomic::{AtomicUsize, Ordering::SeqCst},
13};
14use sum_tree::{self, Bias, Cursor, FilterCursor, SumTree};
15
16pub trait ToFoldPoint {
17 fn to_fold_point(&self, snapshot: &Snapshot, bias: Bias) -> FoldPoint;
18}
19
20#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
21pub struct FoldPoint(pub super::Point);
22
23impl FoldPoint {
24 pub fn new(row: u32, column: u32) -> Self {
25 Self(super::Point::new(row, column))
26 }
27
28 pub fn row(self) -> u32 {
29 self.0.row
30 }
31
32 pub fn column(self) -> u32 {
33 self.0.column
34 }
35
36 pub fn row_mut(&mut self) -> &mut u32 {
37 &mut self.0.row
38 }
39
40 #[cfg(test)]
41 pub fn column_mut(&mut self) -> &mut u32 {
42 &mut self.0.column
43 }
44
45 pub fn to_buffer_point(&self, snapshot: &Snapshot) -> Point {
46 let mut cursor = snapshot.transforms.cursor::<(FoldPoint, Point)>();
47 cursor.seek(self, Bias::Right, &());
48 let overshoot = self.0 - cursor.start().0 .0;
49 cursor.start().1 + overshoot
50 }
51
52 pub fn to_buffer_offset(&self, snapshot: &Snapshot) -> usize {
53 let mut cursor = snapshot.transforms.cursor::<(FoldPoint, Point)>();
54 cursor.seek(self, Bias::Right, &());
55 let overshoot = self.0 - cursor.start().0 .0;
56 snapshot
57 .buffer_snapshot
58 .to_offset(cursor.start().1 + overshoot)
59 }
60
61 pub fn to_offset(&self, snapshot: &Snapshot) -> FoldOffset {
62 let mut cursor = snapshot
63 .transforms
64 .cursor::<(FoldPoint, TransformSummary)>();
65 cursor.seek(self, Bias::Right, &());
66 let overshoot = self.0 - cursor.start().1.output.lines;
67 let mut offset = cursor.start().1.output.bytes;
68 if !overshoot.is_zero() {
69 let transform = cursor.item().expect("display point out of range");
70 assert!(transform.output_text.is_none());
71 let end_buffer_offset = snapshot
72 .buffer_snapshot
73 .to_offset(cursor.start().1.input.lines + overshoot);
74 offset += end_buffer_offset - cursor.start().1.input.bytes;
75 }
76 FoldOffset(offset)
77 }
78}
79
80impl ToFoldPoint for Point {
81 fn to_fold_point(&self, snapshot: &Snapshot, bias: Bias) -> FoldPoint {
82 let mut cursor = snapshot.transforms.cursor::<(Point, FoldPoint)>();
83 cursor.seek(self, Bias::Right, &());
84 if cursor.item().map_or(false, |t| t.is_fold()) {
85 if bias == Bias::Left || *self == cursor.start().0 {
86 cursor.start().1
87 } else {
88 cursor.end(&()).1
89 }
90 } else {
91 let overshoot = *self - cursor.start().0;
92 FoldPoint(cmp::min(
93 cursor.start().1 .0 + overshoot,
94 cursor.end(&()).1 .0,
95 ))
96 }
97 }
98}
99
100pub struct FoldMapWriter<'a>(&'a mut FoldMap);
101
102impl<'a> FoldMapWriter<'a> {
103 pub fn fold<T: ToOffset>(
104 &mut self,
105 ranges: impl IntoIterator<Item = Range<T>>,
106 cx: &AppContext,
107 ) -> (Snapshot, Vec<FoldEdit>) {
108 let mut edits = Vec::new();
109 let mut folds = Vec::new();
110 let buffer = self.0.buffer.read(cx).snapshot();
111 for range in ranges.into_iter() {
112 let range = range.start.to_offset(&buffer)..range.end.to_offset(&buffer);
113 if range.start != range.end {
114 let fold = Fold(buffer.anchor_after(range.start)..buffer.anchor_before(range.end));
115 folds.push(fold);
116 edits.push(buffer::Edit {
117 old_bytes: range.clone(),
118 new_bytes: range.clone(),
119 ..Default::default()
120 });
121 }
122 }
123
124 folds.sort_unstable_by(|a, b| sum_tree::SeekTarget::cmp(a, b, &buffer));
125
126 self.0.folds = {
127 let mut new_tree = SumTree::new();
128 let mut cursor = self.0.folds.cursor::<Fold>();
129 for fold in folds {
130 new_tree.push_tree(cursor.slice(&fold, Bias::Right, &buffer), &buffer);
131 new_tree.push(fold, &buffer);
132 }
133 new_tree.push_tree(cursor.suffix(&buffer), &buffer);
134 new_tree
135 };
136
137 consolidate_buffer_edits(&mut edits);
138 let edits = self.0.apply_edits(edits, cx);
139 let snapshot = Snapshot {
140 transforms: self.0.transforms.lock().clone(),
141 folds: self.0.folds.clone(),
142 buffer_snapshot: self.0.buffer.read(cx).snapshot(),
143 version: self.0.version.load(SeqCst),
144 };
145 (snapshot, edits)
146 }
147
148 pub fn unfold<T: ToOffset>(
149 &mut self,
150 ranges: impl IntoIterator<Item = Range<T>>,
151 cx: &AppContext,
152 ) -> (Snapshot, Vec<FoldEdit>) {
153 let mut edits = Vec::new();
154 let mut fold_ixs_to_delete = Vec::new();
155 let buffer = self.0.buffer.read(cx).snapshot();
156 for range in ranges.into_iter() {
157 // Remove intersecting folds and add their ranges to edits that are passed to apply_edits.
158 let mut folds_cursor = intersecting_folds(&buffer, &self.0.folds, range, true);
159 while let Some(fold) = folds_cursor.item() {
160 let offset_range = fold.0.start.to_offset(&buffer)..fold.0.end.to_offset(&buffer);
161 edits.push(buffer::Edit {
162 old_bytes: offset_range.clone(),
163 new_bytes: offset_range,
164 ..Default::default()
165 });
166 fold_ixs_to_delete.push(*folds_cursor.start());
167 folds_cursor.next(&buffer);
168 }
169 }
170
171 fold_ixs_to_delete.sort_unstable();
172 fold_ixs_to_delete.dedup();
173
174 self.0.folds = {
175 let mut cursor = self.0.folds.cursor::<usize>();
176 let mut folds = SumTree::new();
177 for fold_ix in fold_ixs_to_delete {
178 folds.push_tree(cursor.slice(&fold_ix, Bias::Right, &buffer), &buffer);
179 cursor.next(&buffer);
180 }
181 folds.push_tree(cursor.suffix(&buffer), &buffer);
182 folds
183 };
184
185 consolidate_buffer_edits(&mut edits);
186 let edits = self.0.apply_edits(edits, cx);
187 let snapshot = Snapshot {
188 transforms: self.0.transforms.lock().clone(),
189 folds: self.0.folds.clone(),
190 buffer_snapshot: self.0.buffer.read(cx).snapshot(),
191 version: self.0.version.load(SeqCst),
192 };
193 (snapshot, edits)
194 }
195}
196
197pub struct FoldMap {
198 buffer: ModelHandle<Buffer>,
199 transforms: Mutex<SumTree<Transform>>,
200 folds: SumTree<Fold>,
201 last_sync: Mutex<SyncState>,
202 version: AtomicUsize,
203}
204
205#[derive(Clone)]
206struct SyncState {
207 version: clock::Global,
208 parse_count: usize,
209}
210
211impl FoldMap {
212 pub fn new(buffer_handle: ModelHandle<Buffer>, cx: &AppContext) -> (Self, Snapshot) {
213 let buffer = buffer_handle.read(cx);
214 let this = Self {
215 buffer: buffer_handle,
216 folds: Default::default(),
217 transforms: Mutex::new(SumTree::from_item(
218 Transform {
219 summary: TransformSummary {
220 input: buffer.text_summary(),
221 output: buffer.text_summary(),
222 },
223 output_text: None,
224 },
225 &(),
226 )),
227 last_sync: Mutex::new(SyncState {
228 version: buffer.version(),
229 parse_count: buffer.parse_count(),
230 }),
231 version: AtomicUsize::new(0),
232 };
233 let (snapshot, _) = this.read(cx);
234 (this, snapshot)
235 }
236
237 pub fn read(&self, cx: &AppContext) -> (Snapshot, Vec<FoldEdit>) {
238 let edits = self.sync(cx);
239 self.check_invariants(cx);
240 let snapshot = Snapshot {
241 transforms: self.transforms.lock().clone(),
242 folds: self.folds.clone(),
243 buffer_snapshot: self.buffer.read(cx).snapshot(),
244 version: self.version.load(SeqCst),
245 };
246 (snapshot, edits)
247 }
248
249 pub fn write(&mut self, cx: &AppContext) -> (FoldMapWriter, Snapshot, Vec<FoldEdit>) {
250 let (snapshot, edits) = self.read(cx);
251 (FoldMapWriter(self), snapshot, edits)
252 }
253
254 fn sync(&self, cx: &AppContext) -> Vec<FoldEdit> {
255 let buffer = self.buffer.read(cx);
256 let last_sync = mem::replace(
257 &mut *self.last_sync.lock(),
258 SyncState {
259 version: buffer.version(),
260 parse_count: buffer.parse_count(),
261 },
262 );
263 let edits = buffer
264 .edits_since(last_sync.version)
265 .map(Into::into)
266 .collect::<Vec<_>>();
267 if edits.is_empty() {
268 if last_sync.parse_count != buffer.parse_count() {
269 self.version.fetch_add(1, SeqCst);
270 }
271 Vec::new()
272 } else {
273 self.apply_edits(edits, cx)
274 }
275 }
276
277 fn check_invariants(&self, cx: &AppContext) {
278 if cfg!(test) {
279 let buffer = self.buffer.read(cx);
280 assert_eq!(
281 self.transforms.lock().summary().input.bytes,
282 buffer.len(),
283 "transform tree does not match buffer's length"
284 );
285 }
286 }
287
288 fn apply_edits(&self, buffer_edits: Vec<buffer::Edit>, cx: &AppContext) -> Vec<FoldEdit> {
289 let buffer = self.buffer.read(cx).snapshot();
290 let mut buffer_edits_iter = buffer_edits.iter().cloned().peekable();
291
292 let mut new_transforms = SumTree::new();
293 let mut transforms = self.transforms.lock();
294 let mut cursor = transforms.cursor::<usize>();
295 cursor.seek(&0, Bias::Right, &());
296
297 while let Some(mut edit) = buffer_edits_iter.next() {
298 new_transforms.push_tree(cursor.slice(&edit.old_bytes.start, Bias::Left, &()), &());
299 edit.new_bytes.start -= edit.old_bytes.start - cursor.start();
300 edit.old_bytes.start = *cursor.start();
301
302 cursor.seek(&edit.old_bytes.end, Bias::Right, &());
303 cursor.next(&());
304
305 let mut delta = edit.delta();
306 loop {
307 edit.old_bytes.end = *cursor.start();
308
309 if let Some(next_edit) = buffer_edits_iter.peek() {
310 if next_edit.old_bytes.start > edit.old_bytes.end {
311 break;
312 }
313
314 let next_edit = buffer_edits_iter.next().unwrap();
315 delta += next_edit.delta();
316
317 if next_edit.old_bytes.end >= edit.old_bytes.end {
318 edit.old_bytes.end = next_edit.old_bytes.end;
319 cursor.seek(&edit.old_bytes.end, Bias::Right, &());
320 cursor.next(&());
321 }
322 } else {
323 break;
324 }
325 }
326
327 edit.new_bytes.end =
328 ((edit.new_bytes.start + edit.deleted_bytes()) as isize + delta) as usize;
329
330 let anchor = buffer.anchor_before(edit.new_bytes.start);
331 let mut folds_cursor = self.folds.cursor::<Fold>();
332 folds_cursor.seek(&Fold(anchor..Anchor::max()), Bias::Left, &buffer);
333
334 let mut folds = iter::from_fn({
335 let buffer = &buffer;
336 move || {
337 let item = folds_cursor
338 .item()
339 .map(|f| f.0.start.to_offset(buffer)..f.0.end.to_offset(buffer));
340 folds_cursor.next(buffer);
341 item
342 }
343 })
344 .peekable();
345
346 while folds
347 .peek()
348 .map_or(false, |fold| fold.start < edit.new_bytes.end)
349 {
350 let mut fold = folds.next().unwrap();
351 let sum = new_transforms.summary();
352
353 assert!(fold.start >= sum.input.bytes);
354
355 while folds
356 .peek()
357 .map_or(false, |next_fold| next_fold.start <= fold.end)
358 {
359 let next_fold = folds.next().unwrap();
360 if next_fold.end > fold.end {
361 fold.end = next_fold.end;
362 }
363 }
364
365 if fold.start > sum.input.bytes {
366 let text_summary = buffer.text_summary_for_range(sum.input.bytes..fold.start);
367 new_transforms.push(
368 Transform {
369 summary: TransformSummary {
370 output: text_summary.clone(),
371 input: text_summary,
372 },
373 output_text: None,
374 },
375 &(),
376 );
377 }
378
379 if fold.end > fold.start {
380 let output_text = "…";
381 let chars = output_text.chars().count() as u32;
382 let lines = super::Point::new(0, output_text.len() as u32);
383 new_transforms.push(
384 Transform {
385 summary: TransformSummary {
386 output: TextSummary {
387 bytes: output_text.len(),
388 lines,
389 first_line_chars: chars,
390 last_line_chars: chars,
391 longest_row: 0,
392 longest_row_chars: chars,
393 },
394 input: buffer.text_summary_for_range(fold.start..fold.end),
395 },
396 output_text: Some(output_text),
397 },
398 &(),
399 );
400 }
401 }
402
403 let sum = new_transforms.summary();
404 if sum.input.bytes < edit.new_bytes.end {
405 let text_summary =
406 buffer.text_summary_for_range(sum.input.bytes..edit.new_bytes.end);
407 new_transforms.push(
408 Transform {
409 summary: TransformSummary {
410 output: text_summary.clone(),
411 input: text_summary,
412 },
413 output_text: None,
414 },
415 &(),
416 );
417 }
418 }
419
420 new_transforms.push_tree(cursor.suffix(&()), &());
421 if new_transforms.is_empty() {
422 let text_summary = buffer.text_summary();
423 new_transforms.push(
424 Transform {
425 summary: TransformSummary {
426 output: text_summary.clone(),
427 input: text_summary,
428 },
429 output_text: None,
430 },
431 &(),
432 );
433 }
434
435 drop(cursor);
436
437 let mut fold_edits = Vec::with_capacity(buffer_edits.len());
438 {
439 let mut old_transforms = transforms.cursor::<(usize, FoldOffset)>();
440 let mut new_transforms = new_transforms.cursor::<(usize, FoldOffset)>();
441
442 for mut edit in buffer_edits {
443 old_transforms.seek(&edit.old_bytes.start, Bias::Left, &());
444 if old_transforms.item().map_or(false, |t| t.is_fold()) {
445 edit.old_bytes.start = old_transforms.start().0;
446 }
447 let old_start =
448 old_transforms.start().1 .0 + (edit.old_bytes.start - old_transforms.start().0);
449
450 old_transforms.seek_forward(&edit.old_bytes.end, Bias::Right, &());
451 if old_transforms.item().map_or(false, |t| t.is_fold()) {
452 old_transforms.next(&());
453 edit.old_bytes.end = old_transforms.start().0;
454 }
455 let old_end =
456 old_transforms.start().1 .0 + (edit.old_bytes.end - old_transforms.start().0);
457
458 new_transforms.seek(&edit.new_bytes.start, Bias::Left, &());
459 if new_transforms.item().map_or(false, |t| t.is_fold()) {
460 edit.new_bytes.start = new_transforms.start().0;
461 }
462 let new_start =
463 new_transforms.start().1 .0 + (edit.new_bytes.start - new_transforms.start().0);
464
465 new_transforms.seek_forward(&edit.new_bytes.end, Bias::Right, &());
466 if new_transforms.item().map_or(false, |t| t.is_fold()) {
467 new_transforms.next(&());
468 edit.new_bytes.end = new_transforms.start().0;
469 }
470 let new_end =
471 new_transforms.start().1 .0 + (edit.new_bytes.end - new_transforms.start().0);
472
473 fold_edits.push(FoldEdit {
474 old_bytes: FoldOffset(old_start)..FoldOffset(old_end),
475 new_bytes: FoldOffset(new_start)..FoldOffset(new_end),
476 });
477 }
478
479 consolidate_fold_edits(&mut fold_edits);
480 }
481
482 *transforms = new_transforms;
483 self.version.fetch_add(1, SeqCst);
484 fold_edits
485 }
486}
487
488#[derive(Clone)]
489pub struct Snapshot {
490 transforms: SumTree<Transform>,
491 folds: SumTree<Fold>,
492 buffer_snapshot: buffer::Snapshot,
493 pub version: usize,
494}
495
496impl Snapshot {
497 #[cfg(test)]
498 pub fn text(&self) -> String {
499 self.chunks_at(FoldOffset(0)).collect()
500 }
501
502 #[cfg(test)]
503 pub fn fold_count(&self) -> usize {
504 self.folds.items(&self.buffer_snapshot).len()
505 }
506
507 pub fn text_summary_for_range(&self, range: Range<FoldPoint>) -> TextSummary {
508 let mut summary = TextSummary::default();
509
510 let mut cursor = self.transforms.cursor::<(FoldPoint, Point)>();
511 cursor.seek(&range.start, Bias::Right, &());
512 if let Some(transform) = cursor.item() {
513 let start_in_transform = range.start.0 - cursor.start().0 .0;
514 let end_in_transform = cmp::min(range.end, cursor.end(&()).0).0 - cursor.start().0 .0;
515 if let Some(output_text) = transform.output_text {
516 summary = TextSummary::from(
517 &output_text
518 [start_in_transform.column as usize..end_in_transform.column as usize],
519 );
520 } else {
521 let buffer_start = cursor.start().1 + start_in_transform;
522 let buffer_end = cursor.start().1 + end_in_transform;
523 summary = self
524 .buffer_snapshot
525 .text_summary_for_range(buffer_start..buffer_end);
526 }
527 }
528
529 if range.end > cursor.end(&()).0 {
530 cursor.next(&());
531 summary += &cursor
532 .summary::<_, TransformSummary>(&range.end, Bias::Right, &())
533 .output;
534 if let Some(transform) = cursor.item() {
535 let end_in_transform = range.end.0 - cursor.start().0 .0;
536 if let Some(output_text) = transform.output_text {
537 summary += TextSummary::from(&output_text[..end_in_transform.column as usize]);
538 } else {
539 let buffer_start = cursor.start().1;
540 let buffer_end = cursor.start().1 + end_in_transform;
541 summary += self
542 .buffer_snapshot
543 .text_summary_for_range(buffer_start..buffer_end);
544 }
545 }
546 }
547
548 summary
549 }
550
551 #[cfg(test)]
552 pub fn len(&self) -> FoldOffset {
553 FoldOffset(self.transforms.summary().output.bytes)
554 }
555
556 #[cfg(test)]
557 pub fn line_len(&self, row: u32) -> u32 {
558 let line_start = FoldPoint::new(row, 0).to_offset(self).0;
559 let line_end = if row >= self.max_point().row() {
560 self.len().0
561 } else {
562 FoldPoint::new(row + 1, 0).to_offset(self).0 - 1
563 };
564 (line_end - line_start) as u32
565 }
566
567 pub fn buffer_rows(&self, start_row: u32) -> BufferRows {
568 if start_row > self.transforms.summary().output.lines.row {
569 panic!("invalid display row {}", start_row);
570 }
571
572 let fold_point = FoldPoint::new(start_row, 0);
573 let mut cursor = self.transforms.cursor();
574 cursor.seek(&fold_point, Bias::Left, &());
575 BufferRows { fold_point, cursor }
576 }
577
578 pub fn max_point(&self) -> FoldPoint {
579 FoldPoint(self.transforms.summary().output.lines)
580 }
581
582 #[cfg(test)]
583 pub fn longest_row(&self) -> u32 {
584 self.transforms.summary().output.longest_row
585 }
586
587 pub fn folds_in_range<'a, T>(
588 &'a self,
589 range: Range<T>,
590 ) -> impl Iterator<Item = &'a Range<Anchor>>
591 where
592 T: ToOffset,
593 {
594 let mut folds = intersecting_folds(&self.buffer_snapshot, &self.folds, range, false);
595 iter::from_fn(move || {
596 let item = folds.item().map(|f| &f.0);
597 folds.next(&self.buffer_snapshot);
598 item
599 })
600 }
601
602 pub fn intersects_fold<T>(&self, offset: T) -> bool
603 where
604 T: ToOffset,
605 {
606 let offset = offset.to_offset(&self.buffer_snapshot);
607 let mut cursor = self.transforms.cursor::<usize>();
608 cursor.seek(&offset, Bias::Right, &());
609 cursor.item().map_or(false, |t| t.output_text.is_some())
610 }
611
612 pub fn is_line_folded(&self, output_row: u32) -> bool {
613 let mut cursor = self.transforms.cursor::<FoldPoint>();
614 cursor.seek(&FoldPoint::new(output_row, 0), Bias::Right, &());
615 while let Some(transform) = cursor.item() {
616 if transform.output_text.is_some() {
617 return true;
618 }
619 if cursor.end(&()).row() == output_row {
620 cursor.next(&())
621 } else {
622 break;
623 }
624 }
625 false
626 }
627
628 pub fn chunks_at(&self, offset: FoldOffset) -> Chunks {
629 let mut transform_cursor = self.transforms.cursor::<(FoldOffset, usize)>();
630 transform_cursor.seek(&offset, Bias::Right, &());
631 let overshoot = offset.0 - transform_cursor.start().0 .0;
632 let buffer_offset = transform_cursor.start().1 + overshoot;
633 Chunks {
634 transform_cursor,
635 buffer_offset,
636 buffer_chunks: self
637 .buffer_snapshot
638 .text_for_range(buffer_offset..self.buffer_snapshot.len()),
639 }
640 }
641
642 pub fn highlighted_chunks(&mut self, range: Range<FoldOffset>) -> HighlightedChunks {
643 let mut transform_cursor = self.transforms.cursor::<(FoldOffset, usize)>();
644
645 transform_cursor.seek(&range.end, Bias::Right, &());
646 let overshoot = range.end.0 - transform_cursor.start().0 .0;
647 let buffer_end = transform_cursor.start().1 + overshoot;
648
649 transform_cursor.seek(&range.start, Bias::Right, &());
650 let overshoot = range.start.0 - transform_cursor.start().0 .0;
651 let buffer_start = transform_cursor.start().1 + overshoot;
652
653 HighlightedChunks {
654 transform_cursor,
655 buffer_offset: buffer_start,
656 buffer_chunks: self
657 .buffer_snapshot
658 .highlighted_text_for_range(buffer_start..buffer_end),
659 buffer_chunk: None,
660 }
661 }
662
663 pub fn chars_at<'a>(&'a self, point: FoldPoint) -> impl Iterator<Item = char> + 'a {
664 let offset = point.to_offset(self);
665 self.chunks_at(offset).flat_map(str::chars)
666 }
667
668 #[cfg(test)]
669 pub fn clip_offset(&self, offset: FoldOffset, bias: Bias) -> FoldOffset {
670 let mut cursor = self.transforms.cursor::<(FoldOffset, usize)>();
671 cursor.seek(&offset, Bias::Right, &());
672 if let Some(transform) = cursor.item() {
673 let transform_start = cursor.start().0 .0;
674 if transform.output_text.is_some() {
675 if offset.0 == transform_start || matches!(bias, Bias::Left) {
676 FoldOffset(transform_start)
677 } else {
678 FoldOffset(cursor.end(&()).0 .0)
679 }
680 } else {
681 let overshoot = offset.0 - transform_start;
682 let buffer_offset = cursor.start().1 + overshoot;
683 let clipped_buffer_offset = self.buffer_snapshot.clip_offset(buffer_offset, bias);
684 FoldOffset(
685 (offset.0 as isize + (clipped_buffer_offset as isize - buffer_offset as isize))
686 as usize,
687 )
688 }
689 } else {
690 FoldOffset(self.transforms.summary().output.bytes)
691 }
692 }
693
694 pub fn clip_point(&self, point: FoldPoint, bias: Bias) -> FoldPoint {
695 let mut cursor = self.transforms.cursor::<(FoldPoint, Point)>();
696 cursor.seek(&point, Bias::Right, &());
697 if let Some(transform) = cursor.item() {
698 let transform_start = cursor.start().0 .0;
699 if transform.output_text.is_some() {
700 if point.0 == transform_start || matches!(bias, Bias::Left) {
701 FoldPoint(transform_start)
702 } else {
703 FoldPoint(cursor.end(&()).0 .0)
704 }
705 } else {
706 let overshoot = point.0 - transform_start;
707 let buffer_position = cursor.start().1 + overshoot;
708 let clipped_buffer_position =
709 self.buffer_snapshot.clip_point(buffer_position, bias);
710 FoldPoint::new(
711 point.row(),
712 ((point.column() as i32) + clipped_buffer_position.column as i32
713 - buffer_position.column as i32) as u32,
714 )
715 }
716 } else {
717 FoldPoint(self.transforms.summary().output.lines)
718 }
719 }
720}
721
722fn intersecting_folds<'a, T>(
723 buffer: &'a buffer::Snapshot,
724 folds: &'a SumTree<Fold>,
725 range: Range<T>,
726 inclusive: bool,
727) -> FilterCursor<'a, impl 'a + Fn(&FoldSummary) -> bool, Fold, usize>
728where
729 T: ToOffset,
730{
731 let start = buffer.anchor_before(range.start.to_offset(buffer));
732 let end = buffer.anchor_after(range.end.to_offset(buffer));
733 folds.filter::<_, usize>(
734 move |summary| {
735 let start_cmp = start.cmp(&summary.max_end, buffer).unwrap();
736 let end_cmp = end.cmp(&summary.min_start, buffer).unwrap();
737
738 if inclusive {
739 start_cmp <= Ordering::Equal && end_cmp >= Ordering::Equal
740 } else {
741 start_cmp == Ordering::Less && end_cmp == Ordering::Greater
742 }
743 },
744 buffer,
745 )
746}
747
748fn consolidate_buffer_edits(edits: &mut Vec<buffer::Edit>) {
749 edits.sort_unstable_by(|a, b| {
750 a.old_bytes
751 .start
752 .cmp(&b.old_bytes.start)
753 .then_with(|| b.old_bytes.end.cmp(&a.old_bytes.end))
754 });
755
756 let mut i = 1;
757 while i < edits.len() {
758 let edit = edits[i].clone();
759 let prev_edit = &mut edits[i - 1];
760 if prev_edit.old_bytes.end >= edit.old_bytes.start {
761 prev_edit.old_bytes.end = prev_edit.old_bytes.end.max(edit.old_bytes.end);
762 prev_edit.new_bytes.start = prev_edit.new_bytes.start.min(edit.new_bytes.start);
763 prev_edit.new_bytes.end = prev_edit.new_bytes.end.max(edit.new_bytes.end);
764 edits.remove(i);
765 continue;
766 }
767 i += 1;
768 }
769}
770
771fn consolidate_fold_edits(edits: &mut Vec<FoldEdit>) {
772 edits.sort_unstable_by(|a, b| {
773 a.old_bytes
774 .start
775 .cmp(&b.old_bytes.start)
776 .then_with(|| b.old_bytes.end.cmp(&a.old_bytes.end))
777 });
778
779 let mut i = 1;
780 while i < edits.len() {
781 let edit = edits[i].clone();
782 let prev_edit = &mut edits[i - 1];
783 if prev_edit.old_bytes.end >= edit.old_bytes.start {
784 prev_edit.old_bytes.end = prev_edit.old_bytes.end.max(edit.old_bytes.end);
785 prev_edit.new_bytes.start = prev_edit.new_bytes.start.min(edit.new_bytes.start);
786 prev_edit.new_bytes.end = prev_edit.new_bytes.end.max(edit.new_bytes.end);
787 edits.remove(i);
788 continue;
789 }
790 i += 1;
791 }
792}
793
794#[derive(Clone, Debug, Default, Eq, PartialEq)]
795struct Transform {
796 summary: TransformSummary,
797 output_text: Option<&'static str>,
798}
799
800impl Transform {
801 fn is_fold(&self) -> bool {
802 self.output_text.is_some()
803 }
804}
805
806#[derive(Clone, Debug, Default, Eq, PartialEq)]
807struct TransformSummary {
808 output: TextSummary,
809 input: TextSummary,
810}
811
812impl sum_tree::Item for Transform {
813 type Summary = TransformSummary;
814
815 fn summary(&self) -> Self::Summary {
816 self.summary.clone()
817 }
818}
819
820impl sum_tree::Summary for TransformSummary {
821 type Context = ();
822
823 fn add_summary(&mut self, other: &Self, _: &()) {
824 self.input += &other.input;
825 self.output += &other.output;
826 }
827}
828
829#[derive(Clone, Debug)]
830struct Fold(Range<Anchor>);
831
832impl Default for Fold {
833 fn default() -> Self {
834 Self(Anchor::min()..Anchor::max())
835 }
836}
837
838impl sum_tree::Item for Fold {
839 type Summary = FoldSummary;
840
841 fn summary(&self) -> Self::Summary {
842 FoldSummary {
843 start: self.0.start.clone(),
844 end: self.0.end.clone(),
845 min_start: self.0.start.clone(),
846 max_end: self.0.end.clone(),
847 count: 1,
848 }
849 }
850}
851
852#[derive(Clone, Debug)]
853struct FoldSummary {
854 start: Anchor,
855 end: Anchor,
856 min_start: Anchor,
857 max_end: Anchor,
858 count: usize,
859}
860
861impl Default for FoldSummary {
862 fn default() -> Self {
863 Self {
864 start: Anchor::min(),
865 end: Anchor::max(),
866 min_start: Anchor::max(),
867 max_end: Anchor::min(),
868 count: 0,
869 }
870 }
871}
872
873impl sum_tree::Summary for FoldSummary {
874 type Context = buffer::Snapshot;
875
876 fn add_summary(&mut self, other: &Self, buffer: &buffer::Snapshot) {
877 if other.min_start.cmp(&self.min_start, buffer).unwrap() == Ordering::Less {
878 self.min_start = other.min_start.clone();
879 }
880 if other.max_end.cmp(&self.max_end, buffer).unwrap() == Ordering::Greater {
881 self.max_end = other.max_end.clone();
882 }
883
884 #[cfg(debug_assertions)]
885 {
886 let start_comparison = self.start.cmp(&other.start, buffer).unwrap();
887 assert!(start_comparison <= Ordering::Equal);
888 if start_comparison == Ordering::Equal {
889 assert!(self.end.cmp(&other.end, buffer).unwrap() >= Ordering::Equal);
890 }
891 }
892
893 self.start = other.start.clone();
894 self.end = other.end.clone();
895 self.count += other.count;
896 }
897}
898
899impl<'a> sum_tree::Dimension<'a, FoldSummary> for Fold {
900 fn add_summary(&mut self, summary: &'a FoldSummary, _: &buffer::Snapshot) {
901 self.0.start = summary.start.clone();
902 self.0.end = summary.end.clone();
903 }
904}
905
906impl<'a> sum_tree::SeekTarget<'a, FoldSummary, Fold> for Fold {
907 fn cmp(&self, other: &Self, buffer: &buffer::Snapshot) -> Ordering {
908 self.0.cmp(&other.0, buffer).unwrap()
909 }
910}
911
912impl<'a> sum_tree::Dimension<'a, FoldSummary> for usize {
913 fn add_summary(&mut self, summary: &'a FoldSummary, _: &buffer::Snapshot) {
914 *self += summary.count;
915 }
916}
917
918pub struct BufferRows<'a> {
919 cursor: Cursor<'a, Transform, (FoldPoint, Point)>,
920 fold_point: FoldPoint,
921}
922
923impl<'a> Iterator for BufferRows<'a> {
924 type Item = u32;
925
926 fn next(&mut self) -> Option<Self::Item> {
927 while self.fold_point > self.cursor.end(&()).0 {
928 self.cursor.next(&());
929 if self.cursor.item().is_none() {
930 // TODO: Return a bool from next?
931 break;
932 }
933 }
934
935 if self.cursor.item().is_some() {
936 let overshoot = self.fold_point.0 - self.cursor.start().0 .0;
937 let buffer_point = self.cursor.start().1 + overshoot;
938 *self.fold_point.row_mut() += 1;
939 Some(buffer_point.row)
940 } else {
941 None
942 }
943 }
944}
945
946pub struct Chunks<'a> {
947 transform_cursor: Cursor<'a, Transform, (FoldOffset, usize)>,
948 buffer_chunks: buffer::Chunks<'a>,
949 buffer_offset: usize,
950}
951
952impl<'a> Iterator for Chunks<'a> {
953 type Item = &'a str;
954
955 fn next(&mut self) -> Option<Self::Item> {
956 let transform = if let Some(item) = self.transform_cursor.item() {
957 item
958 } else {
959 return None;
960 };
961
962 // If we're in a fold, then return the fold's display text and
963 // advance the transform and buffer cursors to the end of the fold.
964 if let Some(output_text) = transform.output_text {
965 self.buffer_offset += transform.summary.input.bytes;
966 self.buffer_chunks.seek(self.buffer_offset);
967
968 while self.buffer_offset >= self.transform_cursor.end(&()).1
969 && self.transform_cursor.item().is_some()
970 {
971 self.transform_cursor.next(&());
972 }
973
974 return Some(output_text);
975 }
976
977 // Otherwise, take a chunk from the buffer's text.
978 if let Some(mut chunk) = self.buffer_chunks.peek() {
979 let offset_in_chunk = self.buffer_offset - self.buffer_chunks.offset();
980 chunk = &chunk[offset_in_chunk..];
981
982 // Truncate the chunk so that it ends at the next fold.
983 let region_end = self.transform_cursor.end(&()).1 - self.buffer_offset;
984 if chunk.len() >= region_end {
985 chunk = &chunk[0..region_end];
986 self.transform_cursor.next(&());
987 } else {
988 self.buffer_chunks.next();
989 }
990
991 self.buffer_offset += chunk.len();
992 return Some(chunk);
993 }
994
995 None
996 }
997}
998
999pub struct HighlightedChunks<'a> {
1000 transform_cursor: Cursor<'a, Transform, (FoldOffset, usize)>,
1001 buffer_chunks: buffer::HighlightedChunks<'a>,
1002 buffer_chunk: Option<(usize, &'a str, HighlightId)>,
1003 buffer_offset: usize,
1004}
1005
1006impl<'a> Iterator for HighlightedChunks<'a> {
1007 type Item = (&'a str, HighlightId);
1008
1009 fn next(&mut self) -> Option<Self::Item> {
1010 let transform = if let Some(item) = self.transform_cursor.item() {
1011 item
1012 } else {
1013 return None;
1014 };
1015
1016 // If we're in a fold, then return the fold's display text and
1017 // advance the transform and buffer cursors to the end of the fold.
1018 if let Some(output_text) = transform.output_text {
1019 self.buffer_chunk.take();
1020 self.buffer_offset += transform.summary.input.bytes;
1021 self.buffer_chunks.seek(self.buffer_offset);
1022
1023 while self.buffer_offset >= self.transform_cursor.end(&()).1
1024 && self.transform_cursor.item().is_some()
1025 {
1026 self.transform_cursor.next(&());
1027 }
1028
1029 return Some((output_text, HighlightId::default()));
1030 }
1031
1032 // Retrieve a chunk from the current location in the buffer.
1033 if self.buffer_chunk.is_none() {
1034 let chunk_offset = self.buffer_chunks.offset();
1035 self.buffer_chunk = self
1036 .buffer_chunks
1037 .next()
1038 .map(|(chunk, capture_ix)| (chunk_offset, chunk, capture_ix));
1039 }
1040
1041 // Otherwise, take a chunk from the buffer's text.
1042 if let Some((chunk_offset, mut chunk, capture_ix)) = self.buffer_chunk {
1043 let offset_in_chunk = self.buffer_offset - chunk_offset;
1044 chunk = &chunk[offset_in_chunk..];
1045
1046 // Truncate the chunk so that it ends at the next fold.
1047 let region_end = self.transform_cursor.end(&()).1 - self.buffer_offset;
1048 if chunk.len() >= region_end {
1049 chunk = &chunk[0..region_end];
1050 self.transform_cursor.next(&());
1051 } else {
1052 self.buffer_chunk.take();
1053 }
1054
1055 self.buffer_offset += chunk.len();
1056 return Some((chunk, capture_ix));
1057 }
1058
1059 None
1060 }
1061}
1062
1063impl<'a> sum_tree::Dimension<'a, TransformSummary> for FoldPoint {
1064 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
1065 self.0 += &summary.output.lines;
1066 }
1067}
1068
1069#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
1070pub struct FoldOffset(pub usize);
1071
1072impl FoldOffset {
1073 pub fn to_point(&self, snapshot: &Snapshot) -> FoldPoint {
1074 let mut cursor = snapshot
1075 .transforms
1076 .cursor::<(FoldOffset, TransformSummary)>();
1077 cursor.seek(self, Bias::Right, &());
1078 let overshoot = if cursor.item().map_or(true, |t| t.is_fold()) {
1079 Point::new(0, (self.0 - cursor.start().0 .0) as u32)
1080 } else {
1081 let buffer_offset = cursor.start().1.input.bytes + self.0 - cursor.start().0 .0;
1082 let buffer_point = snapshot.buffer_snapshot.to_point(buffer_offset);
1083 buffer_point - cursor.start().1.input.lines
1084 };
1085 FoldPoint(cursor.start().1.output.lines + overshoot)
1086 }
1087}
1088
1089impl<'a> sum_tree::Dimension<'a, TransformSummary> for FoldOffset {
1090 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
1091 self.0 += &summary.output.bytes;
1092 }
1093}
1094
1095impl<'a> sum_tree::Dimension<'a, TransformSummary> for Point {
1096 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
1097 *self += &summary.input.lines;
1098 }
1099}
1100
1101impl<'a> sum_tree::Dimension<'a, TransformSummary> for usize {
1102 fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
1103 *self += &summary.input.bytes;
1104 }
1105}
1106
1107#[derive(Clone, Debug, PartialEq, Eq)]
1108pub struct FoldEdit {
1109 pub old_bytes: Range<FoldOffset>,
1110 pub new_bytes: Range<FoldOffset>,
1111}
1112
1113#[cfg(test)]
1114impl FoldEdit {
1115 pub fn delta(&self) -> isize {
1116 self.inserted_bytes() as isize - self.deleted_bytes() as isize
1117 }
1118
1119 pub fn deleted_bytes(&self) -> usize {
1120 self.old_bytes.end.0 - self.old_bytes.start.0
1121 }
1122
1123 pub fn inserted_bytes(&self) -> usize {
1124 self.new_bytes.end.0 - self.new_bytes.start.0
1125 }
1126}
1127
1128#[cfg(test)]
1129mod tests {
1130 use super::*;
1131 use crate::{test::sample_text, ToPoint};
1132 use buffer::RandomCharIter;
1133 use rand::prelude::*;
1134 use std::{env, mem};
1135 use Bias::{Left, Right};
1136
1137 #[gpui::test]
1138 fn test_basic_folds(cx: &mut gpui::MutableAppContext) {
1139 let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
1140 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1141
1142 let (mut writer, _, _) = map.write(cx.as_ref());
1143 let (snapshot2, edits) = writer.fold(
1144 vec![
1145 Point::new(0, 2)..Point::new(2, 2),
1146 Point::new(2, 4)..Point::new(4, 1),
1147 ],
1148 cx.as_ref(),
1149 );
1150 assert_eq!(snapshot2.text(), "aa…cc…eeeee");
1151 assert_eq!(
1152 edits,
1153 &[
1154 FoldEdit {
1155 old_bytes: FoldOffset(2)..FoldOffset(16),
1156 new_bytes: FoldOffset(2)..FoldOffset(5),
1157 },
1158 FoldEdit {
1159 old_bytes: FoldOffset(18)..FoldOffset(29),
1160 new_bytes: FoldOffset(7)..FoldOffset(10)
1161 },
1162 ]
1163 );
1164
1165 buffer.update(cx, |buffer, cx| {
1166 buffer.edit(
1167 vec![
1168 Point::new(0, 0)..Point::new(0, 1),
1169 Point::new(2, 3)..Point::new(2, 3),
1170 ],
1171 "123",
1172 cx,
1173 );
1174 });
1175 let (snapshot3, edits) = map.read(cx.as_ref());
1176 assert_eq!(snapshot3.text(), "123a…c123c…eeeee");
1177 assert_eq!(
1178 edits,
1179 &[
1180 FoldEdit {
1181 old_bytes: FoldOffset(0)..FoldOffset(1),
1182 new_bytes: FoldOffset(0)..FoldOffset(3),
1183 },
1184 FoldEdit {
1185 old_bytes: FoldOffset(6)..FoldOffset(6),
1186 new_bytes: FoldOffset(8)..FoldOffset(11),
1187 },
1188 ]
1189 );
1190
1191 buffer.update(cx, |buffer, cx| {
1192 buffer.edit(vec![Point::new(2, 6)..Point::new(4, 3)], "456", cx)
1193 });
1194 let (snapshot4, _) = map.read(cx.as_ref());
1195 assert_eq!(snapshot4.text(), "123a…c123456eee");
1196
1197 let (mut writer, _, _) = map.write(cx.as_ref());
1198 writer.unfold(Some(Point::new(0, 4)..Point::new(0, 5)), cx.as_ref());
1199 let (snapshot5, _) = map.read(cx.as_ref());
1200 assert_eq!(snapshot5.text(), "123aaaaa\nbbbbbb\nccc123456eee");
1201 }
1202
1203 #[gpui::test]
1204 fn test_adjacent_folds(cx: &mut gpui::MutableAppContext) {
1205 let buffer = cx.add_model(|cx| Buffer::new(0, "abcdefghijkl", cx));
1206
1207 {
1208 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1209
1210 let (mut writer, _, _) = map.write(cx.as_ref());
1211 writer.fold(vec![5..8], cx.as_ref());
1212 let (snapshot, _) = map.read(cx.as_ref());
1213 assert_eq!(snapshot.text(), "abcde…ijkl");
1214
1215 // Create an fold adjacent to the start of the first fold.
1216 let (mut writer, _, _) = map.write(cx.as_ref());
1217 writer.fold(vec![0..1, 2..5], cx.as_ref());
1218 let (snapshot, _) = map.read(cx.as_ref());
1219 assert_eq!(snapshot.text(), "…b…ijkl");
1220
1221 // Create an fold adjacent to the end of the first fold.
1222 let (mut writer, _, _) = map.write(cx.as_ref());
1223 writer.fold(vec![11..11, 8..10], cx.as_ref());
1224 let (snapshot, _) = map.read(cx.as_ref());
1225 assert_eq!(snapshot.text(), "…b…kl");
1226 }
1227
1228 {
1229 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1230
1231 // Create two adjacent folds.
1232 let (mut writer, _, _) = map.write(cx.as_ref());
1233 writer.fold(vec![0..2, 2..5], cx.as_ref());
1234 let (snapshot, _) = map.read(cx.as_ref());
1235 assert_eq!(snapshot.text(), "…fghijkl");
1236
1237 // Edit within one of the folds.
1238 buffer.update(cx, |buffer, cx| buffer.edit(vec![0..1], "12345", cx));
1239 let (snapshot, _) = map.read(cx.as_ref());
1240 assert_eq!(snapshot.text(), "12345…fghijkl");
1241 }
1242 }
1243
1244 #[gpui::test]
1245 fn test_overlapping_folds(cx: &mut gpui::MutableAppContext) {
1246 let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
1247 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1248 let (mut writer, _, _) = map.write(cx.as_ref());
1249 writer.fold(
1250 vec![
1251 Point::new(0, 2)..Point::new(2, 2),
1252 Point::new(0, 4)..Point::new(1, 0),
1253 Point::new(1, 2)..Point::new(3, 2),
1254 Point::new(3, 1)..Point::new(4, 1),
1255 ],
1256 cx.as_ref(),
1257 );
1258 let (snapshot, _) = map.read(cx.as_ref());
1259 assert_eq!(snapshot.text(), "aa…eeeee");
1260 }
1261
1262 #[gpui::test]
1263 fn test_merging_folds_via_edit(cx: &mut gpui::MutableAppContext) {
1264 let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
1265 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1266
1267 let (mut writer, _, _) = map.write(cx.as_ref());
1268 writer.fold(
1269 vec![
1270 Point::new(0, 2)..Point::new(2, 2),
1271 Point::new(3, 1)..Point::new(4, 1),
1272 ],
1273 cx.as_ref(),
1274 );
1275 let (snapshot, _) = map.read(cx.as_ref());
1276 assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee");
1277
1278 buffer.update(cx, |buffer, cx| {
1279 buffer.edit(Some(Point::new(2, 2)..Point::new(3, 1)), "", cx)
1280 });
1281 let (snapshot, _) = map.read(cx.as_ref());
1282 assert_eq!(snapshot.text(), "aa…eeeee");
1283 }
1284
1285 #[gpui::test]
1286 fn test_folds_in_range(cx: &mut gpui::MutableAppContext) {
1287 let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
1288 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1289 let buffer = buffer.read(cx);
1290
1291 let (mut writer, _, _) = map.write(cx.as_ref());
1292 writer.fold(
1293 vec![
1294 Point::new(0, 2)..Point::new(2, 2),
1295 Point::new(0, 4)..Point::new(1, 0),
1296 Point::new(1, 2)..Point::new(3, 2),
1297 Point::new(3, 1)..Point::new(4, 1),
1298 ],
1299 cx.as_ref(),
1300 );
1301 let (snapshot, _) = map.read(cx.as_ref());
1302 let fold_ranges = snapshot
1303 .folds_in_range(Point::new(1, 0)..Point::new(1, 3))
1304 .map(|fold| fold.start.to_point(buffer)..fold.end.to_point(buffer))
1305 .collect::<Vec<_>>();
1306 assert_eq!(
1307 fold_ranges,
1308 vec![
1309 Point::new(0, 2)..Point::new(2, 2),
1310 Point::new(1, 2)..Point::new(3, 2)
1311 ]
1312 );
1313 }
1314
1315 #[gpui::test(iterations = 100)]
1316 fn test_random_folds(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
1317 let operations = env::var("OPERATIONS")
1318 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1319 .unwrap_or(10);
1320
1321 let buffer = cx.add_model(|cx| {
1322 let len = rng.gen_range(0..10);
1323 let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
1324 Buffer::new(0, text, cx)
1325 });
1326 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1327
1328 let (mut initial_snapshot, _) = map.read(cx.as_ref());
1329 let mut snapshot_edits = Vec::new();
1330
1331 for _ in 0..operations {
1332 log::info!("text: {:?}", buffer.read(cx).text());
1333 match rng.gen_range(0..=100) {
1334 0..=59 => {
1335 snapshot_edits.extend(map.randomly_mutate(&mut rng, cx.as_ref()));
1336 }
1337 _ => {
1338 let edits = buffer.update(cx, |buffer, cx| {
1339 let start_version = buffer.version.clone();
1340 let edit_count = rng.gen_range(1..=5);
1341 buffer.randomly_edit(&mut rng, edit_count, cx);
1342 buffer.edits_since(start_version).collect::<Vec<_>>()
1343 });
1344 log::info!("editing {:?}", edits);
1345 }
1346 }
1347
1348 let buffer = map.buffer.read(cx).snapshot();
1349 let mut expected_text: String = buffer.text().into();
1350 let mut expected_buffer_rows = Vec::new();
1351 let mut next_row = buffer.max_point().row;
1352 for fold_range in map.merged_fold_ranges(cx.as_ref()).into_iter().rev() {
1353 let fold_start = buffer.point_for_offset(fold_range.start).unwrap();
1354 let fold_end = buffer.point_for_offset(fold_range.end).unwrap();
1355 expected_buffer_rows.extend((fold_end.row + 1..=next_row).rev());
1356 next_row = fold_start.row;
1357
1358 expected_text.replace_range(fold_range.start..fold_range.end, "…");
1359 }
1360 expected_buffer_rows.extend((0..=next_row).rev());
1361 expected_buffer_rows.reverse();
1362
1363 let (snapshot, edits) = map.read(cx.as_ref());
1364 assert_eq!(snapshot.text(), expected_text);
1365 snapshot_edits.push((snapshot.clone(), edits));
1366
1367 for (output_row, line) in expected_text.lines().enumerate() {
1368 let line_len = snapshot.line_len(output_row as u32);
1369 assert_eq!(line_len, line.len() as u32);
1370 }
1371
1372 let longest_row = snapshot.longest_row();
1373 let longest_char_column = expected_text
1374 .split('\n')
1375 .nth(longest_row as usize)
1376 .unwrap()
1377 .chars()
1378 .count();
1379 let mut fold_point = FoldPoint::new(0, 0);
1380 let mut fold_offset = FoldOffset(0);
1381 let mut char_column = 0;
1382 for c in expected_text.chars() {
1383 let buffer_point = fold_point.to_buffer_point(&snapshot);
1384 let buffer_offset = buffer_point.to_offset(&buffer);
1385 assert_eq!(
1386 buffer_point.to_fold_point(&snapshot, Right),
1387 fold_point,
1388 "{:?} -> fold point",
1389 buffer_point,
1390 );
1391 assert_eq!(
1392 fold_point.to_buffer_offset(&snapshot),
1393 buffer_offset,
1394 "fold_point.to_buffer_offset({:?})",
1395 fold_point,
1396 );
1397 assert_eq!(
1398 fold_point.to_offset(&snapshot),
1399 fold_offset,
1400 "fold_point.to_offset({:?})",
1401 fold_point,
1402 );
1403
1404 if c == '\n' {
1405 *fold_point.row_mut() += 1;
1406 *fold_point.column_mut() = 0;
1407 char_column = 0;
1408 } else {
1409 *fold_point.column_mut() += c.len_utf8() as u32;
1410 char_column += 1;
1411 }
1412 fold_offset.0 += c.len_utf8();
1413 if char_column > longest_char_column {
1414 panic!(
1415 "invalid longest row {:?} (chars {}), found row {:?} (chars: {})",
1416 longest_row,
1417 longest_char_column,
1418 fold_point.row(),
1419 char_column
1420 );
1421 }
1422 }
1423
1424 for _ in 0..5 {
1425 let offset = snapshot
1426 .clip_offset(FoldOffset(rng.gen_range(0..=snapshot.len().0)), Bias::Right);
1427 assert_eq!(
1428 snapshot.chunks_at(offset).collect::<String>(),
1429 &expected_text[offset.0..],
1430 );
1431 }
1432
1433 for (idx, buffer_row) in expected_buffer_rows.iter().enumerate() {
1434 let fold_row = Point::new(*buffer_row, 0)
1435 .to_fold_point(&snapshot, Right)
1436 .row();
1437 assert_eq!(
1438 snapshot.buffer_rows(fold_row).collect::<Vec<_>>(),
1439 expected_buffer_rows[idx..],
1440 );
1441 }
1442
1443 for fold_range in map.merged_fold_ranges(cx.as_ref()) {
1444 let fold_point = fold_range
1445 .start
1446 .to_point(&buffer)
1447 .to_fold_point(&snapshot, Right);
1448 assert!(snapshot.is_line_folded(fold_point.row()));
1449 }
1450
1451 for _ in 0..5 {
1452 let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
1453 let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
1454 let expected_folds = map
1455 .folds
1456 .items(&buffer)
1457 .into_iter()
1458 .filter(|fold| {
1459 let start = buffer.anchor_before(start);
1460 let end = buffer.anchor_after(end);
1461 start.cmp(&fold.0.end, &buffer).unwrap() == Ordering::Less
1462 && end.cmp(&fold.0.start, &buffer).unwrap() == Ordering::Greater
1463 })
1464 .map(|fold| fold.0)
1465 .collect::<Vec<_>>();
1466
1467 assert_eq!(
1468 snapshot
1469 .folds_in_range(start..end)
1470 .cloned()
1471 .collect::<Vec<_>>(),
1472 expected_folds
1473 );
1474 }
1475
1476 let text = snapshot.text();
1477 for _ in 0..5 {
1478 let start_row = rng.gen_range(0..=snapshot.max_point().row());
1479 let start_column = rng.gen_range(0..=snapshot.line_len(start_row));
1480 let end_row = rng.gen_range(0..=snapshot.max_point().row());
1481 let end_column = rng.gen_range(0..=snapshot.line_len(end_row));
1482 let mut start =
1483 snapshot.clip_point(FoldPoint::new(start_row, start_column), Bias::Left);
1484 let mut end = snapshot.clip_point(FoldPoint::new(end_row, end_column), Bias::Right);
1485 if start > end {
1486 mem::swap(&mut start, &mut end);
1487 }
1488
1489 let lines = start..end;
1490 let bytes = start.to_offset(&snapshot)..end.to_offset(&snapshot);
1491 assert_eq!(
1492 snapshot.text_summary_for_range(lines),
1493 TextSummary::from(&text[bytes.start.0..bytes.end.0])
1494 )
1495 }
1496
1497 let mut text = initial_snapshot.text();
1498 for (snapshot, edits) in snapshot_edits.drain(..) {
1499 let new_text = snapshot.text();
1500 let mut delta = 0isize;
1501 for edit in edits {
1502 let old_bytes = ((edit.old_bytes.start.0 as isize) + delta) as usize
1503 ..((edit.old_bytes.end.0 as isize) + delta) as usize;
1504 let new_bytes = edit.new_bytes.start.0..edit.new_bytes.end.0;
1505 delta += edit.delta();
1506 text.replace_range(old_bytes, &new_text[new_bytes]);
1507 }
1508
1509 assert_eq!(text, new_text);
1510 initial_snapshot = snapshot;
1511 }
1512 }
1513 }
1514
1515 #[gpui::test]
1516 fn test_buffer_rows(cx: &mut gpui::MutableAppContext) {
1517 let text = sample_text(6, 6) + "\n";
1518 let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
1519
1520 let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
1521
1522 let (mut writer, _, _) = map.write(cx.as_ref());
1523 writer.fold(
1524 vec![
1525 Point::new(0, 2)..Point::new(2, 2),
1526 Point::new(3, 1)..Point::new(4, 1),
1527 ],
1528 cx.as_ref(),
1529 );
1530
1531 let (snapshot, _) = map.read(cx.as_ref());
1532 assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee\nffffff\n");
1533 assert_eq!(snapshot.buffer_rows(0).collect::<Vec<_>>(), [0, 3, 5, 6]);
1534 assert_eq!(snapshot.buffer_rows(3).collect::<Vec<_>>(), [6]);
1535 }
1536
1537 impl FoldMap {
1538 fn merged_fold_ranges(&self, cx: &AppContext) -> Vec<Range<usize>> {
1539 let buffer = self.buffer.read(cx).snapshot();
1540 let mut folds = self.folds.items(&buffer);
1541 // Ensure sorting doesn't change how folds get merged and displayed.
1542 folds.sort_by(|a, b| a.0.cmp(&b.0, &buffer).unwrap());
1543 let mut fold_ranges = folds
1544 .iter()
1545 .map(|fold| fold.0.start.to_offset(&buffer)..fold.0.end.to_offset(&buffer))
1546 .peekable();
1547
1548 let mut merged_ranges = Vec::new();
1549 while let Some(mut fold_range) = fold_ranges.next() {
1550 while let Some(next_range) = fold_ranges.peek() {
1551 if fold_range.end >= next_range.start {
1552 if next_range.end > fold_range.end {
1553 fold_range.end = next_range.end;
1554 }
1555 fold_ranges.next();
1556 } else {
1557 break;
1558 }
1559 }
1560 if fold_range.end > fold_range.start {
1561 merged_ranges.push(fold_range);
1562 }
1563 }
1564 merged_ranges
1565 }
1566
1567 pub fn randomly_mutate(
1568 &mut self,
1569 rng: &mut impl Rng,
1570 cx: &AppContext,
1571 ) -> Vec<(Snapshot, Vec<FoldEdit>)> {
1572 let mut snapshot_edits = Vec::new();
1573 match rng.gen_range(0..=100) {
1574 0..=39 if !self.folds.is_empty() => {
1575 let buffer = self.buffer.read(cx);
1576 let mut to_unfold = Vec::new();
1577 for _ in 0..rng.gen_range(1..=3) {
1578 let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
1579 let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
1580 to_unfold.push(start..end);
1581 }
1582 log::info!("unfolding {:?}", to_unfold);
1583 let (mut writer, snapshot, edits) = self.write(cx.as_ref());
1584 snapshot_edits.push((snapshot, edits));
1585 let (snapshot, edits) = writer.fold(to_unfold, cx.as_ref());
1586 snapshot_edits.push((snapshot, edits));
1587 }
1588 _ => {
1589 let buffer = self.buffer.read(cx);
1590 let mut to_fold = Vec::new();
1591 for _ in 0..rng.gen_range(1..=2) {
1592 let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
1593 let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
1594 to_fold.push(start..end);
1595 }
1596 log::info!("folding {:?}", to_fold);
1597 let (mut writer, snapshot, edits) = self.write(cx.as_ref());
1598 snapshot_edits.push((snapshot, edits));
1599 let (snapshot, edits) = writer.fold(to_fold, cx.as_ref());
1600 snapshot_edits.push((snapshot, edits));
1601 }
1602 }
1603 snapshot_edits
1604 }
1605 }
1606}