1586 lines
67 KiB
Rust
1586 lines
67 KiB
Rust
use collections::{HashMap, HashSet};
|
|
use git::diff::DiffHunkStatus;
|
|
use gpui::{
|
|
Action, AppContext, Corner, CursorStyle, Focusable as _, Hsla, Model, MouseButton,
|
|
Subscription, Task,
|
|
};
|
|
use language::{Buffer, BufferId, Point};
|
|
use multi_buffer::{
|
|
Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferDiffHunk, MultiBufferRow,
|
|
MultiBufferSnapshot, ToOffset, ToPoint,
|
|
};
|
|
use project::buffer_store::BufferChangeSet;
|
|
use std::{ops::Range, sync::Arc};
|
|
use sum_tree::TreeMap;
|
|
use text::OffsetRangeExt;
|
|
use ui::{
|
|
prelude::*, ActiveTheme, Context, Context, ContextMenu, IconButtonShape, InteractiveElement,
|
|
IntoElement, ParentElement, PopoverMenu, Styled, Tooltip, Window,
|
|
};
|
|
use util::RangeExt;
|
|
use workspace::Item;
|
|
|
|
use crate::{
|
|
editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections, ApplyAllDiffHunks,
|
|
ApplyDiffHunk, BlockPlacement, BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight,
|
|
DisplayRow, DisplaySnapshot, Editor, EditorElement, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk,
|
|
RevertFile, RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
|
|
};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(super) struct HoveredHunk {
|
|
pub multi_buffer_range: Range<Anchor>,
|
|
pub status: DiffHunkStatus,
|
|
pub diff_base_byte_range: Range<usize>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct DiffMap {
|
|
pub(crate) hunks: Vec<ExpandedHunk>,
|
|
pub(crate) diff_bases: HashMap<BufferId, DiffBaseState>,
|
|
pub(crate) snapshot: DiffMapSnapshot,
|
|
hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
|
|
expand_all: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(super) struct ExpandedHunk {
|
|
pub blocks: Vec<CustomBlockId>,
|
|
pub hunk_range: Range<Anchor>,
|
|
pub diff_base_byte_range: Range<usize>,
|
|
pub status: DiffHunkStatus,
|
|
pub folded: bool,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default)]
|
|
pub(crate) struct DiffMapSnapshot(TreeMap<BufferId, git::diff::BufferDiff>);
|
|
|
|
pub(crate) struct DiffBaseState {
|
|
pub(crate) change_set: Model<BufferChangeSet>,
|
|
pub(crate) last_version: Option<usize>,
|
|
_subscription: Subscription,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum DisplayDiffHunk {
|
|
Folded {
|
|
display_row: DisplayRow,
|
|
},
|
|
|
|
Unfolded {
|
|
diff_base_byte_range: Range<usize>,
|
|
display_row_range: Range<DisplayRow>,
|
|
multi_buffer_range: Range<Anchor>,
|
|
status: DiffHunkStatus,
|
|
},
|
|
}
|
|
|
|
impl DiffMap {
|
|
pub fn snapshot(&self) -> DiffMapSnapshot {
|
|
self.snapshot.clone()
|
|
}
|
|
|
|
pub fn add_change_set(
|
|
&mut self,
|
|
change_set: Model<BufferChangeSet>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Editor>,
|
|
) {
|
|
let buffer_id = change_set.read(cx).buffer_id;
|
|
self.snapshot
|
|
.0
|
|
.insert(buffer_id, change_set.read(cx).diff_to_buffer.clone());
|
|
self.diff_bases.insert(
|
|
buffer_id,
|
|
DiffBaseState {
|
|
last_version: None,
|
|
_subscription: cx.observe_in(
|
|
&change_set,
|
|
window,
|
|
move |editor, change_set, window, cx| {
|
|
editor
|
|
.diff_map
|
|
.snapshot
|
|
.0
|
|
.insert(buffer_id, change_set.read(cx).diff_to_buffer.clone());
|
|
Editor::sync_expanded_diff_hunks(
|
|
&mut editor.diff_map,
|
|
buffer_id,
|
|
window,
|
|
cx,
|
|
);
|
|
},
|
|
),
|
|
change_set,
|
|
},
|
|
);
|
|
Editor::sync_expanded_diff_hunks(self, buffer_id, window, cx);
|
|
}
|
|
|
|
pub fn hunks(&self, include_folded: bool) -> impl Iterator<Item = &ExpandedHunk> {
|
|
self.hunks
|
|
.iter()
|
|
.filter(move |hunk| include_folded || !hunk.folded)
|
|
}
|
|
}
|
|
|
|
impl DiffMapSnapshot {
|
|
pub fn is_empty(&self) -> bool {
|
|
self.0.values().all(|diff| diff.is_empty())
|
|
}
|
|
|
|
pub fn diff_hunks<'a>(
|
|
&'a self,
|
|
buffer_snapshot: &'a MultiBufferSnapshot,
|
|
) -> impl Iterator<Item = MultiBufferDiffHunk> + 'a {
|
|
self.diff_hunks_in_range(0..buffer_snapshot.len(), buffer_snapshot)
|
|
}
|
|
|
|
pub fn diff_hunks_in_range<'a, T: ToOffset>(
|
|
&'a self,
|
|
range: Range<T>,
|
|
buffer_snapshot: &'a MultiBufferSnapshot,
|
|
) -> impl Iterator<Item = MultiBufferDiffHunk> + 'a {
|
|
let range = range.start.to_offset(buffer_snapshot)..range.end.to_offset(buffer_snapshot);
|
|
buffer_snapshot
|
|
.excerpts_for_range(range.clone())
|
|
.filter_map(move |excerpt| {
|
|
let buffer = excerpt.buffer();
|
|
let buffer_id = buffer.remote_id();
|
|
let diff = self.0.get(&buffer_id)?;
|
|
let buffer_range = excerpt.map_range_to_buffer(range.clone());
|
|
let buffer_range =
|
|
buffer.anchor_before(buffer_range.start)..buffer.anchor_after(buffer_range.end);
|
|
Some(
|
|
diff.hunks_intersecting_range(buffer_range, excerpt.buffer())
|
|
.map(move |hunk| {
|
|
let start =
|
|
excerpt.map_point_from_buffer(Point::new(hunk.row_range.start, 0));
|
|
let end =
|
|
excerpt.map_point_from_buffer(Point::new(hunk.row_range.end, 0));
|
|
MultiBufferDiffHunk {
|
|
row_range: MultiBufferRow(start.row)..MultiBufferRow(end.row),
|
|
buffer_id,
|
|
buffer_range: hunk.buffer_range.clone(),
|
|
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
|
|
}
|
|
}),
|
|
)
|
|
})
|
|
.flatten()
|
|
}
|
|
|
|
pub fn diff_hunks_in_range_rev<'a, T: ToOffset>(
|
|
&'a self,
|
|
range: Range<T>,
|
|
buffer_snapshot: &'a MultiBufferSnapshot,
|
|
) -> impl Iterator<Item = MultiBufferDiffHunk> + 'a {
|
|
let range = range.start.to_offset(buffer_snapshot)..range.end.to_offset(buffer_snapshot);
|
|
buffer_snapshot
|
|
.excerpts_for_range_rev(range.clone())
|
|
.filter_map(move |excerpt| {
|
|
let buffer = excerpt.buffer();
|
|
let buffer_id = buffer.remote_id();
|
|
let diff = self.0.get(&buffer_id)?;
|
|
let buffer_range = excerpt.map_range_to_buffer(range.clone());
|
|
let buffer_range =
|
|
buffer.anchor_before(buffer_range.start)..buffer.anchor_after(buffer_range.end);
|
|
Some(
|
|
diff.hunks_intersecting_range_rev(buffer_range, excerpt.buffer())
|
|
.map(move |hunk| {
|
|
let start_row = excerpt
|
|
.map_point_from_buffer(Point::new(hunk.row_range.start, 0))
|
|
.row;
|
|
let end_row = excerpt
|
|
.map_point_from_buffer(Point::new(hunk.row_range.end, 0))
|
|
.row;
|
|
MultiBufferDiffHunk {
|
|
row_range: MultiBufferRow(start_row)..MultiBufferRow(end_row),
|
|
buffer_id,
|
|
buffer_range: hunk.buffer_range.clone(),
|
|
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
|
|
}
|
|
}),
|
|
)
|
|
})
|
|
.flatten()
|
|
}
|
|
}
|
|
|
|
impl Editor {
|
|
pub fn set_expand_all_diff_hunks(&mut self) {
|
|
self.diff_map.expand_all = true;
|
|
}
|
|
|
|
pub(super) fn toggle_hovered_hunk(
|
|
&mut self,
|
|
hovered_hunk: &HoveredHunk,
|
|
window: &mut Window,
|
|
cx: &mut Context<Editor>,
|
|
) {
|
|
let editor_snapshot = self.snapshot(window, cx);
|
|
if let Some(diff_hunk) = to_diff_hunk(hovered_hunk, &editor_snapshot.buffer_snapshot) {
|
|
self.toggle_hunks_expanded(vec![diff_hunk], window, cx);
|
|
self.change_selections(None, window, cx, |selections| selections.refresh());
|
|
}
|
|
}
|
|
|
|
pub fn toggle_hunk_diff(
|
|
&mut self,
|
|
_: &ToggleHunkDiff,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let snapshot = self.snapshot(window, cx);
|
|
let selections = self.selections.all(cx);
|
|
self.toggle_hunks_expanded(hunks_for_selections(&snapshot, &selections), window, cx);
|
|
}
|
|
|
|
pub fn expand_all_hunk_diffs(
|
|
&mut self,
|
|
_: &ExpandAllHunkDiffs,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let snapshot = self.snapshot(window, cx);
|
|
let display_rows_with_expanded_hunks = self
|
|
.diff_map
|
|
.hunks(false)
|
|
.map(|hunk| &hunk.hunk_range)
|
|
.map(|anchor_range| {
|
|
(
|
|
anchor_range
|
|
.start
|
|
.to_display_point(&snapshot.display_snapshot)
|
|
.row(),
|
|
anchor_range
|
|
.end
|
|
.to_display_point(&snapshot.display_snapshot)
|
|
.row(),
|
|
)
|
|
})
|
|
.collect::<HashMap<_, _>>();
|
|
let hunks = self
|
|
.diff_map
|
|
.snapshot
|
|
.diff_hunks(&snapshot.display_snapshot.buffer_snapshot)
|
|
.filter(|hunk| {
|
|
let hunk_display_row_range = Point::new(hunk.row_range.start.0, 0)
|
|
.to_display_point(&snapshot.display_snapshot)
|
|
..Point::new(hunk.row_range.end.0, 0)
|
|
.to_display_point(&snapshot.display_snapshot);
|
|
let row_range_end =
|
|
display_rows_with_expanded_hunks.get(&hunk_display_row_range.start.row());
|
|
row_range_end.is_none() || row_range_end != Some(&hunk_display_row_range.end.row())
|
|
});
|
|
self.toggle_hunks_expanded(hunks.collect(), window, cx);
|
|
}
|
|
|
|
fn toggle_hunks_expanded(
|
|
&mut self,
|
|
hunks_to_toggle: Vec<MultiBufferDiffHunk>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if self.diff_map.expand_all {
|
|
return;
|
|
}
|
|
|
|
let previous_toggle_task = self.diff_map.hunk_update_tasks.remove(&None);
|
|
let new_toggle_task = cx.spawn_in(window, move |editor, mut cx| async move {
|
|
if let Some(task) = previous_toggle_task {
|
|
task.await;
|
|
}
|
|
|
|
editor
|
|
.update_in(&mut cx, |editor, window, cx| {
|
|
let snapshot = editor.snapshot(window, cx);
|
|
let mut hunks_to_toggle = hunks_to_toggle.into_iter().fuse().peekable();
|
|
let mut highlights_to_remove = Vec::with_capacity(editor.diff_map.hunks.len());
|
|
let mut blocks_to_remove = HashSet::default();
|
|
let mut hunks_to_expand = Vec::new();
|
|
editor.diff_map.hunks.retain(|expanded_hunk| {
|
|
if expanded_hunk.folded {
|
|
return true;
|
|
}
|
|
let expanded_hunk_row_range = expanded_hunk
|
|
.hunk_range
|
|
.start
|
|
.to_display_point(&snapshot)
|
|
.row()
|
|
..expanded_hunk
|
|
.hunk_range
|
|
.end
|
|
.to_display_point(&snapshot)
|
|
.row();
|
|
let mut retain = true;
|
|
while let Some(hunk_to_toggle) = hunks_to_toggle.peek() {
|
|
match diff_hunk_to_display(hunk_to_toggle, &snapshot) {
|
|
DisplayDiffHunk::Folded { .. } => {
|
|
hunks_to_toggle.next();
|
|
continue;
|
|
}
|
|
DisplayDiffHunk::Unfolded {
|
|
diff_base_byte_range,
|
|
display_row_range,
|
|
multi_buffer_range,
|
|
status,
|
|
} => {
|
|
let hunk_to_toggle_row_range = display_row_range;
|
|
if hunk_to_toggle_row_range.start > expanded_hunk_row_range.end
|
|
{
|
|
break;
|
|
} else if expanded_hunk_row_range == hunk_to_toggle_row_range {
|
|
highlights_to_remove.push(expanded_hunk.hunk_range.clone());
|
|
blocks_to_remove
|
|
.extend(expanded_hunk.blocks.iter().copied());
|
|
hunks_to_toggle.next();
|
|
retain = false;
|
|
break;
|
|
} else {
|
|
hunks_to_expand.push(HoveredHunk {
|
|
status,
|
|
multi_buffer_range,
|
|
diff_base_byte_range,
|
|
});
|
|
hunks_to_toggle.next();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
retain
|
|
});
|
|
for hunk in hunks_to_toggle {
|
|
let remaining_hunk_point_range = Point::new(hunk.row_range.start.0, 0)
|
|
..Point::new(hunk.row_range.end.0, 0);
|
|
let hunk_start = snapshot
|
|
.buffer_snapshot
|
|
.anchor_before(remaining_hunk_point_range.start);
|
|
let hunk_end = snapshot
|
|
.buffer_snapshot
|
|
.anchor_in_excerpt(hunk_start.excerpt_id, hunk.buffer_range.end)
|
|
.unwrap();
|
|
hunks_to_expand.push(HoveredHunk {
|
|
status: hunk_status(&hunk),
|
|
multi_buffer_range: hunk_start..hunk_end,
|
|
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
|
|
});
|
|
}
|
|
|
|
editor.remove_highlighted_rows::<DiffRowHighlight>(highlights_to_remove, cx);
|
|
editor.remove_blocks(blocks_to_remove, None, cx);
|
|
for hunk in hunks_to_expand {
|
|
editor.expand_diff_hunk(None, &hunk, window, cx);
|
|
}
|
|
cx.notify();
|
|
})
|
|
.ok();
|
|
});
|
|
|
|
self.diff_map
|
|
.hunk_update_tasks
|
|
.insert(None, cx.background_executor().spawn(new_toggle_task));
|
|
}
|
|
|
|
pub(super) fn expand_diff_hunk(
|
|
&mut self,
|
|
diff_base_buffer: Option<Model<Buffer>>,
|
|
hunk: &HoveredHunk,
|
|
window: &mut Window,
|
|
cx: &mut Context<Editor>,
|
|
) -> Option<()> {
|
|
let buffer = self.buffer.clone();
|
|
let multi_buffer_snapshot = buffer.read(cx).snapshot(cx);
|
|
let hunk_range = hunk.multi_buffer_range.clone();
|
|
let buffer_id = hunk_range.start.buffer_id?;
|
|
let diff_base_buffer = diff_base_buffer.or_else(|| {
|
|
self.diff_map
|
|
.diff_bases
|
|
.get(&buffer_id)?
|
|
.change_set
|
|
.read(cx)
|
|
.base_text
|
|
.clone()
|
|
})?;
|
|
|
|
let diff_base = diff_base_buffer.read(cx);
|
|
let diff_start_row = diff_base
|
|
.offset_to_point(hunk.diff_base_byte_range.start)
|
|
.row;
|
|
let diff_end_row = diff_base.offset_to_point(hunk.diff_base_byte_range.end).row;
|
|
let deleted_text_lines = diff_end_row - diff_start_row;
|
|
|
|
let block_insert_index = self
|
|
.diff_map
|
|
.hunks
|
|
.binary_search_by(|probe| {
|
|
probe
|
|
.hunk_range
|
|
.start
|
|
.cmp(&hunk_range.start, &multi_buffer_snapshot)
|
|
})
|
|
.err()?;
|
|
|
|
let blocks;
|
|
match hunk.status {
|
|
DiffHunkStatus::Removed => {
|
|
blocks = self.insert_blocks(
|
|
[
|
|
self.hunk_header_block(&hunk, cx),
|
|
Self::deleted_text_block(
|
|
hunk,
|
|
diff_base_buffer,
|
|
deleted_text_lines,
|
|
window,
|
|
cx,
|
|
),
|
|
],
|
|
None,
|
|
cx,
|
|
);
|
|
}
|
|
DiffHunkStatus::Added => {
|
|
self.highlight_rows::<DiffRowHighlight>(
|
|
hunk_range.clone(),
|
|
added_hunk_color(cx),
|
|
false,
|
|
cx,
|
|
);
|
|
blocks = self.insert_blocks([self.hunk_header_block(&hunk, cx)], None, cx);
|
|
}
|
|
DiffHunkStatus::Modified => {
|
|
self.highlight_rows::<DiffRowHighlight>(
|
|
hunk_range.clone(),
|
|
added_hunk_color(cx),
|
|
false,
|
|
cx,
|
|
);
|
|
blocks = self.insert_blocks(
|
|
[
|
|
self.hunk_header_block(&hunk, cx),
|
|
Self::deleted_text_block(
|
|
hunk,
|
|
diff_base_buffer,
|
|
deleted_text_lines,
|
|
window,
|
|
cx,
|
|
),
|
|
],
|
|
None,
|
|
cx,
|
|
);
|
|
}
|
|
};
|
|
self.diff_map.hunks.insert(
|
|
block_insert_index,
|
|
ExpandedHunk {
|
|
blocks,
|
|
hunk_range,
|
|
status: hunk.status,
|
|
folded: false,
|
|
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
|
|
},
|
|
);
|
|
|
|
Some(())
|
|
}
|
|
|
|
fn apply_diff_hunks_in_range(
|
|
&mut self,
|
|
range: Range<Anchor>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Editor>,
|
|
) -> Option<()> {
|
|
let multi_buffer = self.buffer.read(cx);
|
|
let multi_buffer_snapshot = multi_buffer.snapshot(cx);
|
|
let (excerpt, range) = multi_buffer_snapshot
|
|
.range_to_buffer_ranges(range)
|
|
.into_iter()
|
|
.next()?;
|
|
|
|
multi_buffer
|
|
.buffer(excerpt.buffer_id())
|
|
.unwrap()
|
|
.update(cx, |branch_buffer, cx| {
|
|
branch_buffer.merge_into_base(vec![range], cx);
|
|
});
|
|
|
|
if let Some(project) = self.project.clone() {
|
|
self.save(true, project, window, cx).detach_and_log_err(cx);
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub(crate) fn apply_all_diff_hunks(
|
|
&mut self,
|
|
_: &ApplyAllDiffHunks,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let buffers = self.buffer.read(cx).all_buffers();
|
|
for branch_buffer in buffers {
|
|
branch_buffer.update(cx, |branch_buffer, cx| {
|
|
branch_buffer.merge_into_base(Vec::new(), cx);
|
|
});
|
|
}
|
|
|
|
if let Some(project) = self.project.clone() {
|
|
self.save(true, project, window, cx).detach_and_log_err(cx);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn apply_selected_diff_hunks(
|
|
&mut self,
|
|
_: &ApplyDiffHunk,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let snapshot = self.snapshot(window, cx);
|
|
let hunks = hunks_for_selections(&snapshot, &self.selections.all(cx));
|
|
let mut ranges_by_buffer = HashMap::default();
|
|
self.transact(window, cx, |editor, _, cx| {
|
|
for hunk in hunks {
|
|
if let Some(buffer) = editor.buffer.read(cx).buffer(hunk.buffer_id) {
|
|
ranges_by_buffer
|
|
.entry(buffer.clone())
|
|
.or_insert_with(Vec::new)
|
|
.push(hunk.buffer_range.to_offset(buffer.read(cx)));
|
|
}
|
|
}
|
|
|
|
for (buffer, ranges) in ranges_by_buffer {
|
|
buffer.update(cx, |buffer, cx| {
|
|
buffer.merge_into_base(ranges, cx);
|
|
});
|
|
}
|
|
});
|
|
|
|
if let Some(project) = self.project.clone() {
|
|
self.save(true, project, window, cx).detach_and_log_err(cx);
|
|
}
|
|
}
|
|
|
|
fn has_multiple_hunks(&self, cx: &AppContext) -> bool {
|
|
let snapshot = self.buffer.read(cx).snapshot(cx);
|
|
let mut hunks = self.diff_map.snapshot.diff_hunks(&snapshot);
|
|
hunks.nth(1).is_some()
|
|
}
|
|
|
|
fn hunk_header_block(
|
|
&self,
|
|
hunk: &HoveredHunk,
|
|
cx: &mut Context<Editor>,
|
|
) -> BlockProperties<Anchor> {
|
|
let is_branch_buffer = self
|
|
.buffer
|
|
.read(cx)
|
|
.point_to_buffer_offset(hunk.multi_buffer_range.start, cx)
|
|
.map_or(false, |(buffer, _, _)| {
|
|
buffer.read(cx).base_buffer().is_some()
|
|
});
|
|
|
|
let border_color = cx.theme().colors().border_variant;
|
|
let bg_color = cx.theme().colors().editor_background;
|
|
let gutter_color = match hunk.status {
|
|
DiffHunkStatus::Added => cx.theme().status().created,
|
|
DiffHunkStatus::Modified => cx.theme().status().modified,
|
|
DiffHunkStatus::Removed => cx.theme().status().deleted,
|
|
};
|
|
|
|
BlockProperties {
|
|
placement: BlockPlacement::Above(hunk.multi_buffer_range.start),
|
|
height: 1,
|
|
style: BlockStyle::Sticky,
|
|
priority: 0,
|
|
render: Arc::new({
|
|
let editor = cx.entity().clone();
|
|
let hunk = hunk.clone();
|
|
let has_multiple_hunks = self.has_multiple_hunks(cx);
|
|
|
|
move |cx| {
|
|
let hunk_controls_menu_handle =
|
|
editor.read(cx).hunk_controls_menu_handle.clone();
|
|
|
|
h_flex()
|
|
.id(cx.block_id)
|
|
.block_mouse_down()
|
|
.h(cx.window.line_height())
|
|
.w_full()
|
|
.border_t_1()
|
|
.border_color(border_color)
|
|
.bg(bg_color)
|
|
.child(
|
|
div()
|
|
.id("gutter-strip")
|
|
.w(EditorElement::diff_hunk_strip_width(
|
|
cx.window.line_height(),
|
|
))
|
|
.h_full()
|
|
.bg(gutter_color)
|
|
.cursor(CursorStyle::PointingHand)
|
|
.on_click({
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor.toggle_hovered_hunk(&hunk, window, cx);
|
|
});
|
|
}
|
|
}),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.px_6()
|
|
.size_full()
|
|
.justify_end()
|
|
.child(
|
|
h_flex()
|
|
.gap_1()
|
|
.when(!is_branch_buffer, |row| {
|
|
row.child(
|
|
IconButton::new("next-hunk", IconName::ArrowDown)
|
|
.shape(IconButtonShape::Square)
|
|
.icon_size(IconSize::Small)
|
|
.disabled(!has_multiple_hunks)
|
|
.tooltip({
|
|
let focus_handle = editor.focus_handle(cx);
|
|
move |window, cx| {
|
|
Tooltip::for_action_in(
|
|
"Next Hunk",
|
|
&GoToHunk,
|
|
&focus_handle,
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
})
|
|
.on_click({
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor.go_to_subsequent_hunk(
|
|
hunk.multi_buffer_range.end,
|
|
window,
|
|
cx,
|
|
);
|
|
});
|
|
}
|
|
}),
|
|
)
|
|
.child(
|
|
IconButton::new("prev-hunk", IconName::ArrowUp)
|
|
.shape(IconButtonShape::Square)
|
|
.icon_size(IconSize::Small)
|
|
.disabled(!has_multiple_hunks)
|
|
.tooltip({
|
|
let focus_handle = editor.focus_handle(cx);
|
|
move |window, cx| {
|
|
Tooltip::for_action_in(
|
|
"Previous Hunk",
|
|
&GoToPrevHunk,
|
|
&focus_handle,
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
})
|
|
.on_click({
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor.go_to_preceding_hunk(
|
|
hunk.multi_buffer_range.start,
|
|
window,
|
|
cx,
|
|
);
|
|
});
|
|
}
|
|
}),
|
|
)
|
|
})
|
|
.child(
|
|
IconButton::new("discard", IconName::Undo)
|
|
.shape(IconButtonShape::Square)
|
|
.icon_size(IconSize::Small)
|
|
.tooltip({
|
|
let focus_handle = editor.focus_handle(cx);
|
|
move |window, cx| {
|
|
Tooltip::for_action_in(
|
|
"Discard Hunk",
|
|
&RevertSelectedHunks,
|
|
&focus_handle,
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
})
|
|
.on_click({
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor.revert_hunk(
|
|
hunk.clone(),
|
|
window,
|
|
cx,
|
|
);
|
|
});
|
|
}
|
|
}),
|
|
)
|
|
.map(|this| {
|
|
if is_branch_buffer {
|
|
this.child(
|
|
IconButton::new("apply", IconName::Check)
|
|
.shape(IconButtonShape::Square)
|
|
.icon_size(IconSize::Small)
|
|
.tooltip({
|
|
let focus_handle =
|
|
editor.focus_handle(cx);
|
|
move |window, cx| {
|
|
Tooltip::for_action_in(
|
|
"Apply Hunk",
|
|
&ApplyDiffHunk,
|
|
&focus_handle,
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
})
|
|
.on_click({
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor
|
|
.apply_diff_hunks_in_range(
|
|
hunk.multi_buffer_range
|
|
.clone(),
|
|
window,
|
|
cx,
|
|
);
|
|
});
|
|
}
|
|
}),
|
|
)
|
|
} else {
|
|
this.child({
|
|
let focus = editor.focus_handle(cx);
|
|
PopoverMenu::new("hunk-controls-dropdown")
|
|
.trigger(
|
|
IconButton::new(
|
|
"toggle_editor_selections_icon",
|
|
IconName::EllipsisVertical,
|
|
)
|
|
.shape(IconButtonShape::Square)
|
|
.icon_size(IconSize::Small)
|
|
.style(ButtonStyle::Subtle)
|
|
.toggle_state(
|
|
hunk_controls_menu_handle
|
|
.is_deployed(),
|
|
)
|
|
.when(
|
|
!hunk_controls_menu_handle
|
|
.is_deployed(),
|
|
|this| {
|
|
this.tooltip(|_, cx| {
|
|
Tooltip::simple(
|
|
"Hunk Controls",
|
|
cx,
|
|
)
|
|
})
|
|
},
|
|
),
|
|
)
|
|
.anchor(Corner::TopRight)
|
|
.with_handle(hunk_controls_menu_handle)
|
|
.menu(move |window, cx| {
|
|
let focus = focus.clone();
|
|
let menu = ContextMenu::build(
|
|
window,
|
|
cx,
|
|
move |menu, _, _| {
|
|
menu.context(focus.clone())
|
|
.action(
|
|
"Discard All Hunks",
|
|
RevertFile
|
|
.boxed_clone(),
|
|
)
|
|
},
|
|
);
|
|
Some(menu)
|
|
})
|
|
})
|
|
}
|
|
}),
|
|
)
|
|
.when(!is_branch_buffer, |div| {
|
|
div.child(
|
|
IconButton::new("collapse", IconName::Close)
|
|
.shape(IconButtonShape::Square)
|
|
.icon_size(IconSize::Small)
|
|
.tooltip({
|
|
let focus_handle = editor.focus_handle(cx);
|
|
move |window, cx| {
|
|
Tooltip::for_action_in(
|
|
"Collapse Hunk",
|
|
&ToggleHunkDiff,
|
|
&focus_handle,
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
})
|
|
.on_click({
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor
|
|
.toggle_hovered_hunk(&hunk, window, cx);
|
|
});
|
|
}
|
|
}),
|
|
)
|
|
}),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn deleted_text_block(
|
|
hunk: &HoveredHunk,
|
|
diff_base_buffer: Model<Buffer>,
|
|
deleted_text_height: u32,
|
|
window: &mut Window,
|
|
cx: &mut Context<Editor>,
|
|
) -> BlockProperties<Anchor> {
|
|
let gutter_color = match hunk.status {
|
|
DiffHunkStatus::Added => unreachable!(),
|
|
DiffHunkStatus::Modified => cx.theme().status().modified,
|
|
DiffHunkStatus::Removed => cx.theme().status().deleted,
|
|
};
|
|
let deleted_hunk_color = deleted_hunk_color(cx);
|
|
let (editor_height, editor_with_deleted_text) =
|
|
editor_with_deleted_text(diff_base_buffer, deleted_hunk_color, hunk, window, cx);
|
|
let editor = cx.entity().clone();
|
|
let hunk = hunk.clone();
|
|
let height = editor_height.max(deleted_text_height);
|
|
BlockProperties {
|
|
placement: BlockPlacement::Above(hunk.multi_buffer_range.start),
|
|
height,
|
|
style: BlockStyle::Flex,
|
|
priority: 0,
|
|
render: Arc::new(move |cx| {
|
|
let width = EditorElement::diff_hunk_strip_width(cx.window.line_height());
|
|
let gutter_dimensions = editor.read(cx.app).gutter_dimensions;
|
|
|
|
h_flex()
|
|
.id(cx.block_id)
|
|
.block_mouse_down()
|
|
.bg(deleted_hunk_color)
|
|
.h(height as f32 * cx.window.line_height())
|
|
.w_full()
|
|
.child(
|
|
h_flex()
|
|
.id("gutter")
|
|
.max_w(gutter_dimensions.full_width())
|
|
.min_w(gutter_dimensions.full_width())
|
|
.size_full()
|
|
.child(
|
|
h_flex()
|
|
.id("gutter hunk")
|
|
.bg(gutter_color)
|
|
.pl(gutter_dimensions.margin
|
|
+ gutter_dimensions
|
|
.git_blame_entries_width
|
|
.unwrap_or_default())
|
|
.max_w(width)
|
|
.min_w(width)
|
|
.size_full()
|
|
.cursor(CursorStyle::PointingHand)
|
|
.on_mouse_down(MouseButton::Left, {
|
|
let editor = editor.clone();
|
|
let hunk = hunk.clone();
|
|
move |_event, window, cx| {
|
|
editor.update(cx, |editor, cx| {
|
|
editor.toggle_hovered_hunk(&hunk, window, cx);
|
|
});
|
|
}
|
|
}),
|
|
),
|
|
)
|
|
.child(editor_with_deleted_text.clone())
|
|
.into_any_element()
|
|
}),
|
|
}
|
|
}
|
|
|
|
pub(super) fn clear_expanded_diff_hunks(&mut self, cx: &mut Context<Editor>) -> bool {
|
|
if self.diff_map.expand_all {
|
|
return false;
|
|
}
|
|
self.diff_map.hunk_update_tasks.clear();
|
|
self.clear_row_highlights::<DiffRowHighlight>();
|
|
let to_remove = self
|
|
.diff_map
|
|
.hunks
|
|
.drain(..)
|
|
.flat_map(|expanded_hunk| expanded_hunk.blocks.into_iter())
|
|
.collect::<HashSet<_>>();
|
|
if to_remove.is_empty() {
|
|
false
|
|
} else {
|
|
self.remove_blocks(to_remove, None, cx);
|
|
true
|
|
}
|
|
}
|
|
|
|
pub(super) fn sync_expanded_diff_hunks(
|
|
diff_map: &mut DiffMap,
|
|
buffer_id: BufferId,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let diff_base_state = diff_map.diff_bases.get_mut(&buffer_id);
|
|
let mut diff_base_buffer = None;
|
|
let mut diff_base_buffer_unchanged = true;
|
|
if let Some(diff_base_state) = diff_base_state {
|
|
diff_base_state.change_set.update(cx, |change_set, _| {
|
|
if diff_base_state.last_version != Some(change_set.base_text_version) {
|
|
diff_base_state.last_version = Some(change_set.base_text_version);
|
|
diff_base_buffer_unchanged = false;
|
|
}
|
|
diff_base_buffer = change_set.base_text.clone();
|
|
})
|
|
}
|
|
|
|
diff_map.hunk_update_tasks.remove(&Some(buffer_id));
|
|
|
|
let new_sync_task = cx.spawn_in(window, move |editor, mut cx| async move {
|
|
editor
|
|
.update_in(&mut cx, |editor, window, cx| {
|
|
let snapshot = editor.snapshot(window, cx);
|
|
let mut recalculated_hunks = snapshot
|
|
.diff_map
|
|
.diff_hunks(&snapshot.buffer_snapshot)
|
|
.filter(|hunk| hunk.buffer_id == buffer_id)
|
|
.fuse()
|
|
.peekable();
|
|
let mut highlights_to_remove = Vec::with_capacity(editor.diff_map.hunks.len());
|
|
let mut blocks_to_remove = HashSet::default();
|
|
let mut hunks_to_reexpand = Vec::with_capacity(editor.diff_map.hunks.len());
|
|
editor.diff_map.hunks.retain_mut(|expanded_hunk| {
|
|
if expanded_hunk.hunk_range.start.buffer_id != Some(buffer_id) {
|
|
return true;
|
|
};
|
|
|
|
let mut retain = false;
|
|
if diff_base_buffer_unchanged {
|
|
let expanded_hunk_display_range = expanded_hunk
|
|
.hunk_range
|
|
.start
|
|
.to_display_point(&snapshot)
|
|
.row()
|
|
..expanded_hunk
|
|
.hunk_range
|
|
.end
|
|
.to_display_point(&snapshot)
|
|
.row();
|
|
while let Some(buffer_hunk) = recalculated_hunks.peek() {
|
|
match diff_hunk_to_display(buffer_hunk, &snapshot) {
|
|
DisplayDiffHunk::Folded { display_row } => {
|
|
recalculated_hunks.next();
|
|
if !expanded_hunk.folded
|
|
&& expanded_hunk_display_range
|
|
.to_inclusive()
|
|
.contains(&display_row)
|
|
{
|
|
retain = true;
|
|
expanded_hunk.folded = true;
|
|
highlights_to_remove
|
|
.push(expanded_hunk.hunk_range.clone());
|
|
for block in expanded_hunk.blocks.drain(..) {
|
|
blocks_to_remove.insert(block);
|
|
}
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
DisplayDiffHunk::Unfolded {
|
|
diff_base_byte_range,
|
|
display_row_range,
|
|
multi_buffer_range,
|
|
status,
|
|
} => {
|
|
let hunk_display_range = display_row_range;
|
|
|
|
if expanded_hunk_display_range.start
|
|
> hunk_display_range.end
|
|
{
|
|
recalculated_hunks.next();
|
|
if editor.diff_map.expand_all {
|
|
hunks_to_reexpand.push(HoveredHunk {
|
|
status,
|
|
multi_buffer_range,
|
|
diff_base_byte_range,
|
|
});
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if expanded_hunk_display_range.end
|
|
< hunk_display_range.start
|
|
{
|
|
break;
|
|
}
|
|
|
|
if !expanded_hunk.folded
|
|
&& expanded_hunk_display_range == hunk_display_range
|
|
&& expanded_hunk.status == hunk_status(buffer_hunk)
|
|
&& expanded_hunk.diff_base_byte_range
|
|
== buffer_hunk.diff_base_byte_range
|
|
{
|
|
recalculated_hunks.next();
|
|
retain = true;
|
|
} else {
|
|
hunks_to_reexpand.push(HoveredHunk {
|
|
status,
|
|
multi_buffer_range,
|
|
diff_base_byte_range,
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !retain {
|
|
blocks_to_remove.extend(expanded_hunk.blocks.drain(..));
|
|
highlights_to_remove.push(expanded_hunk.hunk_range.clone());
|
|
}
|
|
retain
|
|
});
|
|
|
|
if editor.diff_map.expand_all {
|
|
for hunk in recalculated_hunks {
|
|
match diff_hunk_to_display(&hunk, &snapshot) {
|
|
DisplayDiffHunk::Folded { .. } => {}
|
|
DisplayDiffHunk::Unfolded {
|
|
diff_base_byte_range,
|
|
multi_buffer_range,
|
|
status,
|
|
..
|
|
} => {
|
|
hunks_to_reexpand.push(HoveredHunk {
|
|
status,
|
|
multi_buffer_range,
|
|
diff_base_byte_range,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
drop(recalculated_hunks);
|
|
}
|
|
|
|
editor.remove_highlighted_rows::<DiffRowHighlight>(highlights_to_remove, cx);
|
|
editor.remove_blocks(blocks_to_remove, None, cx);
|
|
|
|
if let Some(diff_base_buffer) = &diff_base_buffer {
|
|
for hunk in hunks_to_reexpand {
|
|
editor.expand_diff_hunk(
|
|
Some(diff_base_buffer.clone()),
|
|
&hunk,
|
|
window,
|
|
cx,
|
|
);
|
|
}
|
|
}
|
|
})
|
|
.ok();
|
|
});
|
|
|
|
diff_map.hunk_update_tasks.insert(
|
|
Some(buffer_id),
|
|
cx.background_executor().spawn(new_sync_task),
|
|
);
|
|
}
|
|
|
|
fn go_to_subsequent_hunk(
|
|
&mut self,
|
|
position: Anchor,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let snapshot = self.snapshot(window, cx);
|
|
let position = position.to_point(&snapshot.buffer_snapshot);
|
|
if let Some(hunk) = self.go_to_hunk_after_position(&snapshot, position, window, cx) {
|
|
let multi_buffer_start = snapshot
|
|
.buffer_snapshot
|
|
.anchor_before(Point::new(hunk.row_range.start.0, 0));
|
|
let multi_buffer_end = snapshot
|
|
.buffer_snapshot
|
|
.anchor_after(Point::new(hunk.row_range.end.0, 0));
|
|
self.expand_diff_hunk(
|
|
None,
|
|
&HoveredHunk {
|
|
multi_buffer_range: multi_buffer_start..multi_buffer_end,
|
|
status: hunk_status(&hunk),
|
|
diff_base_byte_range: hunk.diff_base_byte_range,
|
|
},
|
|
window,
|
|
cx,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn go_to_preceding_hunk(
|
|
&mut self,
|
|
position: Anchor,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let snapshot = self.snapshot(window, cx);
|
|
let position = position.to_point(&snapshot.buffer_snapshot);
|
|
let hunk = self.go_to_hunk_before_position(&snapshot, position, window, cx);
|
|
if let Some(hunk) = hunk {
|
|
let multi_buffer_start = snapshot
|
|
.buffer_snapshot
|
|
.anchor_before(Point::new(hunk.row_range.start.0, 0));
|
|
let multi_buffer_end = snapshot
|
|
.buffer_snapshot
|
|
.anchor_after(Point::new(hunk.row_range.end.0, 0));
|
|
self.expand_diff_hunk(
|
|
None,
|
|
&HoveredHunk {
|
|
multi_buffer_range: multi_buffer_start..multi_buffer_end,
|
|
status: hunk_status(&hunk),
|
|
diff_base_byte_range: hunk.diff_base_byte_range,
|
|
},
|
|
window,
|
|
cx,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn to_diff_hunk(
|
|
hovered_hunk: &HoveredHunk,
|
|
multi_buffer_snapshot: &MultiBufferSnapshot,
|
|
) -> Option<MultiBufferDiffHunk> {
|
|
let buffer_id = hovered_hunk
|
|
.multi_buffer_range
|
|
.start
|
|
.buffer_id
|
|
.or(hovered_hunk.multi_buffer_range.end.buffer_id)?;
|
|
let buffer_range = hovered_hunk.multi_buffer_range.start.text_anchor
|
|
..hovered_hunk.multi_buffer_range.end.text_anchor;
|
|
let point_range = hovered_hunk
|
|
.multi_buffer_range
|
|
.to_point(multi_buffer_snapshot);
|
|
Some(MultiBufferDiffHunk {
|
|
row_range: MultiBufferRow(point_range.start.row)..MultiBufferRow(point_range.end.row),
|
|
buffer_id,
|
|
buffer_range,
|
|
diff_base_byte_range: hovered_hunk.diff_base_byte_range.clone(),
|
|
})
|
|
}
|
|
|
|
fn added_hunk_color(cx: &AppContext) -> Hsla {
|
|
let mut created_color = cx.theme().status().git().created;
|
|
created_color.fade_out(0.7);
|
|
created_color
|
|
}
|
|
|
|
fn deleted_hunk_color(cx: &AppContext) -> Hsla {
|
|
let mut deleted_color = cx.theme().status().deleted;
|
|
deleted_color.fade_out(0.7);
|
|
deleted_color
|
|
}
|
|
|
|
fn editor_with_deleted_text(
|
|
diff_base_buffer: Model<Buffer>,
|
|
deleted_color: Hsla,
|
|
hunk: &HoveredHunk,
|
|
window: &mut Window,
|
|
cx: &mut Context<Editor>,
|
|
) -> (u32, Model<Editor>) {
|
|
let parent_editor = cx.entity().downgrade();
|
|
let editor = cx.new(|cx| {
|
|
let multi_buffer = cx.new(|_| MultiBuffer::without_headers(language::Capability::ReadOnly));
|
|
multi_buffer.update(cx, |multi_buffer, cx| {
|
|
multi_buffer.push_excerpts(
|
|
diff_base_buffer,
|
|
Some(ExcerptRange {
|
|
context: hunk.diff_base_byte_range.clone(),
|
|
primary: None,
|
|
}),
|
|
cx,
|
|
);
|
|
});
|
|
|
|
let mut editor = Editor::for_multibuffer(multi_buffer, None, true, window, cx);
|
|
editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx);
|
|
editor.set_show_wrap_guides(false, cx);
|
|
editor.set_show_gutter(false, cx);
|
|
editor.set_show_line_numbers(false, cx);
|
|
editor.set_show_scrollbars(false, cx);
|
|
editor.set_show_runnables(false, cx);
|
|
editor.set_show_git_diff_gutter(false, cx);
|
|
editor.set_show_code_actions(false, cx);
|
|
editor.scroll_manager.set_forbid_vertical_scroll(true);
|
|
editor.set_read_only(true);
|
|
editor.set_show_inline_completions(Some(false), window, cx);
|
|
|
|
enum DeletedBlockRowHighlight {}
|
|
editor.highlight_rows::<DeletedBlockRowHighlight>(
|
|
Anchor::min()..Anchor::max(),
|
|
deleted_color,
|
|
false,
|
|
cx,
|
|
);
|
|
editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
|
|
editor._subscriptions.extend([cx.on_blur(
|
|
&editor.focus_handle,
|
|
window,
|
|
|editor, window, cx| {
|
|
editor.change_selections(None, window, cx, |s| {
|
|
s.try_cancel();
|
|
});
|
|
},
|
|
)]);
|
|
|
|
editor
|
|
.register_action::<RevertSelectedHunks>({
|
|
let hunk = hunk.clone();
|
|
let parent_editor = parent_editor.clone();
|
|
move |_, window, cx| {
|
|
parent_editor
|
|
.update(cx, |editor, cx| {
|
|
editor.revert_hunk(hunk.clone(), window, cx)
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
editor
|
|
.register_action::<ToggleHunkDiff>({
|
|
let hunk = hunk.clone();
|
|
move |_, window, cx| {
|
|
parent_editor
|
|
.update(cx, |editor, cx| {
|
|
editor.toggle_hovered_hunk(&hunk, window, cx);
|
|
})
|
|
.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
editor
|
|
});
|
|
|
|
let editor_height = editor.update(cx, |editor, cx| editor.max_point(cx).row().0);
|
|
(editor_height, editor)
|
|
}
|
|
|
|
impl DisplayDiffHunk {
|
|
pub fn start_display_row(&self) -> DisplayRow {
|
|
match self {
|
|
&DisplayDiffHunk::Folded { display_row } => display_row,
|
|
DisplayDiffHunk::Unfolded {
|
|
display_row_range, ..
|
|
} => display_row_range.start,
|
|
}
|
|
}
|
|
|
|
pub fn contains_display_row(&self, display_row: DisplayRow) -> bool {
|
|
let range = match self {
|
|
&DisplayDiffHunk::Folded { display_row } => display_row..=display_row,
|
|
|
|
DisplayDiffHunk::Unfolded {
|
|
display_row_range, ..
|
|
} => display_row_range.start..=display_row_range.end,
|
|
};
|
|
|
|
range.contains(&display_row)
|
|
}
|
|
}
|
|
|
|
pub fn diff_hunk_to_display(
|
|
hunk: &MultiBufferDiffHunk,
|
|
snapshot: &DisplaySnapshot,
|
|
) -> DisplayDiffHunk {
|
|
let hunk_start_point = Point::new(hunk.row_range.start.0, 0);
|
|
let hunk_start_point_sub = Point::new(hunk.row_range.start.0.saturating_sub(1), 0);
|
|
let hunk_end_point_sub = Point::new(
|
|
hunk.row_range
|
|
.end
|
|
.0
|
|
.saturating_sub(1)
|
|
.max(hunk.row_range.start.0),
|
|
0,
|
|
);
|
|
|
|
let status = hunk_status(hunk);
|
|
let is_removal = status == DiffHunkStatus::Removed;
|
|
|
|
let folds_start = Point::new(hunk.row_range.start.0.saturating_sub(2), 0);
|
|
let folds_end = Point::new(hunk.row_range.end.0 + 2, 0);
|
|
let folds_range = folds_start..folds_end;
|
|
|
|
let containing_fold = snapshot.folds_in_range(folds_range).find(|fold| {
|
|
let fold_point_range = fold.range.to_point(&snapshot.buffer_snapshot);
|
|
let fold_point_range = fold_point_range.start..=fold_point_range.end;
|
|
|
|
let folded_start = fold_point_range.contains(&hunk_start_point);
|
|
let folded_end = fold_point_range.contains(&hunk_end_point_sub);
|
|
let folded_start_sub = fold_point_range.contains(&hunk_start_point_sub);
|
|
|
|
(folded_start && folded_end) || (is_removal && folded_start_sub)
|
|
});
|
|
|
|
if let Some(fold) = containing_fold {
|
|
let row = fold.range.start.to_display_point(snapshot).row();
|
|
DisplayDiffHunk::Folded { display_row: row }
|
|
} else {
|
|
let start = hunk_start_point.to_display_point(snapshot).row();
|
|
|
|
let hunk_end_row = hunk.row_range.end.max(hunk.row_range.start);
|
|
let hunk_end_point = Point::new(hunk_end_row.0, 0);
|
|
|
|
let multi_buffer_start = snapshot.buffer_snapshot.anchor_before(hunk_start_point);
|
|
let multi_buffer_end = snapshot
|
|
.buffer_snapshot
|
|
.anchor_in_excerpt(multi_buffer_start.excerpt_id, hunk.buffer_range.end)
|
|
.unwrap();
|
|
let end = hunk_end_point.to_display_point(snapshot).row();
|
|
|
|
DisplayDiffHunk::Unfolded {
|
|
display_row_range: start..end,
|
|
multi_buffer_range: multi_buffer_start..multi_buffer_end,
|
|
status,
|
|
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{editor_tests::init_test, hunk_status};
|
|
use gpui::{Context, TestAppContext};
|
|
use language::Capability::ReadWrite;
|
|
use multi_buffer::{ExcerptRange, MultiBuffer, MultiBufferRow};
|
|
use project::{FakeFs, Project};
|
|
use unindent::Unindent as _;
|
|
|
|
#[gpui::test]
|
|
async fn test_diff_hunks_in_range(cx: &mut TestAppContext) {
|
|
use git::diff::DiffHunkStatus;
|
|
init_test(cx, |_| {});
|
|
|
|
let fs = FakeFs::new(cx.background_executor.clone());
|
|
let project = Project::test(fs, [], cx).await;
|
|
|
|
// buffer has two modified hunks with two rows each
|
|
let diff_base_1 = "
|
|
1.zero
|
|
1.one
|
|
1.two
|
|
1.three
|
|
1.four
|
|
1.five
|
|
1.six
|
|
"
|
|
.unindent();
|
|
|
|
let text_1 = "
|
|
1.zero
|
|
1.ONE
|
|
1.TWO
|
|
1.three
|
|
1.FOUR
|
|
1.FIVE
|
|
1.six
|
|
"
|
|
.unindent();
|
|
|
|
// buffer has a deletion hunk and an insertion hunk
|
|
let diff_base_2 = "
|
|
2.zero
|
|
2.one
|
|
2.one-and-a-half
|
|
2.two
|
|
2.three
|
|
2.four
|
|
2.six
|
|
"
|
|
.unindent();
|
|
|
|
let text_2 = "
|
|
2.zero
|
|
2.one
|
|
2.two
|
|
2.three
|
|
2.four
|
|
2.five
|
|
2.six
|
|
"
|
|
.unindent();
|
|
|
|
let buffer_1 = project.update(cx, |project, cx| {
|
|
project.create_local_buffer(text_1.as_str(), None, cx)
|
|
});
|
|
let buffer_2 = project.update(cx, |project, cx| {
|
|
project.create_local_buffer(text_2.as_str(), None, cx)
|
|
});
|
|
|
|
let multibuffer = cx.new(|cx| {
|
|
let mut multibuffer = MultiBuffer::new(ReadWrite);
|
|
multibuffer.push_excerpts(
|
|
buffer_1.clone(),
|
|
[
|
|
// excerpt ends in the middle of a modified hunk
|
|
ExcerptRange {
|
|
context: Point::new(0, 0)..Point::new(1, 5),
|
|
primary: Default::default(),
|
|
},
|
|
// excerpt begins in the middle of a modified hunk
|
|
ExcerptRange {
|
|
context: Point::new(5, 0)..Point::new(6, 5),
|
|
primary: Default::default(),
|
|
},
|
|
],
|
|
cx,
|
|
);
|
|
multibuffer.push_excerpts(
|
|
buffer_2.clone(),
|
|
[
|
|
// excerpt ends at a deletion
|
|
ExcerptRange {
|
|
context: Point::new(0, 0)..Point::new(1, 5),
|
|
primary: Default::default(),
|
|
},
|
|
// excerpt starts at a deletion
|
|
ExcerptRange {
|
|
context: Point::new(2, 0)..Point::new(2, 5),
|
|
primary: Default::default(),
|
|
},
|
|
// excerpt fully contains a deletion hunk
|
|
ExcerptRange {
|
|
context: Point::new(1, 0)..Point::new(2, 5),
|
|
primary: Default::default(),
|
|
},
|
|
// excerpt fully contains an insertion hunk
|
|
ExcerptRange {
|
|
context: Point::new(4, 0)..Point::new(6, 5),
|
|
primary: Default::default(),
|
|
},
|
|
],
|
|
cx,
|
|
);
|
|
multibuffer
|
|
});
|
|
|
|
let editor = cx
|
|
.add_window(|window, cx| Editor::for_multibuffer(multibuffer, None, false, window, cx));
|
|
editor
|
|
.update(cx, |editor, window, cx| {
|
|
for (buffer, diff_base) in [
|
|
(buffer_1.clone(), diff_base_1),
|
|
(buffer_2.clone(), diff_base_2),
|
|
] {
|
|
let change_set = cx.new(|cx| {
|
|
BufferChangeSet::new_with_base_text(
|
|
diff_base.to_string(),
|
|
buffer.read(cx).text_snapshot(),
|
|
cx,
|
|
)
|
|
});
|
|
editor.diff_map.add_change_set(change_set, window, cx)
|
|
}
|
|
})
|
|
.unwrap();
|
|
cx.background_executor.run_until_parked();
|
|
|
|
let snapshot = editor
|
|
.update(cx, |editor, window, cx| editor.snapshot(window, cx))
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
snapshot.buffer_snapshot.text(),
|
|
"
|
|
1.zero
|
|
1.ONE
|
|
1.FIVE
|
|
1.six
|
|
2.zero
|
|
2.one
|
|
2.two
|
|
2.one
|
|
2.two
|
|
2.four
|
|
2.five
|
|
2.six"
|
|
.unindent()
|
|
);
|
|
|
|
let expected = [
|
|
(
|
|
DiffHunkStatus::Modified,
|
|
MultiBufferRow(1)..MultiBufferRow(2),
|
|
),
|
|
(
|
|
DiffHunkStatus::Modified,
|
|
MultiBufferRow(2)..MultiBufferRow(3),
|
|
),
|
|
//TODO: Define better when and where removed hunks show up at range extremities
|
|
(
|
|
DiffHunkStatus::Removed,
|
|
MultiBufferRow(6)..MultiBufferRow(6),
|
|
),
|
|
(
|
|
DiffHunkStatus::Removed,
|
|
MultiBufferRow(8)..MultiBufferRow(8),
|
|
),
|
|
(
|
|
DiffHunkStatus::Added,
|
|
MultiBufferRow(10)..MultiBufferRow(11),
|
|
),
|
|
];
|
|
|
|
assert_eq!(
|
|
snapshot
|
|
.diff_map
|
|
.diff_hunks_in_range(Point::zero()..Point::new(12, 0), &snapshot.buffer_snapshot)
|
|
.map(|hunk| (hunk_status(&hunk), hunk.row_range))
|
|
.collect::<Vec<_>>(),
|
|
&expected,
|
|
);
|
|
|
|
assert_eq!(
|
|
snapshot
|
|
.diff_map
|
|
.diff_hunks_in_range_rev(
|
|
Point::zero()..Point::new(12, 0),
|
|
&snapshot.buffer_snapshot
|
|
)
|
|
.map(|hunk| (hunk_status(&hunk), hunk.row_range))
|
|
.collect::<Vec<_>>(),
|
|
expected
|
|
.iter()
|
|
.rev()
|
|
.cloned()
|
|
.collect::<Vec<_>>()
|
|
.as_slice(),
|
|
);
|
|
}
|
|
}
|