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