1use futures::channel::oneshot;
2use git2::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
3use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task, TaskLabel};
4use language::{
5 BufferRow, Capability, DiffOptions, File, Language, LanguageName, LanguageRegistry,
6 language_settings::language_settings, word_diff_ranges,
7};
8use rope::Rope;
9use std::{
10 cmp::Ordering,
11 iter,
12 ops::Range,
13 sync::{Arc, LazyLock},
14};
15use sum_tree::SumTree;
16use text::{Anchor, Bias, BufferId, OffsetRangeExt, Point, ToOffset as _, ToPoint as _};
17use util::ResultExt;
18
19pub static CALCULATE_DIFF_TASK: LazyLock<TaskLabel> = LazyLock::new(TaskLabel::new);
20pub const MAX_WORD_DIFF_LINE_COUNT: usize = 5;
21
22pub struct BufferDiff {
23 pub buffer_id: BufferId,
24 inner: BufferDiffInner<Entity<language::Buffer>>,
25 // diff of the index vs head
26 secondary_diff: Option<Entity<BufferDiff>>,
27}
28
29#[derive(Clone)]
30pub struct BufferDiffSnapshot {
31 inner: BufferDiffInner,
32 secondary_diff: Option<Box<BufferDiffSnapshot>>,
33}
34
35impl std::fmt::Debug for BufferDiffSnapshot {
36 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37 f.debug_struct("BufferDiffSnapshot")
38 .field("inner", &self.inner)
39 .field("secondary_diff", &self.secondary_diff)
40 .finish()
41 }
42}
43
44// FIXME figure out how to hide this
45#[derive(Clone)]
46pub struct BufferDiffInner<BaseText = language::BufferSnapshot> {
47 hunks: SumTree<InternalDiffHunk>,
48 pending_hunks: SumTree<PendingHunk>,
49 base_text: BaseText,
50 base_text_exists: bool,
51}
52
53#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
54pub struct DiffHunkStatus {
55 pub kind: DiffHunkStatusKind,
56 pub secondary: DiffHunkSecondaryStatus,
57}
58
59#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
60pub enum DiffHunkStatusKind {
61 Added,
62 Modified,
63 Deleted,
64}
65
66#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
67/// Diff of Working Copy vs Index
68/// aka 'is this hunk staged or not'
69pub enum DiffHunkSecondaryStatus {
70 /// Unstaged
71 HasSecondaryHunk,
72 /// Partially staged
73 OverlapsWithSecondaryHunk,
74 /// Staged
75 NoSecondaryHunk,
76 /// We are unstaging
77 SecondaryHunkAdditionPending,
78 /// We are stagind
79 SecondaryHunkRemovalPending,
80}
81
82/// A diff hunk resolved to rows in the buffer.
83#[derive(Debug, Clone, PartialEq, Eq)]
84pub struct DiffHunk {
85 /// The buffer range as points.
86 pub range: Range<Point>,
87 /// The range in the buffer to which this hunk corresponds.
88 pub buffer_range: Range<Anchor>,
89 /// The range in the buffer's diff base text to which this hunk corresponds.
90 pub diff_base_byte_range: Range<usize>,
91 pub secondary_status: DiffHunkSecondaryStatus,
92 // Anchors representing the word diff locations in the active buffer
93 pub buffer_word_diffs: Vec<Range<Anchor>>,
94 // Offsets relative to the start of the deleted diff that represent word diff locations
95 pub base_word_diffs: Vec<Range<usize>>,
96}
97
98/// We store [`InternalDiffHunk`]s internally so we don't need to store the additional row range.
99#[derive(Debug, Clone, PartialEq, Eq)]
100struct InternalDiffHunk {
101 buffer_range: Range<Anchor>,
102 diff_base_byte_range: Range<usize>,
103 base_word_diffs: Vec<Range<usize>>,
104 buffer_word_diffs: Vec<Range<Anchor>>,
105}
106
107#[derive(Debug, Clone, PartialEq, Eq)]
108struct PendingHunk {
109 buffer_range: Range<Anchor>,
110 diff_base_byte_range: Range<usize>,
111 buffer_version: clock::Global,
112 new_status: DiffHunkSecondaryStatus,
113}
114
115#[derive(Debug, Clone)]
116pub struct DiffHunkSummary {
117 buffer_range: Range<Anchor>,
118 diff_base_byte_range: Range<usize>,
119}
120
121impl sum_tree::Item for InternalDiffHunk {
122 type Summary = DiffHunkSummary;
123
124 fn summary(&self, _cx: &text::BufferSnapshot) -> Self::Summary {
125 DiffHunkSummary {
126 buffer_range: self.buffer_range.clone(),
127 diff_base_byte_range: self.diff_base_byte_range.clone(),
128 }
129 }
130}
131
132impl sum_tree::Item for PendingHunk {
133 type Summary = DiffHunkSummary;
134
135 fn summary(&self, _cx: &text::BufferSnapshot) -> Self::Summary {
136 DiffHunkSummary {
137 buffer_range: self.buffer_range.clone(),
138 diff_base_byte_range: self.diff_base_byte_range.clone(),
139 }
140 }
141}
142
143impl sum_tree::Summary for DiffHunkSummary {
144 type Context<'a> = &'a text::BufferSnapshot;
145
146 fn zero(_cx: Self::Context<'_>) -> Self {
147 DiffHunkSummary {
148 buffer_range: Anchor::MIN..Anchor::MIN,
149 diff_base_byte_range: 0..0,
150 }
151 }
152
153 fn add_summary(&mut self, other: &Self, buffer: Self::Context<'_>) {
154 self.buffer_range.start = *self
155 .buffer_range
156 .start
157 .min(&other.buffer_range.start, buffer);
158 self.buffer_range.end = *self.buffer_range.end.max(&other.buffer_range.end, buffer);
159
160 self.diff_base_byte_range.start = self
161 .diff_base_byte_range
162 .start
163 .min(other.diff_base_byte_range.start);
164 self.diff_base_byte_range.end = self
165 .diff_base_byte_range
166 .end
167 .max(other.diff_base_byte_range.end);
168 }
169}
170
171impl sum_tree::SeekTarget<'_, DiffHunkSummary, DiffHunkSummary> for Anchor {
172 fn cmp(&self, cursor_location: &DiffHunkSummary, buffer: &text::BufferSnapshot) -> Ordering {
173 if self
174 .cmp(&cursor_location.buffer_range.start, buffer)
175 .is_lt()
176 {
177 Ordering::Less
178 } else if self.cmp(&cursor_location.buffer_range.end, buffer).is_gt() {
179 Ordering::Greater
180 } else {
181 Ordering::Equal
182 }
183 }
184}
185
186impl std::fmt::Debug for BufferDiffInner {
187 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
188 f.debug_struct("BufferDiffSnapshot")
189 .field("hunks", &self.hunks)
190 .field("remote_id", &self.base_text.remote_id())
191 .finish()
192 }
193}
194
195impl BufferDiffSnapshot {
196 pub fn buffer_diff_id(&self) -> BufferId {
197 self.inner.base_text.remote_id()
198 }
199
200 #[cfg(test)]
201 fn new_sync(
202 buffer: text::BufferSnapshot,
203 diff_base: String,
204 cx: &mut gpui::TestAppContext,
205 ) -> BufferDiffSnapshot {
206 let buffer_diff = cx.new(|cx| BufferDiff::new_with_base_text(&diff_base, &buffer, cx));
207 buffer_diff.update(cx, |buffer_diff, cx| buffer_diff.snapshot(cx))
208 }
209
210 pub fn is_empty(&self) -> bool {
211 self.inner.hunks.is_empty()
212 }
213
214 pub fn secondary_diff(&self) -> Option<&BufferDiffSnapshot> {
215 self.secondary_diff.as_deref()
216 }
217
218 pub fn hunks_intersecting_range<'a>(
219 &'a self,
220 range: Range<Anchor>,
221 buffer: &'a text::BufferSnapshot,
222 ) -> impl 'a + Iterator<Item = DiffHunk> {
223 let unstaged_counterpart = self.secondary_diff.as_ref().map(|diff| &diff.inner);
224 self.inner
225 .hunks_intersecting_range(range, buffer, unstaged_counterpart)
226 }
227
228 pub fn hunks_intersecting_range_rev<'a>(
229 &'a self,
230 range: Range<Anchor>,
231 buffer: &'a text::BufferSnapshot,
232 ) -> impl 'a + Iterator<Item = DiffHunk> {
233 self.inner.hunks_intersecting_range_rev(range, buffer)
234 }
235
236 pub fn hunks_intersecting_base_text_range<'a>(
237 &'a self,
238 range: Range<usize>,
239 main_buffer: &'a text::BufferSnapshot,
240 ) -> impl 'a + Iterator<Item = DiffHunk> {
241 let unstaged_counterpart = self.secondary_diff.as_ref().map(|diff| &diff.inner);
242 let filter = move |summary: &DiffHunkSummary| {
243 let before_start = summary.diff_base_byte_range.end < range.start;
244 let after_end = summary.diff_base_byte_range.start > range.end;
245 !before_start && !after_end
246 };
247 self.inner
248 .hunks_intersecting_range_impl(filter, main_buffer, unstaged_counterpart)
249 }
250
251 pub fn hunks<'a>(
252 &'a self,
253 buffer_snapshot: &'a text::BufferSnapshot,
254 ) -> impl 'a + Iterator<Item = DiffHunk> {
255 self.hunks_intersecting_range(
256 Anchor::min_max_range_for_buffer(buffer_snapshot.remote_id()),
257 buffer_snapshot,
258 )
259 }
260
261 pub fn hunks_in_row_range<'a>(
262 &'a self,
263 range: Range<u32>,
264 buffer: &'a text::BufferSnapshot,
265 ) -> impl 'a + Iterator<Item = DiffHunk> {
266 let start = buffer.anchor_before(Point::new(range.start, 0));
267 let end = buffer.anchor_after(Point::new(range.end, 0));
268 self.hunks_intersecting_range(start..end, buffer)
269 }
270
271 pub fn range_to_hunk_range(
272 &self,
273 range: Range<Anchor>,
274 buffer: &text::BufferSnapshot,
275 ) -> (Option<Range<Anchor>>, Option<Range<usize>>) {
276 let first_hunk = self.hunks_intersecting_range(range.clone(), buffer).next();
277 let last_hunk = self.hunks_intersecting_range_rev(range, buffer).next();
278 let range = first_hunk
279 .as_ref()
280 .zip(last_hunk.as_ref())
281 .map(|(first, last)| first.buffer_range.start..last.buffer_range.end);
282 let base_text_range = first_hunk
283 .zip(last_hunk)
284 .map(|(first, last)| first.diff_base_byte_range.start..last.diff_base_byte_range.end);
285 (range, base_text_range)
286 }
287
288 pub fn base_text(&self) -> &language::BufferSnapshot {
289 &self.inner.base_text
290 }
291
292 pub fn base_texts_eq(&self, other: &Self) -> bool {
293 if self.inner.base_text_exists != other.inner.base_text_exists {
294 return false;
295 }
296 let left = &self.inner.base_text;
297 let right = &other.inner.base_text;
298 // FIXME this is wrong
299 let (old_id, old_empty) = (left.remote_id(), left.is_empty());
300 let (new_id, new_empty) = (right.remote_id(), right.is_empty());
301 new_id == old_id || (new_empty && old_empty)
302 }
303
304 pub fn row_to_base_text_row(&self, row: BufferRow, buffer: &text::BufferSnapshot) -> u32 {
305 // TODO(split-diff) expose a parameter to reuse a cursor to avoid repeatedly seeking from the start
306
307 // Find the last hunk that starts before this position.
308 let mut cursor = self.inner.hunks.cursor::<DiffHunkSummary>(buffer);
309 let position = buffer.anchor_before(Point::new(row, 0));
310 cursor.seek(&position, Bias::Left);
311 if cursor
312 .item()
313 .is_none_or(|hunk| hunk.buffer_range.start.cmp(&position, buffer).is_gt())
314 {
315 cursor.prev();
316 }
317
318 let unclipped_point = if let Some(hunk) = cursor.item()
319 && hunk.buffer_range.start.cmp(&position, buffer).is_le()
320 {
321 let mut unclipped_point = cursor
322 .end()
323 .diff_base_byte_range
324 .end
325 .to_point(self.base_text());
326 if position.cmp(&cursor.end().buffer_range.end, buffer).is_ge() {
327 unclipped_point +=
328 Point::new(row, 0) - cursor.end().buffer_range.end.to_point(buffer);
329 }
330 // Move the cursor so that at the next step we can clip with the start of the next hunk.
331 cursor.next();
332 unclipped_point
333 } else {
334 // Position is before the added region for the first hunk.
335 debug_assert!(self.inner.hunks.first().is_none_or(|first_hunk| {
336 position.cmp(&first_hunk.buffer_range.start, buffer).is_le()
337 }));
338 Point::new(row, 0)
339 };
340
341 let max_point = if let Some(next_hunk) = cursor.item() {
342 next_hunk
343 .diff_base_byte_range
344 .start
345 .to_point(self.base_text())
346 } else {
347 self.base_text().max_point()
348 };
349 unclipped_point.min(max_point).row
350 }
351}
352
353impl BufferDiffInner<Entity<language::Buffer>> {
354 /// Returns the new index text and new pending hunks.
355 fn stage_or_unstage_hunks_impl(
356 &mut self,
357 unstaged_diff: &Self,
358 stage: bool,
359 hunks: &[DiffHunk],
360 buffer: &text::BufferSnapshot,
361 file_exists: bool,
362 cx: &mut Context<BufferDiff>,
363 ) -> Option<Rope> {
364 let head_text = self
365 .base_text_exists
366 .then(|| self.base_text.read(cx).as_rope().clone());
367 let index_text = unstaged_diff
368 .base_text_exists
369 .then(|| unstaged_diff.base_text.read(cx).as_rope().clone());
370
371 // If the file doesn't exist in either HEAD or the index, then the
372 // entire file must be either created or deleted in the index.
373 let (index_text, head_text) = match (index_text, head_text) {
374 (Some(index_text), Some(head_text)) if file_exists || !stage => (index_text, head_text),
375 (index_text, head_text) => {
376 let (new_index_text, new_status) = if stage {
377 log::debug!("stage all");
378 (
379 file_exists.then(|| buffer.as_rope().clone()),
380 DiffHunkSecondaryStatus::SecondaryHunkRemovalPending,
381 )
382 } else {
383 log::debug!("unstage all");
384 (
385 head_text,
386 DiffHunkSecondaryStatus::SecondaryHunkAdditionPending,
387 )
388 };
389
390 let hunk = PendingHunk {
391 buffer_range: Anchor::min_max_range_for_buffer(buffer.remote_id()),
392 diff_base_byte_range: 0..index_text.map_or(0, |rope| rope.len()),
393 buffer_version: buffer.version().clone(),
394 new_status,
395 };
396 self.pending_hunks = SumTree::from_item(hunk, buffer);
397 return new_index_text;
398 }
399 };
400
401 let mut pending_hunks = SumTree::new(buffer);
402 let mut old_pending_hunks = self.pending_hunks.cursor::<DiffHunkSummary>(buffer);
403
404 // first, merge new hunks into pending_hunks
405 for DiffHunk {
406 buffer_range,
407 diff_base_byte_range,
408 secondary_status,
409 ..
410 } in hunks.iter().cloned()
411 {
412 let preceding_pending_hunks = old_pending_hunks.slice(&buffer_range.start, Bias::Left);
413 pending_hunks.append(preceding_pending_hunks, buffer);
414
415 // Skip all overlapping or adjacent old pending hunks
416 while old_pending_hunks.item().is_some_and(|old_hunk| {
417 old_hunk
418 .buffer_range
419 .start
420 .cmp(&buffer_range.end, buffer)
421 .is_le()
422 }) {
423 old_pending_hunks.next();
424 }
425
426 if (stage && secondary_status == DiffHunkSecondaryStatus::NoSecondaryHunk)
427 || (!stage && secondary_status == DiffHunkSecondaryStatus::HasSecondaryHunk)
428 {
429 continue;
430 }
431
432 pending_hunks.push(
433 PendingHunk {
434 buffer_range,
435 diff_base_byte_range,
436 buffer_version: buffer.version().clone(),
437 new_status: if stage {
438 DiffHunkSecondaryStatus::SecondaryHunkRemovalPending
439 } else {
440 DiffHunkSecondaryStatus::SecondaryHunkAdditionPending
441 },
442 },
443 buffer,
444 );
445 }
446 // append the remainder
447 pending_hunks.append(old_pending_hunks.suffix(), buffer);
448
449 let mut unstaged_hunk_cursor = unstaged_diff.hunks.cursor::<DiffHunkSummary>(buffer);
450 unstaged_hunk_cursor.next();
451
452 // then, iterate over all pending hunks (both new ones and the existing ones) and compute the edits
453 let mut prev_unstaged_hunk_buffer_end = 0;
454 let mut prev_unstaged_hunk_base_text_end = 0;
455 let mut edits = Vec::<(Range<usize>, String)>::new();
456 let mut pending_hunks_iter = pending_hunks.iter().cloned().peekable();
457 while let Some(PendingHunk {
458 buffer_range,
459 diff_base_byte_range,
460 new_status,
461 ..
462 }) = pending_hunks_iter.next()
463 {
464 // Advance unstaged_hunk_cursor to skip unstaged hunks before current hunk
465 let skipped_unstaged = unstaged_hunk_cursor.slice(&buffer_range.start, Bias::Left);
466
467 if let Some(unstaged_hunk) = skipped_unstaged.last() {
468 prev_unstaged_hunk_base_text_end = unstaged_hunk.diff_base_byte_range.end;
469 prev_unstaged_hunk_buffer_end = unstaged_hunk.buffer_range.end.to_offset(buffer);
470 }
471
472 // Find where this hunk is in the index if it doesn't overlap
473 let mut buffer_offset_range = buffer_range.to_offset(buffer);
474 let start_overshoot = buffer_offset_range.start - prev_unstaged_hunk_buffer_end;
475 let mut index_start = prev_unstaged_hunk_base_text_end + start_overshoot;
476
477 loop {
478 // Merge this hunk with any overlapping unstaged hunks.
479 if let Some(unstaged_hunk) = unstaged_hunk_cursor.item() {
480 let unstaged_hunk_offset_range = unstaged_hunk.buffer_range.to_offset(buffer);
481 if unstaged_hunk_offset_range.start <= buffer_offset_range.end {
482 prev_unstaged_hunk_base_text_end = unstaged_hunk.diff_base_byte_range.end;
483 prev_unstaged_hunk_buffer_end = unstaged_hunk_offset_range.end;
484
485 index_start = index_start.min(unstaged_hunk.diff_base_byte_range.start);
486 buffer_offset_range.start = buffer_offset_range
487 .start
488 .min(unstaged_hunk_offset_range.start);
489 buffer_offset_range.end =
490 buffer_offset_range.end.max(unstaged_hunk_offset_range.end);
491
492 unstaged_hunk_cursor.next();
493 continue;
494 }
495 }
496
497 // If any unstaged hunks were merged, then subsequent pending hunks may
498 // now overlap this hunk. Merge them.
499 if let Some(next_pending_hunk) = pending_hunks_iter.peek() {
500 let next_pending_hunk_offset_range =
501 next_pending_hunk.buffer_range.to_offset(buffer);
502 if next_pending_hunk_offset_range.start <= buffer_offset_range.end {
503 buffer_offset_range.end = next_pending_hunk_offset_range.end;
504 pending_hunks_iter.next();
505 continue;
506 }
507 }
508
509 break;
510 }
511
512 let end_overshoot = buffer_offset_range
513 .end
514 .saturating_sub(prev_unstaged_hunk_buffer_end);
515 let index_end = prev_unstaged_hunk_base_text_end + end_overshoot;
516 let index_byte_range = index_start..index_end;
517
518 let replacement_text = match new_status {
519 DiffHunkSecondaryStatus::SecondaryHunkRemovalPending => {
520 log::debug!("staging hunk {:?}", buffer_offset_range);
521 buffer
522 .text_for_range(buffer_offset_range)
523 .collect::<String>()
524 }
525 DiffHunkSecondaryStatus::SecondaryHunkAdditionPending => {
526 log::debug!("unstaging hunk {:?}", buffer_offset_range);
527 head_text
528 .chunks_in_range(diff_base_byte_range.clone())
529 .collect::<String>()
530 }
531 _ => {
532 debug_assert!(false);
533 continue;
534 }
535 };
536
537 edits.push((index_byte_range, replacement_text));
538 }
539 drop(pending_hunks_iter);
540 drop(old_pending_hunks);
541 self.pending_hunks = pending_hunks;
542
543 #[cfg(debug_assertions)] // invariants: non-overlapping and sorted
544 {
545 for window in edits.windows(2) {
546 let (range_a, range_b) = (&window[0].0, &window[1].0);
547 debug_assert!(range_a.end < range_b.start);
548 }
549 }
550
551 let mut new_index_text = Rope::new();
552 let mut index_cursor = index_text.cursor(0);
553
554 for (old_range, replacement_text) in edits {
555 new_index_text.append(index_cursor.slice(old_range.start));
556 index_cursor.seek_forward(old_range.end);
557 new_index_text.push(&replacement_text);
558 }
559 new_index_text.append(index_cursor.suffix());
560 Some(new_index_text)
561 }
562}
563
564impl BufferDiffInner {
565 fn hunks_intersecting_range<'a>(
566 &'a self,
567 range: Range<Anchor>,
568 buffer: &'a text::BufferSnapshot,
569 secondary: Option<&'a Self>,
570 ) -> impl 'a + Iterator<Item = DiffHunk> {
571 let range = range.to_offset(buffer);
572 let filter = move |summary: &DiffHunkSummary| {
573 let summary_range = summary.buffer_range.to_offset(buffer);
574 let before_start = summary_range.end < range.start;
575 let after_end = summary_range.start > range.end;
576 !before_start && !after_end
577 };
578 self.hunks_intersecting_range_impl(filter, buffer, secondary)
579 }
580
581 fn hunks_intersecting_range_impl<'a>(
582 &'a self,
583 filter: impl 'a + Fn(&DiffHunkSummary) -> bool,
584 buffer: &'a text::BufferSnapshot,
585 secondary: Option<&'a Self>,
586 ) -> impl 'a + Iterator<Item = DiffHunk> {
587 let mut cursor = self.hunks.filter::<_, DiffHunkSummary>(buffer, filter);
588
589 let anchor_iter = iter::from_fn(move || {
590 cursor.next();
591 cursor.item()
592 })
593 .flat_map(move |hunk| {
594 [
595 (
596 &hunk.buffer_range.start,
597 (
598 hunk.buffer_range.start,
599 hunk.diff_base_byte_range.start,
600 hunk,
601 ),
602 ),
603 (
604 &hunk.buffer_range.end,
605 (hunk.buffer_range.end, hunk.diff_base_byte_range.end, hunk),
606 ),
607 ]
608 });
609
610 let mut pending_hunks_cursor = self.pending_hunks.cursor::<DiffHunkSummary>(buffer);
611 pending_hunks_cursor.next();
612
613 let mut secondary_cursor = None;
614 if let Some(secondary) = secondary.as_ref() {
615 let mut cursor = secondary.hunks.cursor::<DiffHunkSummary>(buffer);
616 cursor.next();
617 secondary_cursor = Some(cursor);
618 }
619
620 let max_point = buffer.max_point();
621 let mut summaries = buffer.summaries_for_anchors_with_payload::<Point, _, _>(anchor_iter);
622 iter::from_fn(move || {
623 loop {
624 let (start_point, (start_anchor, start_base, hunk)) = summaries.next()?;
625 let (mut end_point, (mut end_anchor, end_base, _)) = summaries.next()?;
626
627 let base_word_diffs = hunk.base_word_diffs.clone();
628 let buffer_word_diffs = hunk.buffer_word_diffs.clone();
629
630 if !start_anchor.is_valid(buffer) {
631 continue;
632 }
633
634 if end_point.column > 0 && end_point < max_point {
635 end_point.row += 1;
636 end_point.column = 0;
637 end_anchor = buffer.anchor_before(end_point);
638 }
639
640 let mut secondary_status = DiffHunkSecondaryStatus::NoSecondaryHunk;
641
642 let mut has_pending = false;
643 if start_anchor
644 .cmp(&pending_hunks_cursor.start().buffer_range.start, buffer)
645 .is_gt()
646 {
647 pending_hunks_cursor.seek_forward(&start_anchor, Bias::Left);
648 }
649
650 if let Some(pending_hunk) = pending_hunks_cursor.item() {
651 let mut pending_range = pending_hunk.buffer_range.to_point(buffer);
652 if pending_range.end.column > 0 {
653 pending_range.end.row += 1;
654 pending_range.end.column = 0;
655 }
656
657 if pending_range == (start_point..end_point)
658 && !buffer.has_edits_since_in_range(
659 &pending_hunk.buffer_version,
660 start_anchor..end_anchor,
661 )
662 {
663 has_pending = true;
664 secondary_status = pending_hunk.new_status;
665 }
666 }
667
668 if let (Some(secondary_cursor), false) = (secondary_cursor.as_mut(), has_pending) {
669 if start_anchor
670 .cmp(&secondary_cursor.start().buffer_range.start, buffer)
671 .is_gt()
672 {
673 secondary_cursor.seek_forward(&start_anchor, Bias::Left);
674 }
675
676 if let Some(secondary_hunk) = secondary_cursor.item() {
677 let mut secondary_range = secondary_hunk.buffer_range.to_point(buffer);
678 if secondary_range.end.column > 0 {
679 secondary_range.end.row += 1;
680 secondary_range.end.column = 0;
681 }
682 if secondary_range.is_empty()
683 && secondary_hunk.diff_base_byte_range.is_empty()
684 {
685 // ignore
686 } else if secondary_range == (start_point..end_point) {
687 secondary_status = DiffHunkSecondaryStatus::HasSecondaryHunk;
688 } else if secondary_range.start <= end_point {
689 secondary_status = DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk;
690 }
691 }
692 }
693
694 return Some(DiffHunk {
695 range: start_point..end_point,
696 diff_base_byte_range: start_base..end_base,
697 buffer_range: start_anchor..end_anchor,
698 base_word_diffs,
699 buffer_word_diffs,
700 secondary_status,
701 });
702 }
703 })
704 }
705
706 fn hunks_intersecting_range_rev<'a>(
707 &'a self,
708 range: Range<Anchor>,
709 buffer: &'a text::BufferSnapshot,
710 ) -> impl 'a + Iterator<Item = DiffHunk> {
711 let mut cursor = self
712 .hunks
713 .filter::<_, DiffHunkSummary>(buffer, move |summary| {
714 let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
715 let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
716 !before_start && !after_end
717 });
718
719 iter::from_fn(move || {
720 cursor.prev();
721
722 let hunk = cursor.item()?;
723 let range = hunk.buffer_range.to_point(buffer);
724
725 Some(DiffHunk {
726 range,
727 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
728 buffer_range: hunk.buffer_range.clone(),
729 // The secondary status is not used by callers of this method.
730 secondary_status: DiffHunkSecondaryStatus::NoSecondaryHunk,
731 base_word_diffs: hunk.base_word_diffs.clone(),
732 buffer_word_diffs: hunk.buffer_word_diffs.clone(),
733 })
734 })
735 }
736}
737
738fn build_diff_options(
739 file: Option<&Arc<dyn File>>,
740 language: Option<LanguageName>,
741 language_scope: Option<language::LanguageScope>,
742 cx: &App,
743) -> Option<DiffOptions> {
744 #[cfg(any(test, feature = "test-support"))]
745 {
746 if !cx.has_global::<settings::SettingsStore>() {
747 return Some(DiffOptions {
748 language_scope,
749 max_word_diff_line_count: MAX_WORD_DIFF_LINE_COUNT,
750 ..Default::default()
751 });
752 }
753 }
754
755 language_settings(language, file, cx)
756 .word_diff_enabled
757 .then_some(DiffOptions {
758 language_scope,
759 max_word_diff_line_count: MAX_WORD_DIFF_LINE_COUNT,
760 ..Default::default()
761 })
762}
763
764fn compute_hunks(
765 diff_base: Option<(Arc<str>, Rope)>,
766 buffer: text::BufferSnapshot,
767 diff_options: Option<DiffOptions>,
768) -> SumTree<InternalDiffHunk> {
769 let mut tree = SumTree::new(&buffer);
770
771 if let Some((diff_base, diff_base_rope)) = diff_base {
772 let buffer_text = buffer.as_rope().to_string();
773
774 let mut options = GitOptions::default();
775 options.context_lines(0);
776 let patch = GitPatch::from_buffers(
777 diff_base.as_bytes(),
778 None,
779 buffer_text.as_bytes(),
780 None,
781 Some(&mut options),
782 )
783 .log_err();
784
785 // A common case in Zed is that the empty buffer is represented as just a newline,
786 // but if we just compute a naive diff you get a "preserved" line in the middle,
787 // which is a bit odd.
788 if buffer_text == "\n" && diff_base.ends_with("\n") && diff_base.len() > 1 {
789 tree.push(
790 InternalDiffHunk {
791 buffer_range: buffer.anchor_before(0)..buffer.anchor_before(0),
792 diff_base_byte_range: 0..diff_base.len() - 1,
793 base_word_diffs: Vec::default(),
794 buffer_word_diffs: Vec::default(),
795 },
796 &buffer,
797 );
798 return tree;
799 }
800
801 if let Some(patch) = patch {
802 let mut divergence = 0;
803 for hunk_index in 0..patch.num_hunks() {
804 let hunk = process_patch_hunk(
805 &patch,
806 hunk_index,
807 &diff_base_rope,
808 &buffer,
809 &mut divergence,
810 diff_options.as_ref(),
811 );
812 tree.push(hunk, &buffer);
813 }
814 }
815 } else {
816 tree.push(
817 InternalDiffHunk {
818 buffer_range: Anchor::min_max_range_for_buffer(buffer.remote_id()),
819 diff_base_byte_range: 0..0,
820 base_word_diffs: Vec::default(),
821 buffer_word_diffs: Vec::default(),
822 },
823 &buffer,
824 );
825 }
826
827 tree
828}
829
830fn compare_hunks(
831 new_hunks: &SumTree<InternalDiffHunk>,
832 old_hunks: &SumTree<InternalDiffHunk>,
833 new_snapshot: &text::BufferSnapshot,
834) -> (Option<Range<Anchor>>, Option<Range<usize>>) {
835 let mut new_cursor = new_hunks.cursor::<()>(new_snapshot);
836 let mut old_cursor = old_hunks.cursor::<()>(new_snapshot);
837 old_cursor.next();
838 new_cursor.next();
839 let mut start = None;
840 let mut end = None;
841 let mut base_text_start = None;
842 let mut base_text_end = None;
843
844 loop {
845 match (new_cursor.item(), old_cursor.item()) {
846 (Some(new_hunk), Some(old_hunk)) => {
847 match new_hunk
848 .buffer_range
849 .start
850 .cmp(&old_hunk.buffer_range.start, new_snapshot)
851 {
852 Ordering::Less => {
853 start.get_or_insert(new_hunk.buffer_range.start);
854 base_text_start.get_or_insert(new_hunk.diff_base_byte_range.start);
855 end.replace(new_hunk.buffer_range.end);
856 base_text_end.get_or_insert(new_hunk.diff_base_byte_range.end);
857 new_cursor.next();
858 }
859 Ordering::Equal => {
860 if new_hunk != old_hunk {
861 start.get_or_insert(new_hunk.buffer_range.start);
862 base_text_start.get_or_insert(new_hunk.diff_base_byte_range.start);
863 if old_hunk
864 .buffer_range
865 .end
866 .cmp(&new_hunk.buffer_range.end, new_snapshot)
867 .is_ge()
868 {
869 end.replace(old_hunk.buffer_range.end);
870 base_text_end.replace(old_hunk.diff_base_byte_range.end);
871 } else {
872 end.replace(new_hunk.buffer_range.end);
873 base_text_end.replace(new_hunk.diff_base_byte_range.end);
874 }
875 }
876
877 new_cursor.next();
878 old_cursor.next();
879 }
880 Ordering::Greater => {
881 start.get_or_insert(old_hunk.buffer_range.start);
882 base_text_start.get_or_insert(old_hunk.diff_base_byte_range.start);
883 end.replace(old_hunk.buffer_range.end);
884 base_text_end.replace(old_hunk.diff_base_byte_range.end);
885 old_cursor.next();
886 }
887 }
888 }
889 (Some(new_hunk), None) => {
890 start.get_or_insert(new_hunk.buffer_range.start);
891 base_text_start.get_or_insert(new_hunk.diff_base_byte_range.start);
892 end.replace(new_hunk.buffer_range.end);
893 base_text_end.replace(new_hunk.diff_base_byte_range.end);
894 new_cursor.next();
895 }
896 (None, Some(old_hunk)) => {
897 start.get_or_insert(old_hunk.buffer_range.start);
898 base_text_start.get_or_insert(old_hunk.diff_base_byte_range.start);
899 end.replace(old_hunk.buffer_range.end);
900 base_text_end.replace(old_hunk.diff_base_byte_range.end);
901 old_cursor.next();
902 }
903 (None, None) => break,
904 }
905 }
906
907 (
908 start.zip(end).map(|(start, end)| start..end),
909 base_text_start
910 .zip(base_text_end)
911 .map(|(start, end)| start..end),
912 )
913}
914
915fn process_patch_hunk(
916 patch: &GitPatch<'_>,
917 hunk_index: usize,
918 diff_base: &Rope,
919 buffer: &text::BufferSnapshot,
920 buffer_row_divergence: &mut i64,
921 diff_options: Option<&DiffOptions>,
922) -> InternalDiffHunk {
923 let line_item_count = patch.num_lines_in_hunk(hunk_index).unwrap();
924 assert!(line_item_count > 0);
925
926 let mut first_deletion_buffer_row: Option<u32> = None;
927 let mut buffer_row_range: Option<Range<u32>> = None;
928 let mut diff_base_byte_range: Option<Range<usize>> = None;
929 let mut first_addition_old_row: Option<u32> = None;
930
931 for line_index in 0..line_item_count {
932 let line = patch.line_in_hunk(hunk_index, line_index).unwrap();
933 let kind = line.origin_value();
934 let content_offset = line.content_offset() as isize;
935 let content_len = line.content().len() as isize;
936 match kind {
937 GitDiffLineType::Addition => {
938 if first_addition_old_row.is_none() {
939 first_addition_old_row = Some(
940 (line.new_lineno().unwrap() as i64 - *buffer_row_divergence - 1) as u32,
941 );
942 }
943 *buffer_row_divergence += 1;
944 let row = line.new_lineno().unwrap().saturating_sub(1);
945
946 match &mut buffer_row_range {
947 Some(Range { end, .. }) => *end = row + 1,
948 None => buffer_row_range = Some(row..row + 1),
949 }
950 }
951 GitDiffLineType::Deletion => {
952 let end = content_offset + content_len;
953
954 match &mut diff_base_byte_range {
955 Some(head_byte_range) => head_byte_range.end = end as usize,
956 None => diff_base_byte_range = Some(content_offset as usize..end as usize),
957 }
958
959 if first_deletion_buffer_row.is_none() {
960 let old_row = line.old_lineno().unwrap().saturating_sub(1);
961 let row = old_row as i64 + *buffer_row_divergence;
962 first_deletion_buffer_row = Some(row as u32);
963 }
964
965 *buffer_row_divergence -= 1;
966 }
967 _ => {}
968 }
969 }
970
971 let buffer_row_range = buffer_row_range.unwrap_or_else(|| {
972 // Pure deletion hunk without addition.
973 let row = first_deletion_buffer_row.unwrap();
974 row..row
975 });
976 let diff_base_byte_range = diff_base_byte_range.unwrap_or_else(|| {
977 // Pure addition hunk without deletion.
978 let row = first_addition_old_row.unwrap();
979 let offset = diff_base.point_to_offset(Point::new(row, 0));
980 offset..offset
981 });
982
983 let start = Point::new(buffer_row_range.start, 0);
984 let end = Point::new(buffer_row_range.end, 0);
985 let buffer_range = buffer.anchor_before(start)..buffer.anchor_before(end);
986
987 let base_line_count = line_item_count.saturating_sub(buffer_row_range.len());
988
989 let (base_word_diffs, buffer_word_diffs) = if let Some(diff_options) = diff_options
990 && !buffer_row_range.is_empty()
991 && base_line_count == buffer_row_range.len()
992 && diff_options.max_word_diff_line_count >= base_line_count
993 {
994 let base_text: String = diff_base
995 .chunks_in_range(diff_base_byte_range.clone())
996 .collect();
997
998 let buffer_text: String = buffer.text_for_range(buffer_range.clone()).collect();
999
1000 let (base_word_diffs, buffer_word_diffs_relative) = word_diff_ranges(
1001 &base_text,
1002 &buffer_text,
1003 DiffOptions {
1004 language_scope: diff_options.language_scope.clone(),
1005 ..*diff_options
1006 },
1007 );
1008
1009 let buffer_start_offset = buffer_range.start.to_offset(buffer);
1010 let buffer_word_diffs = buffer_word_diffs_relative
1011 .into_iter()
1012 .map(|range| {
1013 let start = buffer.anchor_after(buffer_start_offset + range.start);
1014 let end = buffer.anchor_after(buffer_start_offset + range.end);
1015 start..end
1016 })
1017 .collect();
1018
1019 (base_word_diffs, buffer_word_diffs)
1020 } else {
1021 (Vec::default(), Vec::default())
1022 };
1023
1024 InternalDiffHunk {
1025 buffer_range,
1026 diff_base_byte_range,
1027 base_word_diffs,
1028 buffer_word_diffs,
1029 }
1030}
1031
1032impl std::fmt::Debug for BufferDiff {
1033 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1034 f.debug_struct("BufferChangeSet")
1035 .field("buffer_id", &self.buffer_id)
1036 .finish()
1037 }
1038}
1039
1040#[derive(Clone, Debug)]
1041pub enum BufferDiffEvent {
1042 DiffChanged {
1043 changed_range: Option<Range<text::Anchor>>,
1044 base_text_changed_range: Option<Range<usize>>,
1045 },
1046 LanguageChanged,
1047 HunksStagedOrUnstaged(Option<Rope>),
1048}
1049
1050impl EventEmitter<BufferDiffEvent> for BufferDiff {}
1051
1052impl BufferDiff {
1053 pub fn new(buffer: &text::BufferSnapshot, cx: &mut App) -> Self {
1054 let base_text = cx.new(|cx| {
1055 let mut buffer = language::Buffer::local("", cx);
1056 buffer.set_capability(Capability::ReadOnly, cx);
1057 buffer
1058 });
1059
1060 BufferDiff {
1061 buffer_id: buffer.remote_id(),
1062 inner: BufferDiffInner {
1063 base_text,
1064 hunks: SumTree::new(buffer),
1065 pending_hunks: SumTree::new(buffer),
1066 base_text_exists: false,
1067 },
1068 secondary_diff: None,
1069 }
1070 }
1071
1072 pub fn new_unchanged(buffer: &text::BufferSnapshot, cx: &mut Context<Self>) -> Self {
1073 let base_text = buffer.text();
1074 let base_text = cx.new(|cx| {
1075 let mut buffer = language::Buffer::local(base_text, cx);
1076 buffer.set_capability(Capability::ReadOnly, cx);
1077 buffer
1078 });
1079
1080 BufferDiff {
1081 buffer_id: buffer.remote_id(),
1082 inner: BufferDiffInner {
1083 base_text,
1084 hunks: SumTree::new(buffer),
1085 pending_hunks: SumTree::new(buffer),
1086 base_text_exists: false,
1087 },
1088 secondary_diff: None,
1089 }
1090 }
1091
1092 #[cfg(any(test, feature = "test-support"))]
1093 pub fn new_with_base_text(
1094 base_text: &str,
1095 buffer: &text::BufferSnapshot,
1096 cx: &mut Context<Self>,
1097 ) -> Self {
1098 let mut this = BufferDiff::new(&buffer, cx);
1099 let executor = cx.background_executor().clone();
1100 let mut base_text = base_text.to_owned();
1101 text::LineEnding::normalize(&mut base_text);
1102 let inner = executor.block(this.update_diff(
1103 buffer.clone(),
1104 Some(Arc::from(base_text)),
1105 true,
1106 None,
1107 cx,
1108 ));
1109 // FIXME
1110 this.set_snapshot(inner, &buffer, true, cx);
1111 this
1112 }
1113
1114 pub fn set_secondary_diff(&mut self, diff: Entity<BufferDiff>) {
1115 self.secondary_diff = Some(diff);
1116 }
1117
1118 pub fn secondary_diff(&self) -> Option<Entity<BufferDiff>> {
1119 self.secondary_diff.clone()
1120 }
1121
1122 pub fn clear_pending_hunks(&mut self, cx: &mut Context<Self>) {
1123 if self.secondary_diff.is_some() {
1124 self.inner.pending_hunks = SumTree::from_summary(DiffHunkSummary {
1125 buffer_range: Anchor::min_min_range_for_buffer(self.buffer_id),
1126 diff_base_byte_range: 0..0,
1127 });
1128 cx.emit(BufferDiffEvent::DiffChanged {
1129 changed_range: Some(Anchor::min_max_range_for_buffer(self.buffer_id)),
1130 base_text_changed_range: Some(0..self.base_text(cx).len()),
1131 });
1132 }
1133 }
1134
1135 pub fn stage_or_unstage_hunks(
1136 &mut self,
1137 stage: bool,
1138 hunks: &[DiffHunk],
1139 buffer: &text::BufferSnapshot,
1140 file_exists: bool,
1141 cx: &mut Context<Self>,
1142 ) -> Option<Rope> {
1143 let new_index_text = self
1144 .secondary_diff
1145 .as_ref()?
1146 .update(cx, |secondary_diff, cx| {
1147 self.inner.stage_or_unstage_hunks_impl(
1148 &secondary_diff.inner,
1149 stage,
1150 hunks,
1151 buffer,
1152 file_exists,
1153 cx,
1154 )
1155 });
1156
1157 cx.emit(BufferDiffEvent::HunksStagedOrUnstaged(
1158 new_index_text.clone(),
1159 ));
1160 if let Some((first, last)) = hunks.first().zip(hunks.last()) {
1161 let changed_range = first.buffer_range.start..last.buffer_range.end;
1162 let base_text_changed_range =
1163 first.diff_base_byte_range.start..last.diff_base_byte_range.end;
1164 cx.emit(BufferDiffEvent::DiffChanged {
1165 changed_range: Some(changed_range),
1166 base_text_changed_range: Some(base_text_changed_range),
1167 });
1168 }
1169 new_index_text
1170 }
1171
1172 pub fn update_diff(
1173 &self,
1174 buffer: text::BufferSnapshot,
1175 base_text: Option<Arc<str>>,
1176 base_text_changed: bool,
1177 language: Option<Arc<Language>>,
1178 cx: &App,
1179 ) -> Task<BufferDiffInner<Arc<str>>> {
1180 let prev_base_text = self.base_text(cx).as_rope().clone();
1181 let diff_options = build_diff_options(
1182 None,
1183 language.as_ref().map(|l| l.name()),
1184 language.as_ref().map(|l| l.default_scope()),
1185 cx,
1186 );
1187
1188 cx.background_executor()
1189 .spawn_labeled(*CALCULATE_DIFF_TASK, async move {
1190 let base_text_rope = if let Some(base_text) = &base_text {
1191 if base_text_changed {
1192 Rope::from(base_text.as_ref())
1193 } else {
1194 prev_base_text
1195 }
1196 } else {
1197 Rope::new()
1198 };
1199 let base_text_exists = base_text.is_some();
1200 let hunks = compute_hunks(
1201 base_text
1202 .clone()
1203 .map(|base_text| (base_text, base_text_rope.clone())),
1204 buffer.clone(),
1205 diff_options,
1206 );
1207 let base_text = base_text.unwrap_or_default();
1208 BufferDiffInner {
1209 base_text,
1210 hunks,
1211 base_text_exists,
1212 pending_hunks: SumTree::new(&buffer),
1213 }
1214 })
1215 }
1216
1217 pub fn language_changed(
1218 &mut self,
1219 language: Option<Arc<Language>>,
1220 language_registry: Option<Arc<LanguageRegistry>>,
1221 cx: &mut Context<Self>,
1222 ) {
1223 self.inner.base_text.update(cx, |base_text, cx| {
1224 base_text.set_language(language, cx);
1225 if let Some(language_registry) = language_registry {
1226 base_text.set_language_registry(language_registry);
1227 }
1228 });
1229 cx.emit(BufferDiffEvent::LanguageChanged);
1230 }
1231
1232 // FIXME name
1233 pub fn set_snapshot(
1234 &mut self,
1235 new_state: BufferDiffInner<Arc<str>>,
1236 buffer: &text::BufferSnapshot,
1237 base_text_changed: bool,
1238 cx: &mut Context<Self>,
1239 ) -> Option<Range<Anchor>> {
1240 self.set_snapshot_with_secondary(new_state, buffer, None, base_text_changed, false, cx)
1241 }
1242
1243 // FIXME name
1244 pub fn set_snapshot_with_secondary(
1245 &mut self,
1246 new_state: BufferDiffInner<Arc<str>>,
1247 buffer: &text::BufferSnapshot,
1248 secondary_diff_change: Option<Range<Anchor>>,
1249 base_text_changed: bool,
1250 clear_pending_hunks: bool,
1251 cx: &mut Context<Self>,
1252 ) -> Option<Range<Anchor>> {
1253 log::debug!("set snapshot with secondary {secondary_diff_change:?}");
1254
1255 let old_snapshot = self.snapshot(cx);
1256 let state = &mut self.inner;
1257 let (mut changed_range, mut base_text_changed_range) =
1258 match (state.base_text_exists, new_state.base_text_exists) {
1259 (false, false) => (None, None),
1260 (true, true) if !base_text_changed => {
1261 compare_hunks(&new_state.hunks, &old_snapshot.inner.hunks, buffer)
1262 }
1263 _ => (
1264 Some(text::Anchor::min_max_range_for_buffer(self.buffer_id)),
1265 Some(0..new_state.base_text.len()),
1266 ),
1267 };
1268
1269 if let Some(secondary_changed_range) = secondary_diff_change
1270 && let (Some(secondary_hunk_range), Some(secondary_base_range)) =
1271 old_snapshot.range_to_hunk_range(secondary_changed_range, buffer)
1272 {
1273 if let Some(range) = &mut changed_range {
1274 range.start = *secondary_hunk_range.start.min(&range.start, buffer);
1275 range.end = *secondary_hunk_range.end.max(&range.end, buffer);
1276 } else {
1277 changed_range = Some(secondary_hunk_range);
1278 }
1279
1280 if let Some(base_text_range) = &mut base_text_changed_range {
1281 base_text_range.start = secondary_base_range.start.min(base_text_range.start);
1282 base_text_range.end = secondary_base_range.end.max(base_text_range.end);
1283 } else {
1284 base_text_changed_range = Some(secondary_base_range);
1285 }
1286 }
1287
1288 let state = &mut self.inner;
1289 state.base_text_exists = new_state.base_text_exists;
1290 if base_text_changed {
1291 state.base_text.update(cx, |base_text, cx| {
1292 base_text.set_capability(Capability::ReadWrite, cx);
1293 base_text.set_text(new_state.base_text.clone(), cx);
1294 base_text.set_capability(Capability::ReadOnly, cx);
1295 })
1296 }
1297 state.hunks = new_state.hunks;
1298 if base_text_changed || clear_pending_hunks {
1299 if let Some((first, last)) = state.pending_hunks.first().zip(state.pending_hunks.last())
1300 {
1301 if let Some(range) = &mut changed_range {
1302 range.start = *range.start.min(&first.buffer_range.start, buffer);
1303 range.end = *range.end.max(&last.buffer_range.end, buffer);
1304 } else {
1305 changed_range = Some(first.buffer_range.start..last.buffer_range.end);
1306 }
1307
1308 if let Some(base_text_range) = &mut base_text_changed_range {
1309 base_text_range.start =
1310 base_text_range.start.min(first.diff_base_byte_range.start);
1311 base_text_range.end = base_text_range.end.max(last.diff_base_byte_range.end);
1312 } else {
1313 base_text_changed_range =
1314 Some(first.diff_base_byte_range.start..last.diff_base_byte_range.end);
1315 }
1316 }
1317 state.pending_hunks = SumTree::new(buffer);
1318 }
1319
1320 cx.emit(BufferDiffEvent::DiffChanged {
1321 changed_range: changed_range.clone(),
1322 base_text_changed_range,
1323 });
1324 changed_range
1325 }
1326
1327 pub fn base_text(&self, cx: &App) -> language::BufferSnapshot {
1328 self.inner.base_text.read(cx).snapshot()
1329 }
1330
1331 pub fn base_text_exists(&self) -> bool {
1332 self.inner.base_text_exists
1333 }
1334
1335 pub fn snapshot(&self, cx: &App) -> BufferDiffSnapshot {
1336 BufferDiffSnapshot {
1337 inner: BufferDiffInner {
1338 hunks: self.inner.hunks.clone(),
1339 pending_hunks: self.inner.pending_hunks.clone(),
1340 base_text: self.inner.base_text.read(cx).snapshot(),
1341 base_text_exists: self.inner.base_text_exists,
1342 },
1343 secondary_diff: self
1344 .secondary_diff
1345 .as_ref()
1346 .map(|diff| Box::new(diff.read(cx).snapshot(cx))),
1347 }
1348 }
1349
1350 /// Used in cases where the change set isn't derived from git.
1351 pub fn set_base_text(
1352 &mut self,
1353 base_text: Option<Arc<str>>,
1354 language: Option<Arc<Language>>,
1355 buffer: text::BufferSnapshot,
1356 cx: &mut Context<Self>,
1357 ) -> oneshot::Receiver<()> {
1358 let (tx, rx) = oneshot::channel();
1359 let complete_on_drop = util::defer(|| {
1360 tx.send(()).ok();
1361 });
1362 cx.spawn(async move |this, cx| {
1363 let Some(state) = this
1364 .update(cx, |this, cx| {
1365 this.update_diff(buffer.clone(), base_text, true, language, cx)
1366 })
1367 .log_err()
1368 else {
1369 return;
1370 };
1371 let state = state.await;
1372 this.update(cx, |this, cx| {
1373 this.set_snapshot(state, &buffer, true, cx);
1374 })
1375 .log_err();
1376 drop(complete_on_drop)
1377 })
1378 .detach();
1379 rx
1380 }
1381
1382 pub fn base_text_string(&self, cx: &App) -> Option<String> {
1383 self.inner
1384 .base_text_exists
1385 .then(|| self.inner.base_text.read(cx).text())
1386 }
1387
1388 #[cfg(any(test, feature = "test-support"))]
1389 pub fn recalculate_diff_sync(&mut self, buffer: text::BufferSnapshot, cx: &mut Context<Self>) {
1390 let language = self.base_text(cx).language().cloned();
1391 let base_text = self.base_text_string(cx).map(|s| s.as_str().into());
1392 let fut = self.update_diff(buffer.clone(), base_text, false, language, cx);
1393 let snapshot = cx.background_executor().block(fut);
1394 self.set_snapshot(snapshot, &buffer, false, cx);
1395 }
1396
1397 pub fn base_text_buffer(&self) -> Entity<language::Buffer> {
1398 self.inner.base_text.clone()
1399 }
1400}
1401
1402impl DiffHunk {
1403 pub fn is_created_file(&self) -> bool {
1404 self.diff_base_byte_range == (0..0)
1405 && self.buffer_range.start.is_min()
1406 && self.buffer_range.end.is_max()
1407 }
1408
1409 pub fn status(&self) -> DiffHunkStatus {
1410 let kind = if self.buffer_range.start == self.buffer_range.end {
1411 DiffHunkStatusKind::Deleted
1412 } else if self.diff_base_byte_range.is_empty() {
1413 DiffHunkStatusKind::Added
1414 } else {
1415 DiffHunkStatusKind::Modified
1416 };
1417 DiffHunkStatus {
1418 kind,
1419 secondary: self.secondary_status,
1420 }
1421 }
1422}
1423
1424impl DiffHunkStatus {
1425 pub fn has_secondary_hunk(&self) -> bool {
1426 matches!(
1427 self.secondary,
1428 DiffHunkSecondaryStatus::HasSecondaryHunk
1429 | DiffHunkSecondaryStatus::SecondaryHunkAdditionPending
1430 | DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk
1431 )
1432 }
1433
1434 pub fn is_pending(&self) -> bool {
1435 matches!(
1436 self.secondary,
1437 DiffHunkSecondaryStatus::SecondaryHunkAdditionPending
1438 | DiffHunkSecondaryStatus::SecondaryHunkRemovalPending
1439 )
1440 }
1441
1442 pub fn is_deleted(&self) -> bool {
1443 self.kind == DiffHunkStatusKind::Deleted
1444 }
1445
1446 pub fn is_added(&self) -> bool {
1447 self.kind == DiffHunkStatusKind::Added
1448 }
1449
1450 pub fn is_modified(&self) -> bool {
1451 self.kind == DiffHunkStatusKind::Modified
1452 }
1453
1454 pub fn added(secondary: DiffHunkSecondaryStatus) -> Self {
1455 Self {
1456 kind: DiffHunkStatusKind::Added,
1457 secondary,
1458 }
1459 }
1460
1461 pub fn modified(secondary: DiffHunkSecondaryStatus) -> Self {
1462 Self {
1463 kind: DiffHunkStatusKind::Modified,
1464 secondary,
1465 }
1466 }
1467
1468 pub fn deleted(secondary: DiffHunkSecondaryStatus) -> Self {
1469 Self {
1470 kind: DiffHunkStatusKind::Deleted,
1471 secondary,
1472 }
1473 }
1474
1475 pub fn deleted_none() -> Self {
1476 Self {
1477 kind: DiffHunkStatusKind::Deleted,
1478 secondary: DiffHunkSecondaryStatus::NoSecondaryHunk,
1479 }
1480 }
1481
1482 pub fn added_none() -> Self {
1483 Self {
1484 kind: DiffHunkStatusKind::Added,
1485 secondary: DiffHunkSecondaryStatus::NoSecondaryHunk,
1486 }
1487 }
1488
1489 pub fn modified_none() -> Self {
1490 Self {
1491 kind: DiffHunkStatusKind::Modified,
1492 secondary: DiffHunkSecondaryStatus::NoSecondaryHunk,
1493 }
1494 }
1495}
1496
1497#[cfg(any(test, feature = "test-support"))]
1498#[track_caller]
1499pub fn assert_hunks<ExpectedText, HunkIter>(
1500 diff_hunks: HunkIter,
1501 buffer: &text::BufferSnapshot,
1502 diff_base: &str,
1503 // Line range, deleted, added, status
1504 expected_hunks: &[(Range<u32>, ExpectedText, ExpectedText, DiffHunkStatus)],
1505) where
1506 HunkIter: Iterator<Item = DiffHunk>,
1507 ExpectedText: AsRef<str>,
1508{
1509 let actual_hunks = diff_hunks
1510 .map(|hunk| {
1511 (
1512 hunk.range.clone(),
1513 &diff_base[hunk.diff_base_byte_range.clone()],
1514 buffer
1515 .text_for_range(hunk.range.clone())
1516 .collect::<String>(),
1517 hunk.status(),
1518 )
1519 })
1520 .collect::<Vec<_>>();
1521
1522 let expected_hunks: Vec<_> = expected_hunks
1523 .iter()
1524 .map(|(line_range, deleted_text, added_text, status)| {
1525 (
1526 Point::new(line_range.start, 0)..Point::new(line_range.end, 0),
1527 deleted_text.as_ref(),
1528 added_text.as_ref().to_string(),
1529 *status,
1530 )
1531 })
1532 .collect();
1533
1534 pretty_assertions::assert_eq!(actual_hunks, expected_hunks);
1535}
1536
1537#[cfg(test)]
1538mod tests {
1539 use std::fmt::Write as _;
1540
1541 use super::*;
1542 use gpui::TestAppContext;
1543 use pretty_assertions::{assert_eq, assert_ne};
1544 use rand::{Rng as _, rngs::StdRng};
1545 use text::{Buffer, BufferId, ReplicaId, Rope};
1546 use unindent::Unindent as _;
1547 use util::test::marked_text_ranges;
1548
1549 #[ctor::ctor]
1550 fn init_logger() {
1551 zlog::init_test();
1552 }
1553
1554 #[gpui::test]
1555 async fn test_buffer_diff_simple(cx: &mut gpui::TestAppContext) {
1556 let diff_base = "
1557 one
1558 two
1559 three
1560 "
1561 .unindent();
1562
1563 let buffer_text = "
1564 one
1565 HELLO
1566 three
1567 "
1568 .unindent();
1569
1570 let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text);
1571 let mut diff = BufferDiffSnapshot::new_sync(buffer.clone(), diff_base.clone(), cx);
1572 assert_hunks(
1573 diff.hunks_intersecting_range(
1574 Anchor::min_max_range_for_buffer(buffer.remote_id()),
1575 &buffer,
1576 ),
1577 &buffer,
1578 &diff_base,
1579 &[(1..2, "two\n", "HELLO\n", DiffHunkStatus::modified_none())],
1580 );
1581
1582 buffer.edit([(0..0, "point five\n")]);
1583 diff = BufferDiffSnapshot::new_sync(buffer.clone(), diff_base.clone(), cx);
1584 assert_hunks(
1585 diff.hunks_intersecting_range(
1586 Anchor::min_max_range_for_buffer(buffer.remote_id()),
1587 &buffer,
1588 ),
1589 &buffer,
1590 &diff_base,
1591 &[
1592 (0..1, "", "point five\n", DiffHunkStatus::added_none()),
1593 (2..3, "two\n", "HELLO\n", DiffHunkStatus::modified_none()),
1594 ],
1595 );
1596
1597 diff = cx.update(|cx| BufferDiff::new(&buffer, cx).snapshot(cx));
1598 assert_hunks::<&str, _>(
1599 diff.hunks_intersecting_range(
1600 Anchor::min_max_range_for_buffer(buffer.remote_id()),
1601 &buffer,
1602 ),
1603 &buffer,
1604 &diff_base,
1605 &[],
1606 );
1607 }
1608
1609 #[gpui::test]
1610 async fn test_buffer_diff_with_secondary(cx: &mut gpui::TestAppContext) {
1611 let head_text = "
1612 zero
1613 one
1614 two
1615 three
1616 four
1617 five
1618 six
1619 seven
1620 eight
1621 nine
1622 "
1623 .unindent();
1624
1625 let index_text = "
1626 zero
1627 one
1628 TWO
1629 three
1630 FOUR
1631 five
1632 six
1633 seven
1634 eight
1635 NINE
1636 "
1637 .unindent();
1638
1639 let buffer_text = "
1640 zero
1641 one
1642 TWO
1643 three
1644 FOUR
1645 FIVE
1646 six
1647 SEVEN
1648 eight
1649 nine
1650 "
1651 .unindent();
1652
1653 let buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text);
1654 let unstaged_diff = BufferDiffSnapshot::new_sync(buffer.clone(), index_text, cx);
1655 let mut uncommitted_diff =
1656 BufferDiffSnapshot::new_sync(buffer.clone(), head_text.clone(), cx);
1657 uncommitted_diff.secondary_diff = Some(Box::new(unstaged_diff));
1658
1659 let expected_hunks = vec![
1660 (2..3, "two\n", "TWO\n", DiffHunkStatus::modified_none()),
1661 (
1662 4..6,
1663 "four\nfive\n",
1664 "FOUR\nFIVE\n",
1665 DiffHunkStatus::modified(DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk),
1666 ),
1667 (
1668 7..8,
1669 "seven\n",
1670 "SEVEN\n",
1671 DiffHunkStatus::modified(DiffHunkSecondaryStatus::HasSecondaryHunk),
1672 ),
1673 ];
1674
1675 assert_hunks(
1676 uncommitted_diff.hunks_intersecting_range(
1677 Anchor::min_max_range_for_buffer(buffer.remote_id()),
1678 &buffer,
1679 ),
1680 &buffer,
1681 &head_text,
1682 &expected_hunks,
1683 );
1684 }
1685
1686 #[gpui::test]
1687 async fn test_buffer_diff_range(cx: &mut TestAppContext) {
1688 let diff_base = "
1689 one
1690 two
1691 three
1692 four
1693 five
1694 six
1695 seven
1696 eight
1697 nine
1698 ten
1699 "
1700 .unindent();
1701
1702 let buffer_text = "
1703 A
1704 one
1705 B
1706 two
1707 C
1708 three
1709 HELLO
1710 four
1711 five
1712 SIXTEEN
1713 seven
1714 eight
1715 WORLD
1716 nine
1717
1718 ten
1719
1720 "
1721 .unindent();
1722
1723 let buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text);
1724 let diff = BufferDiffSnapshot::new_sync(buffer.snapshot(), diff_base.clone(), cx);
1725 assert_eq!(
1726 diff.hunks_intersecting_range(
1727 Anchor::min_max_range_for_buffer(buffer.remote_id()),
1728 &buffer
1729 )
1730 .count(),
1731 8
1732 );
1733
1734 assert_hunks(
1735 diff.hunks_intersecting_range(
1736 buffer.anchor_before(Point::new(7, 0))..buffer.anchor_before(Point::new(12, 0)),
1737 &buffer,
1738 ),
1739 &buffer,
1740 &diff_base,
1741 &[
1742 (6..7, "", "HELLO\n", DiffHunkStatus::added_none()),
1743 (9..10, "six\n", "SIXTEEN\n", DiffHunkStatus::modified_none()),
1744 (12..13, "", "WORLD\n", DiffHunkStatus::added_none()),
1745 ],
1746 );
1747 }
1748
1749 #[gpui::test]
1750 async fn test_stage_hunk(cx: &mut TestAppContext) {
1751 struct Example {
1752 name: &'static str,
1753 head_text: String,
1754 index_text: String,
1755 buffer_marked_text: String,
1756 final_index_text: String,
1757 }
1758
1759 let table = [
1760 Example {
1761 name: "uncommitted hunk straddles end of unstaged hunk",
1762 head_text: "
1763 one
1764 two
1765 three
1766 four
1767 five
1768 "
1769 .unindent(),
1770 index_text: "
1771 one
1772 TWO_HUNDRED
1773 three
1774 FOUR_HUNDRED
1775 five
1776 "
1777 .unindent(),
1778 buffer_marked_text: "
1779 ZERO
1780 one
1781 two
1782 «THREE_HUNDRED
1783 FOUR_HUNDRED»
1784 five
1785 SIX
1786 "
1787 .unindent(),
1788 final_index_text: "
1789 one
1790 two
1791 THREE_HUNDRED
1792 FOUR_HUNDRED
1793 five
1794 "
1795 .unindent(),
1796 },
1797 Example {
1798 name: "uncommitted hunk straddles start of unstaged hunk",
1799 head_text: "
1800 one
1801 two
1802 three
1803 four
1804 five
1805 "
1806 .unindent(),
1807 index_text: "
1808 one
1809 TWO_HUNDRED
1810 three
1811 FOUR_HUNDRED
1812 five
1813 "
1814 .unindent(),
1815 buffer_marked_text: "
1816 ZERO
1817 one
1818 «TWO_HUNDRED
1819 THREE_HUNDRED»
1820 four
1821 five
1822 SIX
1823 "
1824 .unindent(),
1825 final_index_text: "
1826 one
1827 TWO_HUNDRED
1828 THREE_HUNDRED
1829 four
1830 five
1831 "
1832 .unindent(),
1833 },
1834 Example {
1835 name: "uncommitted hunk strictly contains unstaged hunks",
1836 head_text: "
1837 one
1838 two
1839 three
1840 four
1841 five
1842 six
1843 seven
1844 "
1845 .unindent(),
1846 index_text: "
1847 one
1848 TWO
1849 THREE
1850 FOUR
1851 FIVE
1852 SIX
1853 seven
1854 "
1855 .unindent(),
1856 buffer_marked_text: "
1857 one
1858 TWO
1859 «THREE_HUNDRED
1860 FOUR
1861 FIVE_HUNDRED»
1862 SIX
1863 seven
1864 "
1865 .unindent(),
1866 final_index_text: "
1867 one
1868 TWO
1869 THREE_HUNDRED
1870 FOUR
1871 FIVE_HUNDRED
1872 SIX
1873 seven
1874 "
1875 .unindent(),
1876 },
1877 Example {
1878 name: "uncommitted deletion hunk",
1879 head_text: "
1880 one
1881 two
1882 three
1883 four
1884 five
1885 "
1886 .unindent(),
1887 index_text: "
1888 one
1889 two
1890 three
1891 four
1892 five
1893 "
1894 .unindent(),
1895 buffer_marked_text: "
1896 one
1897 ˇfive
1898 "
1899 .unindent(),
1900 final_index_text: "
1901 one
1902 five
1903 "
1904 .unindent(),
1905 },
1906 Example {
1907 name: "one unstaged hunk that contains two uncommitted hunks",
1908 head_text: "
1909 one
1910 two
1911
1912 three
1913 four
1914 "
1915 .unindent(),
1916 index_text: "
1917 one
1918 two
1919 three
1920 four
1921 "
1922 .unindent(),
1923 buffer_marked_text: "
1924 «one
1925
1926 three // modified
1927 four»
1928 "
1929 .unindent(),
1930 final_index_text: "
1931 one
1932
1933 three // modified
1934 four
1935 "
1936 .unindent(),
1937 },
1938 Example {
1939 name: "one uncommitted hunk that contains two unstaged hunks",
1940 head_text: "
1941 one
1942 two
1943 three
1944 four
1945 five
1946 "
1947 .unindent(),
1948 index_text: "
1949 ZERO
1950 one
1951 TWO
1952 THREE
1953 FOUR
1954 five
1955 "
1956 .unindent(),
1957 buffer_marked_text: "
1958 «one
1959 TWO_HUNDRED
1960 THREE
1961 FOUR_HUNDRED
1962 five»
1963 "
1964 .unindent(),
1965 final_index_text: "
1966 ZERO
1967 one
1968 TWO_HUNDRED
1969 THREE
1970 FOUR_HUNDRED
1971 five
1972 "
1973 .unindent(),
1974 },
1975 ];
1976
1977 for example in table {
1978 let (buffer_text, ranges) = marked_text_ranges(&example.buffer_marked_text, false);
1979 let buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text);
1980 let hunk_range =
1981 buffer.anchor_before(ranges[0].start)..buffer.anchor_before(ranges[0].end);
1982
1983 let unstaged_diff =
1984 cx.new(|cx| BufferDiff::new_with_base_text(&example.index_text, &buffer, cx));
1985
1986 let uncommitted_diff = cx.new(|cx| {
1987 let mut diff = BufferDiff::new_with_base_text(&example.head_text, &buffer, cx);
1988 diff.set_secondary_diff(unstaged_diff);
1989 diff
1990 });
1991
1992 uncommitted_diff.update(cx, |diff, cx| {
1993 let hunks = diff
1994 .snapshot(cx)
1995 .hunks_intersecting_range(hunk_range.clone(), &buffer)
1996 .collect::<Vec<_>>();
1997 for hunk in &hunks {
1998 assert_ne!(
1999 hunk.secondary_status,
2000 DiffHunkSecondaryStatus::NoSecondaryHunk
2001 )
2002 }
2003
2004 let new_index_text = diff
2005 .stage_or_unstage_hunks(true, &hunks, &buffer, true, cx)
2006 .unwrap()
2007 .to_string();
2008
2009 let hunks = diff
2010 .snapshot(cx)
2011 .hunks_intersecting_range(hunk_range.clone(), &buffer)
2012 .collect::<Vec<_>>();
2013 for hunk in &hunks {
2014 assert_eq!(
2015 hunk.secondary_status,
2016 DiffHunkSecondaryStatus::SecondaryHunkRemovalPending
2017 )
2018 }
2019
2020 pretty_assertions::assert_eq!(
2021 new_index_text,
2022 example.final_index_text,
2023 "example: {}",
2024 example.name
2025 );
2026 });
2027 }
2028 }
2029
2030 #[gpui::test]
2031 async fn test_toggling_stage_and_unstage_same_hunk(cx: &mut TestAppContext) {
2032 let head_text = "
2033 one
2034 two
2035 three
2036 "
2037 .unindent();
2038 let index_text = head_text.clone();
2039 let buffer_text = "
2040 one
2041 three
2042 "
2043 .unindent();
2044
2045 let buffer = Buffer::new(
2046 ReplicaId::LOCAL,
2047 BufferId::new(1).unwrap(),
2048 buffer_text.clone(),
2049 );
2050 let unstaged_diff = cx.new(|cx| BufferDiff::new_with_base_text(&index_text, &buffer, cx));
2051 let uncommitted_diff = cx.new(|cx| {
2052 let mut diff = BufferDiff::new_with_base_text(&head_text, &buffer, cx);
2053 diff.set_secondary_diff(unstaged_diff.clone());
2054 diff
2055 });
2056
2057 uncommitted_diff.update(cx, |diff, cx| {
2058 let hunk = diff.snapshot(cx).hunks(&buffer).next().unwrap();
2059
2060 let new_index_text = diff
2061 .stage_or_unstage_hunks(true, std::slice::from_ref(&hunk), &buffer, true, cx)
2062 .unwrap()
2063 .to_string();
2064 assert_eq!(new_index_text, buffer_text);
2065
2066 let hunk = diff.snapshot(cx).hunks(&buffer).next().unwrap();
2067 assert_eq!(
2068 hunk.secondary_status,
2069 DiffHunkSecondaryStatus::SecondaryHunkRemovalPending
2070 );
2071
2072 let index_text = diff
2073 .stage_or_unstage_hunks(false, &[hunk], &buffer, true, cx)
2074 .unwrap()
2075 .to_string();
2076 assert_eq!(index_text, head_text);
2077
2078 let hunk = diff.snapshot(cx).hunks(&buffer).next().unwrap();
2079 // optimistically unstaged (fine, could also be HasSecondaryHunk)
2080 assert_eq!(
2081 hunk.secondary_status,
2082 DiffHunkSecondaryStatus::SecondaryHunkAdditionPending
2083 );
2084 });
2085 }
2086
2087 #[gpui::test]
2088 async fn test_buffer_diff_compare(cx: &mut TestAppContext) {
2089 let base_text = "
2090 zero
2091 one
2092 two
2093 three
2094 four
2095 five
2096 six
2097 seven
2098 eight
2099 nine
2100 "
2101 .unindent();
2102
2103 let buffer_text_1 = "
2104 one
2105 three
2106 four
2107 five
2108 SIX
2109 seven
2110 eight
2111 NINE
2112 "
2113 .unindent();
2114
2115 let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text_1);
2116
2117 let empty_diff = cx.update(|cx| BufferDiff::new(&buffer, cx).snapshot(cx));
2118 let diff_1 = BufferDiffSnapshot::new_sync(buffer.clone(), base_text.clone(), cx);
2119 // FIXME assert the other half of the range
2120 let (range, base_text_range) =
2121 compare_hunks(&diff_1.inner.hunks, &empty_diff.inner.hunks, &buffer);
2122 let range = range.unwrap();
2123 assert_eq!(range.to_point(&buffer), Point::new(0, 0)..Point::new(8, 0));
2124
2125 // Edit does not affect the diff.
2126 buffer.edit_via_marked_text(
2127 &"
2128 one
2129 three
2130 four
2131 five
2132 «SIX.5»
2133 seven
2134 eight
2135 NINE
2136 "
2137 .unindent(),
2138 );
2139 let diff_2 = BufferDiffSnapshot::new_sync(buffer.clone(), base_text.clone(), cx);
2140 assert_eq!(
2141 (None, None),
2142 compare_hunks(&diff_2.inner.hunks, &diff_1.inner.hunks, &buffer)
2143 );
2144
2145 // Edit turns a deletion hunk into a modification.
2146 buffer.edit_via_marked_text(
2147 &"
2148 one
2149 «THREE»
2150 four
2151 five
2152 SIX.5
2153 seven
2154 eight
2155 NINE
2156 "
2157 .unindent(),
2158 );
2159 let diff_3 = BufferDiffSnapshot::new_sync(buffer.clone(), base_text.clone(), cx);
2160 // FIXME assert the other range
2161 let (range, base_text_range) =
2162 compare_hunks(&diff_3.inner.hunks, &diff_2.inner.hunks, &buffer);
2163 let range = range.unwrap();
2164 assert_eq!(range.to_point(&buffer), Point::new(1, 0)..Point::new(2, 0));
2165
2166 // Edit turns a modification hunk into a deletion.
2167 buffer.edit_via_marked_text(
2168 &"
2169 one
2170 THREE
2171 four
2172 five«»
2173 seven
2174 eight
2175 NINE
2176 "
2177 .unindent(),
2178 );
2179 let diff_4 = BufferDiffSnapshot::new_sync(buffer.clone(), base_text.clone(), cx);
2180 let (range, base_text_range) =
2181 compare_hunks(&diff_4.inner.hunks, &diff_3.inner.hunks, &buffer);
2182 let range = range.unwrap();
2183 assert_eq!(range.to_point(&buffer), Point::new(3, 4)..Point::new(4, 0));
2184
2185 // Edit introduces a new insertion hunk.
2186 buffer.edit_via_marked_text(
2187 &"
2188 one
2189 THREE
2190 four«
2191 FOUR.5
2192 »five
2193 seven
2194 eight
2195 NINE
2196 "
2197 .unindent(),
2198 );
2199 let diff_5 = BufferDiffSnapshot::new_sync(buffer.snapshot(), base_text.clone(), cx);
2200 let (range, base_text_range) =
2201 compare_hunks(&diff_5.inner.hunks, &diff_4.inner.hunks, &buffer);
2202 let range = range.unwrap();
2203 assert_eq!(range.to_point(&buffer), Point::new(3, 0)..Point::new(4, 0));
2204
2205 // Edit removes a hunk.
2206 buffer.edit_via_marked_text(
2207 &"
2208 one
2209 THREE
2210 four
2211 FOUR.5
2212 five
2213 seven
2214 eight
2215 «nine»
2216 "
2217 .unindent(),
2218 );
2219 let diff_6 = BufferDiffSnapshot::new_sync(buffer.snapshot(), base_text, cx);
2220 let (range, base_text_range) =
2221 compare_hunks(&diff_6.inner.hunks, &diff_5.inner.hunks, &buffer);
2222 let range = range.unwrap();
2223 assert_eq!(range.to_point(&buffer), Point::new(7, 0)..Point::new(8, 0));
2224 }
2225
2226 #[gpui::test(iterations = 100)]
2227 async fn test_staging_and_unstaging_hunks(cx: &mut TestAppContext, mut rng: StdRng) {
2228 fn gen_line(rng: &mut StdRng) -> String {
2229 if rng.random_bool(0.2) {
2230 "\n".to_owned()
2231 } else {
2232 let c = rng.random_range('A'..='Z');
2233 format!("{c}{c}{c}\n")
2234 }
2235 }
2236
2237 fn gen_working_copy(rng: &mut StdRng, head: &str) -> String {
2238 let mut old_lines = {
2239 let mut old_lines = Vec::new();
2240 let old_lines_iter = head.lines();
2241 for line in old_lines_iter {
2242 assert!(!line.ends_with("\n"));
2243 old_lines.push(line.to_owned());
2244 }
2245 if old_lines.last().is_some_and(|line| line.is_empty()) {
2246 old_lines.pop();
2247 }
2248 old_lines.into_iter()
2249 };
2250 let mut result = String::new();
2251 let unchanged_count = rng.random_range(0..=old_lines.len());
2252 result +=
2253 &old_lines
2254 .by_ref()
2255 .take(unchanged_count)
2256 .fold(String::new(), |mut s, line| {
2257 writeln!(&mut s, "{line}").unwrap();
2258 s
2259 });
2260 while old_lines.len() > 0 {
2261 let deleted_count = rng.random_range(0..=old_lines.len());
2262 let _advance = old_lines
2263 .by_ref()
2264 .take(deleted_count)
2265 .map(|line| line.len() + 1)
2266 .sum::<usize>();
2267 let minimum_added = if deleted_count == 0 { 1 } else { 0 };
2268 let added_count = rng.random_range(minimum_added..=5);
2269 let addition = (0..added_count).map(|_| gen_line(rng)).collect::<String>();
2270 result += &addition;
2271
2272 if old_lines.len() > 0 {
2273 let blank_lines = old_lines.clone().take_while(|line| line.is_empty()).count();
2274 if blank_lines == old_lines.len() {
2275 break;
2276 };
2277 let unchanged_count =
2278 rng.random_range((blank_lines + 1).max(1)..=old_lines.len());
2279 result += &old_lines.by_ref().take(unchanged_count).fold(
2280 String::new(),
2281 |mut s, line| {
2282 writeln!(&mut s, "{line}").unwrap();
2283 s
2284 },
2285 );
2286 }
2287 }
2288 result
2289 }
2290
2291 fn uncommitted_diff(
2292 working_copy: &language::BufferSnapshot,
2293 index_text: &Rope,
2294 head_text: String,
2295 cx: &mut TestAppContext,
2296 ) -> Entity<BufferDiff> {
2297 let secondary = cx.new(|cx| {
2298 BufferDiff::new_with_base_text(&index_text.to_string(), &working_copy.text, cx)
2299 });
2300 cx.new(|cx| {
2301 let mut diff = BufferDiff::new_with_base_text(&head_text, &working_copy.text, cx);
2302 diff.secondary_diff = Some(secondary);
2303 diff
2304 })
2305 }
2306
2307 let operations = std::env::var("OPERATIONS")
2308 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2309 .unwrap_or(10);
2310
2311 let rng = &mut rng;
2312 let head_text = ('a'..='z').fold(String::new(), |mut s, c| {
2313 writeln!(&mut s, "{c}{c}{c}").unwrap();
2314 s
2315 });
2316 let working_copy = gen_working_copy(rng, &head_text);
2317 let working_copy = cx.new(|cx| {
2318 language::Buffer::local_normalized(
2319 Rope::from(working_copy.as_str()),
2320 text::LineEnding::default(),
2321 cx,
2322 )
2323 });
2324 let working_copy = working_copy.read_with(cx, |working_copy, _| working_copy.snapshot());
2325 let mut index_text = if rng.random() {
2326 Rope::from(head_text.as_str())
2327 } else {
2328 working_copy.as_rope().clone()
2329 };
2330
2331 let mut diff = uncommitted_diff(&working_copy, &index_text, head_text.clone(), cx);
2332 let mut hunks = diff.update(cx, |diff, cx| {
2333 diff.snapshot(cx)
2334 .hunks_intersecting_range(
2335 Anchor::min_max_range_for_buffer(diff.buffer_id),
2336 &working_copy,
2337 )
2338 .collect::<Vec<_>>()
2339 });
2340 if hunks.is_empty() {
2341 return;
2342 }
2343
2344 for _ in 0..operations {
2345 let i = rng.random_range(0..hunks.len());
2346 let hunk = &mut hunks[i];
2347 let hunk_to_change = hunk.clone();
2348 let stage = match hunk.secondary_status {
2349 DiffHunkSecondaryStatus::HasSecondaryHunk => {
2350 hunk.secondary_status = DiffHunkSecondaryStatus::NoSecondaryHunk;
2351 true
2352 }
2353 DiffHunkSecondaryStatus::NoSecondaryHunk => {
2354 hunk.secondary_status = DiffHunkSecondaryStatus::HasSecondaryHunk;
2355 false
2356 }
2357 _ => unreachable!(),
2358 };
2359
2360 index_text = diff.update(cx, |diff, cx| {
2361 diff.stage_or_unstage_hunks(stage, &[hunk_to_change], &working_copy, true, cx)
2362 .unwrap()
2363 });
2364
2365 diff = uncommitted_diff(&working_copy, &index_text, head_text.clone(), cx);
2366 let found_hunks = diff.update(cx, |diff, cx| {
2367 diff.snapshot(cx)
2368 .hunks_intersecting_range(
2369 Anchor::min_max_range_for_buffer(diff.buffer_id),
2370 &working_copy,
2371 )
2372 .collect::<Vec<_>>()
2373 });
2374 assert_eq!(hunks.len(), found_hunks.len());
2375
2376 for (expected_hunk, found_hunk) in hunks.iter().zip(&found_hunks) {
2377 assert_eq!(
2378 expected_hunk.buffer_range.to_point(&working_copy),
2379 found_hunk.buffer_range.to_point(&working_copy)
2380 );
2381 assert_eq!(
2382 expected_hunk.diff_base_byte_range,
2383 found_hunk.diff_base_byte_range
2384 );
2385 assert_eq!(expected_hunk.secondary_status, found_hunk.secondary_status);
2386 }
2387 hunks = found_hunks;
2388 }
2389 }
2390
2391 #[gpui::test]
2392 async fn test_row_to_base_text_row(cx: &mut TestAppContext) {
2393 let base_text = "
2394 zero
2395 one
2396 two
2397 three
2398 four
2399 five
2400 six
2401 seven
2402 eight
2403 "
2404 .unindent();
2405 let buffer_text = "
2406 zero
2407 ONE
2408 two
2409 NINE
2410 five
2411 seven
2412 "
2413 .unindent();
2414
2415 // zero
2416 // - one
2417 // + ONE
2418 // two
2419 // - three
2420 // - four
2421 // + NINE
2422 // five
2423 // - six
2424 // seven
2425 // + eight
2426
2427 let buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text);
2428 let buffer_snapshot = buffer.snapshot();
2429 let diff = BufferDiffSnapshot::new_sync(buffer_snapshot.clone(), base_text, cx);
2430 let expected_results = [
2431 // don't format me
2432 (0, 0),
2433 (1, 2),
2434 (2, 2),
2435 (3, 5),
2436 (4, 5),
2437 (5, 7),
2438 (6, 9),
2439 ];
2440 for (buffer_row, expected) in expected_results {
2441 assert_eq!(
2442 diff.row_to_base_text_row(buffer_row, &buffer_snapshot),
2443 expected,
2444 "{buffer_row}"
2445 );
2446 }
2447 }
2448}