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