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