1use super::*;
2use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
3use gpui::{App, TestAppContext};
4use indoc::indoc;
5use language::{Buffer, Rope};
6use parking_lot::RwLock;
7use rand::prelude::*;
8use settings::SettingsStore;
9use std::env;
10use std::time::{Duration, Instant};
11use util::RandomCharIter;
12use util::rel_path::rel_path;
13use util::test::sample_text;
14
15#[ctor::ctor]
16fn init_logger() {
17 zlog::init_test();
18}
19
20#[gpui::test]
21fn test_empty_singleton(cx: &mut App) {
22 let buffer = cx.new(|cx| Buffer::local("", cx));
23 let buffer_id = buffer.read(cx).remote_id();
24 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
25 let snapshot = multibuffer.read(cx).snapshot(cx);
26 assert_eq!(snapshot.text(), "");
27 assert_eq!(
28 snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),
29 [RowInfo {
30 buffer_id: Some(buffer_id),
31 buffer_row: Some(0),
32 multibuffer_row: Some(MultiBufferRow(0)),
33 diff_status: None,
34 expand_info: None,
35 wrapped_buffer_row: None,
36 }]
37 );
38}
39
40#[gpui::test]
41fn test_singleton(cx: &mut App) {
42 let buffer = cx.new(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
43 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
44
45 let snapshot = multibuffer.read(cx).snapshot(cx);
46 assert_eq!(snapshot.text(), buffer.read(cx).text());
47
48 assert_eq!(
49 snapshot
50 .row_infos(MultiBufferRow(0))
51 .map(|info| info.buffer_row)
52 .collect::<Vec<_>>(),
53 (0..buffer.read(cx).row_count())
54 .map(Some)
55 .collect::<Vec<_>>()
56 );
57 assert_consistent_line_numbers(&snapshot);
58
59 buffer.update(cx, |buffer, cx| buffer.edit([(1..3, "XXX\n")], None, cx));
60 let snapshot = multibuffer.read(cx).snapshot(cx);
61
62 assert_eq!(snapshot.text(), buffer.read(cx).text());
63 assert_eq!(
64 snapshot
65 .row_infos(MultiBufferRow(0))
66 .map(|info| info.buffer_row)
67 .collect::<Vec<_>>(),
68 (0..buffer.read(cx).row_count())
69 .map(Some)
70 .collect::<Vec<_>>()
71 );
72 assert_consistent_line_numbers(&snapshot);
73}
74
75#[gpui::test]
76fn test_remote(cx: &mut App) {
77 let host_buffer = cx.new(|cx| Buffer::local("a", cx));
78 let guest_buffer = cx.new(|cx| {
79 let state = host_buffer.read(cx).to_proto(cx);
80 let ops = cx
81 .foreground_executor()
82 .block_on(host_buffer.read(cx).serialize_ops(None, cx));
83 let mut buffer =
84 Buffer::from_proto(ReplicaId::REMOTE_SERVER, Capability::ReadWrite, state, None)
85 .unwrap();
86 buffer.apply_ops(
87 ops.into_iter()
88 .map(|op| language::proto::deserialize_operation(op).unwrap()),
89 cx,
90 );
91 buffer
92 });
93 let multibuffer = cx.new(|cx| MultiBuffer::singleton(guest_buffer.clone(), cx));
94 let snapshot = multibuffer.read(cx).snapshot(cx);
95 assert_eq!(snapshot.text(), "a");
96
97 guest_buffer.update(cx, |buffer, cx| buffer.edit([(1..1, "b")], None, cx));
98 let snapshot = multibuffer.read(cx).snapshot(cx);
99 assert_eq!(snapshot.text(), "ab");
100
101 guest_buffer.update(cx, |buffer, cx| buffer.edit([(2..2, "c")], None, cx));
102 let snapshot = multibuffer.read(cx).snapshot(cx);
103 assert_eq!(snapshot.text(), "abc");
104}
105
106#[gpui::test]
107fn test_excerpt_boundaries_and_clipping(cx: &mut App) {
108 let buffer_1 = cx.new(|cx| Buffer::local(sample_text(7, 6, 'a'), cx));
109 let buffer_2 = cx.new(|cx| Buffer::local(sample_text(7, 6, 'g'), cx));
110 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
111
112 let events = Arc::new(RwLock::new(Vec::<Event>::new()));
113 multibuffer.update(cx, |_, cx| {
114 let events = events.clone();
115 cx.subscribe(&multibuffer, move |_, _, event, _| {
116 if let Event::Edited { .. } = event {
117 events.write().push(event.clone())
118 }
119 })
120 .detach();
121 });
122
123 let subscription = multibuffer.update(cx, |multibuffer, cx| {
124 let subscription = multibuffer.subscribe();
125 multibuffer.set_excerpt_ranges_for_path(
126 PathKey::sorted(0),
127 buffer_1.clone(),
128 &buffer_1.read(cx).snapshot(),
129 vec![ExcerptRange::new(Point::new(1, 2)..Point::new(2, 5))],
130 cx,
131 );
132 assert_eq!(
133 subscription.consume().into_inner(),
134 [Edit {
135 old: MultiBufferOffset(0)..MultiBufferOffset(0),
136 new: MultiBufferOffset(0)..MultiBufferOffset(10)
137 }]
138 );
139
140 multibuffer.set_excerpt_ranges_for_path(
141 PathKey::sorted(0),
142 buffer_1.clone(),
143 &buffer_1.read(cx).snapshot(),
144 vec![
145 ExcerptRange::new(Point::new(1, 2)..Point::new(2, 5)),
146 ExcerptRange::new(Point::new(5, 3)..Point::new(6, 4)),
147 ],
148 cx,
149 );
150 multibuffer.set_excerpt_ranges_for_path(
151 PathKey::sorted(1),
152 buffer_2.clone(),
153 &buffer_2.read(cx).snapshot(),
154 vec![ExcerptRange::new(Point::new(3, 1)..Point::new(3, 3))],
155 cx,
156 );
157 assert_eq!(
158 subscription.consume().into_inner(),
159 [Edit {
160 old: MultiBufferOffset(10)..MultiBufferOffset(10),
161 new: MultiBufferOffset(10)..MultiBufferOffset(22)
162 }]
163 );
164
165 subscription
166 });
167
168 // Adding excerpts emits an edited event.
169 assert_eq!(
170 events.read().as_slice(),
171 &[
172 Event::Edited {
173 edited_buffer: None,
174 },
175 Event::Edited {
176 edited_buffer: None,
177 },
178 Event::Edited {
179 edited_buffer: None,
180 }
181 ]
182 );
183
184 let snapshot = multibuffer.read(cx).snapshot(cx);
185 assert_eq!(
186 snapshot.text(),
187 indoc!(
188 "
189 bbbb
190 ccccc
191 fff
192 gggg
193 jj"
194 ),
195 );
196 assert_eq!(
197 snapshot
198 .row_infos(MultiBufferRow(0))
199 .map(|info| info.buffer_row)
200 .collect::<Vec<_>>(),
201 [Some(1), Some(2), Some(5), Some(6), Some(3)]
202 );
203 assert_eq!(
204 snapshot
205 .row_infos(MultiBufferRow(2))
206 .map(|info| info.buffer_row)
207 .collect::<Vec<_>>(),
208 [Some(5), Some(6), Some(3)]
209 );
210 assert_eq!(
211 snapshot
212 .row_infos(MultiBufferRow(4))
213 .map(|info| info.buffer_row)
214 .collect::<Vec<_>>(),
215 [Some(3)]
216 );
217 assert!(
218 snapshot
219 .row_infos(MultiBufferRow(5))
220 .map(|info| info.buffer_row)
221 .collect::<Vec<_>>()
222 .is_empty()
223 );
224
225 assert_eq!(
226 boundaries_in_range(Point::new(0, 0)..Point::new(4, 2), &snapshot),
227 &[
228 (MultiBufferRow(0), "bbbb\nccccc".to_string(), true),
229 (MultiBufferRow(2), "fff\ngggg".to_string(), false),
230 (MultiBufferRow(4), "jj".to_string(), true),
231 ]
232 );
233 assert_eq!(
234 boundaries_in_range(Point::new(0, 0)..Point::new(2, 0), &snapshot),
235 &[(MultiBufferRow(0), "bbbb\nccccc".to_string(), true)]
236 );
237 assert_eq!(
238 boundaries_in_range(Point::new(1, 0)..Point::new(1, 5), &snapshot),
239 &[]
240 );
241 assert_eq!(
242 boundaries_in_range(Point::new(1, 0)..Point::new(2, 0), &snapshot),
243 &[]
244 );
245 assert_eq!(
246 boundaries_in_range(Point::new(1, 0)..Point::new(4, 0), &snapshot),
247 &[(MultiBufferRow(2), "fff\ngggg".to_string(), false)]
248 );
249 assert_eq!(
250 boundaries_in_range(Point::new(1, 0)..Point::new(4, 0), &snapshot),
251 &[(MultiBufferRow(2), "fff\ngggg".to_string(), false)]
252 );
253 assert_eq!(
254 boundaries_in_range(Point::new(2, 0)..Point::new(3, 0), &snapshot),
255 &[(MultiBufferRow(2), "fff\ngggg".to_string(), false)]
256 );
257 assert_eq!(
258 boundaries_in_range(Point::new(4, 0)..Point::new(4, 2), &snapshot),
259 &[(MultiBufferRow(4), "jj".to_string(), true)]
260 );
261 assert_eq!(
262 boundaries_in_range(Point::new(4, 2)..Point::new(4, 2), &snapshot),
263 &[]
264 );
265
266 buffer_1.update(cx, |buffer, cx| {
267 let text = "\n";
268 buffer.edit(
269 [
270 (Point::new(0, 0)..Point::new(0, 0), text),
271 (Point::new(2, 1)..Point::new(2, 3), text),
272 ],
273 None,
274 cx,
275 );
276 });
277
278 let snapshot = multibuffer.read(cx).snapshot(cx);
279 assert_eq!(
280 snapshot.text(),
281 concat!(
282 "bbbb\n", // Preserve newlines
283 "c\n", //
284 "cc\n", //
285 "fff\n", //
286 "gggg\n", //
287 "jj" //
288 )
289 );
290
291 assert_eq!(
292 subscription.consume().into_inner(),
293 [Edit {
294 old: MultiBufferOffset(6)..MultiBufferOffset(8),
295 new: MultiBufferOffset(6)..MultiBufferOffset(7)
296 }]
297 );
298
299 let snapshot = multibuffer.read(cx).snapshot(cx);
300 assert_eq!(
301 snapshot.clip_point(Point::new(0, 5), Bias::Left),
302 Point::new(0, 4)
303 );
304 assert_eq!(
305 snapshot.clip_point(Point::new(0, 5), Bias::Right),
306 Point::new(0, 4)
307 );
308 assert_eq!(
309 snapshot.clip_point(Point::new(5, 1), Bias::Right),
310 Point::new(5, 1)
311 );
312 assert_eq!(
313 snapshot.clip_point(Point::new(5, 2), Bias::Right),
314 Point::new(5, 2)
315 );
316 assert_eq!(
317 snapshot.clip_point(Point::new(5, 3), Bias::Right),
318 Point::new(5, 2)
319 );
320
321 let snapshot = multibuffer.update(cx, |multibuffer, cx| {
322 multibuffer.remove_excerpts_for_path(PathKey::sorted(1), cx);
323 multibuffer.snapshot(cx)
324 });
325
326 assert_eq!(
327 snapshot.text(),
328 concat!(
329 "bbbb\n", // Preserve newlines
330 "c\n", //
331 "cc\n", //
332 "fff\n", //
333 "gggg", //
334 )
335 );
336
337 fn boundaries_in_range(
338 range: Range<Point>,
339 snapshot: &MultiBufferSnapshot,
340 ) -> Vec<(MultiBufferRow, String, bool)> {
341 snapshot
342 .excerpt_boundaries_in_range(range)
343 .map(|boundary| {
344 let starts_new_buffer = boundary.starts_new_buffer();
345 (
346 boundary.row,
347 boundary
348 .next
349 .buffer
350 .text_for_range(boundary.next.range.context)
351 .collect::<String>(),
352 starts_new_buffer,
353 )
354 })
355 .collect::<Vec<_>>()
356 }
357}
358
359#[gpui::test]
360async fn test_diff_boundary_anchors(cx: &mut TestAppContext) {
361 let base_text = "one\ntwo\nthree\n";
362 let text = "one\nthree\n";
363 let buffer = cx.new(|cx| Buffer::local(text, cx));
364 let diff = cx
365 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
366 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
367 multibuffer.update(cx, |multibuffer, cx| multibuffer.add_diff(diff, cx));
368
369 let (before, after) = multibuffer.update(cx, |multibuffer, cx| {
370 let before = multibuffer.snapshot(cx).anchor_before(Point::new(1, 0));
371 let after = multibuffer.snapshot(cx).anchor_after(Point::new(1, 0));
372 multibuffer.set_all_diff_hunks_expanded(cx);
373 (before, after)
374 });
375 cx.run_until_parked();
376
377 let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
378 let actual_text = snapshot.text();
379 let actual_row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
380 let actual_diff = format_diff(&actual_text, &actual_row_infos, &Default::default(), None);
381 pretty_assertions::assert_eq!(
382 actual_diff,
383 indoc! {
384 " one
385 - two
386 three
387 "
388 },
389 );
390
391 multibuffer.update(cx, |multibuffer, cx| {
392 let snapshot = multibuffer.snapshot(cx);
393 assert_eq!(before.to_point(&snapshot), Point::new(1, 0));
394 assert_eq!(after.to_point(&snapshot), Point::new(2, 0));
395 assert_eq!(
396 vec![Point::new(1, 0), Point::new(2, 0),],
397 snapshot.summaries_for_anchors::<Point, _>(&[before, after]),
398 )
399 })
400}
401
402#[gpui::test]
403async fn test_diff_hunks_in_range(cx: &mut TestAppContext) {
404 let base_text = "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\n";
405 let text = "one\nfour\nseven\n";
406 let buffer = cx.new(|cx| Buffer::local(text, cx));
407 let diff = cx
408 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
409 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
410 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
411 (multibuffer.snapshot(cx), multibuffer.subscribe())
412 });
413
414 multibuffer.update(cx, |multibuffer, cx| {
415 multibuffer.add_diff(diff, cx);
416 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
417 });
418
419 assert_new_snapshot(
420 &multibuffer,
421 &mut snapshot,
422 &mut subscription,
423 cx,
424 indoc! {
425 " one
426 - two
427 - three
428 four
429 - five
430 - six
431 seven
432 - eight
433 "
434 },
435 );
436
437 assert_eq!(
438 snapshot
439 .diff_hunks_in_range(Point::new(1, 0)..Point::MAX)
440 .map(|hunk| hunk.row_range.start.0..hunk.row_range.end.0)
441 .collect::<Vec<_>>(),
442 vec![1..3, 4..6, 7..8]
443 );
444
445 assert_eq!(snapshot.diff_hunk_before(Point::new(1, 1)), None,);
446 assert_eq!(
447 snapshot.diff_hunk_before(Point::new(7, 0)),
448 Some(MultiBufferRow(4))
449 );
450 assert_eq!(
451 snapshot.diff_hunk_before(Point::new(4, 0)),
452 Some(MultiBufferRow(1))
453 );
454
455 multibuffer.update(cx, |multibuffer, cx| {
456 multibuffer.collapse_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
457 });
458
459 assert_new_snapshot(
460 &multibuffer,
461 &mut snapshot,
462 &mut subscription,
463 cx,
464 indoc! {
465 "
466 one
467 four
468 seven
469 "
470 },
471 );
472
473 assert_eq!(
474 snapshot.diff_hunk_before(Point::new(2, 0)),
475 Some(MultiBufferRow(1)),
476 );
477 assert_eq!(
478 snapshot.diff_hunk_before(Point::new(4, 0)),
479 Some(MultiBufferRow(2))
480 );
481}
482
483#[gpui::test]
484async fn test_diff_hunks_in_range_query_starting_at_added_row(cx: &mut TestAppContext) {
485 let base_text = "one\ntwo\nthree\n";
486 let text = "one\nTWO\nthree\n";
487 let buffer = cx.new(|cx| Buffer::local(text, cx));
488 let diff = cx
489 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
490 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
491 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
492 (multibuffer.snapshot(cx), multibuffer.subscribe())
493 });
494
495 multibuffer.update(cx, |multibuffer, cx| {
496 multibuffer.add_diff(diff, cx);
497 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
498 });
499
500 assert_new_snapshot(
501 &multibuffer,
502 &mut snapshot,
503 &mut subscription,
504 cx,
505 indoc! {
506 " one
507 - two
508 + TWO
509 three
510 "
511 },
512 );
513
514 assert_eq!(
515 snapshot
516 .diff_hunks_in_range(Point::new(2, 0)..Point::MAX)
517 .map(|hunk| hunk.row_range.start.0..hunk.row_range.end.0)
518 .collect::<Vec<_>>(),
519 vec![1..3],
520 "querying starting at the added row should still return the full hunk including deleted lines"
521 );
522}
523
524#[gpui::test]
525async fn test_inverted_diff_hunks_in_range(cx: &mut TestAppContext) {
526 let base_text = "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\n";
527 let text = "ZERO\none\nTHREE\nfour\nseven\nEIGHT\nNINE\n";
528 let buffer = cx.new(|cx| Buffer::local(text, cx));
529 let diff = cx
530 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
531 let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
532 let multibuffer = cx.new(|cx| MultiBuffer::singleton(base_text_buffer.clone(), cx));
533 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
534 (multibuffer.snapshot(cx), multibuffer.subscribe())
535 });
536
537 multibuffer.update(cx, |multibuffer, cx| {
538 multibuffer.add_inverted_diff(diff, buffer.clone(), cx);
539 });
540
541 assert_new_snapshot(
542 &multibuffer,
543 &mut snapshot,
544 &mut subscription,
545 cx,
546 indoc! {
547 " one
548 - two
549 - three
550 four
551 - five
552 - six
553 seven
554 - eight
555 "
556 },
557 );
558
559 assert_eq!(
560 snapshot
561 .diff_hunks_in_range(Point::new(0, 0)..Point::MAX)
562 .map(|hunk| hunk.row_range.start.0..hunk.row_range.end.0)
563 .collect::<Vec<_>>(),
564 vec![0..0, 1..3, 4..6, 7..8]
565 );
566
567 assert_eq!(
568 snapshot.diff_hunk_before(Point::new(1, 1)),
569 Some(MultiBufferRow(0))
570 );
571 assert_eq!(
572 snapshot.diff_hunk_before(Point::new(7, 0)),
573 Some(MultiBufferRow(4))
574 );
575 assert_eq!(
576 snapshot.diff_hunk_before(Point::new(4, 0)),
577 Some(MultiBufferRow(1))
578 );
579}
580
581#[gpui::test]
582async fn test_editing_text_in_diff_hunks(cx: &mut TestAppContext) {
583 let base_text = "one\ntwo\nfour\nfive\nsix\nseven\n";
584 let text = "one\ntwo\nTHREE\nfour\nfive\nseven\n";
585 let buffer = cx.new(|cx| Buffer::local(text, cx));
586 let diff = cx
587 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
588 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
589
590 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
591 multibuffer.add_diff(diff.clone(), cx);
592 (multibuffer.snapshot(cx), multibuffer.subscribe())
593 });
594
595 cx.executor().run_until_parked();
596 multibuffer.update(cx, |multibuffer, cx| {
597 multibuffer.set_all_diff_hunks_expanded(cx);
598 });
599
600 assert_new_snapshot(
601 &multibuffer,
602 &mut snapshot,
603 &mut subscription,
604 cx,
605 indoc! {
606 "
607 one
608 two
609 + THREE
610 four
611 five
612 - six
613 seven
614 "
615 },
616 );
617
618 // Insert a newline within an insertion hunk
619 multibuffer.update(cx, |multibuffer, cx| {
620 multibuffer.edit([(Point::new(2, 0)..Point::new(2, 0), "__\n__")], None, cx);
621 });
622 assert_new_snapshot(
623 &multibuffer,
624 &mut snapshot,
625 &mut subscription,
626 cx,
627 indoc! {
628 "
629 one
630 two
631 + __
632 + __THREE
633 four
634 five
635 - six
636 seven
637 "
638 },
639 );
640
641 // Delete the newline before a deleted hunk.
642 multibuffer.update(cx, |multibuffer, cx| {
643 multibuffer.edit([(Point::new(5, 4)..Point::new(6, 0), "")], None, cx);
644 });
645 assert_new_snapshot(
646 &multibuffer,
647 &mut snapshot,
648 &mut subscription,
649 cx,
650 indoc! {
651 "
652 one
653 two
654 + __
655 + __THREE
656 four
657 fiveseven
658 "
659 },
660 );
661
662 multibuffer.update(cx, |multibuffer, cx| multibuffer.undo(cx));
663 assert_new_snapshot(
664 &multibuffer,
665 &mut snapshot,
666 &mut subscription,
667 cx,
668 indoc! {
669 "
670 one
671 two
672 + __
673 + __THREE
674 four
675 five
676 - six
677 seven
678 "
679 },
680 );
681
682 // Cannot (yet) insert at the beginning of a deleted hunk.
683 // (because it would put the newline in the wrong place)
684 multibuffer.update(cx, |multibuffer, cx| {
685 multibuffer.edit([(Point::new(6, 0)..Point::new(6, 0), "\n")], None, cx);
686 });
687 assert_new_snapshot(
688 &multibuffer,
689 &mut snapshot,
690 &mut subscription,
691 cx,
692 indoc! {
693 "
694 one
695 two
696 + __
697 + __THREE
698 four
699 five
700 - six
701 seven
702 "
703 },
704 );
705
706 // Replace a range that ends in a deleted hunk.
707 multibuffer.update(cx, |multibuffer, cx| {
708 multibuffer.edit([(Point::new(5, 2)..Point::new(6, 2), "fty-")], None, cx);
709 });
710 assert_new_snapshot(
711 &multibuffer,
712 &mut snapshot,
713 &mut subscription,
714 cx,
715 indoc! {
716 "
717 one
718 two
719 + __
720 + __THREE
721 four
722 fifty-seven
723 "
724 },
725 );
726}
727
728#[gpui::test]
729fn test_excerpt_events(cx: &mut App) {
730 let buffer_1 = cx.new(|cx| Buffer::local(sample_text(10, 3, 'a'), cx));
731 let buffer_2 = cx.new(|cx| Buffer::local(sample_text(10, 3, 'm'), cx));
732
733 let leader_multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
734 let follower_multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
735 let follower_edit_event_count = Arc::new(RwLock::new(0));
736
737 follower_multibuffer.update(cx, |_, cx| {
738 let follower_edit_event_count = follower_edit_event_count.clone();
739 cx.subscribe(
740 &leader_multibuffer,
741 move |follower, _, event, cx| match event.clone() {
742 Event::BufferUpdated {
743 buffer,
744 path_key,
745 ranges,
746 } => {
747 let buffer_snapshot = buffer.read(cx).snapshot();
748 follower.set_merged_excerpt_ranges_for_path(
749 path_key,
750 buffer,
751 &buffer_snapshot,
752 ranges,
753 cx,
754 );
755 }
756 Event::BuffersRemoved {
757 removed_buffer_ids, ..
758 } => {
759 for id in removed_buffer_ids {
760 follower.remove_excerpts_for_buffer(id, cx);
761 }
762 }
763 Event::Edited { .. } => {
764 *follower_edit_event_count.write() += 1;
765 }
766 _ => {}
767 },
768 )
769 .detach();
770 });
771
772 let buffer_1_snapshot = buffer_1.read(cx).snapshot();
773 let buffer_2_snapshot = buffer_2.read(cx).snapshot();
774 leader_multibuffer.update(cx, |leader, cx| {
775 leader.set_excerpt_ranges_for_path(
776 PathKey::sorted(0),
777 buffer_1.clone(),
778 &buffer_1_snapshot,
779 vec![
780 ExcerptRange::new((0..8).to_point(&buffer_1_snapshot)),
781 ExcerptRange::new((22..26).to_point(&buffer_1_snapshot)),
782 ],
783 cx,
784 );
785 leader.set_excerpt_ranges_for_path(
786 PathKey::sorted(1),
787 buffer_2.clone(),
788 &buffer_2_snapshot,
789 vec![
790 ExcerptRange::new((0..5).to_point(&buffer_2_snapshot)),
791 ExcerptRange::new((20..25).to_point(&buffer_2_snapshot)),
792 ],
793 cx,
794 );
795 });
796 assert_eq!(
797 leader_multibuffer.read(cx).snapshot(cx).text(),
798 follower_multibuffer.read(cx).snapshot(cx).text(),
799 );
800 assert_eq!(*follower_edit_event_count.read(), 2);
801
802 leader_multibuffer.update(cx, |leader, cx| {
803 leader.set_excerpt_ranges_for_path(
804 PathKey::sorted(0),
805 buffer_1.clone(),
806 &buffer_1_snapshot,
807 vec![ExcerptRange::new((0..8).to_point(&buffer_1_snapshot))],
808 cx,
809 );
810 leader.set_excerpt_ranges_for_path(
811 PathKey::sorted(1),
812 buffer_2,
813 &buffer_2_snapshot,
814 vec![ExcerptRange::new((0..5).to_point(&buffer_2_snapshot))],
815 cx,
816 );
817 });
818 assert_eq!(
819 leader_multibuffer.read(cx).snapshot(cx).text(),
820 follower_multibuffer.read(cx).snapshot(cx).text(),
821 );
822 assert_eq!(*follower_edit_event_count.read(), 4);
823
824 leader_multibuffer.update(cx, |leader, cx| {
825 leader.clear(cx);
826 });
827 assert_eq!(
828 leader_multibuffer.read(cx).snapshot(cx).text(),
829 follower_multibuffer.read(cx).snapshot(cx).text(),
830 );
831 assert_eq!(*follower_edit_event_count.read(), 5);
832}
833
834#[gpui::test]
835fn test_expand_excerpts(cx: &mut App) {
836 let buffer = cx.new(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
837 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
838
839 multibuffer.update(cx, |multibuffer, cx| {
840 multibuffer.set_excerpts_for_path(
841 PathKey::for_buffer(&buffer, cx),
842 buffer,
843 vec![
844 // Note that in this test, this first excerpt
845 // does not contain a new line
846 Point::new(3, 2)..Point::new(3, 3),
847 Point::new(7, 1)..Point::new(7, 3),
848 Point::new(15, 0)..Point::new(15, 0),
849 ],
850 1,
851 cx,
852 )
853 });
854
855 let snapshot = multibuffer.read(cx).snapshot(cx);
856
857 assert_eq!(
858 snapshot.text(),
859 concat!(
860 "ccc\n", //
861 "ddd\n", //
862 "eee", //
863 "\n", // End of excerpt
864 "ggg\n", //
865 "hhh\n", //
866 "iii", //
867 "\n", // End of excerpt
868 "ooo\n", //
869 "ppp\n", //
870 "qqq", // End of excerpt
871 )
872 );
873 drop(snapshot);
874
875 multibuffer.update(cx, |multibuffer, cx| {
876 let line_zero = multibuffer.snapshot(cx).anchor_before(Point::new(0, 0));
877
878 multibuffer.expand_excerpts_with_paths(
879 multibuffer
880 .snapshot(cx)
881 .excerpts()
882 .map(|(_, info)| Anchor::in_buffer(info.path_key_index, info.range.context.end)),
883 1,
884 ExpandExcerptDirection::UpAndDown,
885 cx,
886 );
887 let snapshot = multibuffer.snapshot(cx);
888 let line_two = snapshot.anchor_before(Point::new(2, 0));
889 assert_eq!(line_two.cmp(&line_zero, &snapshot), cmp::Ordering::Greater);
890 });
891
892 let snapshot = multibuffer.read(cx).snapshot(cx);
893
894 assert_eq!(
895 snapshot.text(),
896 concat!(
897 "bbb\n", //
898 "ccc\n", //
899 "ddd\n", //
900 "eee\n", //
901 "fff\n", //
902 "ggg\n", //
903 "hhh\n", //
904 "iii\n", //
905 "jjj\n", // End of excerpt
906 "nnn\n", //
907 "ooo\n", //
908 "ppp\n", //
909 "qqq\n", //
910 "rrr", // End of excerpt
911 )
912 );
913}
914
915#[gpui::test(iterations = 100)]
916async fn test_set_anchored_excerpts_for_path(cx: &mut TestAppContext) {
917 let buffer_1 = cx.new(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
918 let buffer_2 = cx.new(|cx| Buffer::local(sample_text(15, 4, 'a'), cx));
919 let snapshot_1 = buffer_1.update(cx, |buffer, _| buffer.snapshot());
920 let snapshot_2 = buffer_2.update(cx, |buffer, _| buffer.snapshot());
921 let ranges_1 = vec![
922 snapshot_1.anchor_before(Point::new(3, 2))..snapshot_1.anchor_before(Point::new(4, 2)),
923 snapshot_1.anchor_before(Point::new(7, 1))..snapshot_1.anchor_before(Point::new(7, 3)),
924 snapshot_1.anchor_before(Point::new(15, 0))..snapshot_1.anchor_before(Point::new(15, 0)),
925 ];
926 let ranges_2 = vec![
927 snapshot_2.anchor_before(Point::new(2, 1))..snapshot_2.anchor_before(Point::new(3, 1)),
928 snapshot_2.anchor_before(Point::new(10, 0))..snapshot_2.anchor_before(Point::new(10, 2)),
929 ];
930
931 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
932 let anchor_ranges_1 = multibuffer
933 .update(cx, |multibuffer, cx| {
934 multibuffer.set_anchored_excerpts_for_path(
935 PathKey::for_buffer(&buffer_1, cx),
936 buffer_1.clone(),
937 ranges_1,
938 2,
939 cx,
940 )
941 })
942 .await;
943 let snapshot_1 = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
944 assert_eq!(
945 anchor_ranges_1
946 .iter()
947 .map(|range| range.to_point(&snapshot_1))
948 .collect::<Vec<_>>(),
949 vec![
950 Point::new(2, 2)..Point::new(3, 2),
951 Point::new(6, 1)..Point::new(6, 3),
952 Point::new(11, 0)..Point::new(11, 0),
953 ]
954 );
955 let anchor_ranges_2 = multibuffer
956 .update(cx, |multibuffer, cx| {
957 multibuffer.set_anchored_excerpts_for_path(
958 PathKey::for_buffer(&buffer_2, cx),
959 buffer_2.clone(),
960 ranges_2,
961 2,
962 cx,
963 )
964 })
965 .await;
966 let snapshot_2 = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
967 assert_eq!(
968 anchor_ranges_2
969 .iter()
970 .map(|range| range.to_point(&snapshot_2))
971 .collect::<Vec<_>>(),
972 vec![
973 Point::new(16, 1)..Point::new(17, 1),
974 Point::new(22, 0)..Point::new(22, 2)
975 ]
976 );
977
978 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
979 assert_eq!(
980 snapshot.text(),
981 concat!(
982 "bbb\n", // buffer_1
983 "ccc\n", //
984 "ddd\n", // <-- excerpt 1
985 "eee\n", // <-- excerpt 1
986 "fff\n", //
987 "ggg\n", //
988 "hhh\n", // <-- excerpt 2
989 "iii\n", //
990 "jjj\n", //
991 //
992 "nnn\n", //
993 "ooo\n", //
994 "ppp\n", // <-- excerpt 3
995 "qqq\n", //
996 "rrr\n", //
997 //
998 "aaaa\n", // buffer 2
999 "bbbb\n", //
1000 "cccc\n", // <-- excerpt 4
1001 "dddd\n", // <-- excerpt 4
1002 "eeee\n", //
1003 "ffff\n", //
1004 //
1005 "iiii\n", //
1006 "jjjj\n", //
1007 "kkkk\n", // <-- excerpt 5
1008 "llll\n", //
1009 "mmmm", //
1010 )
1011 );
1012}
1013
1014#[gpui::test]
1015fn test_empty_multibuffer(cx: &mut App) {
1016 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
1017
1018 let snapshot = multibuffer.read(cx).snapshot(cx);
1019 assert_eq!(snapshot.text(), "");
1020 assert_eq!(
1021 snapshot
1022 .row_infos(MultiBufferRow(0))
1023 .map(|info| info.buffer_row)
1024 .collect::<Vec<_>>(),
1025 &[Some(0)]
1026 );
1027 assert!(
1028 snapshot
1029 .row_infos(MultiBufferRow(1))
1030 .map(|info| info.buffer_row)
1031 .collect::<Vec<_>>()
1032 .is_empty(),
1033 );
1034}
1035
1036#[gpui::test]
1037async fn test_empty_diff_excerpt(cx: &mut TestAppContext) {
1038 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
1039 let buffer = cx.new(|cx| Buffer::local("", cx));
1040 let base_text = "a\nb\nc";
1041
1042 let diff = cx
1043 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
1044 multibuffer.update(cx, |multibuffer, cx| {
1045 multibuffer.set_excerpt_ranges_for_path(
1046 PathKey::sorted(0),
1047 buffer.clone(),
1048 &buffer.read(cx).snapshot(),
1049 vec![ExcerptRange::new(Point::zero()..Point::zero())],
1050 cx,
1051 );
1052 multibuffer.set_all_diff_hunks_expanded(cx);
1053 multibuffer.add_diff(diff.clone(), cx);
1054 });
1055 cx.run_until_parked();
1056
1057 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
1058 assert_eq!(snapshot.text(), "a\nb\nc\n");
1059
1060 let hunk = snapshot
1061 .diff_hunks_in_range(Point::new(1, 1)..Point::new(1, 1))
1062 .next()
1063 .unwrap();
1064
1065 assert_eq!(hunk.diff_base_byte_range.start, BufferOffset(0));
1066
1067 let buf2 = cx.new(|cx| Buffer::local("X", cx));
1068 multibuffer.update(cx, |multibuffer, cx| {
1069 multibuffer.set_excerpts_for_path(
1070 PathKey::sorted(1),
1071 buf2,
1072 [Point::new(0, 0)..Point::new(0, 1)],
1073 0,
1074 cx,
1075 );
1076 });
1077
1078 buffer.update(cx, |buffer, cx| {
1079 buffer.edit([(0..0, "a\nb\nc")], None, cx);
1080 diff.update(cx, |diff, cx| {
1081 diff.recalculate_diff_sync(&buffer.text_snapshot(), cx);
1082 });
1083 assert_eq!(buffer.text(), "a\nb\nc")
1084 });
1085 cx.run_until_parked();
1086
1087 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
1088 assert_eq!(snapshot.text(), "a\nb\nc\nX");
1089
1090 buffer.update(cx, |buffer, cx| {
1091 buffer.undo(cx);
1092 diff.update(cx, |diff, cx| {
1093 diff.recalculate_diff_sync(&buffer.text_snapshot(), cx);
1094 });
1095 assert_eq!(buffer.text(), "")
1096 });
1097 cx.run_until_parked();
1098
1099 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
1100 assert_eq!(snapshot.text(), "a\nb\nc\n\nX");
1101}
1102
1103#[gpui::test]
1104fn test_singleton_multibuffer_anchors(cx: &mut App) {
1105 let buffer = cx.new(|cx| Buffer::local("abcd", cx));
1106 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
1107 let old_snapshot = multibuffer.read(cx).snapshot(cx);
1108 buffer.update(cx, |buffer, cx| {
1109 buffer.edit([(0..0, "X")], None, cx);
1110 buffer.edit([(5..5, "Y")], None, cx);
1111 });
1112 let new_snapshot = multibuffer.read(cx).snapshot(cx);
1113
1114 assert_eq!(old_snapshot.text(), "abcd");
1115 assert_eq!(new_snapshot.text(), "XabcdY");
1116
1117 assert_eq!(
1118 old_snapshot
1119 .anchor_before(MultiBufferOffset(0))
1120 .to_offset(&new_snapshot),
1121 MultiBufferOffset(0)
1122 );
1123 assert_eq!(
1124 old_snapshot
1125 .anchor_after(MultiBufferOffset(0))
1126 .to_offset(&new_snapshot),
1127 MultiBufferOffset(1)
1128 );
1129 assert_eq!(
1130 old_snapshot
1131 .anchor_before(MultiBufferOffset(4))
1132 .to_offset(&new_snapshot),
1133 MultiBufferOffset(5)
1134 );
1135 assert_eq!(
1136 old_snapshot
1137 .anchor_after(MultiBufferOffset(4))
1138 .to_offset(&new_snapshot),
1139 MultiBufferOffset(6)
1140 );
1141}
1142
1143#[gpui::test]
1144fn test_multibuffer_anchors(cx: &mut App) {
1145 let buffer_1 = cx.new(|cx| Buffer::local("abcd", cx));
1146 let buffer_2 = cx.new(|cx| Buffer::local("efghi", cx));
1147 let multibuffer = cx.new(|cx| {
1148 let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
1149 multibuffer.set_excerpts_for_path(
1150 PathKey::sorted(0),
1151 buffer_1.clone(),
1152 [Point::new(0, 0)..Point::new(0, 4)],
1153 0,
1154 cx,
1155 );
1156 multibuffer.set_excerpts_for_path(
1157 PathKey::sorted(1),
1158 buffer_2.clone(),
1159 [Point::new(0, 0)..Point::new(0, 5)],
1160 0,
1161 cx,
1162 );
1163 multibuffer
1164 });
1165 let old_snapshot = multibuffer.read(cx).snapshot(cx);
1166
1167 assert_eq!(
1168 old_snapshot
1169 .anchor_before(MultiBufferOffset(0))
1170 .to_offset(&old_snapshot),
1171 MultiBufferOffset(0)
1172 );
1173 assert_eq!(
1174 old_snapshot
1175 .anchor_after(MultiBufferOffset(0))
1176 .to_offset(&old_snapshot),
1177 MultiBufferOffset(0)
1178 );
1179 assert_eq!(Anchor::min().to_offset(&old_snapshot), MultiBufferOffset(0));
1180 assert_eq!(Anchor::min().to_offset(&old_snapshot), MultiBufferOffset(0));
1181 assert_eq!(
1182 Anchor::max().to_offset(&old_snapshot),
1183 MultiBufferOffset(10)
1184 );
1185 assert_eq!(
1186 Anchor::max().to_offset(&old_snapshot),
1187 MultiBufferOffset(10)
1188 );
1189
1190 buffer_1.update(cx, |buffer, cx| {
1191 buffer.edit([(0..0, "W")], None, cx);
1192 buffer.edit([(5..5, "X")], None, cx);
1193 });
1194 buffer_2.update(cx, |buffer, cx| {
1195 buffer.edit([(0..0, "Y")], None, cx);
1196 buffer.edit([(6..6, "Z")], None, cx);
1197 });
1198 let new_snapshot = multibuffer.read(cx).snapshot(cx);
1199
1200 assert_eq!(old_snapshot.text(), "abcd\nefghi");
1201 assert_eq!(new_snapshot.text(), "WabcdX\nYefghiZ");
1202
1203 assert_eq!(
1204 old_snapshot
1205 .anchor_before(MultiBufferOffset(0))
1206 .to_offset(&new_snapshot),
1207 MultiBufferOffset(0)
1208 );
1209 assert_eq!(
1210 old_snapshot
1211 .anchor_after(MultiBufferOffset(0))
1212 .to_offset(&new_snapshot),
1213 MultiBufferOffset(1)
1214 );
1215 assert_eq!(
1216 old_snapshot
1217 .anchor_before(MultiBufferOffset(1))
1218 .to_offset(&new_snapshot),
1219 MultiBufferOffset(2)
1220 );
1221 assert_eq!(
1222 old_snapshot
1223 .anchor_after(MultiBufferOffset(1))
1224 .to_offset(&new_snapshot),
1225 MultiBufferOffset(2)
1226 );
1227 assert_eq!(
1228 old_snapshot
1229 .anchor_before(MultiBufferOffset(2))
1230 .to_offset(&new_snapshot),
1231 MultiBufferOffset(3)
1232 );
1233 assert_eq!(
1234 old_snapshot
1235 .anchor_after(MultiBufferOffset(2))
1236 .to_offset(&new_snapshot),
1237 MultiBufferOffset(3)
1238 );
1239 assert_eq!(
1240 old_snapshot
1241 .anchor_before(MultiBufferOffset(5))
1242 .to_offset(&new_snapshot),
1243 MultiBufferOffset(7)
1244 );
1245 assert_eq!(
1246 old_snapshot
1247 .anchor_after(MultiBufferOffset(5))
1248 .to_offset(&new_snapshot),
1249 MultiBufferOffset(8)
1250 );
1251 assert_eq!(
1252 old_snapshot
1253 .anchor_before(MultiBufferOffset(10))
1254 .to_offset(&new_snapshot),
1255 MultiBufferOffset(13)
1256 );
1257 assert_eq!(
1258 old_snapshot
1259 .anchor_after(MultiBufferOffset(10))
1260 .to_offset(&new_snapshot),
1261 MultiBufferOffset(14)
1262 );
1263}
1264
1265#[gpui::test]
1266async fn test_basic_diff_hunks(cx: &mut TestAppContext) {
1267 let text = indoc!(
1268 "
1269 ZERO
1270 one
1271 TWO
1272 three
1273 six
1274 "
1275 );
1276 let base_text = indoc!(
1277 "
1278 one
1279 two
1280 three
1281 four
1282 five
1283 six
1284 "
1285 );
1286
1287 let buffer = cx.new(|cx| Buffer::local(text, cx));
1288 let diff = cx
1289 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
1290 cx.run_until_parked();
1291
1292 let multibuffer = cx.new(|cx| {
1293 let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);
1294 multibuffer.add_diff(diff.clone(), cx);
1295 multibuffer
1296 });
1297
1298 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
1299 (multibuffer.snapshot(cx), multibuffer.subscribe())
1300 });
1301 assert_eq!(
1302 snapshot.text(),
1303 indoc!(
1304 "
1305 ZERO
1306 one
1307 TWO
1308 three
1309 six
1310 "
1311 ),
1312 );
1313
1314 multibuffer.update(cx, |multibuffer, cx| {
1315 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
1316 });
1317
1318 assert_new_snapshot(
1319 &multibuffer,
1320 &mut snapshot,
1321 &mut subscription,
1322 cx,
1323 indoc!(
1324 "
1325 + ZERO
1326 one
1327 - two
1328 + TWO
1329 three
1330 - four
1331 - five
1332 six
1333 "
1334 ),
1335 );
1336
1337 assert_eq!(
1338 snapshot
1339 .row_infos(MultiBufferRow(0))
1340 .map(|info| (info.buffer_row, info.diff_status))
1341 .collect::<Vec<_>>(),
1342 vec![
1343 (Some(0), Some(DiffHunkStatus::added_none())),
1344 (Some(1), None),
1345 (Some(1), Some(DiffHunkStatus::deleted_none())),
1346 (Some(2), Some(DiffHunkStatus::added_none())),
1347 (Some(3), None),
1348 (Some(3), Some(DiffHunkStatus::deleted_none())),
1349 (Some(4), Some(DiffHunkStatus::deleted_none())),
1350 (Some(4), None),
1351 (Some(5), None)
1352 ]
1353 );
1354
1355 assert_chunks_in_ranges(&snapshot);
1356 assert_consistent_line_numbers(&snapshot);
1357 assert_position_translation(&snapshot);
1358 assert_line_indents(&snapshot);
1359
1360 multibuffer.update(cx, |multibuffer, cx| {
1361 multibuffer.collapse_diff_hunks(vec![Anchor::min()..Anchor::max()], cx)
1362 });
1363 assert_new_snapshot(
1364 &multibuffer,
1365 &mut snapshot,
1366 &mut subscription,
1367 cx,
1368 indoc!(
1369 "
1370 ZERO
1371 one
1372 TWO
1373 three
1374 six
1375 "
1376 ),
1377 );
1378
1379 assert_chunks_in_ranges(&snapshot);
1380 assert_consistent_line_numbers(&snapshot);
1381 assert_position_translation(&snapshot);
1382 assert_line_indents(&snapshot);
1383
1384 // Expand the first diff hunk
1385 multibuffer.update(cx, |multibuffer, cx| {
1386 let position = multibuffer.read(cx).anchor_before(Point::new(2, 2));
1387 multibuffer.expand_diff_hunks(vec![position..position], cx)
1388 });
1389 assert_new_snapshot(
1390 &multibuffer,
1391 &mut snapshot,
1392 &mut subscription,
1393 cx,
1394 indoc!(
1395 "
1396 ZERO
1397 one
1398 - two
1399 + TWO
1400 three
1401 six
1402 "
1403 ),
1404 );
1405
1406 // Expand the second diff hunk
1407 multibuffer.update(cx, |multibuffer, cx| {
1408 let start = multibuffer.read(cx).anchor_before(Point::new(4, 0));
1409 let end = multibuffer.read(cx).anchor_before(Point::new(5, 0));
1410 multibuffer.expand_diff_hunks(vec![start..end], cx)
1411 });
1412 assert_new_snapshot(
1413 &multibuffer,
1414 &mut snapshot,
1415 &mut subscription,
1416 cx,
1417 indoc!(
1418 "
1419 ZERO
1420 one
1421 - two
1422 + TWO
1423 three
1424 - four
1425 - five
1426 six
1427 "
1428 ),
1429 );
1430
1431 assert_chunks_in_ranges(&snapshot);
1432 assert_consistent_line_numbers(&snapshot);
1433 assert_position_translation(&snapshot);
1434 assert_line_indents(&snapshot);
1435
1436 // Edit the buffer before the first hunk
1437 buffer.update(cx, |buffer, cx| {
1438 buffer.edit_via_marked_text(
1439 indoc!(
1440 "
1441 ZERO
1442 one« hundred
1443 thousand»
1444 TWO
1445 three
1446 six
1447 "
1448 ),
1449 None,
1450 cx,
1451 );
1452 });
1453 assert_new_snapshot(
1454 &multibuffer,
1455 &mut snapshot,
1456 &mut subscription,
1457 cx,
1458 indoc!(
1459 "
1460 ZERO
1461 one hundred
1462 thousand
1463 - two
1464 + TWO
1465 three
1466 - four
1467 - five
1468 six
1469 "
1470 ),
1471 );
1472
1473 assert_chunks_in_ranges(&snapshot);
1474 assert_consistent_line_numbers(&snapshot);
1475 assert_position_translation(&snapshot);
1476 assert_line_indents(&snapshot);
1477
1478 // Recalculate the diff, changing the first diff hunk.
1479 diff.update(cx, |diff, cx| {
1480 diff.recalculate_diff_sync(&buffer.read(cx).text_snapshot(), cx);
1481 });
1482 cx.run_until_parked();
1483 assert_new_snapshot(
1484 &multibuffer,
1485 &mut snapshot,
1486 &mut subscription,
1487 cx,
1488 indoc!(
1489 "
1490 ZERO
1491 one hundred
1492 thousand
1493 TWO
1494 three
1495 - four
1496 - five
1497 six
1498 "
1499 ),
1500 );
1501
1502 assert_eq!(
1503 snapshot
1504 .diff_hunks_in_range(MultiBufferOffset(0)..snapshot.len())
1505 .map(|hunk| hunk.row_range.start.0..hunk.row_range.end.0)
1506 .collect::<Vec<_>>(),
1507 &[0..4, 5..7]
1508 );
1509}
1510
1511#[gpui::test]
1512async fn test_repeatedly_expand_a_diff_hunk(cx: &mut TestAppContext) {
1513 let text = indoc!(
1514 "
1515 one
1516 TWO
1517 THREE
1518 four
1519 FIVE
1520 six
1521 "
1522 );
1523 let base_text = indoc!(
1524 "
1525 one
1526 four
1527 five
1528 six
1529 "
1530 );
1531
1532 let buffer = cx.new(|cx| Buffer::local(text, cx));
1533 let diff = cx
1534 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
1535 cx.run_until_parked();
1536
1537 let multibuffer = cx.new(|cx| {
1538 let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);
1539 multibuffer.add_diff(diff.clone(), cx);
1540 multibuffer
1541 });
1542
1543 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
1544 (multibuffer.snapshot(cx), multibuffer.subscribe())
1545 });
1546
1547 multibuffer.update(cx, |multibuffer, cx| {
1548 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
1549 });
1550
1551 assert_new_snapshot(
1552 &multibuffer,
1553 &mut snapshot,
1554 &mut subscription,
1555 cx,
1556 indoc!(
1557 "
1558 one
1559 + TWO
1560 + THREE
1561 four
1562 - five
1563 + FIVE
1564 six
1565 "
1566 ),
1567 );
1568
1569 // Regression test: expanding diff hunks that are already expanded should not change anything.
1570 multibuffer.update(cx, |multibuffer, cx| {
1571 multibuffer.expand_diff_hunks(
1572 vec![
1573 snapshot.anchor_before(Point::new(2, 0))..snapshot.anchor_before(Point::new(2, 0)),
1574 ],
1575 cx,
1576 );
1577 });
1578
1579 assert_new_snapshot(
1580 &multibuffer,
1581 &mut snapshot,
1582 &mut subscription,
1583 cx,
1584 indoc!(
1585 "
1586 one
1587 + TWO
1588 + THREE
1589 four
1590 - five
1591 + FIVE
1592 six
1593 "
1594 ),
1595 );
1596
1597 // Now collapse all diff hunks
1598 multibuffer.update(cx, |multibuffer, cx| {
1599 multibuffer.collapse_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
1600 });
1601
1602 assert_new_snapshot(
1603 &multibuffer,
1604 &mut snapshot,
1605 &mut subscription,
1606 cx,
1607 indoc!(
1608 "
1609 one
1610 TWO
1611 THREE
1612 four
1613 FIVE
1614 six
1615 "
1616 ),
1617 );
1618
1619 // Expand the hunks again, but this time provide two ranges that are both within the same hunk
1620 // Target the first hunk which is between "one" and "four"
1621 multibuffer.update(cx, |multibuffer, cx| {
1622 multibuffer.expand_diff_hunks(
1623 vec![
1624 snapshot.anchor_before(Point::new(4, 0))..snapshot.anchor_before(Point::new(4, 0)),
1625 snapshot.anchor_before(Point::new(4, 2))..snapshot.anchor_before(Point::new(4, 2)),
1626 ],
1627 cx,
1628 );
1629 });
1630 assert_new_snapshot(
1631 &multibuffer,
1632 &mut snapshot,
1633 &mut subscription,
1634 cx,
1635 indoc!(
1636 "
1637 one
1638 TWO
1639 THREE
1640 four
1641 - five
1642 + FIVE
1643 six
1644 "
1645 ),
1646 );
1647}
1648
1649#[gpui::test]
1650fn test_set_excerpts_for_buffer_ordering(cx: &mut TestAppContext) {
1651 let buf1 = cx.new(|cx| {
1652 Buffer::local(
1653 indoc! {
1654 "zero
1655 one
1656 two
1657 two.five
1658 three
1659 four
1660 five
1661 six
1662 seven
1663 eight
1664 nine
1665 ten
1666 eleven
1667 ",
1668 },
1669 cx,
1670 )
1671 });
1672 let path1: PathKey = PathKey::with_sort_prefix(0, rel_path("root").into_arc());
1673
1674 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
1675 multibuffer.update(cx, |multibuffer, cx| {
1676 multibuffer.set_excerpts_for_path(
1677 path1.clone(),
1678 buf1.clone(),
1679 vec![
1680 Point::row_range(1..2),
1681 Point::row_range(6..7),
1682 Point::row_range(11..12),
1683 ],
1684 1,
1685 cx,
1686 );
1687 });
1688
1689 assert_excerpts_match(
1690 &multibuffer,
1691 cx,
1692 indoc! {
1693 "-----
1694 zero
1695 one
1696 two
1697 two.five
1698 -----
1699 four
1700 five
1701 six
1702 seven
1703 -----
1704 nine
1705 ten
1706 eleven
1707 "
1708 },
1709 );
1710
1711 buf1.update(cx, |buffer, cx| buffer.edit([(0..5, "")], None, cx));
1712
1713 multibuffer.update(cx, |multibuffer, cx| {
1714 multibuffer.set_excerpts_for_path(
1715 path1.clone(),
1716 buf1.clone(),
1717 vec![
1718 Point::row_range(0..3),
1719 Point::row_range(5..7),
1720 Point::row_range(10..11),
1721 ],
1722 1,
1723 cx,
1724 );
1725 });
1726
1727 assert_excerpts_match(
1728 &multibuffer,
1729 cx,
1730 indoc! {
1731 "-----
1732 one
1733 two
1734 two.five
1735 three
1736 four
1737 five
1738 six
1739 seven
1740 eight
1741 nine
1742 ten
1743 eleven
1744 "
1745 },
1746 );
1747}
1748
1749#[gpui::test]
1750fn test_set_excerpts_for_buffer(cx: &mut TestAppContext) {
1751 let buf1 = cx.new(|cx| {
1752 Buffer::local(
1753 indoc! {
1754 "zero
1755 one
1756 two
1757 three
1758 four
1759 five
1760 six
1761 seven
1762 ",
1763 },
1764 cx,
1765 )
1766 });
1767 let path1: PathKey = PathKey::with_sort_prefix(0, rel_path("root").into_arc());
1768 let buf2 = cx.new(|cx| {
1769 Buffer::local(
1770 indoc! {
1771 "000
1772 111
1773 222
1774 333
1775 444
1776 555
1777 666
1778 777
1779 888
1780 999
1781 "
1782 },
1783 cx,
1784 )
1785 });
1786 let path2 = PathKey::with_sort_prefix(1, rel_path("root").into_arc());
1787
1788 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
1789 multibuffer.update(cx, |multibuffer, cx| {
1790 multibuffer.set_excerpts_for_path(
1791 path1.clone(),
1792 buf1.clone(),
1793 vec![Point::row_range(0..1)],
1794 2,
1795 cx,
1796 );
1797 });
1798
1799 assert_excerpts_match(
1800 &multibuffer,
1801 cx,
1802 indoc! {
1803 "-----
1804 zero
1805 one
1806 two
1807 three
1808 "
1809 },
1810 );
1811
1812 multibuffer.update(cx, |multibuffer, cx| {
1813 multibuffer.set_excerpts_for_path(path1.clone(), buf1.clone(), vec![], 2, cx);
1814 });
1815
1816 assert_excerpts_match(&multibuffer, cx, "");
1817
1818 multibuffer.update(cx, |multibuffer, cx| {
1819 multibuffer.set_excerpts_for_path(
1820 path1.clone(),
1821 buf1.clone(),
1822 vec![Point::row_range(0..1), Point::row_range(7..8)],
1823 2,
1824 cx,
1825 );
1826 });
1827
1828 assert_excerpts_match(
1829 &multibuffer,
1830 cx,
1831 indoc! {"-----
1832 zero
1833 one
1834 two
1835 three
1836 -----
1837 five
1838 six
1839 seven
1840 "},
1841 );
1842
1843 multibuffer.update(cx, |multibuffer, cx| {
1844 multibuffer.set_excerpts_for_path(
1845 path1.clone(),
1846 buf1.clone(),
1847 vec![Point::row_range(0..1), Point::row_range(5..6)],
1848 2,
1849 cx,
1850 );
1851 });
1852
1853 assert_excerpts_match(
1854 &multibuffer,
1855 cx,
1856 indoc! {"-----
1857 zero
1858 one
1859 two
1860 three
1861 four
1862 five
1863 six
1864 seven
1865 "},
1866 );
1867
1868 multibuffer.update(cx, |multibuffer, cx| {
1869 multibuffer.set_excerpts_for_path(
1870 path2.clone(),
1871 buf2.clone(),
1872 vec![Point::row_range(2..3)],
1873 2,
1874 cx,
1875 );
1876 });
1877
1878 assert_excerpts_match(
1879 &multibuffer,
1880 cx,
1881 indoc! {"-----
1882 zero
1883 one
1884 two
1885 three
1886 four
1887 five
1888 six
1889 seven
1890 -----
1891 000
1892 111
1893 222
1894 333
1895 444
1896 555
1897 "},
1898 );
1899
1900 multibuffer.update(cx, |multibuffer, cx| {
1901 multibuffer.set_excerpts_for_path(path1.clone(), buf1.clone(), vec![], 2, cx);
1902 });
1903
1904 multibuffer.update(cx, |multibuffer, cx| {
1905 multibuffer.set_excerpts_for_path(
1906 path1.clone(),
1907 buf1.clone(),
1908 vec![Point::row_range(3..4)],
1909 2,
1910 cx,
1911 );
1912 });
1913
1914 assert_excerpts_match(
1915 &multibuffer,
1916 cx,
1917 indoc! {"-----
1918 one
1919 two
1920 three
1921 four
1922 five
1923 six
1924 -----
1925 000
1926 111
1927 222
1928 333
1929 444
1930 555
1931 "},
1932 );
1933
1934 multibuffer.update(cx, |multibuffer, cx| {
1935 multibuffer.set_excerpts_for_path(
1936 path1.clone(),
1937 buf1.clone(),
1938 vec![Point::row_range(3..4)],
1939 2,
1940 cx,
1941 );
1942 });
1943}
1944
1945#[gpui::test]
1946fn test_set_excerpts_for_buffer_rename(cx: &mut TestAppContext) {
1947 let buf1 = cx.new(|cx| {
1948 Buffer::local(
1949 indoc! {
1950 "zero
1951 one
1952 two
1953 three
1954 four
1955 five
1956 six
1957 seven
1958 ",
1959 },
1960 cx,
1961 )
1962 });
1963 let path: PathKey = PathKey::with_sort_prefix(0, rel_path("root").into_arc());
1964 let buf2 = cx.new(|cx| {
1965 Buffer::local(
1966 indoc! {
1967 "000
1968 111
1969 222
1970 333
1971 "
1972 },
1973 cx,
1974 )
1975 });
1976
1977 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
1978 multibuffer.update(cx, |multibuffer, cx| {
1979 multibuffer.set_excerpts_for_path(
1980 path.clone(),
1981 buf1.clone(),
1982 vec![Point::row_range(1..1), Point::row_range(4..5)],
1983 1,
1984 cx,
1985 );
1986 });
1987
1988 assert_excerpts_match(
1989 &multibuffer,
1990 cx,
1991 indoc! {
1992 "-----
1993 zero
1994 one
1995 two
1996 three
1997 four
1998 five
1999 six
2000 "
2001 },
2002 );
2003
2004 multibuffer.update(cx, |multibuffer, cx| {
2005 multibuffer.set_excerpts_for_path(
2006 path.clone(),
2007 buf2.clone(),
2008 vec![Point::row_range(0..1)],
2009 2,
2010 cx,
2011 );
2012 });
2013
2014 assert_excerpts_match(
2015 &multibuffer,
2016 cx,
2017 indoc! {"-----
2018 000
2019 111
2020 222
2021 333
2022 "},
2023 );
2024}
2025
2026#[gpui::test]
2027async fn test_diff_hunks_with_multiple_excerpts(cx: &mut TestAppContext) {
2028 let base_text_1 = indoc!(
2029 "
2030 one
2031 two
2032 three
2033 four
2034 five
2035 six
2036 "
2037 );
2038 let text_1 = indoc!(
2039 "
2040 ZERO
2041 one
2042 TWO
2043 three
2044 six
2045 "
2046 );
2047 let base_text_2 = indoc!(
2048 "
2049 seven
2050 eight
2051 nine
2052 ten
2053 eleven
2054 twelve
2055 "
2056 );
2057 let text_2 = indoc!(
2058 "
2059 eight
2060 nine
2061 eleven
2062 THIRTEEN
2063 FOURTEEN
2064 "
2065 );
2066
2067 let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
2068 let buffer_2 = cx.new(|cx| Buffer::local(text_2, cx));
2069 let diff_1 = cx.new(|cx| {
2070 BufferDiff::new_with_base_text(base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
2071 });
2072 let diff_2 = cx.new(|cx| {
2073 BufferDiff::new_with_base_text(base_text_2, &buffer_2.read(cx).text_snapshot(), cx)
2074 });
2075 cx.run_until_parked();
2076
2077 let multibuffer = cx.new(|cx| {
2078 let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
2079 multibuffer.set_excerpts_for_path(
2080 PathKey::sorted(0),
2081 buffer_1.clone(),
2082 [Point::zero()..buffer_1.read(cx).max_point()],
2083 0,
2084 cx,
2085 );
2086 multibuffer.set_excerpts_for_path(
2087 PathKey::sorted(1),
2088 buffer_2.clone(),
2089 [Point::zero()..buffer_2.read(cx).max_point()],
2090 0,
2091 cx,
2092 );
2093 multibuffer.add_diff(diff_1.clone(), cx);
2094 multibuffer.add_diff(diff_2.clone(), cx);
2095 multibuffer
2096 });
2097
2098 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
2099 (multibuffer.snapshot(cx), multibuffer.subscribe())
2100 });
2101 assert_eq!(
2102 snapshot.text(),
2103 indoc!(
2104 "
2105 ZERO
2106 one
2107 TWO
2108 three
2109 six
2110
2111 eight
2112 nine
2113 eleven
2114 THIRTEEN
2115 FOURTEEN
2116 "
2117 ),
2118 );
2119
2120 multibuffer.update(cx, |multibuffer, cx| {
2121 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
2122 });
2123
2124 assert_new_snapshot(
2125 &multibuffer,
2126 &mut snapshot,
2127 &mut subscription,
2128 cx,
2129 indoc!(
2130 "
2131 + ZERO
2132 one
2133 - two
2134 + TWO
2135 three
2136 - four
2137 - five
2138 six
2139
2140 - seven
2141 eight
2142 nine
2143 - ten
2144 eleven
2145 - twelve
2146 + THIRTEEN
2147 + FOURTEEN
2148 "
2149 ),
2150 );
2151
2152 let id_1 = buffer_1.read_with(cx, |buffer, _| buffer.remote_id());
2153 let id_2 = buffer_2.read_with(cx, |buffer, _| buffer.remote_id());
2154 let base_id_1 = diff_1.read_with(cx, |diff, cx| diff.base_text(cx).remote_id());
2155 let base_id_2 = diff_2.read_with(cx, |diff, cx| diff.base_text(cx).remote_id());
2156
2157 let buffer_lines = (0..=snapshot.max_row().0)
2158 .map(|row| {
2159 let (buffer, range) = snapshot.buffer_line_for_row(MultiBufferRow(row))?;
2160 Some((
2161 buffer.remote_id(),
2162 buffer.text_for_range(range).collect::<String>(),
2163 ))
2164 })
2165 .collect::<Vec<_>>();
2166 pretty_assertions::assert_eq!(
2167 buffer_lines,
2168 [
2169 Some((id_1, "ZERO".into())),
2170 Some((id_1, "one".into())),
2171 Some((base_id_1, "two".into())),
2172 Some((id_1, "TWO".into())),
2173 Some((id_1, " three".into())),
2174 Some((base_id_1, "four".into())),
2175 Some((base_id_1, "five".into())),
2176 Some((id_1, "six".into())),
2177 Some((id_1, "".into())),
2178 Some((base_id_2, "seven".into())),
2179 Some((id_2, " eight".into())),
2180 Some((id_2, "nine".into())),
2181 Some((base_id_2, "ten".into())),
2182 Some((id_2, "eleven".into())),
2183 Some((base_id_2, "twelve".into())),
2184 Some((id_2, "THIRTEEN".into())),
2185 Some((id_2, "FOURTEEN".into())),
2186 Some((id_2, "".into())),
2187 ]
2188 );
2189
2190 let buffer_ids_by_range = [
2191 (Point::new(0, 0)..Point::new(0, 0), &[id_1] as &[_]),
2192 (Point::new(0, 0)..Point::new(2, 0), &[id_1]),
2193 (Point::new(2, 0)..Point::new(2, 0), &[id_1]),
2194 (Point::new(3, 0)..Point::new(3, 0), &[id_1]),
2195 (Point::new(8, 0)..Point::new(9, 0), &[id_1]),
2196 (Point::new(8, 0)..Point::new(10, 0), &[id_1, id_2]),
2197 (Point::new(9, 0)..Point::new(9, 0), &[id_2]),
2198 ];
2199 for (range, buffer_ids) in buffer_ids_by_range {
2200 assert_eq!(
2201 snapshot
2202 .buffer_ids_for_range(range.clone())
2203 .collect::<Vec<_>>(),
2204 buffer_ids,
2205 "buffer_ids_for_range({range:?}"
2206 );
2207 }
2208
2209 assert_position_translation(&snapshot);
2210 assert_line_indents(&snapshot);
2211
2212 assert_eq!(
2213 snapshot
2214 .diff_hunks_in_range(MultiBufferOffset(0)..snapshot.len())
2215 .map(|hunk| hunk.row_range.start.0..hunk.row_range.end.0)
2216 .collect::<Vec<_>>(),
2217 &[0..1, 2..4, 5..7, 9..10, 12..13, 14..17]
2218 );
2219
2220 buffer_2.update(cx, |buffer, cx| {
2221 buffer.edit_via_marked_text(
2222 indoc!(
2223 "
2224 eight
2225 «»eleven
2226 THIRTEEN
2227 FOURTEEN
2228 "
2229 ),
2230 None,
2231 cx,
2232 );
2233 });
2234
2235 assert_new_snapshot(
2236 &multibuffer,
2237 &mut snapshot,
2238 &mut subscription,
2239 cx,
2240 indoc!(
2241 "
2242 + ZERO
2243 one
2244 - two
2245 + TWO
2246 three
2247 - four
2248 - five
2249 six
2250
2251 - seven
2252 eight
2253 eleven
2254 - twelve
2255 + THIRTEEN
2256 + FOURTEEN
2257 "
2258 ),
2259 );
2260
2261 assert_line_indents(&snapshot);
2262}
2263
2264/// A naive implementation of a multi-buffer that does not maintain
2265/// any derived state, used for comparison in a randomized test.
2266#[derive(Default)]
2267struct ReferenceMultibuffer {
2268 excerpts: Vec<ReferenceExcerpt>,
2269 diffs: HashMap<BufferId, Entity<BufferDiff>>,
2270 inverted_diffs: HashMap<BufferId, (Entity<BufferDiff>, Entity<language::Buffer>)>,
2271 // todo!() is this the right model?
2272 expanded_diff_hunks_by_buffer: HashMap<BufferId, Vec<text::Anchor>>,
2273}
2274
2275#[derive(Debug)]
2276struct ReferenceExcerpt {
2277 path_key: PathKey,
2278 path_key_index: PathKeyIndex,
2279 buffer: Entity<Buffer>,
2280 range: Range<text::Anchor>,
2281}
2282
2283#[derive(Debug)]
2284struct ReferenceRegion {
2285 buffer_id: Option<BufferId>,
2286 range: Range<usize>,
2287 buffer_range: Option<Range<Point>>,
2288 status: Option<DiffHunkStatus>,
2289 excerpt_info: Option<ExcerptInfo>,
2290}
2291
2292impl ReferenceExcerpt {
2293 fn info(&self, cx: &App) -> ExcerptInfo {
2294 ExcerptInfo {
2295 path_key_index: self.path_key_index,
2296 buffer_id: self.buffer.read(cx).remote_id(),
2297 range: self.range.clone(),
2298 }
2299 }
2300}
2301
2302impl ReferenceMultibuffer {
2303 fn expand_excerpts(&mut self, excerpts: &HashSet<ExcerptInfo>, line_count: u32, cx: &App) {
2304 if line_count == 0 {
2305 return;
2306 }
2307
2308 for info in excerpts {
2309 let excerpt = self
2310 .excerpts
2311 .iter_mut()
2312 .find(|e| &e.info(cx) == info)
2313 .unwrap();
2314 let snapshot = excerpt.buffer.read(cx).snapshot();
2315 let mut point_range = excerpt.range.to_point(&snapshot);
2316 point_range.start = Point::new(point_range.start.row.saturating_sub(line_count), 0);
2317 point_range.end =
2318 snapshot.clip_point(Point::new(point_range.end.row + line_count, 0), Bias::Left);
2319 point_range.end.column = snapshot.line_len(point_range.end.row);
2320 excerpt.range =
2321 snapshot.anchor_before(point_range.start)..snapshot.anchor_after(point_range.end);
2322 }
2323 }
2324
2325 fn remove_excerpt(&mut self, info: ExcerptInfo, cx: &App) {
2326 let ix = self
2327 .excerpts
2328 .iter()
2329 .position(|excerpt| excerpt.info(cx) == info)
2330 .unwrap();
2331 let excerpt = self.excerpts.remove(ix);
2332 let buffer = excerpt.buffer.read(cx);
2333 let buffer_id = buffer.remote_id();
2334 log::info!(
2335 "Removing excerpt {}: {:?}",
2336 ix,
2337 buffer
2338 .text_for_range(excerpt.range.to_offset(buffer))
2339 .collect::<String>(),
2340 );
2341 if !self
2342 .excerpts
2343 .iter()
2344 .any(|excerpt| excerpt.buffer.read(cx).remote_id() == buffer_id)
2345 {
2346 self.diffs.remove(&buffer_id);
2347 self.inverted_diffs.remove(&buffer_id);
2348 }
2349 }
2350
2351 fn set_excerpts(
2352 &mut self,
2353 path_key: PathKey,
2354 path_key_index: PathKeyIndex,
2355 buffer: Entity<Buffer>,
2356 ranges: Vec<Range<text::Anchor>>,
2357 ) {
2358 self.excerpts.retain(|excerpt| {
2359 excerpt.path_key != path_key && excerpt.buffer.entity_id() != buffer.entity_id()
2360 });
2361
2362 let (Ok(ix) | Err(ix)) = self
2363 .excerpts
2364 .binary_search_by(|probe| probe.path_key.cmp(&path_key));
2365 self.excerpts.splice(
2366 ix..ix,
2367 ranges.into_iter().map(|range| ReferenceExcerpt {
2368 path_key: path_key.clone(),
2369 path_key_index,
2370 buffer: buffer.clone(),
2371 range,
2372 }),
2373 );
2374 }
2375
2376 fn expand_diff_hunks(&mut self, path_key: PathKey, range: Range<text::Anchor>, cx: &App) {
2377 let excerpt = self
2378 .excerpts
2379 .iter_mut()
2380 .find(|e| {
2381 e.path_key == path_key
2382 && e.range
2383 .start
2384 .cmp(&range.start, &e.buffer.read(cx).snapshot())
2385 .is_le()
2386 })
2387 .unwrap();
2388 let buffer = excerpt.buffer.read(cx).snapshot();
2389 let buffer_id = buffer.remote_id();
2390
2391 // Skip inverted excerpts - hunks are always expanded
2392 if self.inverted_diffs.contains_key(&buffer_id) {
2393 return;
2394 }
2395
2396 let Some(diff) = self.diffs.get(&buffer_id) else {
2397 return;
2398 };
2399 let excerpt_range = excerpt.range.to_offset(&buffer);
2400 let expanded_diff_hunks = self
2401 .expanded_diff_hunks_by_buffer
2402 .entry(buffer_id)
2403 .or_default();
2404 for hunk in diff
2405 .read(cx)
2406 .snapshot(cx)
2407 .hunks_intersecting_range(range, &buffer)
2408 {
2409 let hunk_range = hunk.buffer_range.to_offset(&buffer);
2410 if hunk_range.start < excerpt_range.start || hunk_range.start > excerpt_range.end {
2411 continue;
2412 }
2413 if let Err(ix) = expanded_diff_hunks
2414 .binary_search_by(|anchor| anchor.cmp(&hunk.buffer_range.start, &buffer))
2415 {
2416 log::info!(
2417 "expanding diff hunk {:?}. excerpt range:{:?}",
2418 hunk_range,
2419 excerpt_range
2420 );
2421 expanded_diff_hunks.insert(ix, hunk.buffer_range.start);
2422 } else {
2423 log::trace!("hunk {hunk_range:?} already expanded in excerpt");
2424 }
2425 }
2426 }
2427
2428 fn expected_content(&self, cx: &App) -> (String, Vec<RowInfo>, HashSet<MultiBufferRow>) {
2429 let mut text = String::new();
2430 let mut regions = Vec::<ReferenceRegion>::new();
2431 let mut excerpt_boundary_rows = HashSet::default();
2432 for excerpt in &self.excerpts {
2433 excerpt_boundary_rows.insert(MultiBufferRow(text.matches('\n').count() as u32));
2434 let buffer = excerpt.buffer.read(cx);
2435 let buffer_id = buffer.remote_id();
2436 let buffer_range = excerpt.range.to_offset(buffer);
2437
2438 if let Some((diff, main_buffer)) = self.inverted_diffs.get(&buffer_id) {
2439 let diff_snapshot = diff.read(cx).snapshot(cx);
2440 let main_buffer_snapshot = main_buffer.read(cx).snapshot();
2441
2442 let mut offset = buffer_range.start;
2443 for hunk in diff_snapshot.hunks_intersecting_base_text_range(
2444 buffer_range.clone(),
2445 &main_buffer_snapshot.text,
2446 ) {
2447 let mut hunk_base_range = hunk.diff_base_byte_range.clone();
2448
2449 hunk_base_range.end = hunk_base_range.end.min(buffer_range.end);
2450 if hunk_base_range.start > buffer_range.end
2451 || hunk_base_range.start < buffer_range.start
2452 {
2453 continue;
2454 }
2455
2456 // Add the text before the hunk
2457 if hunk_base_range.start >= offset {
2458 let len = text.len();
2459 text.extend(buffer.text_for_range(offset..hunk_base_range.start));
2460 if text.len() > len {
2461 regions.push(ReferenceRegion {
2462 buffer_id: Some(buffer_id),
2463 range: len..text.len(),
2464 buffer_range: Some(
2465 (offset..hunk_base_range.start).to_point(&buffer),
2466 ),
2467 status: None,
2468 excerpt_info: Some(excerpt.info(cx)),
2469 });
2470 }
2471 }
2472
2473 // Add the "deleted" region (base text that's not in main)
2474 if !hunk_base_range.is_empty() {
2475 let len = text.len();
2476 text.extend(buffer.text_for_range(hunk_base_range.clone()));
2477 regions.push(ReferenceRegion {
2478 buffer_id: Some(buffer_id),
2479 range: len..text.len(),
2480 buffer_range: Some(hunk_base_range.to_point(&buffer)),
2481 status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),
2482 excerpt_info: Some(excerpt.info(cx)),
2483 });
2484 }
2485
2486 offset = hunk_base_range.end;
2487 }
2488
2489 // Add remaining buffer text
2490 let len = text.len();
2491 text.extend(buffer.text_for_range(offset..buffer_range.end));
2492 text.push('\n');
2493 regions.push(ReferenceRegion {
2494 buffer_id: Some(buffer_id),
2495 range: len..text.len(),
2496 buffer_range: Some((offset..buffer_range.end).to_point(&buffer)),
2497 status: None,
2498 excerpt_info: Some(excerpt.info(cx)),
2499 });
2500 } else {
2501 let diff = self.diffs.get(&buffer_id).unwrap().read(cx).snapshot(cx);
2502 let base_buffer = diff.base_text();
2503
2504 let mut offset = buffer_range.start;
2505 let hunks = diff
2506 .hunks_intersecting_range(excerpt.range.clone(), buffer)
2507 .peekable();
2508
2509 for hunk in hunks {
2510 // Ignore hunks that are outside the excerpt range.
2511 let mut hunk_range = hunk.buffer_range.to_offset(buffer);
2512
2513 hunk_range.end = hunk_range.end.min(buffer_range.end);
2514 if hunk_range.start > buffer_range.end || hunk_range.start < buffer_range.start
2515 {
2516 log::trace!("skipping hunk outside excerpt range");
2517 continue;
2518 }
2519
2520 if !self
2521 .expanded_diff_hunks_by_buffer
2522 .get(&buffer_id)
2523 .cloned()
2524 .into_iter()
2525 .flatten()
2526 .any(|expanded_anchor| {
2527 expanded_anchor.to_offset(buffer).max(buffer_range.start)
2528 == hunk_range.start.max(buffer_range.start)
2529 })
2530 {
2531 log::trace!("skipping a hunk that's not marked as expanded");
2532 continue;
2533 }
2534
2535 if !hunk.buffer_range.start.is_valid(buffer) {
2536 log::trace!("skipping hunk with deleted start: {:?}", hunk.range);
2537 continue;
2538 }
2539
2540 if hunk_range.start >= offset {
2541 // Add the buffer text before the hunk
2542 let len = text.len();
2543 text.extend(buffer.text_for_range(offset..hunk_range.start));
2544 if text.len() > len {
2545 regions.push(ReferenceRegion {
2546 buffer_id: Some(buffer_id),
2547 range: len..text.len(),
2548 buffer_range: Some((offset..hunk_range.start).to_point(&buffer)),
2549 status: None,
2550 excerpt_info: Some(excerpt.info(cx)),
2551 });
2552 }
2553
2554 // Add the deleted text for the hunk.
2555 if !hunk.diff_base_byte_range.is_empty() {
2556 let mut base_text = base_buffer
2557 .text_for_range(hunk.diff_base_byte_range.clone())
2558 .collect::<String>();
2559 if !base_text.ends_with('\n') {
2560 base_text.push('\n');
2561 }
2562 let len = text.len();
2563 text.push_str(&base_text);
2564 regions.push(ReferenceRegion {
2565 buffer_id: Some(base_buffer.remote_id()),
2566 range: len..text.len(),
2567 buffer_range: Some(
2568 hunk.diff_base_byte_range.to_point(&base_buffer),
2569 ),
2570 status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),
2571 excerpt_info: Some(excerpt.info(cx)),
2572 });
2573 }
2574
2575 offset = hunk_range.start;
2576 }
2577
2578 // Add the inserted text for the hunk.
2579 if hunk_range.end > offset {
2580 let len = text.len();
2581 text.extend(buffer.text_for_range(offset..hunk_range.end));
2582 let range = len..text.len();
2583 let region = ReferenceRegion {
2584 buffer_id: Some(buffer_id),
2585 range,
2586 buffer_range: Some((offset..hunk_range.end).to_point(&buffer)),
2587 status: Some(DiffHunkStatus::added(hunk.secondary_status)),
2588 excerpt_info: Some(excerpt.info(cx)),
2589 };
2590 offset = hunk_range.end;
2591 regions.push(region);
2592 }
2593 }
2594
2595 // Add the buffer text for the rest of the excerpt.
2596 let len = text.len();
2597 text.extend(buffer.text_for_range(offset..buffer_range.end));
2598 text.push('\n');
2599 regions.push(ReferenceRegion {
2600 buffer_id: Some(buffer_id),
2601 range: len..text.len(),
2602 buffer_range: Some((offset..buffer_range.end).to_point(&buffer)),
2603 status: None,
2604 excerpt_info: Some(excerpt.info(cx)),
2605 });
2606 }
2607 }
2608
2609 // Remove final trailing newline.
2610 if self.excerpts.is_empty() {
2611 regions.push(ReferenceRegion {
2612 buffer_id: None,
2613 range: 0..1,
2614 buffer_range: Some(Point::new(0, 0)..Point::new(0, 1)),
2615 status: None,
2616 excerpt_info: None,
2617 });
2618 } else {
2619 text.pop();
2620 }
2621
2622 // Retrieve the row info using the region that contains
2623 // the start of each multi-buffer line.
2624 let mut ix = 0;
2625 let row_infos = text
2626 .split('\n')
2627 .map(|line| {
2628 let row_info = regions
2629 .iter()
2630 .position(|region| region.range.contains(&ix))
2631 .map_or(RowInfo::default(), |region_ix| {
2632 let region = ®ions[region_ix];
2633 let buffer_row = region.buffer_range.as_ref().map(|buffer_range| {
2634 buffer_range.start.row
2635 + text[region.range.start..ix].matches('\n').count() as u32
2636 });
2637 let main_buffer = self
2638 .excerpts
2639 .iter()
2640 .find(|e| e.info(cx) == region.excerpt_info.unwrap())
2641 .map(|e| e.buffer.clone());
2642 let is_excerpt_start = region_ix == 0
2643 || ®ions[region_ix - 1].excerpt_info != ®ion.excerpt_info
2644 || regions[region_ix - 1].range.is_empty();
2645 let mut is_excerpt_end = region_ix == regions.len() - 1
2646 || ®ions[region_ix + 1].excerpt_info != ®ion.excerpt_info;
2647 let is_start = !text[region.range.start..ix].contains('\n');
2648 let mut is_end = if region.range.end > text.len() {
2649 !text[ix..].contains('\n')
2650 } else {
2651 text[ix..region.range.end.min(text.len())]
2652 .matches('\n')
2653 .count()
2654 == 1
2655 };
2656 if region_ix < regions.len() - 1
2657 && !text[ix..].contains("\n")
2658 && (region.status == Some(DiffHunkStatus::added_none())
2659 || region.status.is_some_and(|s| s.is_deleted()))
2660 && regions[region_ix + 1].excerpt_info == region.excerpt_info
2661 && regions[region_ix + 1].range.start == text.len()
2662 {
2663 is_end = true;
2664 is_excerpt_end = true;
2665 }
2666 let multibuffer_row =
2667 MultiBufferRow(text[..ix].matches('\n').count() as u32);
2668 let mut expand_direction = None;
2669 if let Some(buffer) = &main_buffer {
2670 let buffer_row = buffer_row.unwrap();
2671 let needs_expand_up = is_excerpt_start && is_start && buffer_row > 0;
2672 let needs_expand_down = is_excerpt_end
2673 && is_end
2674 && buffer.read(cx).max_point().row > buffer_row;
2675 expand_direction = if needs_expand_up && needs_expand_down {
2676 Some(ExpandExcerptDirection::UpAndDown)
2677 } else if needs_expand_up {
2678 Some(ExpandExcerptDirection::Up)
2679 } else if needs_expand_down {
2680 Some(ExpandExcerptDirection::Down)
2681 } else {
2682 None
2683 };
2684 }
2685 RowInfo {
2686 buffer_id: region.buffer_id,
2687 diff_status: region.status,
2688 buffer_row,
2689 wrapped_buffer_row: None,
2690
2691 multibuffer_row: Some(multibuffer_row),
2692 expand_info: expand_direction.zip(region.excerpt_info.clone()).map(
2693 |(direction, excerpt_info)| ExpandInfo {
2694 direction,
2695 excerpt_range: excerpt_info.range.context,
2696 },
2697 ),
2698 }
2699 });
2700 ix += line.len() + 1;
2701 row_info
2702 })
2703 .collect();
2704
2705 (text, row_infos, excerpt_boundary_rows)
2706 }
2707
2708 fn diffs_updated(&mut self, cx: &App) {
2709 for excerpt in &mut self.excerpts {
2710 let buffer = excerpt.buffer.read(cx).snapshot();
2711 let buffer_id = buffer.remote_id();
2712
2713 // Skip inverted diff excerpts - hunks are always expanded
2714 if self.inverted_diffs.contains_key(&buffer_id) {
2715 continue;
2716 }
2717
2718 let excerpt_range = excerpt.range.to_offset(&buffer);
2719 let Some(diff) = self.diffs.get(&buffer_id) else {
2720 continue;
2721 };
2722 let diff = diff.read(cx).snapshot(cx);
2723 let mut hunks = diff.hunks_in_row_range(0..u32::MAX, &buffer).peekable();
2724 self.expanded_diff_hunks_by_buffer
2725 .entry(buffer_id)
2726 .or_default()
2727 .retain(|hunk_anchor| {
2728 if !hunk_anchor.is_valid(&buffer) {
2729 return false;
2730 }
2731 while let Some(hunk) = hunks.peek() {
2732 match hunk.buffer_range.start.cmp(hunk_anchor, &buffer) {
2733 cmp::Ordering::Less => {
2734 hunks.next();
2735 }
2736 cmp::Ordering::Equal => {
2737 let hunk_range = hunk.buffer_range.to_offset(&buffer);
2738 return hunk_range.end >= excerpt_range.start
2739 && hunk_range.start <= excerpt_range.end;
2740 }
2741 cmp::Ordering::Greater => break,
2742 }
2743 }
2744 false
2745 });
2746 }
2747 }
2748
2749 fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut App) {
2750 let buffer_id = diff.read(cx).buffer_id;
2751 self.diffs.insert(buffer_id, diff);
2752 }
2753
2754 fn add_inverted_diff(
2755 &mut self,
2756 diff: Entity<BufferDiff>,
2757 main_buffer: Entity<language::Buffer>,
2758 cx: &App,
2759 ) {
2760 let base_text_buffer_id = diff.read(cx).base_text(cx).remote_id();
2761 self.inverted_diffs
2762 .insert(base_text_buffer_id, (diff, main_buffer));
2763 }
2764}
2765
2766#[gpui::test(iterations = 100)]
2767async fn test_random_set_ranges(cx: &mut TestAppContext, mut rng: StdRng) {
2768 let base_text = "a\n".repeat(100);
2769 let buf = cx.update(|cx| cx.new(|cx| Buffer::local(base_text, cx)));
2770 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
2771
2772 let operations = env::var("OPERATIONS")
2773 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2774 .unwrap_or(10);
2775
2776 fn row_ranges(ranges: &Vec<Range<Point>>) -> Vec<Range<u32>> {
2777 ranges
2778 .iter()
2779 .map(|range| range.start.row..range.end.row)
2780 .collect()
2781 }
2782
2783 for _ in 0..operations {
2784 let snapshot = buf.update(cx, |buf, _| buf.snapshot());
2785 let num_ranges = rng.random_range(0..=10);
2786 let max_row = snapshot.max_point().row;
2787 let mut ranges = (0..num_ranges)
2788 .map(|_| {
2789 let start = rng.random_range(0..max_row);
2790 let end = rng.random_range(start + 1..max_row + 1);
2791 Point::row_range(start..end)
2792 })
2793 .collect::<Vec<_>>();
2794 ranges.sort_by_key(|range| range.start);
2795 log::info!("Setting ranges: {:?}", row_ranges(&ranges));
2796 let (created, _) = multibuffer.update(cx, |multibuffer, cx| {
2797 multibuffer.set_excerpts_for_path(
2798 PathKey::for_buffer(&buf, cx),
2799 buf.clone(),
2800 ranges.clone(),
2801 2,
2802 cx,
2803 )
2804 });
2805
2806 assert_eq!(created.len(), ranges.len());
2807
2808 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
2809 let mut last_end = None;
2810 let mut seen_ranges = Vec::default();
2811
2812 for (_, buf, range) in snapshot.excerpts() {
2813 let start = range.context.start.to_point(buf);
2814 let end = range.context.end.to_point(buf);
2815 seen_ranges.push(start..end);
2816
2817 if let Some(last_end) = last_end.take() {
2818 assert!(
2819 start > last_end,
2820 "multibuffer has out-of-order ranges: {:?}; {:?} <= {:?}",
2821 row_ranges(&seen_ranges),
2822 start,
2823 last_end
2824 )
2825 }
2826
2827 ranges.retain(|range| range.start < start || range.end > end);
2828
2829 last_end = Some(end)
2830 }
2831
2832 assert!(
2833 ranges.is_empty(),
2834 "multibuffer {:?} did not include all ranges: {:?}",
2835 row_ranges(&seen_ranges),
2836 row_ranges(&ranges)
2837 );
2838 }
2839}
2840
2841#[gpui::test(iterations = 100)]
2842async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
2843 let operations = env::var("OPERATIONS")
2844 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2845 .unwrap_or(10);
2846 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
2847 let mut buffers: Vec<Entity<Buffer>> = Vec::new();
2848 let mut base_texts: HashMap<BufferId, String> = HashMap::default();
2849 let mut reference = ReferenceMultibuffer::default();
2850 let mut anchors = Vec::new();
2851 let mut old_versions = Vec::new();
2852 let mut needs_diff_calculation = false;
2853 let mut inverted_diff_main_buffers: HashMap<BufferId, Entity<BufferDiff>> = HashMap::default();
2854 for _ in 0..operations {
2855 match rng.random_range(0..100) {
2856 0..=14 if !buffers.is_empty() => {
2857 let buffer = buffers.choose(&mut rng).unwrap();
2858 buffer.update(cx, |buf, cx| {
2859 let edit_count = rng.random_range(1..5);
2860 buf.randomly_edit(&mut rng, edit_count, cx);
2861 log::info!("buffer text:\n{}", buf.text());
2862 needs_diff_calculation = true;
2863 });
2864 cx.update(|cx| reference.diffs_updated(cx));
2865 }
2866 15..=19 if !reference.excerpts.is_empty() => {
2867 multibuffer.update(cx, |multibuffer, cx| {
2868 let snapshot = multibuffer.snapshot(cx);
2869 let infos = snapshot
2870 .excerpts()
2871 .map(|(_, info)| info)
2872 .collect::<Vec<_>>();
2873 let mut excerpts = HashSet::default();
2874 for _ in 0..rng.random_range(0..infos.len()) {
2875 excerpts.extend(infos.choose(&mut rng).cloned());
2876 }
2877
2878 let line_count = rng.random_range(0..5);
2879
2880 let excerpt_ixs = excerpts
2881 .iter()
2882 .map(|info| {
2883 reference
2884 .excerpts
2885 .iter()
2886 .position(|e| e.info(cx) == *info)
2887 .unwrap()
2888 })
2889 .collect::<Vec<_>>();
2890 log::info!("Expanding excerpts {excerpt_ixs:?} by {line_count} lines");
2891 multibuffer.expand_excerpts_with_paths(
2892 excerpts.iter().map(|info| {
2893 Anchor::in_buffer(info.path_key_index, info.range.context.end)
2894 }),
2895 line_count,
2896 ExpandExcerptDirection::UpAndDown,
2897 cx,
2898 );
2899
2900 reference.expand_excerpts(&excerpts, line_count, cx);
2901 });
2902 }
2903 20..=29 if !reference.excerpts.is_empty() => {
2904 let mut excerpts_to_remove = vec![];
2905 for _ in 0..rng.random_range(1..=3) {
2906 let Some(excerpt) = reference.excerpts.choose(&mut rng) else {
2907 break;
2908 };
2909 let info = cx.update(|cx| excerpt.info(cx));
2910 cx.update(|cx| reference.remove_excerpt(info, cx));
2911 excerpts_to_remove.push(info);
2912 }
2913 let snapshot =
2914 multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
2915 excerpts_to_remove.sort_unstable_by(|a, b| {
2916 let a_anchor = Anchor::in_buffer(a.path_key_index, a.range.context.start);
2917 let b_anchor = Anchor::in_buffer(b.path_key_index, b.range.context.start);
2918 a_anchor.cmp(&b_anchor, &snapshot)
2919 });
2920 drop(snapshot);
2921 multibuffer.update(cx, |multibuffer, cx| {
2922 multibuffer.remove_excerpts(excerpts_to_remove, cx)
2923 });
2924 }
2925 30..=39 if !reference.excerpts.is_empty() => {
2926 let multibuffer =
2927 multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
2928 let offset = multibuffer.clip_offset(
2929 MultiBufferOffset(rng.random_range(0..=multibuffer.len().0)),
2930 Bias::Left,
2931 );
2932 let bias = if rng.random() {
2933 Bias::Left
2934 } else {
2935 Bias::Right
2936 };
2937 log::info!("Creating anchor at {} with bias {:?}", offset.0, bias);
2938 anchors.push(multibuffer.anchor_at(offset, bias));
2939 anchors.sort_by(|a, b| a.cmp(b, &multibuffer));
2940 }
2941 40..=44 => todo!("refresh anchors was here"),
2942 45..=55 if !reference.excerpts.is_empty() => {
2943 multibuffer.update(cx, |multibuffer, cx| {
2944 let snapshot = multibuffer.snapshot(cx);
2945 let excerpt_ix = rng.random_range(0..reference.excerpts.len());
2946 let excerpt = &reference.excerpts[excerpt_ix];
2947
2948 // Skip inverted excerpts - hunks can't be collapsed
2949 let buffer_id = excerpt.buffer.read(cx).remote_id();
2950 if reference.inverted_diffs.contains_key(&buffer_id) {
2951 return;
2952 }
2953
2954 let start = excerpt.range.start;
2955 let end = excerpt.range.end;
2956 let range = snapshot.anchor_in_buffer(excerpt.info(cx).buffer_id, start).unwrap()
2957 ..snapshot.anchor_in_buffer(excerpt.info(cx).buffer_id, end).unwrap();
2958
2959 log::info!(
2960 "expanding diff hunks in range {:?} (excerpt index {excerpt_ix:?}, buffer id {:?})",
2961 range.to_offset(&snapshot),
2962 buffer_id,
2963 );
2964 reference.expand_diff_hunks(excerpt.path_key.clone(), start..end, cx);
2965 multibuffer.expand_diff_hunks(vec![range], cx);
2966 });
2967 }
2968 56..=85 if needs_diff_calculation => {
2969 multibuffer.update(cx, |multibuffer, cx| {
2970 for buffer in multibuffer.all_buffers() {
2971 let snapshot = buffer.read(cx).snapshot();
2972 let buffer_id = snapshot.remote_id();
2973
2974 if let Some(diff) = multibuffer.diff_for(buffer_id) {
2975 diff.update(cx, |diff, cx| {
2976 log::info!("recalculating diff for buffer {:?}", buffer_id,);
2977 diff.recalculate_diff_sync(&snapshot.text, cx);
2978 });
2979 }
2980
2981 if let Some(inverted_diff) = inverted_diff_main_buffers.get(&buffer_id) {
2982 inverted_diff.update(cx, |diff, cx| {
2983 log::info!(
2984 "recalculating inverted diff for main buffer {:?}",
2985 buffer_id,
2986 );
2987 diff.recalculate_diff_sync(&snapshot.text, cx);
2988 });
2989 }
2990 }
2991 reference.diffs_updated(cx);
2992 needs_diff_calculation = false;
2993 });
2994 }
2995 _ => {
2996 // Decide if we're creating a new buffer or reusing an existing one
2997 let create_new_buffer = buffers.is_empty() || rng.random_bool(0.4);
2998
2999 let (excerpt_buffer, diff, inverted_main_buffer) = if create_new_buffer {
3000 let create_inverted = rng.random_bool(0.3);
3001
3002 if create_inverted {
3003 let mut main_buffer_text = util::RandomCharIter::new(&mut rng)
3004 .take(256)
3005 .collect::<String>();
3006 let main_buffer = cx.new(|cx| Buffer::local(main_buffer_text.clone(), cx));
3007 text::LineEnding::normalize(&mut main_buffer_text);
3008 let main_buffer_id =
3009 main_buffer.read_with(cx, |buffer, _| buffer.remote_id());
3010 base_texts.insert(main_buffer_id, main_buffer_text.clone());
3011 buffers.push(main_buffer.clone());
3012
3013 let diff = cx.new(|cx| {
3014 BufferDiff::new_with_base_text(
3015 &main_buffer_text,
3016 &main_buffer.read(cx).text_snapshot(),
3017 cx,
3018 )
3019 });
3020
3021 let base_text_buffer =
3022 diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
3023
3024 // Track for recalculation when main buffer is edited
3025 inverted_diff_main_buffers.insert(main_buffer_id, diff.clone());
3026
3027 (base_text_buffer, diff, Some(main_buffer))
3028 } else {
3029 let mut base_text = util::RandomCharIter::new(&mut rng)
3030 .take(256)
3031 .collect::<String>();
3032
3033 let buffer_handle = cx.new(|cx| Buffer::local(base_text.clone(), cx));
3034 text::LineEnding::normalize(&mut base_text);
3035 let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());
3036 base_texts.insert(buffer_id, base_text.clone());
3037 buffers.push(buffer_handle.clone());
3038
3039 let diff = cx.new(|cx| {
3040 BufferDiff::new_with_base_text(
3041 &base_text,
3042 &buffer_handle.read(cx).text_snapshot(),
3043 cx,
3044 )
3045 });
3046
3047 (buffer_handle, diff, None)
3048 }
3049 } else {
3050 // Reuse an existing buffer
3051 let buffer_handle = buffers.choose(&mut rng).unwrap().clone();
3052 let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());
3053
3054 if let Some(diff) = inverted_diff_main_buffers.get(&buffer_id) {
3055 let base_text_buffer =
3056 diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
3057 (base_text_buffer, diff.clone(), Some(buffer_handle))
3058 } else {
3059 // Get existing diff or create new one for regular buffer
3060 let diff = multibuffer
3061 .read_with(cx, |mb, _| mb.diff_for(buffer_id))
3062 .unwrap_or_else(|| {
3063 let base_text = base_texts.get(&buffer_id).unwrap();
3064 cx.new(|cx| {
3065 BufferDiff::new_with_base_text(
3066 base_text,
3067 &buffer_handle.read(cx).text_snapshot(),
3068 cx,
3069 )
3070 })
3071 });
3072 (buffer_handle, diff, None)
3073 }
3074 };
3075
3076 let mut ranges = reference
3077 .excerpts
3078 .iter()
3079 .map(|excerpt| excerpt.range.clone());
3080 excerpt_buffer.read_with(cx, |buffer, cx| {
3081 mutate_excerpt_ranges(&mut rng, &mut ranges, &buffer.snapshot(), 1);
3082 });
3083
3084 let ranges = ranges
3085 .into_iter()
3086 .map(ExcerptRange::new)
3087 .collect::<Vec<_>>();
3088
3089 let (_, path_key_index, _) = multibuffer.update(cx, |multibuffer, cx| {
3090 let excerpt_buffer_snapshot = excerpt_buffer.read(cx).snapshot();
3091 multibuffer.set_excerpt_ranges_for_path(
3092 path,
3093 excerpt_buffer,
3094 &excerpt_buffer_snapshot,
3095 ranges,
3096 cx,
3097 )
3098 });
3099
3100 let path_key_index =
3101 reference.set_excerpts(path, path_key_index, excerpt_buffer, ranges);
3102
3103 let excerpt_buffer_id =
3104 excerpt_buffer.read_with(cx, |buffer, _| buffer.remote_id());
3105 multibuffer.update(cx, |multibuffer, cx| {
3106 if multibuffer.diff_for(excerpt_buffer_id).is_none() {
3107 if let Some(main_buffer) = inverted_main_buffer {
3108 reference.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);
3109 multibuffer.add_inverted_diff(diff, main_buffer, cx);
3110 } else {
3111 reference.add_diff(diff.clone(), cx);
3112 multibuffer.add_diff(diff, cx);
3113 }
3114 }
3115 });
3116 }
3117 }
3118
3119 if rng.random_bool(0.3) {
3120 multibuffer.update(cx, |multibuffer, cx| {
3121 old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));
3122 })
3123 }
3124
3125 multibuffer.read_with(cx, |multibuffer, cx| {
3126 check_multibuffer(multibuffer, &reference, &anchors, cx, &mut rng);
3127 });
3128 }
3129 let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
3130 for (old_snapshot, subscription) in old_versions {
3131 check_multibuffer_edits(&snapshot, &old_snapshot, subscription);
3132 }
3133}
3134
3135fn mutate_excerpt_ranges(
3136 rng: &mut StdRng,
3137 existing_ranges: &mut Vec<Range<text::Anchor>>,
3138 buffer: &BufferSnapshot,
3139 operations: u32,
3140) {
3141 let mut indices_to_remove = HashSet::default();
3142 let mut ranges_to_add = Vec::new();
3143
3144 for _ in 0..operations {
3145 match rng.random_range(0..5) {
3146 0..=1 if !existing_ranges.is_empty() => {
3147 log::info!(
3148 "Removing excerpt at {} of {} for buffer {}: {:?}[{:?}] = {:?}",
3149 excerpt_ix,
3150 reference.excerpts.len(),
3151 buffer.remote_id(),
3152 buffer.text(),
3153 start_ix..end_ix,
3154 &buffer.text()[start_ix..end_ix]
3155 );
3156 let index = existing_ranges.choose(rng).unwrap();
3157 existing_ranges.remove(index);
3158 }
3159 _ => {
3160 log::info!(
3161 "Inserting excerpt at {} of {} for buffer {}: {:?}[{:?}] = {:?}",
3162 excerpt_ix,
3163 reference.excerpts.len(),
3164 buffer.remote_id(),
3165 buffer.text(),
3166 start_ix..end_ix,
3167 &buffer.text()[start_ix..end_ix]
3168 );
3169 let end_row = rng.random_range(0..=buffer.max_point().row);
3170 let start_row = rng.random_range(0..=end_row);
3171 let end_ix = buffer.point_to_offset(Point::new(end_row, 0));
3172 let start_ix = buffer.point_to_offset(Point::new(start_row, 0));
3173 let anchor_range = buffer.anchor_before(start_ix)..buffer.anchor_after(end_ix);
3174 ranges_to_add.push(anchor_range);
3175 }
3176 }
3177 }
3178
3179 existing_ranges.extend(ranges_to_add);
3180 existing_ranges.sort_by(|l, r| l.start.cmp(&r.start, buffer));
3181}
3182
3183fn check_multibuffer(
3184 multibuffer: &MultiBuffer,
3185 reference: &ReferenceMultibuffer,
3186 anchors: &[Anchor],
3187 cx: &App,
3188 rng: &mut StdRng,
3189) {
3190 let snapshot = multibuffer.snapshot(cx);
3191 let actual_text = snapshot.text();
3192 let actual_boundary_rows = snapshot
3193 .excerpt_boundaries_in_range(MultiBufferOffset(0)..)
3194 .map(|b| b.row)
3195 .collect::<HashSet<_>>();
3196 let actual_row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
3197
3198 let (expected_text, expected_row_infos, expected_boundary_rows) =
3199 reference.expected_content(cx);
3200
3201 let has_diff = actual_row_infos
3202 .iter()
3203 .any(|info| info.diff_status.is_some())
3204 || expected_row_infos
3205 .iter()
3206 .any(|info| info.diff_status.is_some());
3207 let actual_diff = format_diff(
3208 &actual_text,
3209 &actual_row_infos,
3210 &actual_boundary_rows,
3211 Some(has_diff),
3212 );
3213 let expected_diff = format_diff(
3214 &expected_text,
3215 &expected_row_infos,
3216 &expected_boundary_rows,
3217 Some(has_diff),
3218 );
3219
3220 log::info!("Multibuffer content:\n{}", actual_diff);
3221
3222 assert_eq!(
3223 actual_row_infos.len(),
3224 actual_text.split('\n').count(),
3225 "line count: {}",
3226 actual_text.split('\n').count()
3227 );
3228 pretty_assertions::assert_eq!(actual_diff, expected_diff);
3229 pretty_assertions::assert_eq!(actual_text, expected_text);
3230 pretty_assertions::assert_eq!(actual_row_infos, expected_row_infos);
3231
3232 for _ in 0..5 {
3233 let start_row = rng.random_range(0..=expected_row_infos.len());
3234 assert_eq!(
3235 snapshot
3236 .row_infos(MultiBufferRow(start_row as u32))
3237 .collect::<Vec<_>>(),
3238 &expected_row_infos[start_row..],
3239 "buffer_rows({})",
3240 start_row
3241 );
3242 }
3243
3244 assert_eq!(
3245 snapshot.widest_line_number(),
3246 expected_row_infos
3247 .into_iter()
3248 .filter_map(|info| {
3249 // For inverted diffs, deleted rows are visible and should be counted.
3250 // Only filter out deleted rows that are NOT from inverted diffs.
3251 let is_inverted_diff = info
3252 .buffer_id
3253 .is_some_and(|id| reference.inverted_diffs.contains_key(&id));
3254 if info.diff_status.is_some_and(|status| status.is_deleted()) && !is_inverted_diff {
3255 None
3256 } else {
3257 info.buffer_row
3258 }
3259 })
3260 .max()
3261 .unwrap()
3262 + 1
3263 );
3264 let reference_ranges = reference
3265 .excerpts
3266 .iter()
3267 .map(|excerpt| {
3268 (
3269 excerpt.id,
3270 excerpt.range.to_offset(&excerpt.buffer.read(cx).snapshot()),
3271 )
3272 })
3273 .collect::<HashMap<_, _>>();
3274 for i in 0..snapshot.len().0 {
3275 let excerpt = snapshot
3276 .excerpt_containing(MultiBufferOffset(i)..MultiBufferOffset(i))
3277 .unwrap();
3278 assert_eq!(
3279 excerpt.buffer_range().start.0..excerpt.buffer_range().end.0,
3280 reference_ranges[&excerpt.id()]
3281 );
3282 }
3283
3284 assert_consistent_line_numbers(&snapshot);
3285 assert_position_translation(&snapshot);
3286
3287 for (row, line) in expected_text.split('\n').enumerate() {
3288 assert_eq!(
3289 snapshot.line_len(MultiBufferRow(row as u32)),
3290 line.len() as u32,
3291 "line_len({}).",
3292 row
3293 );
3294 }
3295
3296 let text_rope = Rope::from(expected_text.as_str());
3297 for _ in 0..10 {
3298 let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
3299 let start_ix = text_rope.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
3300
3301 let text_for_range = snapshot
3302 .text_for_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))
3303 .collect::<String>();
3304 assert_eq!(
3305 text_for_range,
3306 &expected_text[start_ix..end_ix],
3307 "incorrect text for range {:?}",
3308 start_ix..end_ix
3309 );
3310
3311 let expected_summary =
3312 MBTextSummary::from(TextSummary::from(&expected_text[start_ix..end_ix]));
3313 assert_eq!(
3314 snapshot.text_summary_for_range::<MBTextSummary, _>(
3315 MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix)
3316 ),
3317 expected_summary,
3318 "incorrect summary for range {:?}",
3319 start_ix..end_ix
3320 );
3321 }
3322
3323 // Anchor resolution
3324 let summaries = snapshot.summaries_for_anchors::<MultiBufferOffset, _>(anchors);
3325 assert_eq!(anchors.len(), summaries.len());
3326 for (anchor, resolved_offset) in anchors.iter().zip(summaries) {
3327 assert!(resolved_offset <= snapshot.len());
3328 assert_eq!(
3329 snapshot.summary_for_anchor::<MultiBufferOffset>(anchor),
3330 resolved_offset,
3331 "anchor: {:?}",
3332 anchor
3333 );
3334 }
3335
3336 for _ in 0..10 {
3337 let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
3338 assert_eq!(
3339 snapshot
3340 .reversed_chars_at(MultiBufferOffset(end_ix))
3341 .collect::<String>(),
3342 expected_text[..end_ix].chars().rev().collect::<String>(),
3343 );
3344 }
3345
3346 for _ in 0..10 {
3347 let end_ix = rng.random_range(0..=text_rope.len());
3348 let end_ix = text_rope.floor_char_boundary(end_ix);
3349 let start_ix = rng.random_range(0..=end_ix);
3350 let start_ix = text_rope.floor_char_boundary(start_ix);
3351 assert_eq!(
3352 snapshot
3353 .bytes_in_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))
3354 .flatten()
3355 .copied()
3356 .collect::<Vec<_>>(),
3357 expected_text.as_bytes()[start_ix..end_ix].to_vec(),
3358 "bytes_in_range({:?})",
3359 start_ix..end_ix,
3360 );
3361 }
3362}
3363
3364fn check_multibuffer_edits(
3365 snapshot: &MultiBufferSnapshot,
3366 old_snapshot: &MultiBufferSnapshot,
3367 subscription: Subscription<MultiBufferOffset>,
3368) {
3369 let edits = subscription.consume().into_inner();
3370
3371 log::info!(
3372 "applying subscription edits to old text: {:?}: {:#?}",
3373 old_snapshot.text(),
3374 edits,
3375 );
3376
3377 let mut text = old_snapshot.text();
3378 for edit in edits {
3379 let new_text: String = snapshot
3380 .text_for_range(edit.new.start..edit.new.end)
3381 .collect();
3382 text.replace_range(
3383 (edit.new.start.0..edit.new.start.0 + (edit.old.end.0 - edit.old.start.0)).clone(),
3384 &new_text,
3385 );
3386 pretty_assertions::assert_eq!(
3387 &text[0..edit.new.end.0],
3388 snapshot
3389 .text_for_range(MultiBufferOffset(0)..edit.new.end)
3390 .collect::<String>()
3391 );
3392 }
3393 pretty_assertions::assert_eq!(text, snapshot.text());
3394}
3395
3396#[gpui::test]
3397fn test_history(cx: &mut App) {
3398 let test_settings = SettingsStore::test(cx);
3399 cx.set_global(test_settings);
3400
3401 let group_interval: Duration = Duration::from_millis(1);
3402 let buffer_1 = cx.new(|cx| {
3403 let mut buf = Buffer::local("1234", cx);
3404 buf.set_group_interval(group_interval);
3405 buf
3406 });
3407 let buffer_2 = cx.new(|cx| {
3408 let mut buf = Buffer::local("5678", cx);
3409 buf.set_group_interval(group_interval);
3410 buf
3411 });
3412 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
3413 multibuffer.update(cx, |this, _| {
3414 this.set_group_interval(group_interval);
3415 });
3416 multibuffer.update(cx, |multibuffer, cx| {
3417 multibuffer.set_excerpts_for_path(
3418 PathKey::sorted(0),
3419 buffer_1.clone(),
3420 [Point::zero()..buffer_1.read(cx).max_point()],
3421 0,
3422 cx,
3423 );
3424 multibuffer.set_excerpts_for_path(
3425 PathKey::sorted(1),
3426 buffer_2.clone(),
3427 [Point::zero()..buffer_2.read(cx).max_point()],
3428 0,
3429 cx,
3430 );
3431 });
3432
3433 let mut now = Instant::now();
3434
3435 multibuffer.update(cx, |multibuffer, cx| {
3436 let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();
3437 multibuffer.edit(
3438 [
3439 (Point::new(0, 0)..Point::new(0, 0), "A"),
3440 (Point::new(1, 0)..Point::new(1, 0), "A"),
3441 ],
3442 None,
3443 cx,
3444 );
3445 multibuffer.edit(
3446 [
3447 (Point::new(0, 1)..Point::new(0, 1), "B"),
3448 (Point::new(1, 1)..Point::new(1, 1), "B"),
3449 ],
3450 None,
3451 cx,
3452 );
3453 multibuffer.end_transaction_at(now, cx);
3454 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
3455
3456 // Verify edited ranges for transaction 1
3457 assert_eq!(
3458 multibuffer.edited_ranges_for_transaction(transaction_1, cx),
3459 &[
3460 MultiBufferOffset(0)..MultiBufferOffset(2),
3461 MultiBufferOffset(7)..MultiBufferOffset(9),
3462 ]
3463 );
3464
3465 // Edit buffer 1 through the multibuffer
3466 now += 2 * group_interval;
3467 multibuffer.start_transaction_at(now, cx);
3468 multibuffer.edit(
3469 [(MultiBufferOffset(2)..MultiBufferOffset(2), "C")],
3470 None,
3471 cx,
3472 );
3473 multibuffer.end_transaction_at(now, cx);
3474 assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");
3475
3476 // Edit buffer 1 independently
3477 buffer_1.update(cx, |buffer_1, cx| {
3478 buffer_1.start_transaction_at(now);
3479 buffer_1.edit([(3..3, "D")], None, cx);
3480 buffer_1.end_transaction_at(now, cx);
3481
3482 now += 2 * group_interval;
3483 buffer_1.start_transaction_at(now);
3484 buffer_1.edit([(4..4, "E")], None, cx);
3485 buffer_1.end_transaction_at(now, cx);
3486 });
3487 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
3488
3489 // An undo in the multibuffer undoes the multibuffer transaction
3490 // and also any individual buffer edits that have occurred since
3491 // that transaction.
3492 multibuffer.undo(cx);
3493 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
3494
3495 multibuffer.undo(cx);
3496 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
3497
3498 multibuffer.redo(cx);
3499 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
3500
3501 multibuffer.redo(cx);
3502 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
3503
3504 // Undo buffer 2 independently.
3505 buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));
3506 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");
3507
3508 // An undo in the multibuffer undoes the components of the
3509 // the last multibuffer transaction that are not already undone.
3510 multibuffer.undo(cx);
3511 assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");
3512
3513 multibuffer.undo(cx);
3514 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
3515
3516 multibuffer.redo(cx);
3517 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
3518
3519 buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));
3520 assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
3521
3522 // Redo stack gets cleared after an edit.
3523 now += 2 * group_interval;
3524 multibuffer.start_transaction_at(now, cx);
3525 multibuffer.edit(
3526 [(MultiBufferOffset(0)..MultiBufferOffset(0), "X")],
3527 None,
3528 cx,
3529 );
3530 multibuffer.end_transaction_at(now, cx);
3531 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
3532 multibuffer.redo(cx);
3533 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
3534 multibuffer.undo(cx);
3535 assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
3536 multibuffer.undo(cx);
3537 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
3538
3539 // Transactions can be grouped manually.
3540 multibuffer.redo(cx);
3541 multibuffer.redo(cx);
3542 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
3543 multibuffer.group_until_transaction(transaction_1, cx);
3544 multibuffer.undo(cx);
3545 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
3546 multibuffer.redo(cx);
3547 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
3548 });
3549}
3550
3551#[gpui::test]
3552async fn test_enclosing_indent(cx: &mut TestAppContext) {
3553 async fn enclosing_indent(
3554 text: &str,
3555 buffer_row: u32,
3556 cx: &mut TestAppContext,
3557 ) -> Option<(Range<u32>, LineIndent)> {
3558 let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
3559 let snapshot = cx.read(|cx| buffer.read(cx).snapshot(cx));
3560 let (range, indent) = snapshot
3561 .enclosing_indent(MultiBufferRow(buffer_row))
3562 .await?;
3563 Some((range.start.0..range.end.0, indent))
3564 }
3565
3566 assert_eq!(
3567 enclosing_indent(
3568 indoc!(
3569 "
3570 fn b() {
3571 if c {
3572 let d = 2;
3573 }
3574 }
3575 "
3576 ),
3577 1,
3578 cx,
3579 )
3580 .await,
3581 Some((
3582 1..2,
3583 LineIndent {
3584 tabs: 0,
3585 spaces: 4,
3586 line_blank: false,
3587 }
3588 ))
3589 );
3590
3591 assert_eq!(
3592 enclosing_indent(
3593 indoc!(
3594 "
3595 fn b() {
3596 if c {
3597 let d = 2;
3598 }
3599 }
3600 "
3601 ),
3602 2,
3603 cx,
3604 )
3605 .await,
3606 Some((
3607 1..2,
3608 LineIndent {
3609 tabs: 0,
3610 spaces: 4,
3611 line_blank: false,
3612 }
3613 ))
3614 );
3615
3616 assert_eq!(
3617 enclosing_indent(
3618 indoc!(
3619 "
3620 fn b() {
3621 if c {
3622 let d = 2;
3623
3624 let e = 5;
3625 }
3626 }
3627 "
3628 ),
3629 3,
3630 cx,
3631 )
3632 .await,
3633 Some((
3634 1..4,
3635 LineIndent {
3636 tabs: 0,
3637 spaces: 4,
3638 line_blank: false,
3639 }
3640 ))
3641 );
3642}
3643
3644#[gpui::test]
3645async fn test_summaries_for_anchors(cx: &mut TestAppContext) {
3646 let base_text_1 = indoc!(
3647 "
3648 bar
3649 "
3650 );
3651 let text_1 = indoc!(
3652 "
3653 BAR
3654 "
3655 );
3656 let base_text_2 = indoc!(
3657 "
3658 foo
3659 "
3660 );
3661 let text_2 = indoc!(
3662 "
3663 FOO
3664 "
3665 );
3666
3667 let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
3668 let buffer_2 = cx.new(|cx| Buffer::local(text_2, cx));
3669 let diff_1 = cx.new(|cx| {
3670 BufferDiff::new_with_base_text(base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
3671 });
3672 let diff_2 = cx.new(|cx| {
3673 BufferDiff::new_with_base_text(base_text_2, &buffer_2.read(cx).text_snapshot(), cx)
3674 });
3675 cx.run_until_parked();
3676
3677 let mut ids = vec![];
3678 let multibuffer = cx.new(|cx| {
3679 let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
3680 multibuffer.set_all_diff_hunks_expanded(cx);
3681 multibuffer.set_excerpts_for_path(
3682 PathKey::sorted(0),
3683 buffer_1.clone(),
3684 [Point::zero()..buffer_1.read(cx).max_point()],
3685 0,
3686 cx,
3687 );
3688 multibuffer.set_excerpts_for_path(
3689 PathKey::sorted(1),
3690 buffer_2.clone(),
3691 [Point::zero()..buffer_2.read(cx).max_point()],
3692 0,
3693 cx,
3694 );
3695 multibuffer.add_diff(diff_1.clone(), cx);
3696 multibuffer.add_diff(diff_2.clone(), cx);
3697 ids = multibuffer.excerpt_ids();
3698 multibuffer
3699 });
3700
3701 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
3702 (multibuffer.snapshot(cx), multibuffer.subscribe())
3703 });
3704
3705 assert_new_snapshot(
3706 &multibuffer,
3707 &mut snapshot,
3708 &mut subscription,
3709 cx,
3710 indoc!(
3711 "
3712 - bar
3713 + BAR
3714
3715 - foo
3716 + FOO
3717 "
3718 ),
3719 );
3720
3721 let anchor_1 = Anchor::text(ids[0], text::Anchor::MIN);
3722 let point_1 = snapshot.summaries_for_anchors::<Point, _>([&anchor_1])[0];
3723 assert_eq!(point_1, Point::new(0, 0));
3724
3725 let anchor_2 = Anchor::text(ids[1], text::Anchor::MIN);
3726 let point_2 = snapshot.summaries_for_anchors::<Point, _>([&anchor_2])[0];
3727 assert_eq!(point_2, Point::new(3, 0));
3728}
3729
3730#[gpui::test]
3731async fn test_trailing_deletion_without_newline(cx: &mut TestAppContext) {
3732 let base_text_1 = "one\ntwo".to_owned();
3733 let text_1 = "one\n".to_owned();
3734
3735 let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
3736 let diff_1 = cx.new(|cx| {
3737 BufferDiff::new_with_base_text(&base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
3738 });
3739 cx.run_until_parked();
3740
3741 let multibuffer = cx.new(|cx| {
3742 let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
3743 multibuffer.set_excerpts_for_path(
3744 PathKey::sorted(0),
3745 buffer_1.clone(),
3746 [Point::zero()..buffer_1.read(cx).max_point()],
3747 0,
3748 cx,
3749 );
3750 multibuffer.add_diff(diff_1.clone(), cx);
3751 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
3752 multibuffer
3753 });
3754
3755 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
3756 (multibuffer.snapshot(cx), multibuffer.subscribe())
3757 });
3758
3759 assert_new_snapshot(
3760 &multibuffer,
3761 &mut snapshot,
3762 &mut subscription,
3763 cx,
3764 indoc!(
3765 "
3766 one
3767 - two
3768 "
3769 ),
3770 );
3771
3772 assert_eq!(snapshot.max_point(), Point::new(2, 0));
3773 assert_eq!(snapshot.len().0, 8);
3774
3775 assert_eq!(
3776 snapshot
3777 .dimensions_from_points::<Point>([Point::new(2, 0)])
3778 .collect::<Vec<_>>(),
3779 vec![Point::new(2, 0)]
3780 );
3781
3782 let (_, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();
3783 assert_eq!(translated_offset.0, "one\n".len());
3784 let (_, translated_point, _) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();
3785 assert_eq!(translated_point, Point::new(1, 0));
3786
3787 // The same, for an excerpt that's not at the end of the multibuffer.
3788
3789 let text_2 = "foo\n".to_owned();
3790 let buffer_2 = cx.new(|cx| Buffer::local(&text_2, cx));
3791 multibuffer.update(cx, |multibuffer, cx| {
3792 multibuffer.set_excerpt_ranges_for_path(
3793 PathKey::sorted(1),
3794 buffer_2.clone(),
3795 &buffer_2.read(cx).snapshot(),
3796 vec![ExcerptRange::new(Point::new(0, 0)..Point::new(1, 0))],
3797 cx,
3798 );
3799 });
3800
3801 assert_new_snapshot(
3802 &multibuffer,
3803 &mut snapshot,
3804 &mut subscription,
3805 cx,
3806 indoc!(
3807 "
3808 one
3809 - two
3810
3811 foo
3812 "
3813 ),
3814 );
3815
3816 assert_eq!(
3817 snapshot
3818 .dimensions_from_points::<Point>([Point::new(2, 0)])
3819 .collect::<Vec<_>>(),
3820 vec![Point::new(2, 0)]
3821 );
3822
3823 let buffer_1_id = buffer_1.read_with(cx, |buffer_1, _| buffer_1.remote_id());
3824 let (buffer, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();
3825 assert_eq!(buffer.remote_id(), buffer_1_id);
3826 assert_eq!(translated_offset.0, "one\n".len());
3827 let (buffer, translated_point, _) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();
3828 assert_eq!(buffer.remote_id(), buffer_1_id);
3829 assert_eq!(translated_point, Point::new(1, 0));
3830}
3831
3832fn format_diff(
3833 text: &str,
3834 row_infos: &Vec<RowInfo>,
3835 boundary_rows: &HashSet<MultiBufferRow>,
3836 has_diff: Option<bool>,
3837) -> String {
3838 let has_diff =
3839 has_diff.unwrap_or_else(|| row_infos.iter().any(|info| info.diff_status.is_some()));
3840 text.split('\n')
3841 .enumerate()
3842 .zip(row_infos)
3843 .map(|((ix, line), info)| {
3844 let marker = match info.diff_status.map(|status| status.kind) {
3845 Some(DiffHunkStatusKind::Added) => "+ ",
3846 Some(DiffHunkStatusKind::Deleted) => "- ",
3847 Some(DiffHunkStatusKind::Modified) => unreachable!(),
3848 None => {
3849 if has_diff && !line.is_empty() {
3850 " "
3851 } else {
3852 ""
3853 }
3854 }
3855 };
3856 let boundary_row = if boundary_rows.contains(&MultiBufferRow(ix as u32)) {
3857 if has_diff {
3858 " ----------\n"
3859 } else {
3860 "---------\n"
3861 }
3862 } else {
3863 ""
3864 };
3865 let expand = info
3866 .expand_info
3867 .map(|expand_info| match expand_info.direction {
3868 ExpandExcerptDirection::Up => " [↑]",
3869 ExpandExcerptDirection::Down => " [↓]",
3870 ExpandExcerptDirection::UpAndDown => " [↕]",
3871 })
3872 .unwrap_or_default();
3873
3874 format!("{boundary_row}{marker}{line}{expand}")
3875 // let mbr = info
3876 // .multibuffer_row
3877 // .map(|row| format!("{:0>3}", row.0))
3878 // .unwrap_or_else(|| "???".to_string());
3879 // let byte_range = format!("{byte_range_start:0>3}..{byte_range_end:0>3}");
3880 // format!("{boundary_row}Row: {mbr}, Bytes: {byte_range} | {marker}{line}{expand}")
3881 })
3882 .collect::<Vec<_>>()
3883 .join("\n")
3884}
3885
3886// fn format_transforms(snapshot: &MultiBufferSnapshot) -> String {
3887// snapshot
3888// .diff_transforms
3889// .iter()
3890// .map(|transform| {
3891// let (kind, summary) = match transform {
3892// DiffTransform::DeletedHunk { summary, .. } => (" Deleted", (*summary).into()),
3893// DiffTransform::FilteredInsertedHunk { summary, .. } => (" Filtered", *summary),
3894// DiffTransform::InsertedHunk { summary, .. } => (" Inserted", *summary),
3895// DiffTransform::Unmodified { summary, .. } => ("Unmodified", *summary),
3896// };
3897// format!("{kind}(len: {}, lines: {:?})", summary.len, summary.lines)
3898// })
3899// .join("\n")
3900// }
3901
3902// fn format_excerpts(snapshot: &MultiBufferSnapshot) -> String {
3903// snapshot
3904// .excerpts
3905// .iter()
3906// .map(|excerpt| {
3907// format!(
3908// "Excerpt(buffer_range = {:?}, lines = {:?}, has_trailing_newline = {:?})",
3909// excerpt.range.context.to_point(&excerpt.buffer),
3910// excerpt.text_summary.lines,
3911// excerpt.has_trailing_newline
3912// )
3913// })
3914// .join("\n")
3915// }
3916
3917#[gpui::test]
3918async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {
3919 let text = indoc!(
3920 "
3921 ZERO
3922 one
3923 TWO
3924 three
3925 six
3926 "
3927 );
3928 let base_text = indoc!(
3929 "
3930 one
3931 two
3932 three
3933 four
3934 five
3935 six
3936 "
3937 );
3938
3939 let buffer = cx.new(|cx| Buffer::local(text, cx));
3940 let diff = cx
3941 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
3942 cx.run_until_parked();
3943
3944 let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
3945
3946 let multibuffer = cx.new(|cx| {
3947 let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
3948 multibuffer.set_all_diff_hunks_expanded(cx);
3949 multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);
3950 multibuffer
3951 });
3952
3953 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
3954 (multibuffer.snapshot(cx), multibuffer.subscribe())
3955 });
3956
3957 assert_eq!(snapshot.text(), base_text);
3958 assert_new_snapshot(
3959 &multibuffer,
3960 &mut snapshot,
3961 &mut subscription,
3962 cx,
3963 indoc!(
3964 "
3965 one
3966 - two
3967 three
3968 - four
3969 - five
3970 six
3971 "
3972 ),
3973 );
3974
3975 buffer.update(cx, |buffer, cx| {
3976 buffer.edit_via_marked_text(
3977 indoc!(
3978 "
3979 ZERO
3980 one
3981 «<inserted>»W«O
3982 T»hree
3983 six
3984 "
3985 ),
3986 None,
3987 cx,
3988 );
3989 });
3990 cx.run_until_parked();
3991 let update = diff
3992 .update(cx, |diff, cx| {
3993 diff.update_diff(
3994 buffer.read(cx).text_snapshot(),
3995 Some(base_text.into()),
3996 None,
3997 None,
3998 cx,
3999 )
4000 })
4001 .await;
4002 diff.update(cx, |diff, cx| {
4003 diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
4004 })
4005 .await;
4006 cx.run_until_parked();
4007
4008 assert_new_snapshot(
4009 &multibuffer,
4010 &mut snapshot,
4011 &mut subscription,
4012 cx,
4013 indoc! {
4014 "
4015 one
4016 - two
4017 - three
4018 - four
4019 - five
4020 six
4021 "
4022 },
4023 );
4024
4025 buffer.update(cx, |buffer, cx| {
4026 buffer.set_text("ZERO\nONE\nTWO\n", cx);
4027 });
4028 cx.run_until_parked();
4029 let update = diff
4030 .update(cx, |diff, cx| {
4031 diff.update_diff(
4032 buffer.read(cx).text_snapshot(),
4033 Some(base_text.into()),
4034 None,
4035 None,
4036 cx,
4037 )
4038 })
4039 .await;
4040 diff.update(cx, |diff, cx| {
4041 diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
4042 })
4043 .await;
4044 cx.run_until_parked();
4045
4046 assert_new_snapshot(
4047 &multibuffer,
4048 &mut snapshot,
4049 &mut subscription,
4050 cx,
4051 indoc! {
4052 "
4053 - one
4054 - two
4055 - three
4056 - four
4057 - five
4058 - six
4059 "
4060 },
4061 );
4062
4063 diff.update(cx, |diff, cx| {
4064 diff.set_base_text(
4065 Some("new base\n".into()),
4066 None,
4067 buffer.read(cx).text_snapshot(),
4068 cx,
4069 )
4070 })
4071 .await
4072 .unwrap();
4073 cx.run_until_parked();
4074
4075 assert_new_snapshot(
4076 &multibuffer,
4077 &mut snapshot,
4078 &mut subscription,
4079 cx,
4080 indoc! {"
4081 - new base
4082 "},
4083 );
4084}
4085
4086#[gpui::test]
4087async fn test_inverted_diff_base_text_change(cx: &mut TestAppContext) {
4088 let base_text = "aaa\nbbb\nccc\n";
4089 let text = "ddd\n";
4090 let buffer = cx.new(|cx| Buffer::local(text, cx));
4091 let diff = cx
4092 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
4093 cx.run_until_parked();
4094
4095 let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
4096
4097 let multibuffer = cx.new(|cx| {
4098 let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
4099 multibuffer.set_all_diff_hunks_expanded(cx);
4100 multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);
4101 multibuffer
4102 });
4103
4104 let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
4105 (multibuffer.snapshot(cx), multibuffer.subscribe())
4106 });
4107
4108 assert_eq!(snapshot.text(), base_text);
4109 assert_new_snapshot(
4110 &multibuffer,
4111 &mut snapshot,
4112 &mut subscription,
4113 cx,
4114 indoc!(
4115 "
4116 - aaa
4117 - bbb
4118 - ccc
4119 "
4120 ),
4121 );
4122
4123 let update = diff
4124 .update(cx, |diff, cx| {
4125 diff.update_diff(
4126 buffer.read(cx).text_snapshot(),
4127 Some("ddd\n".into()),
4128 Some(true),
4129 None,
4130 cx,
4131 )
4132 })
4133 .await;
4134 diff.update(cx, |diff, cx| {
4135 diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
4136 })
4137 .detach();
4138
4139 let _hunks: Vec<_> = multibuffer
4140 .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
4141 .diff_hunks()
4142 .collect();
4143}
4144
4145#[gpui::test]
4146async fn test_inverted_diff_secondary_version_mismatch(cx: &mut TestAppContext) {
4147 let base_text = "one\ntwo\nthree\nfour\nfive\n";
4148 let index_text = "one\nTWO\nthree\nfour\nfive\n";
4149 let buffer_text = "one\nTWO\nthree\nFOUR\nfive\n";
4150
4151 let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));
4152
4153 let unstaged_diff = cx
4154 .new(|cx| BufferDiff::new_with_base_text(index_text, &buffer.read(cx).text_snapshot(), cx));
4155 cx.run_until_parked();
4156
4157 let uncommitted_diff = cx.new(|cx| {
4158 let mut diff =
4159 BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx);
4160 diff.set_secondary_diff(unstaged_diff.clone());
4161 diff
4162 });
4163 cx.run_until_parked();
4164
4165 buffer.update(cx, |buffer, cx| {
4166 buffer.edit([(0..0, "ZERO\n")], None, cx);
4167 });
4168
4169 let update = unstaged_diff
4170 .update(cx, |diff, cx| {
4171 diff.update_diff(
4172 buffer.read(cx).text_snapshot(),
4173 Some(index_text.into()),
4174 None,
4175 None,
4176 cx,
4177 )
4178 })
4179 .await;
4180 unstaged_diff
4181 .update(cx, |diff, cx| {
4182 diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
4183 })
4184 .await;
4185
4186 let base_text_buffer =
4187 uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
4188
4189 let multibuffer = cx.new(|cx| {
4190 let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
4191 multibuffer.set_all_diff_hunks_expanded(cx);
4192 multibuffer.add_inverted_diff(uncommitted_diff.clone(), buffer.clone(), cx);
4193 multibuffer
4194 });
4195
4196 let _hunks: Vec<_> = multibuffer
4197 .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
4198 .diff_hunks()
4199 .collect();
4200}
4201
4202#[track_caller]
4203fn assert_excerpts_match(
4204 multibuffer: &Entity<MultiBuffer>,
4205 cx: &mut TestAppContext,
4206 expected: &str,
4207) {
4208 let mut output = String::new();
4209 multibuffer.read_with(cx, |multibuffer, cx| {
4210 for (_, buffer, range) in multibuffer.snapshot(cx).excerpts() {
4211 output.push_str("-----\n");
4212 output.extend(buffer.text_for_range(range.context));
4213 if !output.ends_with('\n') {
4214 output.push('\n');
4215 }
4216 }
4217 });
4218 assert_eq!(output, expected);
4219}
4220
4221#[track_caller]
4222fn assert_new_snapshot(
4223 multibuffer: &Entity<MultiBuffer>,
4224 snapshot: &mut MultiBufferSnapshot,
4225 subscription: &mut Subscription<MultiBufferOffset>,
4226 cx: &mut TestAppContext,
4227 expected_diff: &str,
4228) {
4229 let new_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
4230 let actual_text = new_snapshot.text();
4231 let line_infos = new_snapshot
4232 .row_infos(MultiBufferRow(0))
4233 .collect::<Vec<_>>();
4234 let actual_diff = format_diff(&actual_text, &line_infos, &Default::default(), None);
4235 pretty_assertions::assert_eq!(actual_diff, expected_diff);
4236 check_edits(
4237 snapshot,
4238 &new_snapshot,
4239 &subscription.consume().into_inner(),
4240 );
4241 *snapshot = new_snapshot;
4242}
4243
4244#[track_caller]
4245fn check_edits(
4246 old_snapshot: &MultiBufferSnapshot,
4247 new_snapshot: &MultiBufferSnapshot,
4248 edits: &[Edit<MultiBufferOffset>],
4249) {
4250 let mut text = old_snapshot.text();
4251 let new_text = new_snapshot.text();
4252 for edit in edits.iter().rev() {
4253 if !text.is_char_boundary(edit.old.start.0)
4254 || !text.is_char_boundary(edit.old.end.0)
4255 || !new_text.is_char_boundary(edit.new.start.0)
4256 || !new_text.is_char_boundary(edit.new.end.0)
4257 {
4258 panic!(
4259 "invalid edits: {:?}\nold text: {:?}\nnew text: {:?}",
4260 edits, text, new_text
4261 );
4262 }
4263
4264 text.replace_range(
4265 edit.old.start.0..edit.old.end.0,
4266 &new_text[edit.new.start.0..edit.new.end.0],
4267 );
4268 }
4269
4270 pretty_assertions::assert_eq!(text, new_text, "invalid edits: {:?}", edits);
4271}
4272
4273#[track_caller]
4274fn assert_chunks_in_ranges(snapshot: &MultiBufferSnapshot) {
4275 let full_text = snapshot.text();
4276 for ix in 0..full_text.len() {
4277 let mut chunks = snapshot.chunks(MultiBufferOffset(0)..snapshot.len(), false);
4278 chunks.seek(MultiBufferOffset(ix)..snapshot.len());
4279 let tail = chunks.map(|chunk| chunk.text).collect::<String>();
4280 assert_eq!(tail, &full_text[ix..], "seek to range: {:?}", ix..);
4281 }
4282}
4283
4284#[track_caller]
4285fn assert_consistent_line_numbers(snapshot: &MultiBufferSnapshot) {
4286 let all_line_numbers = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
4287 for start_row in 1..all_line_numbers.len() {
4288 let line_numbers = snapshot
4289 .row_infos(MultiBufferRow(start_row as u32))
4290 .collect::<Vec<_>>();
4291 assert_eq!(
4292 line_numbers,
4293 all_line_numbers[start_row..],
4294 "start_row: {start_row}"
4295 );
4296 }
4297}
4298
4299#[track_caller]
4300fn assert_position_translation(snapshot: &MultiBufferSnapshot) {
4301 let text = Rope::from(snapshot.text());
4302
4303 let mut left_anchors = Vec::new();
4304 let mut right_anchors = Vec::new();
4305 let mut offsets = Vec::new();
4306 let mut points = Vec::new();
4307 for offset in 0..=text.len() + 1 {
4308 let offset = MultiBufferOffset(offset);
4309 let clipped_left = snapshot.clip_offset(offset, Bias::Left);
4310 let clipped_right = snapshot.clip_offset(offset, Bias::Right);
4311 assert_eq!(
4312 clipped_left.0,
4313 text.clip_offset(offset.0, Bias::Left),
4314 "clip_offset({offset:?}, Left)"
4315 );
4316 assert_eq!(
4317 clipped_right.0,
4318 text.clip_offset(offset.0, Bias::Right),
4319 "clip_offset({offset:?}, Right)"
4320 );
4321 assert_eq!(
4322 snapshot.offset_to_point(clipped_left),
4323 text.offset_to_point(clipped_left.0),
4324 "offset_to_point({})",
4325 clipped_left.0
4326 );
4327 assert_eq!(
4328 snapshot.offset_to_point(clipped_right),
4329 text.offset_to_point(clipped_right.0),
4330 "offset_to_point({})",
4331 clipped_right.0
4332 );
4333 let anchor_after = snapshot.anchor_after(clipped_left);
4334 assert_eq!(
4335 anchor_after.to_offset(snapshot),
4336 clipped_left,
4337 "anchor_after({}).to_offset {anchor_after:?}",
4338 clipped_left.0
4339 );
4340 let anchor_before = snapshot.anchor_before(clipped_left);
4341 assert_eq!(
4342 anchor_before.to_offset(snapshot),
4343 clipped_left,
4344 "anchor_before({}).to_offset",
4345 clipped_left.0
4346 );
4347 left_anchors.push(anchor_before);
4348 right_anchors.push(anchor_after);
4349 offsets.push(clipped_left);
4350 points.push(text.offset_to_point(clipped_left.0));
4351 }
4352
4353 for row in 0..text.max_point().row {
4354 for column in 0..text.line_len(row) + 1 {
4355 let point = Point { row, column };
4356 let clipped_left = snapshot.clip_point(point, Bias::Left);
4357 let clipped_right = snapshot.clip_point(point, Bias::Right);
4358 assert_eq!(
4359 clipped_left,
4360 text.clip_point(point, Bias::Left),
4361 "clip_point({point:?}, Left)"
4362 );
4363 assert_eq!(
4364 clipped_right,
4365 text.clip_point(point, Bias::Right),
4366 "clip_point({point:?}, Right)"
4367 );
4368 assert_eq!(
4369 snapshot.point_to_offset(clipped_left).0,
4370 text.point_to_offset(clipped_left),
4371 "point_to_offset({clipped_left:?})"
4372 );
4373 assert_eq!(
4374 snapshot.point_to_offset(clipped_right).0,
4375 text.point_to_offset(clipped_right),
4376 "point_to_offset({clipped_right:?})"
4377 );
4378 }
4379 }
4380
4381 assert_eq!(
4382 snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&left_anchors),
4383 offsets,
4384 "left_anchors <-> offsets"
4385 );
4386 assert_eq!(
4387 snapshot.summaries_for_anchors::<Point, _>(&left_anchors),
4388 points,
4389 "left_anchors <-> points"
4390 );
4391 assert_eq!(
4392 snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&right_anchors),
4393 offsets,
4394 "right_anchors <-> offsets"
4395 );
4396 assert_eq!(
4397 snapshot.summaries_for_anchors::<Point, _>(&right_anchors),
4398 points,
4399 "right_anchors <-> points"
4400 );
4401
4402 for (anchors, bias) in [(&left_anchors, Bias::Left), (&right_anchors, Bias::Right)] {
4403 for (ix, (offset, anchor)) in offsets.iter().zip(anchors).enumerate() {
4404 if ix > 0 && *offset == MultiBufferOffset(252) && offset > &offsets[ix - 1] {
4405 let prev_anchor = left_anchors[ix - 1];
4406 assert!(
4407 anchor.cmp(&prev_anchor, snapshot).is_gt(),
4408 "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_gt()",
4409 offsets[ix],
4410 offsets[ix - 1],
4411 );
4412 assert!(
4413 prev_anchor.cmp(anchor, snapshot).is_lt(),
4414 "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_lt()",
4415 offsets[ix - 1],
4416 offsets[ix],
4417 );
4418 }
4419 }
4420 }
4421
4422 if let Some((buffer, offset)) = snapshot.point_to_buffer_offset(snapshot.max_point()) {
4423 assert!(offset.0 <= buffer.len());
4424 }
4425 if let Some((buffer, point)) = snapshot.point_to_buffer_point(snapshot.max_point()) {
4426 assert!(point <= buffer.max_point());
4427 }
4428}
4429
4430fn assert_line_indents(snapshot: &MultiBufferSnapshot) {
4431 let max_row = snapshot.max_point().row;
4432 let buffer_id = snapshot.excerpts().next().unwrap().1.remote_id();
4433 let text = text::Buffer::new(ReplicaId::LOCAL, buffer_id, snapshot.text());
4434 let mut line_indents = text
4435 .line_indents_in_row_range(0..max_row + 1)
4436 .collect::<Vec<_>>();
4437 for start_row in 0..snapshot.max_point().row {
4438 pretty_assertions::assert_eq!(
4439 snapshot
4440 .line_indents(MultiBufferRow(start_row), |_| true)
4441 .map(|(row, indent, _)| (row.0, indent))
4442 .collect::<Vec<_>>(),
4443 &line_indents[(start_row as usize)..],
4444 "line_indents({start_row})"
4445 );
4446 }
4447
4448 line_indents.reverse();
4449 pretty_assertions::assert_eq!(
4450 snapshot
4451 .reversed_line_indents(MultiBufferRow(max_row), |_| true)
4452 .map(|(row, indent, _)| (row.0, indent))
4453 .collect::<Vec<_>>(),
4454 &line_indents[..],
4455 "reversed_line_indents({max_row})"
4456 );
4457}
4458
4459#[gpui::test]
4460fn test_new_empty_buffer_uses_untitled_title(cx: &mut App) {
4461 let buffer = cx.new(|cx| Buffer::local("", cx));
4462 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4463
4464 assert_eq!(multibuffer.read(cx).title(cx), "untitled");
4465}
4466
4467#[gpui::test]
4468fn test_new_empty_buffer_uses_untitled_title_when_only_contains_whitespace(cx: &mut App) {
4469 let buffer = cx.new(|cx| Buffer::local("\n ", cx));
4470 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4471
4472 assert_eq!(multibuffer.read(cx).title(cx), "untitled");
4473}
4474
4475#[gpui::test]
4476fn test_new_empty_buffer_takes_first_line_for_title(cx: &mut App) {
4477 let buffer = cx.new(|cx| Buffer::local("Hello World\nSecond line", cx));
4478 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4479
4480 assert_eq!(multibuffer.read(cx).title(cx), "Hello World");
4481}
4482
4483#[gpui::test]
4484fn test_new_empty_buffer_takes_trimmed_first_line_for_title(cx: &mut App) {
4485 let buffer = cx.new(|cx| Buffer::local("\nHello, World ", cx));
4486 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4487
4488 assert_eq!(multibuffer.read(cx).title(cx), "Hello, World");
4489}
4490
4491#[gpui::test]
4492fn test_new_empty_buffer_uses_truncated_first_line_for_title(cx: &mut App) {
4493 let title = "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee";
4494 let title_after = "aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd";
4495 let buffer = cx.new(|cx| Buffer::local(title, cx));
4496 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4497
4498 assert_eq!(multibuffer.read(cx).title(cx), title_after);
4499}
4500
4501#[gpui::test]
4502fn test_new_empty_buffer_uses_truncated_first_line_for_title_after_merging_adjacent_spaces(
4503 cx: &mut App,
4504) {
4505 let title = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddddeeeeeeeeee";
4506 let title_after = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddd";
4507 let buffer = cx.new(|cx| Buffer::local(title, cx));
4508 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4509
4510 assert_eq!(multibuffer.read(cx).title(cx), title_after);
4511}
4512
4513#[gpui::test]
4514fn test_new_empty_buffers_title_can_be_set(cx: &mut App) {
4515 let buffer = cx.new(|cx| Buffer::local("Hello World", cx));
4516 let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4517 assert_eq!(multibuffer.read(cx).title(cx), "Hello World");
4518
4519 multibuffer.update(cx, |multibuffer, cx| {
4520 multibuffer.set_title("Hey".into(), cx)
4521 });
4522 assert_eq!(multibuffer.read(cx).title(cx), "Hey");
4523}
4524
4525#[gpui::test(iterations = 100)]
4526fn test_random_chunk_bitmaps(cx: &mut App, mut rng: StdRng) {
4527 let multibuffer = if rng.random() {
4528 let len = rng.random_range(0..10000);
4529 let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
4530 let buffer = cx.new(|cx| Buffer::local(text, cx));
4531 cx.new(|cx| MultiBuffer::singleton(buffer, cx))
4532 } else {
4533 MultiBuffer::build_random(&mut rng, cx)
4534 };
4535
4536 let snapshot = multibuffer.read(cx).snapshot(cx);
4537
4538 let chunks = snapshot.chunks(MultiBufferOffset(0)..snapshot.len(), false);
4539
4540 for chunk in chunks {
4541 let chunk_text = chunk.text;
4542 let chars_bitmap = chunk.chars;
4543 let tabs_bitmap = chunk.tabs;
4544
4545 if chunk_text.is_empty() {
4546 assert_eq!(
4547 chars_bitmap, 0,
4548 "Empty chunk should have empty chars bitmap"
4549 );
4550 assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");
4551 continue;
4552 }
4553
4554 assert!(
4555 chunk_text.len() <= 128,
4556 "Chunk text length {} exceeds 128 bytes",
4557 chunk_text.len()
4558 );
4559
4560 // Verify chars bitmap
4561 let char_indices = chunk_text
4562 .char_indices()
4563 .map(|(i, _)| i)
4564 .collect::<Vec<_>>();
4565
4566 for byte_idx in 0..chunk_text.len() {
4567 let should_have_bit = char_indices.contains(&byte_idx);
4568 let has_bit = chars_bitmap & (1 << byte_idx) != 0;
4569
4570 if has_bit != should_have_bit {
4571 eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
4572 eprintln!("Char indices: {:?}", char_indices);
4573 eprintln!("Chars bitmap: {:#b}", chars_bitmap);
4574 }
4575
4576 assert_eq!(
4577 has_bit, should_have_bit,
4578 "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",
4579 byte_idx, chunk_text, should_have_bit, has_bit
4580 );
4581 }
4582
4583 for (byte_idx, byte) in chunk_text.bytes().enumerate() {
4584 let is_tab = byte == b'\t';
4585 let has_bit = tabs_bitmap & (1 << byte_idx) != 0;
4586
4587 if has_bit != is_tab {
4588 eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
4589 eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);
4590 assert_eq!(
4591 has_bit, is_tab,
4592 "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",
4593 byte_idx, chunk_text, byte as char, is_tab, has_bit
4594 );
4595 }
4596 }
4597 }
4598}
4599
4600#[gpui::test(iterations = 10)]
4601fn test_random_chunk_bitmaps_with_diffs(cx: &mut App, mut rng: StdRng) {
4602 let settings_store = SettingsStore::test(cx);
4603 cx.set_global(settings_store);
4604 use buffer_diff::BufferDiff;
4605 use util::RandomCharIter;
4606
4607 let multibuffer = if rng.random() {
4608 let len = rng.random_range(100..10000);
4609 let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
4610 let buffer = cx.new(|cx| Buffer::local(text, cx));
4611 cx.new(|cx| MultiBuffer::singleton(buffer, cx))
4612 } else {
4613 MultiBuffer::build_random(&mut rng, cx)
4614 };
4615
4616 let _diff_count = rng.random_range(1..5);
4617 let mut diffs = Vec::new();
4618
4619 multibuffer.update(cx, |multibuffer, cx| {
4620 for buffer_id in multibuffer.excerpt_buffer_ids() {
4621 if rng.random_bool(0.7) {
4622 if let Some(buffer_handle) = multibuffer.buffer(buffer_id) {
4623 let buffer_text = buffer_handle.read(cx).text();
4624 let mut base_text = String::new();
4625
4626 for line in buffer_text.lines() {
4627 if rng.random_bool(0.3) {
4628 continue;
4629 } else if rng.random_bool(0.3) {
4630 let line_len = rng.random_range(0..50);
4631 let modified_line = RandomCharIter::new(&mut rng)
4632 .take(line_len)
4633 .collect::<String>();
4634 base_text.push_str(&modified_line);
4635 base_text.push('\n');
4636 } else {
4637 base_text.push_str(line);
4638 base_text.push('\n');
4639 }
4640 }
4641
4642 if rng.random_bool(0.5) {
4643 let extra_lines = rng.random_range(1..5);
4644 for _ in 0..extra_lines {
4645 let line_len = rng.random_range(0..50);
4646 let extra_line = RandomCharIter::new(&mut rng)
4647 .take(line_len)
4648 .collect::<String>();
4649 base_text.push_str(&extra_line);
4650 base_text.push('\n');
4651 }
4652 }
4653
4654 let diff = cx.new(|cx| {
4655 BufferDiff::new_with_base_text(
4656 &base_text,
4657 &buffer_handle.read(cx).text_snapshot(),
4658 cx,
4659 )
4660 });
4661 diffs.push(diff.clone());
4662 multibuffer.add_diff(diff, cx);
4663 }
4664 }
4665 }
4666 });
4667
4668 multibuffer.update(cx, |multibuffer, cx| {
4669 if rng.random_bool(0.5) {
4670 multibuffer.set_all_diff_hunks_expanded(cx);
4671 } else {
4672 let snapshot = multibuffer.snapshot(cx);
4673 let text = snapshot.text();
4674
4675 let mut ranges = Vec::new();
4676 for _ in 0..rng.random_range(1..5) {
4677 if snapshot.len().0 == 0 {
4678 break;
4679 }
4680
4681 let diff_size = rng.random_range(5..1000);
4682 let mut start = rng.random_range(0..snapshot.len().0);
4683
4684 while !text.is_char_boundary(start) {
4685 start = start.saturating_sub(1);
4686 }
4687
4688 let mut end = rng.random_range(start..snapshot.len().0.min(start + diff_size));
4689
4690 while !text.is_char_boundary(end) {
4691 end = end.saturating_add(1);
4692 }
4693 let start_anchor = snapshot.anchor_after(MultiBufferOffset(start));
4694 let end_anchor = snapshot.anchor_before(MultiBufferOffset(end));
4695 ranges.push(start_anchor..end_anchor);
4696 }
4697 multibuffer.expand_diff_hunks(ranges, cx);
4698 }
4699 });
4700
4701 let snapshot = multibuffer.read(cx).snapshot(cx);
4702
4703 let chunks = snapshot.chunks(MultiBufferOffset(0)..snapshot.len(), false);
4704
4705 for chunk in chunks {
4706 let chunk_text = chunk.text;
4707 let chars_bitmap = chunk.chars;
4708 let tabs_bitmap = chunk.tabs;
4709
4710 if chunk_text.is_empty() {
4711 assert_eq!(
4712 chars_bitmap, 0,
4713 "Empty chunk should have empty chars bitmap"
4714 );
4715 assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");
4716 continue;
4717 }
4718
4719 assert!(
4720 chunk_text.len() <= 128,
4721 "Chunk text length {} exceeds 128 bytes",
4722 chunk_text.len()
4723 );
4724
4725 let char_indices = chunk_text
4726 .char_indices()
4727 .map(|(i, _)| i)
4728 .collect::<Vec<_>>();
4729
4730 for byte_idx in 0..chunk_text.len() {
4731 let should_have_bit = char_indices.contains(&byte_idx);
4732 let has_bit = chars_bitmap & (1 << byte_idx) != 0;
4733
4734 if has_bit != should_have_bit {
4735 eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
4736 eprintln!("Char indices: {:?}", char_indices);
4737 eprintln!("Chars bitmap: {:#b}", chars_bitmap);
4738 }
4739
4740 assert_eq!(
4741 has_bit, should_have_bit,
4742 "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",
4743 byte_idx, chunk_text, should_have_bit, has_bit
4744 );
4745 }
4746
4747 for (byte_idx, byte) in chunk_text.bytes().enumerate() {
4748 let is_tab = byte == b'\t';
4749 let has_bit = tabs_bitmap & (1 << byte_idx) != 0;
4750
4751 if has_bit != is_tab {
4752 eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
4753 eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);
4754 assert_eq!(
4755 has_bit, is_tab,
4756 "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",
4757 byte_idx, chunk_text, byte as char, is_tab, has_bit
4758 );
4759 }
4760 }
4761 }
4762}
4763
4764fn collect_word_diffs(
4765 base_text: &str,
4766 modified_text: &str,
4767 cx: &mut TestAppContext,
4768) -> Vec<String> {
4769 let buffer = cx.new(|cx| Buffer::local(modified_text, cx));
4770 let diff = cx
4771 .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
4772 cx.run_until_parked();
4773
4774 let multibuffer = cx.new(|cx| {
4775 let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);
4776 multibuffer.add_diff(diff.clone(), cx);
4777 multibuffer
4778 });
4779
4780 multibuffer.update(cx, |multibuffer, cx| {
4781 multibuffer.expand_diff_hunks(vec![Anchor::min()..Anchor::max()], cx);
4782 });
4783
4784 let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
4785 let text = snapshot.text();
4786
4787 snapshot
4788 .diff_hunks()
4789 .flat_map(|hunk| hunk.word_diffs)
4790 .map(|range| text[range.start.0..range.end.0].to_string())
4791 .collect()
4792}
4793
4794#[gpui::test]
4795async fn test_word_diff_simple_replacement(cx: &mut TestAppContext) {
4796 let settings_store = cx.update(|cx| SettingsStore::test(cx));
4797 cx.set_global(settings_store);
4798
4799 let base_text = "hello world foo bar\n";
4800 let modified_text = "hello WORLD foo BAR\n";
4801
4802 let word_diffs = collect_word_diffs(base_text, modified_text, cx);
4803
4804 assert_eq!(word_diffs, vec!["world", "bar", "WORLD", "BAR"]);
4805}
4806
4807#[gpui::test]
4808async fn test_word_diff_white_space(cx: &mut TestAppContext) {
4809 let settings_store = cx.update(|cx| SettingsStore::test(cx));
4810 cx.set_global(settings_store);
4811
4812 let base_text = "hello world foo bar\n";
4813 let modified_text = " hello world foo bar\n";
4814
4815 let word_diffs = collect_word_diffs(base_text, modified_text, cx);
4816
4817 assert_eq!(word_diffs, vec![" "]);
4818}
4819
4820#[gpui::test]
4821async fn test_word_diff_consecutive_modified_lines(cx: &mut TestAppContext) {
4822 let settings_store = cx.update(|cx| SettingsStore::test(cx));
4823 cx.set_global(settings_store);
4824
4825 let base_text = "aaa bbb\nccc ddd\n";
4826 let modified_text = "aaa BBB\nccc DDD\n";
4827
4828 let word_diffs = collect_word_diffs(base_text, modified_text, cx);
4829
4830 assert_eq!(
4831 word_diffs,
4832 vec!["bbb", "ddd", "BBB", "DDD"],
4833 "consecutive modified lines should produce word diffs when line counts match"
4834 );
4835}
4836
4837#[gpui::test]
4838async fn test_word_diff_modified_lines_with_deletion_between(cx: &mut TestAppContext) {
4839 let settings_store = cx.update(|cx| SettingsStore::test(cx));
4840 cx.set_global(settings_store);
4841
4842 let base_text = "aaa bbb\ndeleted line\nccc ddd\n";
4843 let modified_text = "aaa BBB\nccc DDD\n";
4844
4845 let word_diffs = collect_word_diffs(base_text, modified_text, cx);
4846
4847 assert_eq!(
4848 word_diffs,
4849 Vec::<String>::new(),
4850 "modified lines with a deleted line between should not produce word diffs"
4851 );
4852}
4853
4854#[gpui::test]
4855async fn test_word_diff_disabled(cx: &mut TestAppContext) {
4856 let settings_store = cx.update(|cx| {
4857 let mut settings_store = SettingsStore::test(cx);
4858 settings_store.update_user_settings(cx, |settings| {
4859 settings.project.all_languages.defaults.word_diff_enabled = Some(false);
4860 });
4861 settings_store
4862 });
4863 cx.set_global(settings_store);
4864
4865 let base_text = "hello world\n";
4866 let modified_text = "hello WORLD\n";
4867
4868 let word_diffs = collect_word_diffs(base_text, modified_text, cx);
4869
4870 assert_eq!(
4871 word_diffs,
4872 Vec::<String>::new(),
4873 "word diffs should be empty when disabled"
4874 );
4875}
4876
4877/// Tests `excerpt_containing` and `excerpts_for_range` (functions mapping multi-buffer text-coordinates to excerpts)
4878#[gpui::test]
4879fn test_excerpts_containment_functions(cx: &mut App) {
4880 // Multibuffer content for these tests:
4881 // 0123
4882 // 0: aa0
4883 // 1: aa1
4884 // -----
4885 // 2: bb0
4886 // 3: bb1
4887 // -----MultiBufferOffset(0)..
4888 // 4: cc0
4889
4890 let buffer_1 = cx.new(|cx| Buffer::local("aa0\naa1", cx));
4891 let buffer_2 = cx.new(|cx| Buffer::local("bb0\nbb1", cx));
4892 let buffer_3 = cx.new(|cx| Buffer::local("cc0", cx));
4893
4894 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
4895
4896 let (excerpt_1_info, excerpt_2_info, excerpt_3_info) =
4897 multibuffer.update(cx, |multibuffer, cx| {
4898 multibuffer.set_excerpts_for_path(
4899 PathKey::sorted(0),
4900 buffer_1.clone(),
4901 [Point::new(0, 0)..Point::new(1, 3)],
4902 0,
4903 cx,
4904 );
4905
4906 multibuffer.set_excerpts_for_path(
4907 PathKey::sorted(1),
4908 buffer_2.clone(),
4909 [Point::new(0, 0)..Point::new(1, 3)],
4910 0,
4911 cx,
4912 );
4913
4914 multibuffer.set_excerpts_for_path(
4915 PathKey::sorted(2),
4916 buffer_3.clone(),
4917 [Point::new(0, 0)..Point::new(0, 3)],
4918 0,
4919 cx,
4920 );
4921
4922 let snapshot = multibuffer.snapshot(cx);
4923 let mut infos = snapshot.excerpts().map(|(_, info)| info);
4924 (
4925 infos.next().unwrap(),
4926 infos.next().unwrap(),
4927 infos.next().unwrap(),
4928 )
4929 });
4930
4931 let snapshot = multibuffer.read(cx).snapshot(cx);
4932
4933 assert_eq!(snapshot.text(), "aa0\naa1\nbb0\nbb1\ncc0");
4934
4935 //// Test `excerpts_for_range`
4936
4937 let p00 = snapshot.point_to_offset(Point::new(0, 0));
4938 let p10 = snapshot.point_to_offset(Point::new(1, 0));
4939 let p20 = snapshot.point_to_offset(Point::new(2, 0));
4940 let p23 = snapshot.point_to_offset(Point::new(2, 3));
4941 let p13 = snapshot.point_to_offset(Point::new(1, 3));
4942 let p40 = snapshot.point_to_offset(Point::new(4, 0));
4943 let p43 = snapshot.point_to_offset(Point::new(4, 3));
4944
4945 let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p00).collect();
4946 assert_eq!(excerpts.len(), 1);
4947 assert_eq!(excerpts[0].info(), excerpt_1_info);
4948
4949 // Cursor at very end of excerpt 3
4950 let excerpts: Vec<_> = snapshot.excerpts_for_range(p43..p43).collect();
4951 assert_eq!(excerpts.len(), 1);
4952 assert_eq!(excerpts[0].info(), excerpt_3_info);
4953
4954 let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p23).collect();
4955 assert_eq!(excerpts.len(), 2);
4956 assert_eq!(excerpts[0].info(), excerpt_1_info);
4957 assert_eq!(excerpts[1].info(), excerpt_2_info);
4958
4959 // This range represent an selection with end-point just inside excerpt_2
4960 // Today we only expand the first excerpt, but another interpretation that
4961 // we could consider is expanding both here
4962 let excerpts: Vec<_> = snapshot.excerpts_for_range(p10..p20).collect();
4963 assert_eq!(excerpts.len(), 1);
4964 assert_eq!(excerpts[0].info(), excerpt_1_info);
4965
4966 //// Test that `excerpts_for_range` and `excerpt_containing` agree for all single offsets (cursor positions)
4967 for offset in 0..=snapshot.len().0 {
4968 let offset = MultiBufferOffset(offset);
4969 let excerpts_for_range: Vec<_> = snapshot.excerpts_for_range(offset..offset).collect();
4970 assert_eq!(
4971 excerpts_for_range.len(),
4972 1,
4973 "Expected exactly one excerpt for offset {offset}",
4974 );
4975
4976 let excerpt_containing = snapshot.excerpt_containing(offset..offset);
4977 assert!(
4978 excerpt_containing.is_some(),
4979 "Expected excerpt_containing to find excerpt for offset {offset}",
4980 );
4981
4982 assert_eq!(
4983 excerpts_for_range[0].info(),
4984 excerpt_containing.unwrap().excerpt.info(),
4985 "excerpts_for_range and excerpt_containing should agree for offset {offset}",
4986 );
4987 }
4988
4989 //// Test `excerpt_containing` behavior with ranges:
4990
4991 // Ranges intersecting a single-excerpt
4992 let containing = snapshot.excerpt_containing(p00..p13);
4993 assert!(containing.is_some());
4994 assert_eq!(containing.unwrap().excerpt.info(), excerpt_1_info);
4995
4996 // Ranges intersecting multiple excerpts (should return None)
4997 let containing = snapshot.excerpt_containing(p20..p40);
4998 assert!(
4999 containing.is_none(),
5000 "excerpt_containing should return None for ranges spanning multiple excerpts"
5001 );
5002}
5003
5004#[gpui::test]
5005fn test_range_to_buffer_ranges_with_range_bounds(cx: &mut App) {
5006 use std::ops::Bound;
5007
5008 let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));
5009 let buffer_2 = cx.new(|cx| Buffer::local("ccc", cx));
5010
5011 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
5012 let (excerpt_1_id, excerpt_2_id) = multibuffer.update(cx, |multibuffer, cx| {
5013 multibuffer.set_excerpts_for_path(
5014 PathKey::sorted(0),
5015 buffer_1.clone(),
5016 [Point::new(0, 0)..Point::new(1, 3)],
5017 0,
5018 cx,
5019 );
5020
5021 multibuffer.set_excerpts_for_path(
5022 PathKey::sorted(1),
5023 buffer_2.clone(),
5024 [Point::new(0, 0)..Point::new(0, 3)],
5025 0,
5026 cx,
5027 );
5028
5029 let excerpt_ids = multibuffer.excerpt_ids();
5030
5031 (excerpt_ids[0], excerpt_ids[1])
5032 });
5033
5034 let snapshot = multibuffer.read(cx).snapshot(cx);
5035 assert_eq!(snapshot.text(), "aaa\nbbb\nccc");
5036
5037 let excerpt_2_start = Point::new(2, 0);
5038
5039 let ranges_half_open = snapshot.range_to_buffer_ranges(Point::zero()..excerpt_2_start);
5040 assert_eq!(
5041 ranges_half_open.len(),
5042 1,
5043 "Half-open range ending at excerpt start should EXCLUDE that excerpt"
5044 );
5045 assert_eq!(ranges_half_open[0].2, excerpt_1_id);
5046
5047 let ranges_inclusive = snapshot.range_to_buffer_ranges(Point::zero()..=excerpt_2_start);
5048 assert_eq!(
5049 ranges_inclusive.len(),
5050 2,
5051 "Inclusive range ending at excerpt start should INCLUDE that excerpt"
5052 );
5053 assert_eq!(ranges_inclusive[0].2, excerpt_1_id);
5054 assert_eq!(ranges_inclusive[1].2, excerpt_2_id);
5055
5056 let ranges_unbounded =
5057 snapshot.range_to_buffer_ranges((Bound::Included(Point::zero()), Bound::Unbounded));
5058 assert_eq!(
5059 ranges_unbounded.len(),
5060 2,
5061 "Unbounded end should include all excerpts"
5062 );
5063 assert_eq!(ranges_unbounded[0].2, excerpt_1_id);
5064 assert_eq!(ranges_unbounded[1].2, excerpt_2_id);
5065
5066 let ranges_excluded_end = snapshot.range_to_buffer_ranges((
5067 Bound::Included(Point::zero()),
5068 Bound::Excluded(excerpt_2_start),
5069 ));
5070 assert_eq!(
5071 ranges_excluded_end.len(),
5072 1,
5073 "Excluded end bound should exclude excerpt starting at that point"
5074 );
5075 assert_eq!(ranges_excluded_end[0].2, excerpt_1_id);
5076
5077 let buffer_empty = cx.new(|cx| Buffer::local("", cx));
5078 let multibuffer_trailing_empty = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
5079 let (te_excerpt_1_info, te_excerpt_2_info) =
5080 multibuffer_trailing_empty.update(cx, |multibuffer, cx| {
5081 multibuffer.set_excerpts_for_path(
5082 PathKey::sorted(0),
5083 buffer_1.clone(),
5084 [Point::new(0, 0)..Point::new(1, 3)],
5085 0,
5086 cx,
5087 );
5088
5089 multibuffer.set_excerpts_for_path(
5090 PathKey::sorted(1),
5091 buffer_empty.clone(),
5092 [Point::new(0, 0)..Point::new(0, 0)],
5093 0,
5094 cx,
5095 );
5096
5097 let snapshot = multibuffer.snapshot(cx);
5098 let mut infos = snapshot.excerpts().map(|(_, info)| info);
5099 (infos.next().unwrap(), infos.next().unwrap())
5100 });
5101
5102 let snapshot_trailing = multibuffer_trailing_empty.read(cx).snapshot(cx);
5103 assert_eq!(snapshot_trailing.text(), "aaa\nbbb\n");
5104
5105 let max_point = snapshot_trailing.max_point();
5106
5107 let ranges_half_open_max =
5108 snapshot_trailing.range_to_buffer_ranges_with_context(Point::zero()..max_point);
5109 assert_eq!(
5110 ranges_half_open_max.len(),
5111 1,
5112 "Half-open range to max_point should EXCLUDE trailing empty excerpt at max_point"
5113 );
5114 assert_eq!(ranges_half_open_max[0].2, te_excerpt_1_info.range.context);
5115
5116 let ranges_inclusive_max =
5117 snapshot_trailing.range_to_buffer_ranges_with_context(Point::zero()..=max_point);
5118 assert_eq!(
5119 ranges_inclusive_max.len(),
5120 2,
5121 "Inclusive range to max_point should INCLUDE trailing empty excerpt"
5122 );
5123 assert_eq!(ranges_inclusive_max[0].2, te_excerpt_1_info.range.context);
5124 assert_eq!(ranges_inclusive_max[1].2, te_excerpt_2_info.range.context);
5125
5126 let ranges_unbounded_trailing = snapshot_trailing
5127 .range_to_buffer_ranges_with_context((Bound::Included(Point::zero()), Bound::Unbounded));
5128 assert_eq!(
5129 ranges_unbounded_trailing.len(),
5130 2,
5131 "Unbounded end should include trailing empty excerpt"
5132 );
5133 assert_eq!(
5134 ranges_unbounded_trailing[0].2,
5135 te_excerpt_1_info.range.context
5136 );
5137 assert_eq!(
5138 ranges_unbounded_trailing[1].2,
5139 te_excerpt_2_info.range.context
5140 );
5141}
5142
5143#[gpui::test]
5144fn test_cannot_seek_backward_after_excerpt_replacement(cx: &mut TestAppContext) {
5145 let buffer_b_text: String = (0..50).map(|i| format!("line_b {i}\n")).collect();
5146 let buffer_b = cx.new(|cx| Buffer::local(buffer_b_text, cx));
5147
5148 let buffer_c_text: String = (0..10).map(|i| format!("line_c {i}\n")).collect();
5149 let buffer_c = cx.new(|cx| Buffer::local(buffer_c_text, cx));
5150
5151 let buffer_d_text: String = (0..10).map(|i| format!("line_d {i}\n")).collect();
5152 let buffer_d = cx.new(|cx| Buffer::local(buffer_d_text, cx));
5153
5154 let path_b = PathKey::with_sort_prefix(0, rel_path("bbb.rs").into_arc());
5155 let path_c = PathKey::with_sort_prefix(0, rel_path("ddd.rs").into_arc());
5156 let path_d = PathKey::with_sort_prefix(0, rel_path("ccc.rs").into_arc());
5157
5158 let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
5159
5160 multibuffer.update(cx, |multibuffer, cx| {
5161 multibuffer.set_excerpts_for_path(
5162 path_b.clone(),
5163 buffer_b.clone(),
5164 vec![
5165 Point::row_range(0..3),
5166 Point::row_range(15..18),
5167 Point::row_range(30..33),
5168 ],
5169 0,
5170 cx,
5171 );
5172 });
5173
5174 multibuffer.update(cx, |multibuffer, cx| {
5175 multibuffer.set_excerpts_for_path(
5176 path_c.clone(),
5177 buffer_c.clone(),
5178 vec![Point::row_range(0..3)],
5179 0,
5180 cx,
5181 );
5182 });
5183
5184 let (anchor_in_e_b2, anchor_in_e_b3) = multibuffer.read_with(cx, |multibuffer, cx| {
5185 let snapshot = multibuffer.snapshot(cx);
5186 let excerpt_infos: Vec<ExcerptInfo> = snapshot.excerpts().map(|(_, info)| info).collect();
5187 assert_eq!(excerpt_infos.len(), 4, "expected 4 excerpts (3×B + 1×C)");
5188
5189 let e_b2_info = excerpt_infos[1].clone();
5190 let e_b3_info = excerpt_infos[2].clone();
5191
5192 let anchor_b2 = Anchor::in_buffer(e_b2_info.path_key_index, e_b2_info.range.context.start);
5193 let anchor_b3 = Anchor::in_buffer(e_b3_info.path_key_index, e_b3_info.range.context.start);
5194 (anchor_b2, anchor_b3)
5195 });
5196
5197 multibuffer.update(cx, |multibuffer, cx| {
5198 multibuffer.set_excerpts_for_path(
5199 path_b.clone(),
5200 buffer_b.clone(),
5201 vec![Point::row_range(0..3), Point::row_range(28..36)],
5202 0,
5203 cx,
5204 );
5205 });
5206
5207 multibuffer.update(cx, |multibuffer, cx| {
5208 multibuffer.set_excerpts_for_path(
5209 path_d.clone(),
5210 buffer_d.clone(),
5211 vec![Point::row_range(0..3)],
5212 0,
5213 cx,
5214 );
5215 });
5216
5217 multibuffer.read_with(cx, |multibuffer, cx| {
5218 let snapshot = multibuffer.snapshot(cx);
5219 snapshot.summaries_for_anchors::<Point, _>(&[anchor_in_e_b2, anchor_in_e_b3]);
5220 });
5221}