1use std::{
2 ops::{Range, RangeInclusive},
3 sync::Arc,
4};
5
6use collections::{hash_map, HashMap, HashSet};
7use git::diff::{DiffHunk, DiffHunkStatus};
8use gpui::{AppContext, Hsla, Model, Task, View};
9use language::Buffer;
10use multi_buffer::{
11 Anchor, ExcerptRange, MultiBuffer, MultiBufferRow, MultiBufferSnapshot, ToPoint,
12};
13use text::{BufferId, Point};
14use ui::{
15 div, ActiveTheme, Context as _, IntoElement, ParentElement, Styled, ViewContext, VisualContext,
16};
17use util::{debug_panic, RangeExt};
18
19use crate::{
20 git::{diff_hunk_to_display, DisplayDiffHunk},
21 hunk_status, hunks_for_selections, BlockDisposition, BlockId, BlockProperties, BlockStyle,
22 DiffRowHighlight, Editor, EditorSnapshot, ExpandAllHunkDiffs, RangeToAnchorExt,
23 RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
24};
25
26#[derive(Debug, Clone)]
27pub(super) struct HunkToExpand {
28 pub multi_buffer_range: Range<Anchor>,
29 pub status: DiffHunkStatus,
30 pub diff_base_byte_range: Range<usize>,
31}
32
33#[derive(Debug, Default)]
34pub(super) struct ExpandedHunks {
35 hunks: Vec<ExpandedHunk>,
36 diff_base: HashMap<BufferId, DiffBaseBuffer>,
37 hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
38}
39
40#[derive(Debug)]
41struct DiffBaseBuffer {
42 buffer: Model<Buffer>,
43 diff_base_version: usize,
44}
45
46impl ExpandedHunks {
47 pub fn hunks(&self, include_folded: bool) -> impl Iterator<Item = &ExpandedHunk> {
48 self.hunks
49 .iter()
50 .filter(move |hunk| include_folded || !hunk.folded)
51 }
52}
53
54#[derive(Debug, Clone)]
55pub(super) struct ExpandedHunk {
56 pub block: Option<BlockId>,
57 pub hunk_range: Range<Anchor>,
58 pub diff_base_byte_range: Range<usize>,
59 pub status: DiffHunkStatus,
60 pub folded: bool,
61}
62
63impl Editor {
64 pub fn toggle_hunk_diff(&mut self, _: &ToggleHunkDiff, cx: &mut ViewContext<Self>) {
65 let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
66 let selections = self.selections.disjoint_anchors();
67 self.toggle_hunks_expanded(
68 hunks_for_selections(&multi_buffer_snapshot, &selections),
69 cx,
70 );
71 }
72
73 pub fn expand_all_hunk_diffs(&mut self, _: &ExpandAllHunkDiffs, cx: &mut ViewContext<Self>) {
74 let snapshot = self.snapshot(cx);
75 let display_rows_with_expanded_hunks = self
76 .expanded_hunks
77 .hunks(false)
78 .map(|hunk| &hunk.hunk_range)
79 .map(|anchor_range| {
80 (
81 anchor_range
82 .start
83 .to_display_point(&snapshot.display_snapshot)
84 .row(),
85 anchor_range
86 .end
87 .to_display_point(&snapshot.display_snapshot)
88 .row(),
89 )
90 })
91 .collect::<HashMap<_, _>>();
92 let hunks = snapshot
93 .display_snapshot
94 .buffer_snapshot
95 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
96 .filter(|hunk| {
97 let hunk_display_row_range = Point::new(hunk.associated_range.start.0, 0)
98 .to_display_point(&snapshot.display_snapshot)
99 ..Point::new(hunk.associated_range.end.0, 0)
100 .to_display_point(&snapshot.display_snapshot);
101 let row_range_end =
102 display_rows_with_expanded_hunks.get(&hunk_display_row_range.start.row());
103 row_range_end.is_none() || row_range_end != Some(&hunk_display_row_range.end.row())
104 });
105 self.toggle_hunks_expanded(hunks.collect(), cx);
106 }
107
108 fn toggle_hunks_expanded(
109 &mut self,
110 hunks_to_toggle: Vec<DiffHunk<MultiBufferRow>>,
111 cx: &mut ViewContext<Self>,
112 ) {
113 let previous_toggle_task = self.expanded_hunks.hunk_update_tasks.remove(&None);
114 let new_toggle_task = cx.spawn(move |editor, mut cx| async move {
115 if let Some(task) = previous_toggle_task {
116 task.await;
117 }
118
119 editor
120 .update(&mut cx, |editor, cx| {
121 let snapshot = editor.snapshot(cx);
122 let mut hunks_to_toggle = hunks_to_toggle.into_iter().fuse().peekable();
123 let mut highlights_to_remove =
124 Vec::with_capacity(editor.expanded_hunks.hunks.len());
125 let mut blocks_to_remove = HashSet::default();
126 let mut hunks_to_expand = Vec::new();
127 editor.expanded_hunks.hunks.retain(|expanded_hunk| {
128 if expanded_hunk.folded {
129 return true;
130 }
131 let expanded_hunk_row_range = expanded_hunk
132 .hunk_range
133 .start
134 .to_display_point(&snapshot)
135 .row()
136 ..expanded_hunk
137 .hunk_range
138 .end
139 .to_display_point(&snapshot)
140 .row();
141 let mut retain = true;
142 while let Some(hunk_to_toggle) = hunks_to_toggle.peek() {
143 match diff_hunk_to_display(hunk_to_toggle, &snapshot) {
144 DisplayDiffHunk::Folded { .. } => {
145 hunks_to_toggle.next();
146 continue;
147 }
148 DisplayDiffHunk::Unfolded {
149 diff_base_byte_range,
150 display_row_range,
151 multi_buffer_range,
152 status,
153 } => {
154 let hunk_to_toggle_row_range = display_row_range;
155 if hunk_to_toggle_row_range.start > expanded_hunk_row_range.end
156 {
157 break;
158 } else if expanded_hunk_row_range == hunk_to_toggle_row_range {
159 highlights_to_remove.push(expanded_hunk.hunk_range.clone());
160 blocks_to_remove.extend(expanded_hunk.block);
161 hunks_to_toggle.next();
162 retain = false;
163 break;
164 } else {
165 hunks_to_expand.push(HunkToExpand {
166 status,
167 multi_buffer_range,
168 diff_base_byte_range,
169 });
170 hunks_to_toggle.next();
171 continue;
172 }
173 }
174 }
175 }
176
177 retain
178 });
179 for remaining_hunk in hunks_to_toggle {
180 let remaining_hunk_point_range =
181 Point::new(remaining_hunk.associated_range.start.0, 0)
182 ..Point::new(remaining_hunk.associated_range.end.0, 0);
183 hunks_to_expand.push(HunkToExpand {
184 status: hunk_status(&remaining_hunk),
185 multi_buffer_range: remaining_hunk_point_range
186 .to_anchors(&snapshot.buffer_snapshot),
187 diff_base_byte_range: remaining_hunk.diff_base_byte_range.clone(),
188 });
189 }
190
191 for removed_rows in highlights_to_remove {
192 editor.highlight_rows::<DiffRowHighlight>(
193 to_inclusive_row_range(removed_rows, &snapshot),
194 None,
195 cx,
196 );
197 }
198 editor.remove_blocks(blocks_to_remove, None, cx);
199 for hunk in hunks_to_expand {
200 editor.expand_diff_hunk(None, &hunk, cx);
201 }
202 cx.notify();
203 })
204 .ok();
205 });
206
207 self.expanded_hunks
208 .hunk_update_tasks
209 .insert(None, cx.background_executor().spawn(new_toggle_task));
210 }
211
212 pub(super) fn expand_diff_hunk(
213 &mut self,
214 diff_base_buffer: Option<Model<Buffer>>,
215 hunk: &HunkToExpand,
216 cx: &mut ViewContext<'_, Editor>,
217 ) -> Option<()> {
218 let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
219 let multi_buffer_row_range = hunk
220 .multi_buffer_range
221 .start
222 .to_point(&multi_buffer_snapshot)
223 ..hunk.multi_buffer_range.end.to_point(&multi_buffer_snapshot);
224 let hunk_start = hunk.multi_buffer_range.start;
225 let hunk_end = hunk.multi_buffer_range.end;
226
227 let buffer = self.buffer().clone();
228 let snapshot = self.snapshot(cx);
229 let (diff_base_buffer, deleted_text_lines) = buffer.update(cx, |buffer, cx| {
230 let hunk = buffer_diff_hunk(&snapshot.buffer_snapshot, multi_buffer_row_range.clone())?;
231 let mut buffer_ranges = buffer.range_to_buffer_ranges(multi_buffer_row_range, cx);
232 if buffer_ranges.len() == 1 {
233 let (buffer, _, _) = buffer_ranges.pop()?;
234 let diff_base_buffer = diff_base_buffer
235 .or_else(|| self.current_diff_base_buffer(&buffer, cx))
236 .or_else(|| create_diff_base_buffer(&buffer, cx))?;
237 let buffer = buffer.read(cx);
238 let deleted_text_lines = buffer.diff_base().map(|diff_base| {
239 let diff_start_row = diff_base
240 .offset_to_point(hunk.diff_base_byte_range.start)
241 .row;
242 let diff_end_row = diff_base.offset_to_point(hunk.diff_base_byte_range.end).row;
243 let line_count = diff_end_row - diff_start_row;
244 line_count as u8
245 })?;
246 Some((diff_base_buffer, deleted_text_lines))
247 } else {
248 None
249 }
250 })?;
251
252 let block_insert_index = match self.expanded_hunks.hunks.binary_search_by(|probe| {
253 probe
254 .hunk_range
255 .start
256 .cmp(&hunk_start, &multi_buffer_snapshot)
257 }) {
258 Ok(_already_present) => return None,
259 Err(ix) => ix,
260 };
261
262 let block = match hunk.status {
263 DiffHunkStatus::Removed => {
264 self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, &hunk, cx)
265 }
266 DiffHunkStatus::Added => {
267 self.highlight_rows::<DiffRowHighlight>(
268 to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
269 Some(added_hunk_color(cx)),
270 cx,
271 );
272 None
273 }
274 DiffHunkStatus::Modified => {
275 self.highlight_rows::<DiffRowHighlight>(
276 to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
277 Some(added_hunk_color(cx)),
278 cx,
279 );
280 self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, &hunk, cx)
281 }
282 };
283 self.expanded_hunks.hunks.insert(
284 block_insert_index,
285 ExpandedHunk {
286 block,
287 hunk_range: hunk_start..hunk_end,
288 status: hunk.status,
289 folded: false,
290 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
291 },
292 );
293
294 Some(())
295 }
296
297 fn insert_deleted_text_block(
298 &mut self,
299 diff_base_buffer: Model<Buffer>,
300 deleted_text_height: u8,
301 hunk: &HunkToExpand,
302 cx: &mut ViewContext<'_, Self>,
303 ) -> Option<BlockId> {
304 let deleted_hunk_color = deleted_hunk_color(cx);
305 let (editor_height, editor_with_deleted_text) =
306 editor_with_deleted_text(diff_base_buffer, deleted_hunk_color, hunk, cx);
307 let parent_gutter_offset = self.gutter_dimensions.width + self.gutter_dimensions.margin;
308 let mut new_block_ids = self.insert_blocks(
309 Some(BlockProperties {
310 position: hunk.multi_buffer_range.start,
311 height: editor_height.max(deleted_text_height),
312 style: BlockStyle::Flex,
313 render: Box::new(move |_| {
314 div()
315 .bg(deleted_hunk_color)
316 .size_full()
317 .pl(parent_gutter_offset)
318 .child(editor_with_deleted_text.clone())
319 .into_any_element()
320 }),
321 disposition: BlockDisposition::Above,
322 }),
323 None,
324 cx,
325 );
326 if new_block_ids.len() == 1 {
327 new_block_ids.pop()
328 } else {
329 debug_panic!(
330 "Inserted one editor block but did not receive exactly one block id: {new_block_ids:?}"
331 );
332 None
333 }
334 }
335
336 pub(super) fn clear_expanded_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) {
337 self.expanded_hunks.hunk_update_tasks.clear();
338 let to_remove = self
339 .expanded_hunks
340 .hunks
341 .drain(..)
342 .filter_map(|expanded_hunk| expanded_hunk.block)
343 .collect();
344 self.clear_row_highlights::<DiffRowHighlight>();
345 self.remove_blocks(to_remove, None, cx);
346 }
347
348 pub(super) fn sync_expanded_diff_hunks(
349 &mut self,
350 buffer: Model<Buffer>,
351 cx: &mut ViewContext<'_, Self>,
352 ) {
353 let buffer_id = buffer.read(cx).remote_id();
354 let buffer_diff_base_version = buffer.read(cx).diff_base_version();
355 self.expanded_hunks
356 .hunk_update_tasks
357 .remove(&Some(buffer_id));
358 let diff_base_buffer = self.current_diff_base_buffer(&buffer, cx);
359 let new_sync_task = cx.spawn(move |editor, mut cx| async move {
360 let diff_base_buffer_unchanged = diff_base_buffer.is_some();
361 let Ok(diff_base_buffer) =
362 cx.update(|cx| diff_base_buffer.or_else(|| create_diff_base_buffer(&buffer, cx)))
363 else {
364 return;
365 };
366 editor
367 .update(&mut cx, |editor, cx| {
368 if let Some(diff_base_buffer) = &diff_base_buffer {
369 editor.expanded_hunks.diff_base.insert(
370 buffer_id,
371 DiffBaseBuffer {
372 buffer: diff_base_buffer.clone(),
373 diff_base_version: buffer_diff_base_version,
374 },
375 );
376 }
377
378 let snapshot = editor.snapshot(cx);
379 let mut recalculated_hunks = snapshot
380 .buffer_snapshot
381 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
382 .filter(|hunk| hunk.buffer_id == buffer_id)
383 .fuse()
384 .peekable();
385 let mut highlights_to_remove =
386 Vec::with_capacity(editor.expanded_hunks.hunks.len());
387 let mut blocks_to_remove = HashSet::default();
388 let mut hunks_to_reexpand =
389 Vec::with_capacity(editor.expanded_hunks.hunks.len());
390 editor.expanded_hunks.hunks.retain_mut(|expanded_hunk| {
391 if expanded_hunk.hunk_range.start.buffer_id != Some(buffer_id) {
392 return true;
393 };
394
395 let mut retain = false;
396 if diff_base_buffer_unchanged {
397 let expanded_hunk_display_range = expanded_hunk
398 .hunk_range
399 .start
400 .to_display_point(&snapshot)
401 .row()
402 ..expanded_hunk
403 .hunk_range
404 .end
405 .to_display_point(&snapshot)
406 .row();
407 while let Some(buffer_hunk) = recalculated_hunks.peek() {
408 match diff_hunk_to_display(&buffer_hunk, &snapshot) {
409 DisplayDiffHunk::Folded { display_row } => {
410 recalculated_hunks.next();
411 if !expanded_hunk.folded
412 && expanded_hunk_display_range
413 .to_inclusive()
414 .contains(&display_row)
415 {
416 retain = true;
417 expanded_hunk.folded = true;
418 highlights_to_remove
419 .push(expanded_hunk.hunk_range.clone());
420 if let Some(block) = expanded_hunk.block.take() {
421 blocks_to_remove.insert(block);
422 }
423 break;
424 } else {
425 continue;
426 }
427 }
428 DisplayDiffHunk::Unfolded {
429 diff_base_byte_range,
430 display_row_range,
431 multi_buffer_range,
432 status,
433 } => {
434 let hunk_display_range = display_row_range;
435 if expanded_hunk_display_range.start
436 > hunk_display_range.end
437 {
438 recalculated_hunks.next();
439 continue;
440 } else if expanded_hunk_display_range.end
441 < hunk_display_range.start
442 {
443 break;
444 } else {
445 if !expanded_hunk.folded
446 && expanded_hunk_display_range == hunk_display_range
447 && expanded_hunk.status == hunk_status(buffer_hunk)
448 && expanded_hunk.diff_base_byte_range
449 == buffer_hunk.diff_base_byte_range
450 {
451 recalculated_hunks.next();
452 retain = true;
453 } else {
454 hunks_to_reexpand.push(HunkToExpand {
455 status,
456 multi_buffer_range,
457 diff_base_byte_range,
458 });
459 }
460 break;
461 }
462 }
463 }
464 }
465 }
466 if !retain {
467 blocks_to_remove.extend(expanded_hunk.block);
468 highlights_to_remove.push(expanded_hunk.hunk_range.clone());
469 }
470 retain
471 });
472
473 for removed_rows in highlights_to_remove {
474 editor.highlight_rows::<DiffRowHighlight>(
475 to_inclusive_row_range(removed_rows, &snapshot),
476 None,
477 cx,
478 );
479 }
480 editor.remove_blocks(blocks_to_remove, None, cx);
481
482 if let Some(diff_base_buffer) = &diff_base_buffer {
483 for hunk in hunks_to_reexpand {
484 editor.expand_diff_hunk(Some(diff_base_buffer.clone()), &hunk, cx);
485 }
486 }
487 })
488 .ok();
489 });
490
491 self.expanded_hunks.hunk_update_tasks.insert(
492 Some(buffer_id),
493 cx.background_executor().spawn(new_sync_task),
494 );
495 }
496
497 fn current_diff_base_buffer(
498 &mut self,
499 buffer: &Model<Buffer>,
500 cx: &mut AppContext,
501 ) -> Option<Model<Buffer>> {
502 buffer.update(cx, |buffer, _| {
503 match self.expanded_hunks.diff_base.entry(buffer.remote_id()) {
504 hash_map::Entry::Occupied(o) => {
505 if o.get().diff_base_version != buffer.diff_base_version() {
506 o.remove();
507 None
508 } else {
509 Some(o.get().buffer.clone())
510 }
511 }
512 hash_map::Entry::Vacant(_) => None,
513 }
514 })
515 }
516}
517
518fn create_diff_base_buffer(buffer: &Model<Buffer>, cx: &mut AppContext) -> Option<Model<Buffer>> {
519 buffer
520 .update(cx, |buffer, _| {
521 let language = buffer.language().cloned();
522 let diff_base = buffer.diff_base()?.clone();
523 Some((buffer.line_ending(), diff_base, language))
524 })
525 .map(|(line_ending, diff_base, language)| {
526 cx.new_model(|cx| {
527 let buffer = Buffer::local_normalized(diff_base, line_ending, cx);
528 match language {
529 Some(language) => buffer.with_language(language, cx),
530 None => buffer,
531 }
532 })
533 })
534}
535
536fn added_hunk_color(cx: &AppContext) -> Hsla {
537 let mut created_color = cx.theme().status().git().created;
538 created_color.fade_out(0.7);
539 created_color
540}
541
542fn deleted_hunk_color(cx: &AppContext) -> Hsla {
543 let mut deleted_color = cx.theme().status().git().deleted;
544 deleted_color.fade_out(0.7);
545 deleted_color
546}
547
548fn editor_with_deleted_text(
549 diff_base_buffer: Model<Buffer>,
550 deleted_color: Hsla,
551 hunk: &HunkToExpand,
552 cx: &mut ViewContext<'_, Editor>,
553) -> (u8, View<Editor>) {
554 let parent_editor = cx.view().downgrade();
555 let editor = cx.new_view(|cx| {
556 let multi_buffer =
557 cx.new_model(|_| MultiBuffer::without_headers(0, language::Capability::ReadOnly));
558 multi_buffer.update(cx, |multi_buffer, cx| {
559 multi_buffer.push_excerpts(
560 diff_base_buffer,
561 Some(ExcerptRange {
562 context: hunk.diff_base_byte_range.clone(),
563 primary: None,
564 }),
565 cx,
566 );
567 });
568
569 let mut editor = Editor::for_multibuffer(multi_buffer, None, cx);
570 editor.soft_wrap_mode_override = Some(language::language_settings::SoftWrap::None);
571 editor.show_wrap_guides = Some(false);
572 editor.show_gutter = false;
573 editor.scroll_manager.set_forbid_vertical_scroll(true);
574 editor.set_read_only(true);
575
576 let editor_snapshot = editor.snapshot(cx);
577 let start = editor_snapshot.buffer_snapshot.anchor_before(0);
578 let end = editor_snapshot
579 .buffer_snapshot
580 .anchor_after(editor.buffer.read(cx).len(cx));
581
582 editor.highlight_rows::<DiffRowHighlight>(start..=end, Some(deleted_color), cx);
583 let hunk_related_subscription = cx.on_blur(&editor.focus_handle, |editor, cx| {
584 editor.change_selections(None, cx, |s| {
585 s.try_cancel();
586 });
587 });
588 editor._subscriptions.push(hunk_related_subscription);
589 let original_multi_buffer_range = hunk.multi_buffer_range.clone();
590 let diff_base_range = hunk.diff_base_byte_range.clone();
591 editor.register_action::<RevertSelectedHunks>(move |_, cx| {
592 parent_editor
593 .update(cx, |editor, cx| {
594 let Some((buffer, original_text)) = editor.buffer().update(cx, |buffer, cx| {
595 let (_, buffer, _) =
596 buffer.excerpt_containing(original_multi_buffer_range.start, cx)?;
597 let original_text =
598 buffer.read(cx).diff_base()?.slice(diff_base_range.clone());
599 Some((buffer, Arc::from(original_text.to_string())))
600 }) else {
601 return;
602 };
603 buffer.update(cx, |buffer, cx| {
604 buffer.edit(
605 Some((
606 original_multi_buffer_range.start.text_anchor
607 ..original_multi_buffer_range.end.text_anchor,
608 original_text,
609 )),
610 None,
611 cx,
612 )
613 });
614 })
615 .ok();
616 });
617 editor
618 });
619
620 let editor_height = editor.update(cx, |editor, cx| editor.max_point(cx).row().0 as u8);
621 (editor_height, editor)
622}
623
624fn buffer_diff_hunk(
625 buffer_snapshot: &MultiBufferSnapshot,
626 row_range: Range<Point>,
627) -> Option<DiffHunk<MultiBufferRow>> {
628 let mut hunks = buffer_snapshot.git_diff_hunks_in_range(
629 MultiBufferRow(row_range.start.row)..MultiBufferRow(row_range.end.row),
630 );
631 let hunk = hunks.next()?;
632 let second_hunk = hunks.next();
633 if second_hunk.is_none() {
634 return Some(hunk);
635 }
636 None
637}
638
639fn to_inclusive_row_range(
640 row_range: Range<Anchor>,
641 snapshot: &EditorSnapshot,
642) -> RangeInclusive<Anchor> {
643 let mut display_row_range =
644 row_range.start.to_display_point(snapshot)..row_range.end.to_display_point(snapshot);
645 if display_row_range.end.row() > display_row_range.start.row() {
646 *display_row_range.end.row_mut() -= 1;
647 }
648 let point_range = display_row_range.start.to_point(&snapshot.display_snapshot)
649 ..display_row_range.end.to_point(&snapshot.display_snapshot);
650 let new_range = point_range.to_anchors(&snapshot.buffer_snapshot);
651 new_range.start..=new_range.end
652}