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