1use anyhow::{Context as _, Result};
2use buffer_diff::BufferDiff;
3use collections::{BTreeMap, HashMap, HashSet};
4use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task, WeakEntity};
5use language::{
6 Buffer, BufferEvent, DiskState, OffsetRangeExt, Operation, TextBufferSnapshot, ToOffset,
7};
8use std::{ops::Range, sync::Arc};
9
10/// Tracks actions performed by tools in a thread
11pub struct ActionLog {
12 /// Buffers that user manually added to the context, and whose content has
13 /// changed since the model last saw them.
14 stale_buffers_in_context: HashSet<Entity<Buffer>>,
15 /// Buffers that we want to notify the model about when they change.
16 tracked_buffers: BTreeMap<Entity<Buffer>, TrackedBuffer>,
17 /// Has the model edited a file since it last checked diagnostics?
18 edited_since_project_diagnostics_check: bool,
19}
20
21impl ActionLog {
22 /// Creates a new, empty action log.
23 pub fn new() -> Self {
24 Self {
25 stale_buffers_in_context: HashSet::default(),
26 tracked_buffers: BTreeMap::default(),
27 edited_since_project_diagnostics_check: false,
28 }
29 }
30
31 pub fn clear_reviewed_changes(&mut self, cx: &mut Context<Self>) {
32 self.tracked_buffers
33 .retain(|_buffer, tracked_buffer| match &mut tracked_buffer.change {
34 Change::Edited {
35 accepted_edit_ids, ..
36 } => {
37 accepted_edit_ids.clear();
38 tracked_buffer.schedule_diff_update();
39 true
40 }
41 Change::Deleted { reviewed, .. } => !*reviewed,
42 });
43 cx.notify();
44 }
45
46 /// Notifies a diagnostics check
47 pub fn checked_project_diagnostics(&mut self) {
48 self.edited_since_project_diagnostics_check = false;
49 }
50
51 /// Returns true if any files have been edited since the last project diagnostics check
52 pub fn has_edited_files_since_project_diagnostics_check(&self) -> bool {
53 self.edited_since_project_diagnostics_check
54 }
55
56 fn track_buffer(
57 &mut self,
58 buffer: Entity<Buffer>,
59 created: bool,
60 cx: &mut Context<Self>,
61 ) -> &mut TrackedBuffer {
62 let tracked_buffer = self
63 .tracked_buffers
64 .entry(buffer.clone())
65 .or_insert_with(|| {
66 let text_snapshot = buffer.read(cx).text_snapshot();
67 let unreviewed_diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
68 let diff = cx.new(|cx| {
69 let mut diff = BufferDiff::new(&text_snapshot, cx);
70 diff.set_secondary_diff(unreviewed_diff.clone());
71 diff
72 });
73 let (diff_update_tx, diff_update_rx) = async_watch::channel(());
74 TrackedBuffer {
75 buffer: buffer.clone(),
76 change: Change::Edited {
77 unreviewed_edit_ids: HashSet::default(),
78 accepted_edit_ids: HashSet::default(),
79 initial_content: if created {
80 None
81 } else {
82 Some(text_snapshot.clone())
83 },
84 },
85 version: buffer.read(cx).version(),
86 diff,
87 secondary_diff: unreviewed_diff,
88 diff_update: diff_update_tx,
89 _maintain_diff: cx.spawn({
90 let buffer = buffer.clone();
91 async move |this, cx| {
92 Self::maintain_diff(this, buffer, diff_update_rx, cx)
93 .await
94 .ok();
95 }
96 }),
97 _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),
98 }
99 });
100 tracked_buffer.version = buffer.read(cx).version();
101 tracked_buffer
102 }
103
104 fn handle_buffer_event(
105 &mut self,
106 buffer: Entity<Buffer>,
107 event: &BufferEvent,
108 cx: &mut Context<Self>,
109 ) {
110 match event {
111 BufferEvent::Operation { operation, .. } => {
112 self.handle_buffer_operation(buffer, operation, cx)
113 }
114 BufferEvent::FileHandleChanged => {
115 self.handle_buffer_file_changed(buffer, cx);
116 }
117 _ => {}
118 };
119 }
120
121 fn handle_buffer_operation(
122 &mut self,
123 buffer: Entity<Buffer>,
124 operation: &Operation,
125 cx: &mut Context<Self>,
126 ) {
127 let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {
128 return;
129 };
130 let Operation::Buffer(text::Operation::Edit(operation)) = operation else {
131 return;
132 };
133 let Change::Edited {
134 unreviewed_edit_ids,
135 accepted_edit_ids,
136 ..
137 } = &mut tracked_buffer.change
138 else {
139 return;
140 };
141
142 if unreviewed_edit_ids.contains(&operation.timestamp)
143 || accepted_edit_ids.contains(&operation.timestamp)
144 {
145 return;
146 }
147
148 let buffer = buffer.read(cx);
149 let operation_edit_ranges = buffer
150 .edited_ranges_for_edit_ids::<usize>([&operation.timestamp])
151 .collect::<Vec<_>>();
152 let intersects_unreviewed_edits = ranges_intersect(
153 operation_edit_ranges.iter().cloned(),
154 buffer.edited_ranges_for_edit_ids::<usize>(unreviewed_edit_ids.iter()),
155 );
156 let mut intersected_accepted_edits = HashSet::default();
157 for accepted_edit_id in accepted_edit_ids.iter() {
158 let intersects_accepted_edit = ranges_intersect(
159 operation_edit_ranges.iter().cloned(),
160 buffer.edited_ranges_for_edit_ids::<usize>([accepted_edit_id]),
161 );
162 if intersects_accepted_edit {
163 intersected_accepted_edits.insert(*accepted_edit_id);
164 }
165 }
166
167 // If the buffer operation overlaps with any tracked edits, mark it as unreviewed.
168 // If it intersects an already-accepted id, mark that edit as unreviewed again.
169 if intersects_unreviewed_edits || !intersected_accepted_edits.is_empty() {
170 unreviewed_edit_ids.insert(operation.timestamp);
171 for accepted_edit_id in intersected_accepted_edits {
172 unreviewed_edit_ids.insert(accepted_edit_id);
173 accepted_edit_ids.remove(&accepted_edit_id);
174 }
175 tracked_buffer.schedule_diff_update();
176 }
177 }
178
179 fn handle_buffer_file_changed(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
180 let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {
181 return;
182 };
183
184 match tracked_buffer.change {
185 Change::Deleted { .. } => {
186 if buffer
187 .read(cx)
188 .file()
189 .map_or(false, |file| file.disk_state() != DiskState::Deleted)
190 {
191 // If the buffer had been deleted by a tool, but it got
192 // resurrected externally, we want to clear the changes we
193 // were tracking and reset the buffer's state.
194 tracked_buffer.change = Change::Edited {
195 unreviewed_edit_ids: HashSet::default(),
196 accepted_edit_ids: HashSet::default(),
197 initial_content: Some(buffer.read(cx).text_snapshot()),
198 };
199 }
200 tracked_buffer.schedule_diff_update();
201 }
202 Change::Edited { .. } => {
203 if buffer
204 .read(cx)
205 .file()
206 .map_or(false, |file| file.disk_state() == DiskState::Deleted)
207 {
208 // If the buffer had been edited by a tool, but it got
209 // deleted externally, we want to stop tracking it.
210 self.tracked_buffers.remove(&buffer);
211 } else {
212 tracked_buffer.schedule_diff_update();
213 }
214 }
215 }
216 }
217
218 async fn maintain_diff(
219 this: WeakEntity<Self>,
220 buffer: Entity<Buffer>,
221 mut diff_update: async_watch::Receiver<()>,
222 cx: &mut AsyncApp,
223 ) -> Result<()> {
224 while let Some(_) = diff_update.recv().await.ok() {
225 let update = this.update(cx, |this, cx| {
226 let tracked_buffer = this
227 .tracked_buffers
228 .get_mut(&buffer)
229 .context("buffer not tracked")?;
230 anyhow::Ok(tracked_buffer.update_diff(cx))
231 })??;
232 update.await;
233 this.update(cx, |_this, cx| cx.notify())?;
234 }
235
236 Ok(())
237 }
238
239 /// Track a buffer as read, so we can notify the model about user edits.
240 pub fn buffer_read(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
241 self.track_buffer(buffer, false, cx);
242 }
243
244 /// Track a buffer as read, so we can notify the model about user edits.
245 pub fn will_create_buffer(
246 &mut self,
247 buffer: Entity<Buffer>,
248 edit_id: Option<clock::Lamport>,
249 cx: &mut Context<Self>,
250 ) {
251 self.track_buffer(buffer.clone(), true, cx);
252 self.buffer_edited(buffer, edit_id.into_iter().collect(), cx)
253 }
254
255 /// Mark a buffer as edited, so we can refresh it in the context
256 pub fn buffer_edited(
257 &mut self,
258 buffer: Entity<Buffer>,
259 mut edit_ids: Vec<clock::Lamport>,
260 cx: &mut Context<Self>,
261 ) {
262 self.edited_since_project_diagnostics_check = true;
263 self.stale_buffers_in_context.insert(buffer.clone());
264
265 let tracked_buffer = self.track_buffer(buffer.clone(), false, cx);
266
267 match &mut tracked_buffer.change {
268 Change::Edited {
269 unreviewed_edit_ids,
270 ..
271 } => {
272 unreviewed_edit_ids.extend(edit_ids.iter().copied());
273 }
274 Change::Deleted {
275 deleted_content,
276 deletion_id,
277 ..
278 } => {
279 edit_ids.extend(*deletion_id);
280 tracked_buffer.change = Change::Edited {
281 unreviewed_edit_ids: edit_ids.into_iter().collect(),
282 accepted_edit_ids: HashSet::default(),
283 initial_content: Some(deleted_content.clone()),
284 };
285 }
286 }
287
288 tracked_buffer.schedule_diff_update();
289 }
290
291 pub fn will_delete_buffer(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
292 let tracked_buffer = self.track_buffer(buffer.clone(), false, cx);
293 if let Change::Edited {
294 initial_content, ..
295 } = &tracked_buffer.change
296 {
297 if let Some(initial_content) = initial_content {
298 let deletion_id = buffer.update(cx, |buffer, cx| buffer.set_text("", cx));
299 tracked_buffer.change = Change::Deleted {
300 reviewed: false,
301 deleted_content: initial_content.clone(),
302 deletion_id,
303 };
304 tracked_buffer.schedule_diff_update();
305 } else {
306 self.tracked_buffers.remove(&buffer);
307 cx.notify();
308 }
309 }
310 }
311
312 /// Accepts edits in a given range within a buffer.
313 pub fn review_edits_in_range<T: ToOffset>(
314 &mut self,
315 buffer: Entity<Buffer>,
316 buffer_range: Range<T>,
317 accept: bool,
318 cx: &mut Context<Self>,
319 ) {
320 let Some(tracked_buffer) = self.tracked_buffers.get_mut(&buffer) else {
321 return;
322 };
323
324 let buffer = buffer.read(cx);
325 let buffer_range = buffer_range.to_offset(buffer);
326
327 match &mut tracked_buffer.change {
328 Change::Deleted { reviewed, .. } => {
329 *reviewed = accept;
330 }
331 Change::Edited {
332 unreviewed_edit_ids,
333 accepted_edit_ids,
334 ..
335 } => {
336 let (source, destination) = if accept {
337 (unreviewed_edit_ids, accepted_edit_ids)
338 } else {
339 (accepted_edit_ids, unreviewed_edit_ids)
340 };
341 source.retain(|edit_id| {
342 for range in buffer.edited_ranges_for_edit_ids::<usize>([edit_id]) {
343 if buffer_range.end >= range.start && buffer_range.start <= range.end {
344 destination.insert(*edit_id);
345 return false;
346 }
347 }
348 true
349 });
350 }
351 }
352
353 tracked_buffer.schedule_diff_update();
354 }
355
356 /// Keep all edits across all buffers.
357 /// This is a more performant alternative to calling review_edits_in_range for each buffer.
358 pub fn keep_all_edits(&mut self) {
359 // Process all tracked buffers
360 for (_, tracked_buffer) in self.tracked_buffers.iter_mut() {
361 match &mut tracked_buffer.change {
362 Change::Deleted { reviewed, .. } => {
363 *reviewed = true;
364 }
365 Change::Edited {
366 unreviewed_edit_ids,
367 accepted_edit_ids,
368 ..
369 } => {
370 accepted_edit_ids.extend(unreviewed_edit_ids.drain());
371 }
372 }
373
374 tracked_buffer.schedule_diff_update();
375 }
376 }
377
378 /// Returns the set of buffers that contain changes that haven't been reviewed by the user.
379 pub fn changed_buffers(&self, cx: &App) -> BTreeMap<Entity<Buffer>, ChangedBuffer> {
380 self.tracked_buffers
381 .iter()
382 .filter(|(_, tracked)| tracked.has_changes(cx))
383 .map(|(buffer, tracked)| {
384 (
385 buffer.clone(),
386 ChangedBuffer {
387 diff: tracked.diff.clone(),
388 needs_review: match &tracked.change {
389 Change::Edited {
390 unreviewed_edit_ids,
391 ..
392 } => !unreviewed_edit_ids.is_empty(),
393 Change::Deleted { reviewed, .. } => !reviewed,
394 },
395 },
396 )
397 })
398 .collect()
399 }
400
401 /// Iterate over buffers changed since last read or edited by the model
402 pub fn stale_buffers<'a>(&'a self, cx: &'a App) -> impl Iterator<Item = &'a Entity<Buffer>> {
403 self.tracked_buffers
404 .iter()
405 .filter(|(buffer, tracked)| tracked.version != buffer.read(cx).version)
406 .map(|(buffer, _)| buffer)
407 }
408
409 /// Takes and returns the set of buffers pending refresh, clearing internal state.
410 pub fn take_stale_buffers_in_context(&mut self) -> HashSet<Entity<Buffer>> {
411 std::mem::take(&mut self.stale_buffers_in_context)
412 }
413}
414
415fn ranges_intersect(
416 ranges_a: impl IntoIterator<Item = Range<usize>>,
417 ranges_b: impl IntoIterator<Item = Range<usize>>,
418) -> bool {
419 let mut ranges_a_iter = ranges_a.into_iter().peekable();
420 let mut ranges_b_iter = ranges_b.into_iter().peekable();
421 while let (Some(range_a), Some(range_b)) = (ranges_a_iter.peek(), ranges_b_iter.peek()) {
422 if range_a.end < range_b.start {
423 ranges_a_iter.next();
424 } else if range_b.end < range_a.start {
425 ranges_b_iter.next();
426 } else {
427 return true;
428 }
429 }
430 false
431}
432
433struct TrackedBuffer {
434 buffer: Entity<Buffer>,
435 change: Change,
436 version: clock::Global,
437 diff: Entity<BufferDiff>,
438 secondary_diff: Entity<BufferDiff>,
439 diff_update: async_watch::Sender<()>,
440 _maintain_diff: Task<()>,
441 _subscription: Subscription,
442}
443
444enum Change {
445 Edited {
446 unreviewed_edit_ids: HashSet<clock::Lamport>,
447 accepted_edit_ids: HashSet<clock::Lamport>,
448 initial_content: Option<TextBufferSnapshot>,
449 },
450 Deleted {
451 reviewed: bool,
452 deleted_content: TextBufferSnapshot,
453 deletion_id: Option<clock::Lamport>,
454 },
455}
456
457impl TrackedBuffer {
458 fn has_changes(&self, cx: &App) -> bool {
459 self.diff
460 .read(cx)
461 .hunks(&self.buffer.read(cx), cx)
462 .next()
463 .is_some()
464 }
465
466 fn schedule_diff_update(&self) {
467 self.diff_update.send(()).ok();
468 }
469
470 fn update_diff(&mut self, cx: &mut App) -> Task<()> {
471 match &self.change {
472 Change::Edited {
473 unreviewed_edit_ids,
474 accepted_edit_ids,
475 ..
476 } => {
477 let edits_to_undo = unreviewed_edit_ids
478 .iter()
479 .chain(accepted_edit_ids)
480 .map(|edit_id| (*edit_id, u32::MAX))
481 .collect::<HashMap<_, _>>();
482 let buffer_without_edits = self.buffer.update(cx, |buffer, cx| buffer.branch(cx));
483 buffer_without_edits
484 .update(cx, |buffer, cx| buffer.undo_operations(edits_to_undo, cx));
485 let primary_diff_update = self.diff.update(cx, |diff, cx| {
486 diff.set_base_text_buffer(
487 buffer_without_edits,
488 self.buffer.read(cx).text_snapshot(),
489 cx,
490 )
491 });
492
493 let unreviewed_edits_to_undo = unreviewed_edit_ids
494 .iter()
495 .map(|edit_id| (*edit_id, u32::MAX))
496 .collect::<HashMap<_, _>>();
497 let buffer_without_unreviewed_edits =
498 self.buffer.update(cx, |buffer, cx| buffer.branch(cx));
499 buffer_without_unreviewed_edits.update(cx, |buffer, cx| {
500 buffer.undo_operations(unreviewed_edits_to_undo, cx)
501 });
502 let secondary_diff_update = self.secondary_diff.update(cx, |diff, cx| {
503 diff.set_base_text_buffer(
504 buffer_without_unreviewed_edits.clone(),
505 self.buffer.read(cx).text_snapshot(),
506 cx,
507 )
508 });
509
510 cx.background_spawn(async move {
511 _ = primary_diff_update.await;
512 _ = secondary_diff_update.await;
513 })
514 }
515 Change::Deleted {
516 reviewed,
517 deleted_content,
518 ..
519 } => {
520 let reviewed = *reviewed;
521 let deleted_content = deleted_content.clone();
522
523 let primary_diff = self.diff.clone();
524 let secondary_diff = self.secondary_diff.clone();
525 let buffer_snapshot = self.buffer.read(cx).text_snapshot();
526 let language = self.buffer.read(cx).language().cloned();
527 let language_registry = self.buffer.read(cx).language_registry().clone();
528
529 cx.spawn(async move |cx| {
530 let base_text = Arc::new(deleted_content.text());
531
532 let primary_diff_snapshot = BufferDiff::update_diff(
533 primary_diff.clone(),
534 buffer_snapshot.clone(),
535 Some(base_text.clone()),
536 true,
537 false,
538 language.clone(),
539 language_registry.clone(),
540 cx,
541 )
542 .await;
543 let secondary_diff_snapshot = BufferDiff::update_diff(
544 secondary_diff.clone(),
545 buffer_snapshot.clone(),
546 if reviewed {
547 None
548 } else {
549 Some(base_text.clone())
550 },
551 true,
552 false,
553 language.clone(),
554 language_registry.clone(),
555 cx,
556 )
557 .await;
558
559 if let Ok(primary_diff_snapshot) = primary_diff_snapshot {
560 primary_diff
561 .update(cx, |diff, cx| {
562 diff.set_snapshot(primary_diff_snapshot, &buffer_snapshot, None, cx)
563 })
564 .ok();
565 }
566
567 if let Ok(secondary_diff_snapshot) = secondary_diff_snapshot {
568 secondary_diff
569 .update(cx, |diff, cx| {
570 diff.set_snapshot(
571 secondary_diff_snapshot,
572 &buffer_snapshot,
573 None,
574 cx,
575 )
576 })
577 .ok();
578 }
579 })
580 }
581 }
582 }
583}
584
585pub struct ChangedBuffer {
586 pub diff: Entity<BufferDiff>,
587 pub needs_review: bool,
588}
589
590#[cfg(test)]
591mod tests {
592 use super::*;
593 use buffer_diff::DiffHunkStatusKind;
594 use gpui::TestAppContext;
595 use language::Point;
596 use project::{FakeFs, Fs, Project, RemoveOptions};
597 use serde_json::json;
598 use settings::SettingsStore;
599 use util::path;
600
601 #[gpui::test(iterations = 10)]
602 async fn test_edit_review(cx: &mut TestAppContext) {
603 let action_log = cx.new(|_| ActionLog::new());
604 let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno", cx));
605
606 let edit1 = buffer.update(cx, |buffer, cx| {
607 buffer
608 .edit([(Point::new(1, 1)..Point::new(1, 2), "E")], None, cx)
609 .unwrap()
610 });
611 let edit2 = buffer.update(cx, |buffer, cx| {
612 buffer
613 .edit([(Point::new(4, 2)..Point::new(4, 3), "O")], None, cx)
614 .unwrap()
615 });
616 assert_eq!(
617 buffer.read_with(cx, |buffer, _| buffer.text()),
618 "abc\ndEf\nghi\njkl\nmnO"
619 );
620
621 action_log.update(cx, |log, cx| {
622 log.buffer_edited(buffer.clone(), vec![edit1, edit2], cx)
623 });
624 cx.run_until_parked();
625 assert_eq!(
626 unreviewed_hunks(&action_log, cx),
627 vec![(
628 buffer.clone(),
629 vec![
630 HunkStatus {
631 range: Point::new(1, 0)..Point::new(2, 0),
632 review_status: ReviewStatus::Unreviewed,
633 diff_status: DiffHunkStatusKind::Modified,
634 old_text: "def\n".into(),
635 },
636 HunkStatus {
637 range: Point::new(4, 0)..Point::new(4, 3),
638 review_status: ReviewStatus::Unreviewed,
639 diff_status: DiffHunkStatusKind::Modified,
640 old_text: "mno".into(),
641 }
642 ],
643 )]
644 );
645
646 action_log.update(cx, |log, cx| {
647 log.review_edits_in_range(buffer.clone(), Point::new(3, 0)..Point::new(4, 3), true, cx)
648 });
649 cx.run_until_parked();
650 assert_eq!(
651 unreviewed_hunks(&action_log, cx),
652 vec![(
653 buffer.clone(),
654 vec![
655 HunkStatus {
656 range: Point::new(1, 0)..Point::new(2, 0),
657 review_status: ReviewStatus::Unreviewed,
658 diff_status: DiffHunkStatusKind::Modified,
659 old_text: "def\n".into(),
660 },
661 HunkStatus {
662 range: Point::new(4, 0)..Point::new(4, 3),
663 review_status: ReviewStatus::Reviewed,
664 diff_status: DiffHunkStatusKind::Modified,
665 old_text: "mno".into(),
666 }
667 ],
668 )]
669 );
670
671 action_log.update(cx, |log, cx| {
672 log.review_edits_in_range(
673 buffer.clone(),
674 Point::new(3, 0)..Point::new(4, 3),
675 false,
676 cx,
677 )
678 });
679 cx.run_until_parked();
680 assert_eq!(
681 unreviewed_hunks(&action_log, cx),
682 vec![(
683 buffer.clone(),
684 vec![
685 HunkStatus {
686 range: Point::new(1, 0)..Point::new(2, 0),
687 review_status: ReviewStatus::Unreviewed,
688 diff_status: DiffHunkStatusKind::Modified,
689 old_text: "def\n".into(),
690 },
691 HunkStatus {
692 range: Point::new(4, 0)..Point::new(4, 3),
693 review_status: ReviewStatus::Unreviewed,
694 diff_status: DiffHunkStatusKind::Modified,
695 old_text: "mno".into(),
696 }
697 ],
698 )]
699 );
700
701 action_log.update(cx, |log, cx| {
702 log.review_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(4, 3), true, cx)
703 });
704 cx.run_until_parked();
705 assert_eq!(
706 unreviewed_hunks(&action_log, cx),
707 vec![(
708 buffer.clone(),
709 vec![
710 HunkStatus {
711 range: Point::new(1, 0)..Point::new(2, 0),
712 review_status: ReviewStatus::Reviewed,
713 diff_status: DiffHunkStatusKind::Modified,
714 old_text: "def\n".into(),
715 },
716 HunkStatus {
717 range: Point::new(4, 0)..Point::new(4, 3),
718 review_status: ReviewStatus::Reviewed,
719 diff_status: DiffHunkStatusKind::Modified,
720 old_text: "mno".into(),
721 }
722 ],
723 )]
724 );
725 }
726
727 #[gpui::test(iterations = 10)]
728 async fn test_overlapping_user_edits(cx: &mut TestAppContext) {
729 let action_log = cx.new(|_| ActionLog::new());
730 let buffer = cx.new(|cx| Buffer::local("abc\ndef\nghi\njkl\nmno", cx));
731
732 let tool_edit = buffer.update(cx, |buffer, cx| {
733 buffer
734 .edit(
735 [(Point::new(0, 2)..Point::new(2, 3), "C\nDEF\nGHI")],
736 None,
737 cx,
738 )
739 .unwrap()
740 });
741 assert_eq!(
742 buffer.read_with(cx, |buffer, _| buffer.text()),
743 "abC\nDEF\nGHI\njkl\nmno"
744 );
745
746 action_log.update(cx, |log, cx| {
747 log.buffer_edited(buffer.clone(), vec![tool_edit], cx)
748 });
749 cx.run_until_parked();
750 assert_eq!(
751 unreviewed_hunks(&action_log, cx),
752 vec![(
753 buffer.clone(),
754 vec![HunkStatus {
755 range: Point::new(0, 0)..Point::new(3, 0),
756 review_status: ReviewStatus::Unreviewed,
757 diff_status: DiffHunkStatusKind::Modified,
758 old_text: "abc\ndef\nghi\n".into(),
759 }],
760 )]
761 );
762
763 action_log.update(cx, |log, cx| {
764 log.review_edits_in_range(buffer.clone(), Point::new(0, 0)..Point::new(1, 0), true, cx)
765 });
766 cx.run_until_parked();
767 assert_eq!(
768 unreviewed_hunks(&action_log, cx),
769 vec![(
770 buffer.clone(),
771 vec![HunkStatus {
772 range: Point::new(0, 0)..Point::new(3, 0),
773 review_status: ReviewStatus::Reviewed,
774 diff_status: DiffHunkStatusKind::Modified,
775 old_text: "abc\ndef\nghi\n".into(),
776 }],
777 )]
778 );
779
780 buffer.update(cx, |buffer, cx| {
781 buffer.edit([(Point::new(0, 2)..Point::new(0, 2), "X")], None, cx)
782 });
783 cx.run_until_parked();
784 assert_eq!(
785 unreviewed_hunks(&action_log, cx),
786 vec![(
787 buffer.clone(),
788 vec![HunkStatus {
789 range: Point::new(0, 0)..Point::new(3, 0),
790 review_status: ReviewStatus::Unreviewed,
791 diff_status: DiffHunkStatusKind::Modified,
792 old_text: "abc\ndef\nghi\n".into(),
793 }],
794 )]
795 );
796
797 action_log.update(cx, |log, cx| log.clear_reviewed_changes(cx));
798 cx.run_until_parked();
799 assert_eq!(
800 unreviewed_hunks(&action_log, cx),
801 vec![(
802 buffer.clone(),
803 vec![HunkStatus {
804 range: Point::new(0, 0)..Point::new(3, 0),
805 review_status: ReviewStatus::Unreviewed,
806 diff_status: DiffHunkStatusKind::Modified,
807 old_text: "abc\ndef\nghi\n".into(),
808 }],
809 )]
810 );
811 }
812
813 #[gpui::test(iterations = 10)]
814 async fn test_deletion(cx: &mut TestAppContext) {
815 cx.update(|cx| {
816 let settings_store = SettingsStore::test(cx);
817 cx.set_global(settings_store);
818 language::init(cx);
819 Project::init_settings(cx);
820 });
821
822 let fs = FakeFs::new(cx.executor());
823 fs.insert_tree(
824 path!("/dir"),
825 json!({"file1": "lorem\n", "file2": "ipsum\n"}),
826 )
827 .await;
828
829 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
830 let file1_path = project
831 .read_with(cx, |project, cx| project.find_project_path("dir/file1", cx))
832 .unwrap();
833 let file2_path = project
834 .read_with(cx, |project, cx| project.find_project_path("dir/file2", cx))
835 .unwrap();
836
837 let action_log = cx.new(|_| ActionLog::new());
838 let buffer1 = project
839 .update(cx, |project, cx| {
840 project.open_buffer(file1_path.clone(), cx)
841 })
842 .await
843 .unwrap();
844 let buffer2 = project
845 .update(cx, |project, cx| {
846 project.open_buffer(file2_path.clone(), cx)
847 })
848 .await
849 .unwrap();
850
851 action_log.update(cx, |log, cx| log.will_delete_buffer(buffer1.clone(), cx));
852 action_log.update(cx, |log, cx| log.will_delete_buffer(buffer2.clone(), cx));
853 project
854 .update(cx, |project, cx| {
855 project.delete_file(file1_path.clone(), false, cx)
856 })
857 .unwrap()
858 .await
859 .unwrap();
860 project
861 .update(cx, |project, cx| {
862 project.delete_file(file2_path.clone(), false, cx)
863 })
864 .unwrap()
865 .await
866 .unwrap();
867 cx.run_until_parked();
868 assert_eq!(
869 unreviewed_hunks(&action_log, cx),
870 vec![
871 (
872 buffer1.clone(),
873 vec![HunkStatus {
874 range: Point::new(0, 0)..Point::new(0, 0),
875 review_status: ReviewStatus::Unreviewed,
876 diff_status: DiffHunkStatusKind::Deleted,
877 old_text: "lorem\n".into(),
878 }]
879 ),
880 (
881 buffer2.clone(),
882 vec![HunkStatus {
883 range: Point::new(0, 0)..Point::new(0, 0),
884 review_status: ReviewStatus::Unreviewed,
885 diff_status: DiffHunkStatusKind::Deleted,
886 old_text: "ipsum\n".into(),
887 }],
888 )
889 ]
890 );
891
892 // Simulate file1 being recreated externally.
893 fs.insert_file(path!("/dir/file1"), "LOREM".as_bytes().to_vec())
894 .await;
895 let buffer2 = project
896 .update(cx, |project, cx| project.open_buffer(file2_path, cx))
897 .await
898 .unwrap();
899 cx.run_until_parked();
900 // Simulate file2 being recreated by a tool.
901 let edit_id = buffer2.update(cx, |buffer, cx| buffer.set_text("IPSUM", cx));
902 action_log.update(cx, |log, cx| {
903 log.will_create_buffer(buffer2.clone(), edit_id, cx)
904 });
905 project
906 .update(cx, |project, cx| project.save_buffer(buffer2.clone(), cx))
907 .await
908 .unwrap();
909 cx.run_until_parked();
910 assert_eq!(
911 unreviewed_hunks(&action_log, cx),
912 vec![(
913 buffer2.clone(),
914 vec![HunkStatus {
915 range: Point::new(0, 0)..Point::new(0, 5),
916 review_status: ReviewStatus::Unreviewed,
917 diff_status: DiffHunkStatusKind::Modified,
918 old_text: "ipsum\n".into(),
919 }],
920 )]
921 );
922
923 // Simulate file2 being deleted externally.
924 fs.remove_file(path!("/dir/file2").as_ref(), RemoveOptions::default())
925 .await
926 .unwrap();
927 cx.run_until_parked();
928 assert_eq!(unreviewed_hunks(&action_log, cx), vec![]);
929 }
930
931 #[derive(Debug, Clone, PartialEq, Eq)]
932 struct HunkStatus {
933 range: Range<Point>,
934 review_status: ReviewStatus,
935 diff_status: DiffHunkStatusKind,
936 old_text: String,
937 }
938
939 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
940 enum ReviewStatus {
941 Unreviewed,
942 Reviewed,
943 }
944
945 fn unreviewed_hunks(
946 action_log: &Entity<ActionLog>,
947 cx: &TestAppContext,
948 ) -> Vec<(Entity<Buffer>, Vec<HunkStatus>)> {
949 cx.read(|cx| {
950 action_log
951 .read(cx)
952 .changed_buffers(cx)
953 .into_iter()
954 .map(|(buffer, tracked_buffer)| {
955 let snapshot = buffer.read(cx).snapshot();
956 (
957 buffer,
958 tracked_buffer
959 .diff
960 .read(cx)
961 .hunks(&snapshot, cx)
962 .map(|hunk| HunkStatus {
963 review_status: if hunk.status().has_secondary_hunk() {
964 ReviewStatus::Unreviewed
965 } else {
966 ReviewStatus::Reviewed
967 },
968 diff_status: hunk.status().kind,
969 range: hunk.range,
970 old_text: tracked_buffer
971 .diff
972 .read(cx)
973 .base_text()
974 .text_for_range(hunk.diff_base_byte_range)
975 .collect(),
976 })
977 .collect(),
978 )
979 })
980 .collect()
981 })
982 }
983}