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