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, RevertFile,
28 RevertSelectedHunks, 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 .action("Revert File", RevertFile.boxed_clone())
143 }),
144 cx,
145 )
146 }
147
148 pub(super) fn toggle_hovered_hunk(
149 &mut self,
150 hovered_hunk: &HoveredHunk,
151 cx: &mut ViewContext<Editor>,
152 ) {
153 let editor_snapshot = self.snapshot(cx);
154 if let Some(diff_hunk) = to_diff_hunk(hovered_hunk, &editor_snapshot.buffer_snapshot) {
155 self.toggle_hunks_expanded(vec![diff_hunk], cx);
156 self.change_selections(None, cx, |selections| selections.refresh());
157 }
158 }
159
160 pub fn toggle_hunk_diff(&mut self, _: &ToggleHunkDiff, cx: &mut ViewContext<Self>) {
161 let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
162 let selections = self.selections.disjoint_anchors();
163 self.toggle_hunks_expanded(
164 hunks_for_selections(&multi_buffer_snapshot, &selections),
165 cx,
166 );
167 }
168
169 pub fn expand_all_hunk_diffs(&mut self, _: &ExpandAllHunkDiffs, cx: &mut ViewContext<Self>) {
170 let snapshot = self.snapshot(cx);
171 let display_rows_with_expanded_hunks = self
172 .expanded_hunks
173 .hunks(false)
174 .map(|hunk| &hunk.hunk_range)
175 .map(|anchor_range| {
176 (
177 anchor_range
178 .start
179 .to_display_point(&snapshot.display_snapshot)
180 .row(),
181 anchor_range
182 .end
183 .to_display_point(&snapshot.display_snapshot)
184 .row(),
185 )
186 })
187 .collect::<HashMap<_, _>>();
188 let hunks = snapshot
189 .display_snapshot
190 .buffer_snapshot
191 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
192 .filter(|hunk| {
193 let hunk_display_row_range = Point::new(hunk.associated_range.start.0, 0)
194 .to_display_point(&snapshot.display_snapshot)
195 ..Point::new(hunk.associated_range.end.0, 0)
196 .to_display_point(&snapshot.display_snapshot);
197 let row_range_end =
198 display_rows_with_expanded_hunks.get(&hunk_display_row_range.start.row());
199 row_range_end.is_none() || row_range_end != Some(&hunk_display_row_range.end.row())
200 });
201 self.toggle_hunks_expanded(hunks.collect(), cx);
202 }
203
204 fn toggle_hunks_expanded(
205 &mut self,
206 hunks_to_toggle: Vec<DiffHunk<MultiBufferRow>>,
207 cx: &mut ViewContext<Self>,
208 ) {
209 let previous_toggle_task = self.expanded_hunks.hunk_update_tasks.remove(&None);
210 let new_toggle_task = cx.spawn(move |editor, mut cx| async move {
211 if let Some(task) = previous_toggle_task {
212 task.await;
213 }
214
215 editor
216 .update(&mut cx, |editor, cx| {
217 let snapshot = editor.snapshot(cx);
218 let mut hunks_to_toggle = hunks_to_toggle.into_iter().fuse().peekable();
219 let mut highlights_to_remove =
220 Vec::with_capacity(editor.expanded_hunks.hunks.len());
221 let mut blocks_to_remove = HashSet::default();
222 let mut hunks_to_expand = Vec::new();
223 editor.expanded_hunks.hunks.retain(|expanded_hunk| {
224 if expanded_hunk.folded {
225 return true;
226 }
227 let expanded_hunk_row_range = expanded_hunk
228 .hunk_range
229 .start
230 .to_display_point(&snapshot)
231 .row()
232 ..expanded_hunk
233 .hunk_range
234 .end
235 .to_display_point(&snapshot)
236 .row();
237 let mut retain = true;
238 while let Some(hunk_to_toggle) = hunks_to_toggle.peek() {
239 match diff_hunk_to_display(hunk_to_toggle, &snapshot) {
240 DisplayDiffHunk::Folded { .. } => {
241 hunks_to_toggle.next();
242 continue;
243 }
244 DisplayDiffHunk::Unfolded {
245 diff_base_byte_range,
246 display_row_range,
247 multi_buffer_range,
248 status,
249 } => {
250 let hunk_to_toggle_row_range = display_row_range;
251 if hunk_to_toggle_row_range.start > expanded_hunk_row_range.end
252 {
253 break;
254 } else if expanded_hunk_row_range == hunk_to_toggle_row_range {
255 highlights_to_remove.push(expanded_hunk.hunk_range.clone());
256 blocks_to_remove.extend(expanded_hunk.block);
257 hunks_to_toggle.next();
258 retain = false;
259 break;
260 } else {
261 hunks_to_expand.push(HoveredHunk {
262 status,
263 multi_buffer_range,
264 diff_base_byte_range,
265 });
266 hunks_to_toggle.next();
267 continue;
268 }
269 }
270 }
271 }
272
273 retain
274 });
275 for remaining_hunk in hunks_to_toggle {
276 let remaining_hunk_point_range =
277 Point::new(remaining_hunk.associated_range.start.0, 0)
278 ..Point::new(remaining_hunk.associated_range.end.0, 0);
279 hunks_to_expand.push(HoveredHunk {
280 status: hunk_status(&remaining_hunk),
281 multi_buffer_range: remaining_hunk_point_range
282 .to_anchors(&snapshot.buffer_snapshot),
283 diff_base_byte_range: remaining_hunk.diff_base_byte_range.clone(),
284 });
285 }
286
287 for removed_rows in highlights_to_remove {
288 editor.highlight_rows::<DiffRowHighlight>(
289 to_inclusive_row_range(removed_rows, &snapshot),
290 None,
291 false,
292 cx,
293 );
294 }
295 editor.remove_blocks(blocks_to_remove, None, cx);
296 for hunk in hunks_to_expand {
297 editor.expand_diff_hunk(None, &hunk, cx);
298 }
299 cx.notify();
300 })
301 .ok();
302 });
303
304 self.expanded_hunks
305 .hunk_update_tasks
306 .insert(None, cx.background_executor().spawn(new_toggle_task));
307 }
308
309 pub(super) fn expand_diff_hunk(
310 &mut self,
311 diff_base_buffer: Option<Model<Buffer>>,
312 hunk: &HoveredHunk,
313 cx: &mut ViewContext<'_, Editor>,
314 ) -> Option<()> {
315 let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
316 let multi_buffer_row_range = hunk
317 .multi_buffer_range
318 .start
319 .to_point(&multi_buffer_snapshot)
320 ..hunk.multi_buffer_range.end.to_point(&multi_buffer_snapshot);
321 let hunk_start = hunk.multi_buffer_range.start;
322 let hunk_end = hunk.multi_buffer_range.end;
323
324 let buffer = self.buffer().clone();
325 let snapshot = self.snapshot(cx);
326 let (diff_base_buffer, deleted_text_lines) = buffer.update(cx, |buffer, cx| {
327 let hunk = buffer_diff_hunk(&snapshot.buffer_snapshot, multi_buffer_row_range.clone())?;
328 let mut buffer_ranges = buffer.range_to_buffer_ranges(multi_buffer_row_range, cx);
329 if buffer_ranges.len() == 1 {
330 let (buffer, _, _) = buffer_ranges.pop()?;
331 let diff_base_buffer = diff_base_buffer
332 .or_else(|| self.current_diff_base_buffer(&buffer, cx))
333 .or_else(|| create_diff_base_buffer(&buffer, cx))?;
334 let buffer = buffer.read(cx);
335 let deleted_text_lines = buffer.diff_base().map(|diff_base| {
336 let diff_start_row = diff_base
337 .offset_to_point(hunk.diff_base_byte_range.start)
338 .row;
339 let diff_end_row = diff_base.offset_to_point(hunk.diff_base_byte_range.end).row;
340
341 diff_end_row - diff_start_row
342 })?;
343 Some((diff_base_buffer, deleted_text_lines))
344 } else {
345 None
346 }
347 })?;
348
349 let block_insert_index = match self.expanded_hunks.hunks.binary_search_by(|probe| {
350 probe
351 .hunk_range
352 .start
353 .cmp(&hunk_start, &multi_buffer_snapshot)
354 }) {
355 Ok(_already_present) => return None,
356 Err(ix) => ix,
357 };
358
359 let block = match hunk.status {
360 DiffHunkStatus::Removed => {
361 self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, hunk, cx)
362 }
363 DiffHunkStatus::Added => {
364 self.highlight_rows::<DiffRowHighlight>(
365 to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
366 Some(added_hunk_color(cx)),
367 false,
368 cx,
369 );
370 None
371 }
372 DiffHunkStatus::Modified => {
373 self.highlight_rows::<DiffRowHighlight>(
374 to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
375 Some(added_hunk_color(cx)),
376 false,
377 cx,
378 );
379 self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, hunk, cx)
380 }
381 };
382 self.expanded_hunks.hunks.insert(
383 block_insert_index,
384 ExpandedHunk {
385 block,
386 hunk_range: hunk_start..hunk_end,
387 status: hunk.status,
388 folded: false,
389 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
390 },
391 );
392
393 Some(())
394 }
395
396 fn insert_deleted_text_block(
397 &mut self,
398 diff_base_buffer: Model<Buffer>,
399 deleted_text_height: u32,
400 hunk: &HoveredHunk,
401 cx: &mut ViewContext<'_, Self>,
402 ) -> Option<CustomBlockId> {
403 let deleted_hunk_color = deleted_hunk_color(cx);
404 let (editor_height, editor_with_deleted_text) =
405 editor_with_deleted_text(diff_base_buffer, deleted_hunk_color, hunk, cx);
406 let editor = cx.view().clone();
407 let hunk = hunk.clone();
408 let height = editor_height.max(deleted_text_height);
409 let mut new_block_ids = self.insert_blocks(
410 Some(BlockProperties {
411 position: hunk.multi_buffer_range.start,
412 height,
413 style: BlockStyle::Flex,
414 disposition: BlockDisposition::Above,
415 render: Box::new(move |cx| {
416 let Some(gutter_bounds) = editor.read(cx).gutter_bounds() else {
417 return div().into_any_element();
418 };
419 let (gutter_dimensions, hunk_bounds, close_button) =
420 editor.update(cx.context, |editor, cx| {
421 let editor_snapshot = editor.snapshot(cx);
422 let hunk_display_range = hunk
423 .multi_buffer_range
424 .clone()
425 .to_display_points(&editor_snapshot);
426 let gutter_dimensions = editor.gutter_dimensions;
427 let hunk_bounds = EditorElement::diff_hunk_bounds(
428 &editor_snapshot,
429 cx.line_height(),
430 gutter_bounds,
431 &DisplayDiffHunk::Unfolded {
432 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
433 multi_buffer_range: hunk.multi_buffer_range.clone(),
434 display_row_range: hunk_display_range.start.row()
435 ..hunk_display_range.end.row(),
436 status: hunk.status,
437 },
438 );
439
440 let close_button = editor.close_hunk_diff_button(
441 hunk.clone(),
442 hunk_display_range.start.row(),
443 cx,
444 );
445 (gutter_dimensions, hunk_bounds, close_button)
446 });
447 let click_editor = editor.clone();
448 let clicked_hunk = hunk.clone();
449 h_flex()
450 .id("gutter with editor")
451 .bg(deleted_hunk_color)
452 .h(height as f32 * cx.line_height())
453 .w_full()
454 .child(
455 h_flex()
456 .id("gutter")
457 .max_w(gutter_dimensions.full_width())
458 .min_w(gutter_dimensions.full_width())
459 .size_full()
460 .child(
461 h_flex()
462 .id("gutter hunk")
463 .pl(gutter_dimensions.margin
464 + gutter_dimensions
465 .git_blame_entries_width
466 .unwrap_or_default())
467 .max_w(hunk_bounds.size.width)
468 .min_w(hunk_bounds.size.width)
469 .size_full()
470 .cursor(CursorStyle::PointingHand)
471 .on_mouse_down(MouseButton::Left, {
472 let click_hunk = hunk.clone();
473 move |e, cx| {
474 let modifiers = e.modifiers;
475 if modifiers.control || modifiers.platform {
476 click_editor.update(cx, |editor, cx| {
477 editor.toggle_hovered_hunk(&click_hunk, cx);
478 });
479 } else {
480 click_editor.update(cx, |editor, cx| {
481 editor.open_hunk_context_menu(
482 clicked_hunk.clone(),
483 e.position,
484 cx,
485 );
486 });
487 }
488 }
489 }),
490 )
491 .child(
492 v_flex()
493 .size_full()
494 .pt(rems(0.25))
495 .justify_start()
496 .child(close_button),
497 ),
498 )
499 .child(editor_with_deleted_text.clone())
500 .into_any_element()
501 }),
502 priority: 0,
503 }),
504 None,
505 cx,
506 );
507 if new_block_ids.len() == 1 {
508 new_block_ids.pop()
509 } else {
510 debug_panic!(
511 "Inserted one editor block but did not receive exactly one block id: {new_block_ids:?}"
512 );
513 None
514 }
515 }
516
517 pub(super) fn clear_clicked_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) -> bool {
518 self.expanded_hunks.hunk_update_tasks.clear();
519 self.clear_row_highlights::<DiffRowHighlight>();
520 let to_remove = self
521 .expanded_hunks
522 .hunks
523 .drain(..)
524 .filter_map(|expanded_hunk| expanded_hunk.block)
525 .collect::<HashSet<_>>();
526 if to_remove.is_empty() {
527 false
528 } else {
529 self.remove_blocks(to_remove, None, cx);
530 true
531 }
532 }
533
534 pub(super) fn sync_expanded_diff_hunks(
535 &mut self,
536 buffer: Model<Buffer>,
537 cx: &mut ViewContext<'_, Self>,
538 ) {
539 let buffer_id = buffer.read(cx).remote_id();
540 let buffer_diff_base_version = buffer.read(cx).diff_base_version();
541 self.expanded_hunks
542 .hunk_update_tasks
543 .remove(&Some(buffer_id));
544 let diff_base_buffer = self.current_diff_base_buffer(&buffer, cx);
545 let new_sync_task = cx.spawn(move |editor, mut cx| async move {
546 let diff_base_buffer_unchanged = diff_base_buffer.is_some();
547 let Ok(diff_base_buffer) =
548 cx.update(|cx| diff_base_buffer.or_else(|| create_diff_base_buffer(&buffer, cx)))
549 else {
550 return;
551 };
552 editor
553 .update(&mut cx, |editor, cx| {
554 if let Some(diff_base_buffer) = &diff_base_buffer {
555 editor.expanded_hunks.diff_base.insert(
556 buffer_id,
557 DiffBaseBuffer {
558 buffer: diff_base_buffer.clone(),
559 diff_base_version: buffer_diff_base_version,
560 },
561 );
562 }
563
564 let snapshot = editor.snapshot(cx);
565 let mut recalculated_hunks = snapshot
566 .buffer_snapshot
567 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
568 .filter(|hunk| hunk.buffer_id == buffer_id)
569 .fuse()
570 .peekable();
571 let mut highlights_to_remove =
572 Vec::with_capacity(editor.expanded_hunks.hunks.len());
573 let mut blocks_to_remove = HashSet::default();
574 let mut hunks_to_reexpand =
575 Vec::with_capacity(editor.expanded_hunks.hunks.len());
576 editor.expanded_hunks.hunks.retain_mut(|expanded_hunk| {
577 if expanded_hunk.hunk_range.start.buffer_id != Some(buffer_id) {
578 return true;
579 };
580
581 let mut retain = false;
582 if diff_base_buffer_unchanged {
583 let expanded_hunk_display_range = expanded_hunk
584 .hunk_range
585 .start
586 .to_display_point(&snapshot)
587 .row()
588 ..expanded_hunk
589 .hunk_range
590 .end
591 .to_display_point(&snapshot)
592 .row();
593 while let Some(buffer_hunk) = recalculated_hunks.peek() {
594 match diff_hunk_to_display(buffer_hunk, &snapshot) {
595 DisplayDiffHunk::Folded { display_row } => {
596 recalculated_hunks.next();
597 if !expanded_hunk.folded
598 && expanded_hunk_display_range
599 .to_inclusive()
600 .contains(&display_row)
601 {
602 retain = true;
603 expanded_hunk.folded = true;
604 highlights_to_remove
605 .push(expanded_hunk.hunk_range.clone());
606 if let Some(block) = expanded_hunk.block.take() {
607 blocks_to_remove.insert(block);
608 }
609 break;
610 } else {
611 continue;
612 }
613 }
614 DisplayDiffHunk::Unfolded {
615 diff_base_byte_range,
616 display_row_range,
617 multi_buffer_range,
618 status,
619 } => {
620 let hunk_display_range = display_row_range;
621 if expanded_hunk_display_range.start
622 > hunk_display_range.end
623 {
624 recalculated_hunks.next();
625 continue;
626 } else if expanded_hunk_display_range.end
627 < hunk_display_range.start
628 {
629 break;
630 } else {
631 if !expanded_hunk.folded
632 && expanded_hunk_display_range == hunk_display_range
633 && expanded_hunk.status == hunk_status(buffer_hunk)
634 && expanded_hunk.diff_base_byte_range
635 == buffer_hunk.diff_base_byte_range
636 {
637 recalculated_hunks.next();
638 retain = true;
639 } else {
640 hunks_to_reexpand.push(HoveredHunk {
641 status,
642 multi_buffer_range,
643 diff_base_byte_range,
644 });
645 }
646 break;
647 }
648 }
649 }
650 }
651 }
652 if !retain {
653 blocks_to_remove.extend(expanded_hunk.block);
654 highlights_to_remove.push(expanded_hunk.hunk_range.clone());
655 }
656 retain
657 });
658
659 for removed_rows in highlights_to_remove {
660 editor.highlight_rows::<DiffRowHighlight>(
661 to_inclusive_row_range(removed_rows, &snapshot),
662 None,
663 false,
664 cx,
665 );
666 }
667 editor.remove_blocks(blocks_to_remove, None, cx);
668
669 if let Some(diff_base_buffer) = &diff_base_buffer {
670 for hunk in hunks_to_reexpand {
671 editor.expand_diff_hunk(Some(diff_base_buffer.clone()), &hunk, cx);
672 }
673 }
674 })
675 .ok();
676 });
677
678 self.expanded_hunks.hunk_update_tasks.insert(
679 Some(buffer_id),
680 cx.background_executor().spawn(new_sync_task),
681 );
682 }
683
684 fn current_diff_base_buffer(
685 &mut self,
686 buffer: &Model<Buffer>,
687 cx: &mut AppContext,
688 ) -> Option<Model<Buffer>> {
689 buffer.update(cx, |buffer, _| {
690 match self.expanded_hunks.diff_base.entry(buffer.remote_id()) {
691 hash_map::Entry::Occupied(o) => {
692 if o.get().diff_base_version != buffer.diff_base_version() {
693 o.remove();
694 None
695 } else {
696 Some(o.get().buffer.clone())
697 }
698 }
699 hash_map::Entry::Vacant(_) => None,
700 }
701 })
702 }
703}
704
705fn to_diff_hunk(
706 hovered_hunk: &HoveredHunk,
707 multi_buffer_snapshot: &MultiBufferSnapshot,
708) -> Option<DiffHunk<MultiBufferRow>> {
709 let buffer_id = hovered_hunk
710 .multi_buffer_range
711 .start
712 .buffer_id
713 .or(hovered_hunk.multi_buffer_range.end.buffer_id)?;
714 let buffer_range = hovered_hunk.multi_buffer_range.start.text_anchor
715 ..hovered_hunk.multi_buffer_range.end.text_anchor;
716 let point_range = hovered_hunk
717 .multi_buffer_range
718 .to_point(multi_buffer_snapshot);
719 Some(DiffHunk {
720 associated_range: MultiBufferRow(point_range.start.row)
721 ..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(0, 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<DiffHunk<MultiBufferRow>> {
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}