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