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