1use std::{
2 ops::{Range, RangeInclusive},
3 sync::Arc,
4};
5
6use collections::{hash_map, HashMap, HashSet};
7use git::diff::{DiffHunk, DiffHunkStatus};
8use gpui::{Action, AppContext, CursorStyle, Hsla, Model, MouseButton, Subscription, Task, View};
9use language::Buffer;
10use multi_buffer::{
11 Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferRow, MultiBufferSnapshot, ToPoint,
12};
13use settings::SettingsStore;
14use text::{BufferId, Point};
15use ui::{
16 div, h_flex, rems, v_flex, ActiveTheme, Context as _, ContextMenu, InteractiveElement,
17 IntoElement, ParentElement, Pixels, Styled, ViewContext, VisualContext,
18};
19use util::{debug_panic, RangeExt};
20
21use crate::{
22 editor_settings::CurrentLineHighlight,
23 git::{diff_hunk_to_display, DisplayDiffHunk},
24 hunk_status, hunks_for_selections,
25 mouse_context_menu::MouseContextMenu,
26 BlockDisposition, BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, Editor,
27 EditorElement, EditorSnapshot, ExpandAllHunkDiffs, RangeToAnchorExt, RevertSelectedHunks,
28 ToDisplayPoint, ToggleHunkDiff,
29};
30
31#[derive(Debug, Clone)]
32pub(super) struct HoveredHunk {
33 pub multi_buffer_range: Range<Anchor>,
34 pub status: DiffHunkStatus,
35 pub diff_base_byte_range: Range<usize>,
36}
37
38#[derive(Debug, Default)]
39pub(super) struct ExpandedHunks {
40 hunks: Vec<ExpandedHunk>,
41 diff_base: HashMap<BufferId, DiffBaseBuffer>,
42 hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
43}
44
45#[derive(Debug)]
46struct DiffBaseBuffer {
47 buffer: Model<Buffer>,
48 diff_base_version: usize,
49}
50
51impl ExpandedHunks {
52 pub fn hunks(&self, include_folded: bool) -> impl Iterator<Item = &ExpandedHunk> {
53 self.hunks
54 .iter()
55 .filter(move |hunk| include_folded || !hunk.folded)
56 }
57}
58
59#[derive(Debug, Clone)]
60pub(super) struct ExpandedHunk {
61 pub block: Option<CustomBlockId>,
62 pub hunk_range: Range<Anchor>,
63 pub diff_base_byte_range: Range<usize>,
64 pub status: DiffHunkStatus,
65 pub folded: bool,
66}
67
68impl Editor {
69 pub(super) fn open_hunk_context_menu(
70 &mut self,
71 hovered_hunk: HoveredHunk,
72 clicked_point: gpui::Point<Pixels>,
73 cx: &mut ViewContext<Editor>,
74 ) {
75 let focus_handle = self.focus_handle.clone();
76 let expanded = self
77 .expanded_hunks
78 .hunks(false)
79 .any(|expanded_hunk| expanded_hunk.hunk_range == hovered_hunk.multi_buffer_range);
80 let editor_handle = cx.view().clone();
81 let editor_snapshot = self.snapshot(cx);
82 let start_point = self
83 .to_pixel_point(hovered_hunk.multi_buffer_range.start, &editor_snapshot, cx)
84 .unwrap_or(clicked_point);
85 let end_point = self
86 .to_pixel_point(hovered_hunk.multi_buffer_range.start, &editor_snapshot, cx)
87 .unwrap_or(clicked_point);
88 let norm =
89 |a: gpui::Point<Pixels>, b: gpui::Point<Pixels>| (a.x - b.x).abs() + (a.y - b.y).abs();
90 let closest_source = if norm(start_point, clicked_point) < norm(end_point, clicked_point) {
91 hovered_hunk.multi_buffer_range.start
92 } else {
93 hovered_hunk.multi_buffer_range.end
94 };
95
96 self.mouse_context_menu = MouseContextMenu::pinned_to_editor(
97 self,
98 closest_source,
99 clicked_point,
100 ContextMenu::build(cx, move |menu, _| {
101 menu.on_blur_subscription(Subscription::new(|| {}))
102 .context(focus_handle)
103 .entry(
104 if expanded {
105 "Collapse Hunk"
106 } else {
107 "Expand Hunk"
108 },
109 Some(ToggleHunkDiff.boxed_clone()),
110 {
111 let editor = editor_handle.clone();
112 let hunk = hovered_hunk.clone();
113 move |cx| {
114 editor.update(cx, |editor, cx| {
115 editor.toggle_hovered_hunk(&hunk, cx);
116 });
117 }
118 },
119 )
120 .entry("Revert Hunk", Some(RevertSelectedHunks.boxed_clone()), {
121 let editor = editor_handle.clone();
122 let hunk = hovered_hunk.clone();
123 move |cx| {
124 let multi_buffer = editor.read(cx).buffer().clone();
125 let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
126 let mut revert_changes = HashMap::default();
127 if let Some(hunk) =
128 crate::hunk_diff::to_diff_hunk(&hunk, &multi_buffer_snapshot)
129 {
130 Editor::prepare_revert_change(
131 &mut revert_changes,
132 &multi_buffer,
133 &hunk,
134 cx,
135 );
136 }
137 if !revert_changes.is_empty() {
138 editor.update(cx, |editor, cx| editor.revert(revert_changes, cx));
139 }
140 }
141 })
142 .entry("Revert File", None, {
143 let editor = editor_handle.clone();
144 move |cx| {
145 let mut revert_changes = HashMap::default();
146 let multi_buffer = editor.read(cx).buffer().clone();
147 let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
148 for hunk in crate::hunks_for_rows(
149 Some(MultiBufferRow(0)..multi_buffer_snapshot.max_buffer_row())
150 .into_iter(),
151 &multi_buffer_snapshot,
152 ) {
153 Editor::prepare_revert_change(
154 &mut revert_changes,
155 &multi_buffer,
156 &hunk,
157 cx,
158 );
159 }
160 if !revert_changes.is_empty() {
161 editor.update(cx, |editor, cx| {
162 editor.transact(cx, |editor, cx| {
163 editor.revert(revert_changes, cx);
164 });
165 });
166 }
167 }
168 })
169 }),
170 cx,
171 )
172 }
173
174 pub(super) fn toggle_hovered_hunk(
175 &mut self,
176 hovered_hunk: &HoveredHunk,
177 cx: &mut ViewContext<Editor>,
178 ) {
179 let editor_snapshot = self.snapshot(cx);
180 if let Some(diff_hunk) = to_diff_hunk(hovered_hunk, &editor_snapshot.buffer_snapshot) {
181 self.toggle_hunks_expanded(vec![diff_hunk], cx);
182 self.change_selections(None, cx, |selections| selections.refresh());
183 }
184 }
185
186 pub fn toggle_hunk_diff(&mut self, _: &ToggleHunkDiff, cx: &mut ViewContext<Self>) {
187 let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
188 let selections = self.selections.disjoint_anchors();
189 self.toggle_hunks_expanded(
190 hunks_for_selections(&multi_buffer_snapshot, &selections),
191 cx,
192 );
193 }
194
195 pub fn expand_all_hunk_diffs(&mut self, _: &ExpandAllHunkDiffs, cx: &mut ViewContext<Self>) {
196 let snapshot = self.snapshot(cx);
197 let display_rows_with_expanded_hunks = self
198 .expanded_hunks
199 .hunks(false)
200 .map(|hunk| &hunk.hunk_range)
201 .map(|anchor_range| {
202 (
203 anchor_range
204 .start
205 .to_display_point(&snapshot.display_snapshot)
206 .row(),
207 anchor_range
208 .end
209 .to_display_point(&snapshot.display_snapshot)
210 .row(),
211 )
212 })
213 .collect::<HashMap<_, _>>();
214 let hunks = snapshot
215 .display_snapshot
216 .buffer_snapshot
217 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
218 .filter(|hunk| {
219 let hunk_display_row_range = Point::new(hunk.associated_range.start.0, 0)
220 .to_display_point(&snapshot.display_snapshot)
221 ..Point::new(hunk.associated_range.end.0, 0)
222 .to_display_point(&snapshot.display_snapshot);
223 let row_range_end =
224 display_rows_with_expanded_hunks.get(&hunk_display_row_range.start.row());
225 row_range_end.is_none() || row_range_end != Some(&hunk_display_row_range.end.row())
226 });
227 self.toggle_hunks_expanded(hunks.collect(), cx);
228 }
229
230 fn toggle_hunks_expanded(
231 &mut self,
232 hunks_to_toggle: Vec<DiffHunk<MultiBufferRow>>,
233 cx: &mut ViewContext<Self>,
234 ) {
235 let previous_toggle_task = self.expanded_hunks.hunk_update_tasks.remove(&None);
236 let new_toggle_task = cx.spawn(move |editor, mut cx| async move {
237 if let Some(task) = previous_toggle_task {
238 task.await;
239 }
240
241 editor
242 .update(&mut cx, |editor, cx| {
243 let snapshot = editor.snapshot(cx);
244 let mut hunks_to_toggle = hunks_to_toggle.into_iter().fuse().peekable();
245 let mut highlights_to_remove =
246 Vec::with_capacity(editor.expanded_hunks.hunks.len());
247 let mut blocks_to_remove = HashSet::default();
248 let mut hunks_to_expand = Vec::new();
249 editor.expanded_hunks.hunks.retain(|expanded_hunk| {
250 if expanded_hunk.folded {
251 return true;
252 }
253 let expanded_hunk_row_range = expanded_hunk
254 .hunk_range
255 .start
256 .to_display_point(&snapshot)
257 .row()
258 ..expanded_hunk
259 .hunk_range
260 .end
261 .to_display_point(&snapshot)
262 .row();
263 let mut retain = true;
264 while let Some(hunk_to_toggle) = hunks_to_toggle.peek() {
265 match diff_hunk_to_display(hunk_to_toggle, &snapshot) {
266 DisplayDiffHunk::Folded { .. } => {
267 hunks_to_toggle.next();
268 continue;
269 }
270 DisplayDiffHunk::Unfolded {
271 diff_base_byte_range,
272 display_row_range,
273 multi_buffer_range,
274 status,
275 } => {
276 let hunk_to_toggle_row_range = display_row_range;
277 if hunk_to_toggle_row_range.start > expanded_hunk_row_range.end
278 {
279 break;
280 } else if expanded_hunk_row_range == hunk_to_toggle_row_range {
281 highlights_to_remove.push(expanded_hunk.hunk_range.clone());
282 blocks_to_remove.extend(expanded_hunk.block);
283 hunks_to_toggle.next();
284 retain = false;
285 break;
286 } else {
287 hunks_to_expand.push(HoveredHunk {
288 status,
289 multi_buffer_range,
290 diff_base_byte_range,
291 });
292 hunks_to_toggle.next();
293 continue;
294 }
295 }
296 }
297 }
298
299 retain
300 });
301 for remaining_hunk in hunks_to_toggle {
302 let remaining_hunk_point_range =
303 Point::new(remaining_hunk.associated_range.start.0, 0)
304 ..Point::new(remaining_hunk.associated_range.end.0, 0);
305 hunks_to_expand.push(HoveredHunk {
306 status: hunk_status(&remaining_hunk),
307 multi_buffer_range: remaining_hunk_point_range
308 .to_anchors(&snapshot.buffer_snapshot),
309 diff_base_byte_range: remaining_hunk.diff_base_byte_range.clone(),
310 });
311 }
312
313 for removed_rows in highlights_to_remove {
314 editor.highlight_rows::<DiffRowHighlight>(
315 to_inclusive_row_range(removed_rows, &snapshot),
316 None,
317 false,
318 cx,
319 );
320 }
321 editor.remove_blocks(blocks_to_remove, None, cx);
322 for hunk in hunks_to_expand {
323 editor.expand_diff_hunk(None, &hunk, cx);
324 }
325 cx.notify();
326 })
327 .ok();
328 });
329
330 self.expanded_hunks
331 .hunk_update_tasks
332 .insert(None, cx.background_executor().spawn(new_toggle_task));
333 }
334
335 pub(super) fn expand_diff_hunk(
336 &mut self,
337 diff_base_buffer: Option<Model<Buffer>>,
338 hunk: &HoveredHunk,
339 cx: &mut ViewContext<'_, Editor>,
340 ) -> Option<()> {
341 let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
342 let multi_buffer_row_range = hunk
343 .multi_buffer_range
344 .start
345 .to_point(&multi_buffer_snapshot)
346 ..hunk.multi_buffer_range.end.to_point(&multi_buffer_snapshot);
347 let hunk_start = hunk.multi_buffer_range.start;
348 let hunk_end = hunk.multi_buffer_range.end;
349
350 let buffer = self.buffer().clone();
351 let snapshot = self.snapshot(cx);
352 let (diff_base_buffer, deleted_text_lines) = buffer.update(cx, |buffer, cx| {
353 let hunk = buffer_diff_hunk(&snapshot.buffer_snapshot, multi_buffer_row_range.clone())?;
354 let mut buffer_ranges = buffer.range_to_buffer_ranges(multi_buffer_row_range, cx);
355 if buffer_ranges.len() == 1 {
356 let (buffer, _, _) = buffer_ranges.pop()?;
357 let diff_base_buffer = diff_base_buffer
358 .or_else(|| self.current_diff_base_buffer(&buffer, cx))
359 .or_else(|| create_diff_base_buffer(&buffer, cx))?;
360 let buffer = buffer.read(cx);
361 let deleted_text_lines = buffer.diff_base().map(|diff_base| {
362 let diff_start_row = diff_base
363 .offset_to_point(hunk.diff_base_byte_range.start)
364 .row;
365 let diff_end_row = diff_base.offset_to_point(hunk.diff_base_byte_range.end).row;
366 let line_count = diff_end_row - diff_start_row;
367 line_count
368 })?;
369 Some((diff_base_buffer, deleted_text_lines))
370 } else {
371 None
372 }
373 })?;
374
375 let block_insert_index = match self.expanded_hunks.hunks.binary_search_by(|probe| {
376 probe
377 .hunk_range
378 .start
379 .cmp(&hunk_start, &multi_buffer_snapshot)
380 }) {
381 Ok(_already_present) => return None,
382 Err(ix) => ix,
383 };
384
385 let block = match hunk.status {
386 DiffHunkStatus::Removed => {
387 self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, &hunk, cx)
388 }
389 DiffHunkStatus::Added => {
390 self.highlight_rows::<DiffRowHighlight>(
391 to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
392 Some(added_hunk_color(cx)),
393 false,
394 cx,
395 );
396 None
397 }
398 DiffHunkStatus::Modified => {
399 self.highlight_rows::<DiffRowHighlight>(
400 to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
401 Some(added_hunk_color(cx)),
402 false,
403 cx,
404 );
405 self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, &hunk, cx)
406 }
407 };
408 self.expanded_hunks.hunks.insert(
409 block_insert_index,
410 ExpandedHunk {
411 block,
412 hunk_range: hunk_start..hunk_end,
413 status: hunk.status,
414 folded: false,
415 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
416 },
417 );
418
419 Some(())
420 }
421
422 fn insert_deleted_text_block(
423 &mut self,
424 diff_base_buffer: Model<Buffer>,
425 deleted_text_height: u32,
426 hunk: &HoveredHunk,
427 cx: &mut ViewContext<'_, Self>,
428 ) -> Option<CustomBlockId> {
429 let deleted_hunk_color = deleted_hunk_color(cx);
430 let (editor_height, editor_with_deleted_text) =
431 editor_with_deleted_text(diff_base_buffer, deleted_hunk_color, hunk, cx);
432 let editor = cx.view().clone();
433 let hunk = hunk.clone();
434 let height = editor_height.max(deleted_text_height);
435 let mut new_block_ids = self.insert_blocks(
436 Some(BlockProperties {
437 position: hunk.multi_buffer_range.start,
438 height,
439 style: BlockStyle::Flex,
440 disposition: BlockDisposition::Above,
441 render: Box::new(move |cx| {
442 let Some(gutter_bounds) = editor.read(cx).gutter_bounds() else {
443 return div().into_any_element();
444 };
445 let (gutter_dimensions, hunk_bounds, close_button) =
446 editor.update(cx.context, |editor, cx| {
447 let editor_snapshot = editor.snapshot(cx);
448 let hunk_display_range = hunk
449 .multi_buffer_range
450 .clone()
451 .to_display_points(&editor_snapshot);
452 let gutter_dimensions = editor.gutter_dimensions;
453 let hunk_bounds = EditorElement::diff_hunk_bounds(
454 &editor_snapshot,
455 cx.line_height(),
456 gutter_bounds,
457 &DisplayDiffHunk::Unfolded {
458 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
459 multi_buffer_range: hunk.multi_buffer_range.clone(),
460 display_row_range: hunk_display_range.start.row()
461 ..hunk_display_range.end.row(),
462 status: hunk.status,
463 },
464 );
465
466 let close_button = editor.close_hunk_diff_button(
467 hunk.clone(),
468 hunk_display_range.start.row(),
469 cx,
470 );
471 (gutter_dimensions, hunk_bounds, close_button)
472 });
473 let click_editor = editor.clone();
474 let clicked_hunk = hunk.clone();
475 h_flex()
476 .id("gutter with editor")
477 .bg(deleted_hunk_color)
478 .h(height as f32 * cx.line_height())
479 .w_full()
480 .child(
481 h_flex()
482 .id("gutter")
483 .max_w(gutter_dimensions.full_width())
484 .min_w(gutter_dimensions.full_width())
485 .size_full()
486 .child(
487 h_flex()
488 .id("gutter hunk")
489 .pl(gutter_dimensions.margin
490 + gutter_dimensions
491 .git_blame_entries_width
492 .unwrap_or_default())
493 .max_w(hunk_bounds.size.width)
494 .min_w(hunk_bounds.size.width)
495 .size_full()
496 .cursor(CursorStyle::PointingHand)
497 .on_mouse_down(MouseButton::Left, {
498 let click_hunk = hunk.clone();
499 move |e, cx| {
500 let modifiers = e.modifiers;
501 if modifiers.control || modifiers.platform {
502 click_editor.update(cx, |editor, cx| {
503 editor.toggle_hovered_hunk(&click_hunk, cx);
504 });
505 } else {
506 click_editor.update(cx, |editor, cx| {
507 editor.open_hunk_context_menu(
508 clicked_hunk.clone(),
509 e.position,
510 cx,
511 );
512 });
513 }
514 }
515 }),
516 )
517 .child(
518 v_flex()
519 .size_full()
520 .pt(rems(0.25))
521 .justify_start()
522 .child(close_button),
523 ),
524 )
525 .child(editor_with_deleted_text.clone())
526 .into_any_element()
527 }),
528 priority: 0,
529 }),
530 None,
531 cx,
532 );
533 if new_block_ids.len() == 1 {
534 new_block_ids.pop()
535 } else {
536 debug_panic!(
537 "Inserted one editor block but did not receive exactly one block id: {new_block_ids:?}"
538 );
539 None
540 }
541 }
542
543 pub(super) fn clear_clicked_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) -> bool {
544 self.expanded_hunks.hunk_update_tasks.clear();
545 self.clear_row_highlights::<DiffRowHighlight>();
546 let to_remove = self
547 .expanded_hunks
548 .hunks
549 .drain(..)
550 .filter_map(|expanded_hunk| expanded_hunk.block)
551 .collect::<HashSet<_>>();
552 if to_remove.is_empty() {
553 false
554 } else {
555 self.remove_blocks(to_remove, None, cx);
556 true
557 }
558 }
559
560 pub(super) fn sync_expanded_diff_hunks(
561 &mut self,
562 buffer: Model<Buffer>,
563 cx: &mut ViewContext<'_, Self>,
564 ) {
565 let buffer_id = buffer.read(cx).remote_id();
566 let buffer_diff_base_version = buffer.read(cx).diff_base_version();
567 self.expanded_hunks
568 .hunk_update_tasks
569 .remove(&Some(buffer_id));
570 let diff_base_buffer = self.current_diff_base_buffer(&buffer, cx);
571 let new_sync_task = cx.spawn(move |editor, mut cx| async move {
572 let diff_base_buffer_unchanged = diff_base_buffer.is_some();
573 let Ok(diff_base_buffer) =
574 cx.update(|cx| diff_base_buffer.or_else(|| create_diff_base_buffer(&buffer, cx)))
575 else {
576 return;
577 };
578 editor
579 .update(&mut cx, |editor, cx| {
580 if let Some(diff_base_buffer) = &diff_base_buffer {
581 editor.expanded_hunks.diff_base.insert(
582 buffer_id,
583 DiffBaseBuffer {
584 buffer: diff_base_buffer.clone(),
585 diff_base_version: buffer_diff_base_version,
586 },
587 );
588 }
589
590 let snapshot = editor.snapshot(cx);
591 let mut recalculated_hunks = snapshot
592 .buffer_snapshot
593 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
594 .filter(|hunk| hunk.buffer_id == buffer_id)
595 .fuse()
596 .peekable();
597 let mut highlights_to_remove =
598 Vec::with_capacity(editor.expanded_hunks.hunks.len());
599 let mut blocks_to_remove = HashSet::default();
600 let mut hunks_to_reexpand =
601 Vec::with_capacity(editor.expanded_hunks.hunks.len());
602 editor.expanded_hunks.hunks.retain_mut(|expanded_hunk| {
603 if expanded_hunk.hunk_range.start.buffer_id != Some(buffer_id) {
604 return true;
605 };
606
607 let mut retain = false;
608 if diff_base_buffer_unchanged {
609 let expanded_hunk_display_range = expanded_hunk
610 .hunk_range
611 .start
612 .to_display_point(&snapshot)
613 .row()
614 ..expanded_hunk
615 .hunk_range
616 .end
617 .to_display_point(&snapshot)
618 .row();
619 while let Some(buffer_hunk) = recalculated_hunks.peek() {
620 match diff_hunk_to_display(&buffer_hunk, &snapshot) {
621 DisplayDiffHunk::Folded { display_row } => {
622 recalculated_hunks.next();
623 if !expanded_hunk.folded
624 && expanded_hunk_display_range
625 .to_inclusive()
626 .contains(&display_row)
627 {
628 retain = true;
629 expanded_hunk.folded = true;
630 highlights_to_remove
631 .push(expanded_hunk.hunk_range.clone());
632 if let Some(block) = expanded_hunk.block.take() {
633 blocks_to_remove.insert(block);
634 }
635 break;
636 } else {
637 continue;
638 }
639 }
640 DisplayDiffHunk::Unfolded {
641 diff_base_byte_range,
642 display_row_range,
643 multi_buffer_range,
644 status,
645 } => {
646 let hunk_display_range = display_row_range;
647 if expanded_hunk_display_range.start
648 > hunk_display_range.end
649 {
650 recalculated_hunks.next();
651 continue;
652 } else if expanded_hunk_display_range.end
653 < hunk_display_range.start
654 {
655 break;
656 } else {
657 if !expanded_hunk.folded
658 && expanded_hunk_display_range == hunk_display_range
659 && expanded_hunk.status == hunk_status(buffer_hunk)
660 && expanded_hunk.diff_base_byte_range
661 == buffer_hunk.diff_base_byte_range
662 {
663 recalculated_hunks.next();
664 retain = true;
665 } else {
666 hunks_to_reexpand.push(HoveredHunk {
667 status,
668 multi_buffer_range,
669 diff_base_byte_range,
670 });
671 }
672 break;
673 }
674 }
675 }
676 }
677 }
678 if !retain {
679 blocks_to_remove.extend(expanded_hunk.block);
680 highlights_to_remove.push(expanded_hunk.hunk_range.clone());
681 }
682 retain
683 });
684
685 for removed_rows in highlights_to_remove {
686 editor.highlight_rows::<DiffRowHighlight>(
687 to_inclusive_row_range(removed_rows, &snapshot),
688 None,
689 false,
690 cx,
691 );
692 }
693 editor.remove_blocks(blocks_to_remove, None, cx);
694
695 if let Some(diff_base_buffer) = &diff_base_buffer {
696 for hunk in hunks_to_reexpand {
697 editor.expand_diff_hunk(Some(diff_base_buffer.clone()), &hunk, cx);
698 }
699 }
700 })
701 .ok();
702 });
703
704 self.expanded_hunks.hunk_update_tasks.insert(
705 Some(buffer_id),
706 cx.background_executor().spawn(new_sync_task),
707 );
708 }
709
710 fn current_diff_base_buffer(
711 &mut self,
712 buffer: &Model<Buffer>,
713 cx: &mut AppContext,
714 ) -> Option<Model<Buffer>> {
715 buffer.update(cx, |buffer, _| {
716 match self.expanded_hunks.diff_base.entry(buffer.remote_id()) {
717 hash_map::Entry::Occupied(o) => {
718 if o.get().diff_base_version != buffer.diff_base_version() {
719 o.remove();
720 None
721 } else {
722 Some(o.get().buffer.clone())
723 }
724 }
725 hash_map::Entry::Vacant(_) => None,
726 }
727 })
728 }
729}
730
731fn to_diff_hunk(
732 hovered_hunk: &HoveredHunk,
733 multi_buffer_snapshot: &MultiBufferSnapshot,
734) -> Option<DiffHunk<MultiBufferRow>> {
735 let buffer_id = hovered_hunk
736 .multi_buffer_range
737 .start
738 .buffer_id
739 .or_else(|| hovered_hunk.multi_buffer_range.end.buffer_id)?;
740 let buffer_range = hovered_hunk.multi_buffer_range.start.text_anchor
741 ..hovered_hunk.multi_buffer_range.end.text_anchor;
742 let point_range = hovered_hunk
743 .multi_buffer_range
744 .to_point(&multi_buffer_snapshot);
745 Some(DiffHunk {
746 associated_range: MultiBufferRow(point_range.start.row)
747 ..MultiBufferRow(point_range.end.row),
748 buffer_id,
749 buffer_range,
750 diff_base_byte_range: hovered_hunk.diff_base_byte_range.clone(),
751 })
752}
753
754fn create_diff_base_buffer(buffer: &Model<Buffer>, cx: &mut AppContext) -> Option<Model<Buffer>> {
755 buffer
756 .update(cx, |buffer, _| {
757 let language = buffer.language().cloned();
758 let diff_base = buffer.diff_base()?.clone();
759 Some((buffer.line_ending(), diff_base, language))
760 })
761 .map(|(line_ending, diff_base, language)| {
762 cx.new_model(|cx| {
763 let buffer = Buffer::local_normalized(diff_base, line_ending, cx);
764 match language {
765 Some(language) => buffer.with_language(language, cx),
766 None => buffer,
767 }
768 })
769 })
770}
771
772fn added_hunk_color(cx: &AppContext) -> Hsla {
773 let mut created_color = cx.theme().status().git().created;
774 created_color.fade_out(0.7);
775 created_color
776}
777
778fn deleted_hunk_color(cx: &AppContext) -> Hsla {
779 let mut deleted_color = cx.theme().status().git().deleted;
780 deleted_color.fade_out(0.7);
781 deleted_color
782}
783
784fn editor_with_deleted_text(
785 diff_base_buffer: Model<Buffer>,
786 deleted_color: Hsla,
787 hunk: &HoveredHunk,
788 cx: &mut ViewContext<'_, Editor>,
789) -> (u32, View<Editor>) {
790 let parent_editor = cx.view().downgrade();
791 let editor = cx.new_view(|cx| {
792 let multi_buffer =
793 cx.new_model(|_| MultiBuffer::without_headers(0, language::Capability::ReadOnly));
794 multi_buffer.update(cx, |multi_buffer, cx| {
795 multi_buffer.push_excerpts(
796 diff_base_buffer,
797 Some(ExcerptRange {
798 context: hunk.diff_base_byte_range.clone(),
799 primary: None,
800 }),
801 cx,
802 );
803 });
804
805 let mut editor = Editor::for_multibuffer(multi_buffer, None, true, cx);
806 editor.soft_wrap_mode_override = Some(language::language_settings::SoftWrap::None);
807 editor.show_wrap_guides = Some(false);
808 editor.show_gutter = false;
809 editor.scroll_manager.set_forbid_vertical_scroll(true);
810 editor.set_read_only(true);
811
812 let editor_snapshot = editor.snapshot(cx);
813 let start = editor_snapshot.buffer_snapshot.anchor_before(0);
814 let end = editor_snapshot
815 .buffer_snapshot
816 .anchor_after(editor.buffer.read(cx).len(cx));
817
818 editor.highlight_rows::<DiffRowHighlight>(start..=end, Some(deleted_color), false, cx);
819
820 let subscription_editor = parent_editor.clone();
821 editor._subscriptions.extend([
822 cx.on_blur(&editor.focus_handle, |editor, cx| {
823 editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
824 editor.change_selections(None, cx, |s| {
825 s.try_cancel();
826 });
827 cx.notify();
828 }),
829 cx.on_focus(&editor.focus_handle, move |editor, cx| {
830 let restored_highlight = if let Some(parent_editor) = subscription_editor.upgrade()
831 {
832 parent_editor.read(cx).current_line_highlight
833 } else {
834 None
835 };
836 editor.set_current_line_highlight(restored_highlight);
837 cx.notify();
838 }),
839 cx.observe_global::<SettingsStore>(|editor, cx| {
840 if !editor.is_focused(cx) {
841 editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
842 }
843 }),
844 ]);
845 let parent_editor_for_reverts = parent_editor.clone();
846 let original_multi_buffer_range = hunk.multi_buffer_range.clone();
847 let diff_base_range = hunk.diff_base_byte_range.clone();
848 editor
849 .register_action::<RevertSelectedHunks>(move |_, cx| {
850 parent_editor_for_reverts
851 .update(cx, |editor, cx| {
852 let Some((buffer, original_text)) =
853 editor.buffer().update(cx, |buffer, cx| {
854 let (_, buffer, _) = buffer
855 .excerpt_containing(original_multi_buffer_range.start, cx)?;
856 let original_text =
857 buffer.read(cx).diff_base()?.slice(diff_base_range.clone());
858 Some((buffer, Arc::from(original_text.to_string())))
859 })
860 else {
861 return;
862 };
863 buffer.update(cx, |buffer, cx| {
864 buffer.edit(
865 Some((
866 original_multi_buffer_range.start.text_anchor
867 ..original_multi_buffer_range.end.text_anchor,
868 original_text,
869 )),
870 None,
871 cx,
872 )
873 });
874 })
875 .ok();
876 })
877 .detach();
878 let hunk = hunk.clone();
879 editor
880 .register_action::<ToggleHunkDiff>(move |_, cx| {
881 parent_editor
882 .update(cx, |editor, cx| {
883 editor.toggle_hovered_hunk(&hunk, cx);
884 })
885 .ok();
886 })
887 .detach();
888 editor
889 });
890
891 let editor_height = editor.update(cx, |editor, cx| editor.max_point(cx).row().0);
892 (editor_height, editor)
893}
894
895fn buffer_diff_hunk(
896 buffer_snapshot: &MultiBufferSnapshot,
897 row_range: Range<Point>,
898) -> Option<DiffHunk<MultiBufferRow>> {
899 let mut hunks = buffer_snapshot.git_diff_hunks_in_range(
900 MultiBufferRow(row_range.start.row)..MultiBufferRow(row_range.end.row),
901 );
902 let hunk = hunks.next()?;
903 let second_hunk = hunks.next();
904 if second_hunk.is_none() {
905 return Some(hunk);
906 }
907 None
908}
909
910fn to_inclusive_row_range(
911 row_range: Range<Anchor>,
912 snapshot: &EditorSnapshot,
913) -> RangeInclusive<Anchor> {
914 let mut display_row_range =
915 row_range.start.to_display_point(snapshot)..row_range.end.to_display_point(snapshot);
916 if display_row_range.end.row() > display_row_range.start.row() {
917 *display_row_range.end.row_mut() -= 1;
918 }
919 let point_range = display_row_range.start.to_point(&snapshot.display_snapshot)
920 ..display_row_range.end.to_point(&snapshot.display_snapshot);
921 let new_range = point_range.to_anchors(&snapshot.buffer_snapshot);
922 new_range.start..=new_range.end
923}