1use std::{iter, 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 is_empty(&self) -> bool {
75 self.tree.is_empty()
76 }
77
78 pub fn hunks_in_row_range<'a>(
79 &'a self,
80 range: Range<u32>,
81 buffer: &'a BufferSnapshot,
82 ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
83 let start = buffer.anchor_before(Point::new(range.start, 0));
84 let end = buffer.anchor_after(Point::new(range.end, 0));
85
86 self.hunks_intersecting_range(start..end, buffer)
87 }
88
89 pub fn hunks_intersecting_range<'a>(
90 &'a self,
91 range: Range<Anchor>,
92 buffer: &'a BufferSnapshot,
93 ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
94 let mut cursor = self.tree.filter::<_, DiffHunkSummary>(move |summary| {
95 let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
96 let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
97 !before_start && !after_end
98 });
99
100 let anchor_iter = std::iter::from_fn(move || {
101 cursor.next(buffer);
102 cursor.item()
103 })
104 .flat_map(move |hunk| {
105 [
106 (&hunk.buffer_range.start, hunk.diff_base_byte_range.start),
107 (&hunk.buffer_range.end, hunk.diff_base_byte_range.end),
108 ]
109 .into_iter()
110 });
111
112 let mut summaries = buffer.summaries_for_anchors_with_payload::<Point, _, _>(anchor_iter);
113 iter::from_fn(move || {
114 let (start_point, start_base) = summaries.next()?;
115 let (end_point, end_base) = summaries.next()?;
116
117 let end_row = if end_point.column > 0 {
118 end_point.row + 1
119 } else {
120 end_point.row
121 };
122
123 Some(DiffHunk {
124 buffer_range: start_point.row..end_row,
125 diff_base_byte_range: start_base..end_base,
126 })
127 })
128 }
129
130 pub fn hunks_intersecting_range_rev<'a>(
131 &'a self,
132 range: Range<Anchor>,
133 buffer: &'a BufferSnapshot,
134 ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
135 let mut cursor = self.tree.filter::<_, DiffHunkSummary>(move |summary| {
136 let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
137 let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
138 !before_start && !after_end
139 });
140
141 std::iter::from_fn(move || {
142 cursor.prev(buffer);
143
144 let hunk = cursor.item()?;
145 let range = hunk.buffer_range.to_point(buffer);
146 let end_row = if range.end.column > 0 {
147 range.end.row + 1
148 } else {
149 range.end.row
150 };
151
152 Some(DiffHunk {
153 buffer_range: range.start.row..end_row,
154 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
155 })
156 })
157 }
158
159 pub fn clear(&mut self, buffer: &text::BufferSnapshot) {
160 self.last_buffer_version = Some(buffer.version().clone());
161 self.tree = SumTree::new();
162 }
163
164 pub fn needs_update(&self, buffer: &text::BufferSnapshot) -> bool {
165 match &self.last_buffer_version {
166 Some(last) => buffer.version().changed_since(last),
167 None => true,
168 }
169 }
170
171 pub async fn update(&mut self, diff_base: &str, buffer: &text::BufferSnapshot) {
172 let mut tree = SumTree::new();
173
174 let buffer_text = buffer.as_rope().to_string();
175 let patch = Self::diff(&diff_base, &buffer_text);
176
177 if let Some(patch) = patch {
178 let mut divergence = 0;
179 for hunk_index in 0..patch.num_hunks() {
180 let hunk = Self::process_patch_hunk(&patch, hunk_index, buffer, &mut divergence);
181 tree.push(hunk, buffer);
182 }
183 }
184
185 self.tree = tree;
186 self.last_buffer_version = Some(buffer.version().clone());
187 }
188
189 #[cfg(test)]
190 fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
191 let start = text.anchor_before(Point::new(0, 0));
192 let end = text.anchor_after(Point::new(u32::MAX, u32::MAX));
193 self.hunks_intersecting_range(start..end, text)
194 }
195
196 fn diff<'a>(head: &'a str, current: &'a str) -> Option<GitPatch<'a>> {
197 let mut options = GitOptions::default();
198 options.context_lines(0);
199
200 let patch = GitPatch::from_buffers(
201 head.as_bytes(),
202 None,
203 current.as_bytes(),
204 None,
205 Some(&mut options),
206 );
207
208 match patch {
209 Ok(patch) => Some(patch),
210
211 Err(err) => {
212 log::error!("`GitPatch::from_buffers` failed: {}", err);
213 None
214 }
215 }
216 }
217
218 fn process_patch_hunk<'a>(
219 patch: &GitPatch<'a>,
220 hunk_index: usize,
221 buffer: &text::BufferSnapshot,
222 buffer_row_divergence: &mut i64,
223 ) -> DiffHunk<Anchor> {
224 let line_item_count = patch.num_lines_in_hunk(hunk_index).unwrap();
225 assert!(line_item_count > 0);
226
227 let mut first_deletion_buffer_row: Option<u32> = None;
228 let mut buffer_row_range: Option<Range<u32>> = None;
229 let mut diff_base_byte_range: Option<Range<usize>> = None;
230
231 for line_index in 0..line_item_count {
232 let line = patch.line_in_hunk(hunk_index, line_index).unwrap();
233 let kind = line.origin_value();
234 let content_offset = line.content_offset() as isize;
235 let content_len = line.content().len() as isize;
236
237 if kind == GitDiffLineType::Addition {
238 *buffer_row_divergence += 1;
239 let row = line.new_lineno().unwrap().saturating_sub(1);
240
241 match &mut buffer_row_range {
242 Some(buffer_row_range) => buffer_row_range.end = row + 1,
243 None => buffer_row_range = Some(row..row + 1),
244 }
245 }
246
247 if kind == GitDiffLineType::Deletion {
248 let end = content_offset + content_len;
249
250 match &mut diff_base_byte_range {
251 Some(head_byte_range) => head_byte_range.end = end as usize,
252 None => diff_base_byte_range = Some(content_offset as usize..end as usize),
253 }
254
255 if first_deletion_buffer_row.is_none() {
256 let old_row = line.old_lineno().unwrap().saturating_sub(1);
257 let row = old_row as i64 + *buffer_row_divergence;
258 first_deletion_buffer_row = Some(row as u32);
259 }
260
261 *buffer_row_divergence -= 1;
262 }
263 }
264
265 //unwrap_or deletion without addition
266 let buffer_row_range = buffer_row_range.unwrap_or_else(|| {
267 //we cannot have an addition-less hunk without deletion(s) or else there would be no hunk
268 let row = first_deletion_buffer_row.unwrap();
269 row..row
270 });
271
272 //unwrap_or addition without deletion
273 let diff_base_byte_range = diff_base_byte_range.unwrap_or(0..0);
274
275 let start = Point::new(buffer_row_range.start, 0);
276 let end = Point::new(buffer_row_range.end, 0);
277 let buffer_range = buffer.anchor_before(start)..buffer.anchor_before(end);
278 DiffHunk {
279 buffer_range,
280 diff_base_byte_range,
281 }
282 }
283}
284
285/// Range (crossing new lines), old, new
286#[cfg(any(test, feature = "test-support"))]
287#[track_caller]
288pub fn assert_hunks<Iter>(
289 diff_hunks: Iter,
290 buffer: &BufferSnapshot,
291 diff_base: &str,
292 expected_hunks: &[(Range<u32>, &str, &str)],
293) where
294 Iter: Iterator<Item = DiffHunk<u32>>,
295{
296 let actual_hunks = diff_hunks
297 .map(|hunk| {
298 (
299 hunk.buffer_range.clone(),
300 &diff_base[hunk.diff_base_byte_range],
301 buffer
302 .text_for_range(
303 Point::new(hunk.buffer_range.start, 0)
304 ..Point::new(hunk.buffer_range.end, 0),
305 )
306 .collect::<String>(),
307 )
308 })
309 .collect::<Vec<_>>();
310
311 let expected_hunks: Vec<_> = expected_hunks
312 .iter()
313 .map(|(r, s, h)| (r.clone(), *s, h.to_string()))
314 .collect();
315
316 assert_eq!(actual_hunks, expected_hunks);
317}
318
319#[cfg(test)]
320mod tests {
321 use std::assert_eq;
322
323 use super::*;
324 use text::Buffer;
325 use unindent::Unindent as _;
326
327 #[test]
328 fn test_buffer_diff_simple() {
329 let diff_base = "
330 one
331 two
332 three
333 "
334 .unindent();
335
336 let buffer_text = "
337 one
338 HELLO
339 three
340 "
341 .unindent();
342
343 let mut buffer = Buffer::new(0, 0, buffer_text);
344 let mut diff = BufferDiff::new();
345 smol::block_on(diff.update(&diff_base, &buffer));
346 assert_hunks(
347 diff.hunks(&buffer),
348 &buffer,
349 &diff_base,
350 &[(1..2, "two\n", "HELLO\n")],
351 );
352
353 buffer.edit([(0..0, "point five\n")]);
354 smol::block_on(diff.update(&diff_base, &buffer));
355 assert_hunks(
356 diff.hunks(&buffer),
357 &buffer,
358 &diff_base,
359 &[(0..1, "", "point five\n"), (2..3, "two\n", "HELLO\n")],
360 );
361
362 diff.clear(&buffer);
363 assert_hunks(diff.hunks(&buffer), &buffer, &diff_base, &[]);
364 }
365
366 #[test]
367 fn test_buffer_diff_range() {
368 let diff_base = "
369 one
370 two
371 three
372 four
373 five
374 six
375 seven
376 eight
377 nine
378 ten
379 "
380 .unindent();
381
382 let buffer_text = "
383 A
384 one
385 B
386 two
387 C
388 three
389 HELLO
390 four
391 five
392 SIXTEEN
393 seven
394 eight
395 WORLD
396 nine
397
398 ten
399
400 "
401 .unindent();
402
403 let buffer = Buffer::new(0, 0, buffer_text);
404 let mut diff = BufferDiff::new();
405 smol::block_on(diff.update(&diff_base, &buffer));
406 assert_eq!(diff.hunks(&buffer).count(), 8);
407
408 assert_hunks(
409 diff.hunks_in_row_range(7..12, &buffer),
410 &buffer,
411 &diff_base,
412 &[
413 (6..7, "", "HELLO\n"),
414 (9..10, "six\n", "SIXTEEN\n"),
415 (12..13, "", "WORLD\n"),
416 ],
417 );
418 }
419}