1use std::ops::Range;
2use sum_tree::SumTree;
3use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point};
4
5pub use git2 as libgit;
6use libgit::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
7
8#[derive(Debug, Clone, Copy, PartialEq, Eq)]
9pub enum DiffHunkStatus {
10 Added,
11 Modified,
12 Removed,
13}
14
15#[derive(Debug, Clone, PartialEq, Eq)]
16pub struct DiffHunk<T> {
17 pub buffer_range: Range<T>,
18 pub diff_base_byte_range: Range<usize>,
19}
20
21impl DiffHunk<u32> {
22 pub fn status(&self) -> DiffHunkStatus {
23 if self.diff_base_byte_range.is_empty() {
24 DiffHunkStatus::Added
25 } else if self.buffer_range.is_empty() {
26 DiffHunkStatus::Removed
27 } else {
28 DiffHunkStatus::Modified
29 }
30 }
31}
32
33impl sum_tree::Item for DiffHunk<Anchor> {
34 type Summary = DiffHunkSummary;
35
36 fn summary(&self) -> Self::Summary {
37 DiffHunkSummary {
38 buffer_range: self.buffer_range.clone(),
39 }
40 }
41}
42
43#[derive(Debug, Default, Clone)]
44pub struct DiffHunkSummary {
45 buffer_range: Range<Anchor>,
46}
47
48impl sum_tree::Summary for DiffHunkSummary {
49 type Context = text::BufferSnapshot;
50
51 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
52 self.buffer_range.start = self
53 .buffer_range
54 .start
55 .min(&other.buffer_range.start, buffer);
56 self.buffer_range.end = self.buffer_range.end.max(&other.buffer_range.end, buffer);
57 }
58}
59
60#[derive(Clone)]
61pub struct BufferDiff {
62 last_buffer_version: Option<clock::Global>,
63 tree: SumTree<DiffHunk<Anchor>>,
64}
65
66impl BufferDiff {
67 pub fn new() -> BufferDiff {
68 BufferDiff {
69 last_buffer_version: None,
70 tree: SumTree::new(),
71 }
72 }
73
74 pub fn hunks_in_range<'a>(
75 &'a self,
76 range: Range<Anchor>,
77 buffer: &'a BufferSnapshot,
78 reversed: bool,
79 ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
80 let mut cursor = self.tree.filter::<_, DiffHunkSummary>(move |summary| {
81 let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
82 let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
83 !before_start && !after_end
84 });
85
86 std::iter::from_fn(move || {
87 if reversed {
88 cursor.prev(buffer);
89 } else {
90 cursor.next(buffer);
91 }
92
93 let hunk = cursor.item()?;
94
95 let range = hunk.buffer_range.to_point(buffer);
96 let end_row = if range.end.column > 0 {
97 range.end.row + 1
98 } else {
99 range.end.row
100 };
101
102 Some(DiffHunk {
103 buffer_range: range.start.row..end_row,
104 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
105 })
106 })
107 }
108
109 pub fn clear(&mut self, buffer: &text::BufferSnapshot) {
110 self.last_buffer_version = Some(buffer.version().clone());
111 self.tree = SumTree::new();
112 }
113
114 pub fn needs_update(&self, buffer: &text::BufferSnapshot) -> bool {
115 match &self.last_buffer_version {
116 Some(last) => buffer.version().changed_since(last),
117 None => true,
118 }
119 }
120
121 pub async fn update(&mut self, diff_base: &str, buffer: &text::BufferSnapshot) {
122 let mut tree = SumTree::new();
123
124 let buffer_text = buffer.as_rope().to_string();
125 let patch = Self::diff(&diff_base, &buffer_text);
126
127 if let Some(patch) = patch {
128 let mut divergence = 0;
129 for hunk_index in 0..patch.num_hunks() {
130 let hunk = Self::process_patch_hunk(&patch, hunk_index, buffer, &mut divergence);
131 tree.push(hunk, buffer);
132 }
133 }
134
135 self.tree = tree;
136 self.last_buffer_version = Some(buffer.version().clone());
137 }
138
139 #[cfg(test)]
140 fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
141 self.hunks_in_range(0..u32::MAX, text, false)
142 }
143
144 fn diff<'a>(head: &'a str, current: &'a str) -> Option<GitPatch<'a>> {
145 let mut options = GitOptions::default();
146 options.context_lines(0);
147
148 let patch = GitPatch::from_buffers(
149 head.as_bytes(),
150 None,
151 current.as_bytes(),
152 None,
153 Some(&mut options),
154 );
155
156 match patch {
157 Ok(patch) => Some(patch),
158
159 Err(err) => {
160 log::error!("`GitPatch::from_buffers` failed: {}", err);
161 None
162 }
163 }
164 }
165
166 fn process_patch_hunk<'a>(
167 patch: &GitPatch<'a>,
168 hunk_index: usize,
169 buffer: &text::BufferSnapshot,
170 buffer_row_divergence: &mut i64,
171 ) -> DiffHunk<Anchor> {
172 let line_item_count = patch.num_lines_in_hunk(hunk_index).unwrap();
173 assert!(line_item_count > 0);
174
175 let mut first_deletion_buffer_row: Option<u32> = None;
176 let mut buffer_row_range: Option<Range<u32>> = None;
177 let mut diff_base_byte_range: Option<Range<usize>> = None;
178
179 for line_index in 0..line_item_count {
180 let line = patch.line_in_hunk(hunk_index, line_index).unwrap();
181 let kind = line.origin_value();
182 let content_offset = line.content_offset() as isize;
183 let content_len = line.content().len() as isize;
184
185 if kind == GitDiffLineType::Addition {
186 *buffer_row_divergence += 1;
187 let row = line.new_lineno().unwrap().saturating_sub(1);
188
189 match &mut buffer_row_range {
190 Some(buffer_row_range) => buffer_row_range.end = row + 1,
191 None => buffer_row_range = Some(row..row + 1),
192 }
193 }
194
195 if kind == GitDiffLineType::Deletion {
196 let end = content_offset + content_len;
197
198 match &mut diff_base_byte_range {
199 Some(head_byte_range) => head_byte_range.end = end as usize,
200 None => diff_base_byte_range = Some(content_offset as usize..end as usize),
201 }
202
203 if first_deletion_buffer_row.is_none() {
204 let old_row = line.old_lineno().unwrap().saturating_sub(1);
205 let row = old_row as i64 + *buffer_row_divergence;
206 first_deletion_buffer_row = Some(row as u32);
207 }
208
209 *buffer_row_divergence -= 1;
210 }
211 }
212
213 //unwrap_or deletion without addition
214 let buffer_row_range = buffer_row_range.unwrap_or_else(|| {
215 //we cannot have an addition-less hunk without deletion(s) or else there would be no hunk
216 let row = first_deletion_buffer_row.unwrap();
217 row..row
218 });
219
220 //unwrap_or addition without deletion
221 let diff_base_byte_range = diff_base_byte_range.unwrap_or(0..0);
222
223 let start = Point::new(buffer_row_range.start, 0);
224 let end = Point::new(buffer_row_range.end, 0);
225 let buffer_range = buffer.anchor_before(start)..buffer.anchor_before(end);
226 DiffHunk {
227 buffer_range,
228 diff_base_byte_range,
229 }
230 }
231}
232
233/// Range (crossing new lines), old, new
234#[cfg(any(test, feature = "test-support"))]
235#[track_caller]
236pub fn assert_hunks<Iter>(
237 diff_hunks: Iter,
238 buffer: &BufferSnapshot,
239 diff_base: &str,
240 expected_hunks: &[(Range<u32>, &str, &str)],
241) where
242 Iter: Iterator<Item = DiffHunk<u32>>,
243{
244 let actual_hunks = diff_hunks
245 .map(|hunk| {
246 (
247 hunk.buffer_range.clone(),
248 &diff_base[hunk.diff_base_byte_range],
249 buffer
250 .text_for_range(
251 Point::new(hunk.buffer_range.start, 0)
252 ..Point::new(hunk.buffer_range.end, 0),
253 )
254 .collect::<String>(),
255 )
256 })
257 .collect::<Vec<_>>();
258
259 let expected_hunks: Vec<_> = expected_hunks
260 .iter()
261 .map(|(r, s, h)| (r.clone(), *s, h.to_string()))
262 .collect();
263
264 assert_eq!(actual_hunks, expected_hunks);
265}
266
267#[cfg(test)]
268mod tests {
269 use super::*;
270 use text::Buffer;
271 use unindent::Unindent as _;
272
273 #[test]
274 fn test_buffer_diff_simple() {
275 let diff_base = "
276 one
277 two
278 three
279 "
280 .unindent();
281
282 let buffer_text = "
283 one
284 HELLO
285 three
286 "
287 .unindent();
288
289 let mut buffer = Buffer::new(0, 0, buffer_text);
290 let mut diff = BufferDiff::new();
291 smol::block_on(diff.update(&diff_base, &buffer));
292 assert_hunks(
293 diff.hunks(&buffer),
294 &buffer,
295 &diff_base,
296 &[(1..2, "two\n", "HELLO\n")],
297 );
298
299 buffer.edit([(0..0, "point five\n")]);
300 smol::block_on(diff.update(&diff_base, &buffer));
301 assert_hunks(
302 diff.hunks(&buffer),
303 &buffer,
304 &diff_base,
305 &[(0..1, "", "point five\n"), (2..3, "two\n", "HELLO\n")],
306 );
307
308 diff.clear(&buffer);
309 assert_hunks(diff.hunks(&buffer), &buffer, &diff_base, &[]);
310 }
311
312 #[test]
313 fn test_buffer_diff_range() {
314 let diff_base = "
315 one
316 two
317 three
318 four
319 five
320 six
321 seven
322 eight
323 nine
324 ten
325 "
326 .unindent();
327
328 let buffer_text = "
329 A
330 one
331 B
332 two
333 C
334 three
335 HELLO
336 four
337 five
338 SIXTEEN
339 seven
340 eight
341 WORLD
342 nine
343
344 ten
345
346 "
347 .unindent();
348
349 let buffer = Buffer::new(0, 0, buffer_text);
350 let mut diff = BufferDiff::new();
351 smol::block_on(diff.update(&diff_base, &buffer));
352 assert_eq!(diff.hunks(&buffer).count(), 8);
353
354 assert_hunks(
355 diff.hunks_in_range(7..12, &buffer, false),
356 &buffer,
357 &diff_base,
358 &[
359 (6..7, "", "HELLO\n"),
360 (9..10, "six\n", "SIXTEEN\n"),
361 (12..13, "", "WORLD\n"),
362 ],
363 );
364 }
365}