1//! TextDiffView currently provides a UI for displaying differences between the clipboard and selected text.
2
3use anyhow::Result;
4use buffer_diff::BufferDiff;
5use editor::{Editor, EditorEvent, MultiBuffer, ToPoint, actions::DiffClipboardWithSelectionData};
6use futures::{FutureExt, select_biased};
7use gpui::{
8 AnyElement, App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FocusHandle,
9 Focusable, IntoElement, Render, Task, Window,
10};
11use language::{self, Buffer, Point};
12use project::Project;
13use std::{
14 any::{Any, TypeId},
15 cmp,
16 ops::Range,
17 pin::pin,
18 sync::Arc,
19 time::Duration,
20};
21use ui::{Color, Icon, IconName, Label, LabelCommon as _, SharedString};
22use util::paths::PathExt;
23
24use workspace::{
25 Item, ItemHandle as _, ItemNavHistory, ToolbarItemLocation, Workspace,
26 item::{BreadcrumbText, ItemEvent, SaveOptions, TabContentParams},
27 searchable::SearchableItemHandle,
28};
29
30pub struct TextDiffView {
31 diff_editor: Entity<Editor>,
32 title: SharedString,
33 path: Option<SharedString>,
34 buffer_changes_tx: watch::Sender<()>,
35 _recalculate_diff_task: Task<Result<()>>,
36}
37
38const RECALCULATE_DIFF_DEBOUNCE: Duration = Duration::from_millis(250);
39
40impl TextDiffView {
41 pub fn open(
42 diff_data: &DiffClipboardWithSelectionData,
43 workspace: &Workspace,
44 window: &mut Window,
45 cx: &mut App,
46 ) -> Option<Task<Result<Entity<Self>>>> {
47 let source_editor = diff_data.editor.clone();
48
49 let selection_data = source_editor.update(cx, |editor, cx| {
50 let multibuffer = editor.buffer().read(cx);
51 let source_buffer = multibuffer.as_singleton()?;
52 let selections = editor.selections.all::<Point>(&editor.display_snapshot(cx));
53 let buffer_snapshot = source_buffer.read(cx);
54 let first_selection = selections.first()?;
55 let max_point = buffer_snapshot.max_point();
56
57 if first_selection.is_empty() {
58 let full_range = Point::new(0, 0)..max_point;
59 return Some((source_buffer, full_range));
60 }
61
62 let start = first_selection.start;
63 let end = first_selection.end;
64 let expanded_start = Point::new(start.row, 0);
65
66 let expanded_end = if end.column > 0 {
67 let next_row = end.row + 1;
68 cmp::min(max_point, Point::new(next_row, 0))
69 } else {
70 end
71 };
72 Some((source_buffer, expanded_start..expanded_end))
73 });
74
75 let Some((source_buffer, expanded_selection_range)) = selection_data else {
76 log::warn!("There should always be at least one selection in Zed. This is a bug.");
77 return None;
78 };
79
80 source_editor.update(cx, |source_editor, cx| {
81 source_editor.change_selections(Default::default(), window, cx, |s| {
82 s.select_ranges(vec![
83 expanded_selection_range.start..expanded_selection_range.end,
84 ]);
85 })
86 });
87
88 let source_buffer_snapshot = source_buffer.read(cx).snapshot();
89 let mut clipboard_text = diff_data.clipboard_text.clone();
90
91 if !clipboard_text.ends_with("\n") {
92 clipboard_text.push_str("\n");
93 }
94
95 let workspace = workspace.weak_handle();
96 let diff_buffer = cx.new(|cx| BufferDiff::new(&source_buffer_snapshot.text, cx));
97 let clipboard_buffer = build_clipboard_buffer(
98 clipboard_text,
99 &source_buffer,
100 expanded_selection_range.clone(),
101 cx,
102 );
103
104 let task = window.spawn(cx, async move |cx| {
105 let project = workspace.update(cx, |workspace, _| workspace.project().clone())?;
106
107 update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await?;
108
109 workspace.update_in(cx, |workspace, window, cx| {
110 let diff_view = cx.new(|cx| {
111 TextDiffView::new(
112 clipboard_buffer,
113 source_editor,
114 source_buffer,
115 expanded_selection_range,
116 diff_buffer,
117 project,
118 window,
119 cx,
120 )
121 });
122
123 let pane = workspace.active_pane();
124 pane.update(cx, |pane, cx| {
125 pane.add_item(Box::new(diff_view.clone()), true, true, None, window, cx);
126 });
127
128 diff_view
129 })
130 });
131
132 Some(task)
133 }
134
135 pub fn new(
136 clipboard_buffer: Entity<Buffer>,
137 source_editor: Entity<Editor>,
138 source_buffer: Entity<Buffer>,
139 source_range: Range<Point>,
140 diff_buffer: Entity<BufferDiff>,
141 project: Entity<Project>,
142 window: &mut Window,
143 cx: &mut Context<Self>,
144 ) -> Self {
145 let multibuffer = cx.new(|cx| {
146 let mut multibuffer = MultiBuffer::new(language::Capability::ReadWrite);
147
148 multibuffer.push_excerpts(
149 source_buffer.clone(),
150 [editor::ExcerptRange::new(source_range)],
151 cx,
152 );
153
154 multibuffer.add_diff(diff_buffer.clone(), cx);
155 multibuffer
156 });
157 let diff_editor = cx.new(|cx| {
158 let mut editor = Editor::for_multibuffer(multibuffer, Some(project), window, cx);
159 editor.start_temporary_diff_override();
160 editor.disable_diagnostics(cx);
161 editor.set_expand_all_diff_hunks(cx);
162 editor.set_render_diff_hunk_controls(
163 Arc::new(|_, _, _, _, _, _, _, _| gpui::Empty.into_any_element()),
164 cx,
165 );
166 editor
167 });
168
169 let (buffer_changes_tx, mut buffer_changes_rx) = watch::channel(());
170
171 cx.subscribe(&source_buffer, move |this, _, event, _| match event {
172 language::BufferEvent::Edited
173 | language::BufferEvent::LanguageChanged(_)
174 | language::BufferEvent::Reparsed => {
175 this.buffer_changes_tx.send(()).ok();
176 }
177 _ => {}
178 })
179 .detach();
180
181 let editor = source_editor.read(cx);
182 let title = editor.buffer().read(cx).title(cx).to_string();
183 let selection_location_text = selection_location_text(editor, cx);
184 let selection_location_title = selection_location_text
185 .as_ref()
186 .map(|text| format!("{} @ {}", title, text))
187 .unwrap_or(title);
188
189 let path = editor
190 .buffer()
191 .read(cx)
192 .as_singleton()
193 .and_then(|b| {
194 b.read(cx)
195 .file()
196 .map(|f| f.full_path(cx).compact().to_string_lossy().into_owned())
197 })
198 .unwrap_or("untitled".into());
199
200 let selection_location_path = selection_location_text
201 .map(|text| format!("{} @ {}", path, text))
202 .unwrap_or(path);
203
204 Self {
205 diff_editor,
206 title: format!("Clipboard ↔ {selection_location_title}").into(),
207 path: Some(format!("Clipboard ↔ {selection_location_path}").into()),
208 buffer_changes_tx,
209 _recalculate_diff_task: cx.spawn(async move |_, cx| {
210 while buffer_changes_rx.recv().await.is_ok() {
211 loop {
212 let mut timer = cx
213 .background_executor()
214 .timer(RECALCULATE_DIFF_DEBOUNCE)
215 .fuse();
216 let mut recv = pin!(buffer_changes_rx.recv().fuse());
217 select_biased! {
218 _ = timer => break,
219 _ = recv => continue,
220 }
221 }
222
223 log::trace!("start recalculating");
224 update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await?;
225 log::trace!("finish recalculating");
226 }
227 Ok(())
228 }),
229 }
230 }
231}
232
233fn build_clipboard_buffer(
234 text: String,
235 source_buffer: &Entity<Buffer>,
236 replacement_range: Range<Point>,
237 cx: &mut App,
238) -> Entity<Buffer> {
239 let source_buffer_snapshot = source_buffer.read(cx).snapshot();
240 cx.new(|cx| {
241 let mut buffer = language::Buffer::local(source_buffer_snapshot.text(), cx);
242 let language = source_buffer.read(cx).language().cloned();
243 buffer.set_language(language, cx);
244
245 let range_start = source_buffer_snapshot.point_to_offset(replacement_range.start);
246 let range_end = source_buffer_snapshot.point_to_offset(replacement_range.end);
247 buffer.edit([(range_start..range_end, text)], None, cx);
248
249 buffer
250 })
251}
252
253async fn update_diff_buffer(
254 diff: &Entity<BufferDiff>,
255 source_buffer: &Entity<Buffer>,
256 clipboard_buffer: &Entity<Buffer>,
257 cx: &mut AsyncApp,
258) -> Result<()> {
259 let source_buffer_snapshot = source_buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
260 let language = source_buffer_snapshot.language().cloned();
261
262 let base_buffer_snapshot = clipboard_buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
263 let base_text = base_buffer_snapshot.text();
264
265 let update = diff
266 .update(cx, |diff, cx| {
267 diff.update_diff(
268 source_buffer_snapshot.text.clone(),
269 Some(Arc::from(base_text.as_str())),
270 true,
271 language,
272 cx,
273 )
274 })?
275 .await;
276
277 diff.update(cx, |diff, cx| {
278 diff.set_snapshot(update, &source_buffer_snapshot.text, cx)
279 })?
280 .await;
281 Ok(())
282}
283
284impl EventEmitter<EditorEvent> for TextDiffView {}
285
286impl Focusable for TextDiffView {
287 fn focus_handle(&self, cx: &App) -> FocusHandle {
288 self.diff_editor.focus_handle(cx)
289 }
290}
291
292impl Item for TextDiffView {
293 type Event = EditorEvent;
294
295 fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
296 Some(Icon::new(IconName::Diff).color(Color::Muted))
297 }
298
299 fn tab_content(&self, params: TabContentParams, _window: &Window, cx: &App) -> AnyElement {
300 Label::new(self.tab_content_text(params.detail.unwrap_or_default(), cx))
301 .color(if params.selected {
302 Color::Default
303 } else {
304 Color::Muted
305 })
306 .into_any_element()
307 }
308
309 fn tab_content_text(&self, _detail: usize, _: &App) -> SharedString {
310 self.title.clone()
311 }
312
313 fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
314 self.path.clone()
315 }
316
317 fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) {
318 Editor::to_item_events(event, f)
319 }
320
321 fn telemetry_event_text(&self) -> Option<&'static str> {
322 Some("Selection Diff View Opened")
323 }
324
325 fn deactivated(&mut self, window: &mut Window, cx: &mut Context<Self>) {
326 self.diff_editor
327 .update(cx, |editor, cx| editor.deactivated(window, cx));
328 }
329
330 fn act_as_type<'a>(
331 &'a self,
332 type_id: TypeId,
333 self_handle: &'a Entity<Self>,
334 _: &'a App,
335 ) -> Option<gpui::AnyEntity> {
336 if type_id == TypeId::of::<Self>() {
337 Some(self_handle.clone().into())
338 } else if type_id == TypeId::of::<Editor>() {
339 Some(self.diff_editor.clone().into())
340 } else {
341 None
342 }
343 }
344
345 fn as_searchable(&self, _: &Entity<Self>, _: &App) -> Option<Box<dyn SearchableItemHandle>> {
346 Some(Box::new(self.diff_editor.clone()))
347 }
348
349 fn for_each_project_item(
350 &self,
351 cx: &App,
352 f: &mut dyn FnMut(gpui::EntityId, &dyn project::ProjectItem),
353 ) {
354 self.diff_editor.for_each_project_item(cx, f)
355 }
356
357 fn set_nav_history(
358 &mut self,
359 nav_history: ItemNavHistory,
360 _: &mut Window,
361 cx: &mut Context<Self>,
362 ) {
363 self.diff_editor.update(cx, |editor, _| {
364 editor.set_nav_history(Some(nav_history));
365 });
366 }
367
368 fn navigate(
369 &mut self,
370 data: Box<dyn Any>,
371 window: &mut Window,
372 cx: &mut Context<Self>,
373 ) -> bool {
374 self.diff_editor
375 .update(cx, |editor, cx| editor.navigate(data, window, cx))
376 }
377
378 fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
379 ToolbarItemLocation::PrimaryLeft
380 }
381
382 fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
383 self.diff_editor.breadcrumbs(theme, cx)
384 }
385
386 fn added_to_workspace(
387 &mut self,
388 workspace: &mut Workspace,
389 window: &mut Window,
390 cx: &mut Context<Self>,
391 ) {
392 self.diff_editor.update(cx, |editor, cx| {
393 editor.added_to_workspace(workspace, window, cx)
394 });
395 }
396
397 fn can_save(&self, cx: &App) -> bool {
398 // The editor handles the new buffer, so delegate to it
399 self.diff_editor.read(cx).can_save(cx)
400 }
401
402 fn save(
403 &mut self,
404 options: SaveOptions,
405 project: Entity<Project>,
406 window: &mut Window,
407 cx: &mut Context<Self>,
408 ) -> Task<Result<()>> {
409 // Delegate saving to the editor, which manages the new buffer
410 self.diff_editor
411 .update(cx, |editor, cx| editor.save(options, project, window, cx))
412 }
413}
414
415pub fn selection_location_text(editor: &Editor, cx: &App) -> Option<String> {
416 let buffer = editor.buffer().read(cx);
417 let buffer_snapshot = buffer.snapshot(cx);
418 let first_selection = editor.selections.disjoint_anchors().first()?;
419
420 let selection_start = first_selection.start.to_point(&buffer_snapshot);
421 let selection_end = first_selection.end.to_point(&buffer_snapshot);
422
423 let start_row = selection_start.row;
424 let start_column = selection_start.column;
425 let end_row = selection_end.row;
426 let end_column = selection_end.column;
427
428 let range_text = if start_row == end_row {
429 format!("L{}:{}-{}", start_row + 1, start_column + 1, end_column + 1)
430 } else {
431 format!(
432 "L{}:{}-L{}:{}",
433 start_row + 1,
434 start_column + 1,
435 end_row + 1,
436 end_column + 1
437 )
438 };
439
440 Some(range_text)
441}
442
443impl Render for TextDiffView {
444 fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
445 self.diff_editor.clone()
446 }
447}
448
449#[cfg(test)]
450mod tests {
451 use super::*;
452 use editor::{MultiBufferOffset, test::editor_test_context::assert_state_with_diff};
453 use gpui::{TestAppContext, VisualContext};
454 use project::{FakeFs, Project};
455 use serde_json::json;
456 use settings::SettingsStore;
457 use unindent::unindent;
458 use util::{path, test::marked_text_ranges};
459
460 fn init_test(cx: &mut TestAppContext) {
461 cx.update(|cx| {
462 let settings_store = SettingsStore::test(cx);
463 cx.set_global(settings_store);
464 theme::init(theme::LoadThemes::JustBase, cx);
465 });
466 }
467
468 #[gpui::test]
469 async fn test_diffing_clipboard_against_empty_selection_uses_full_buffer_selection(
470 cx: &mut TestAppContext,
471 ) {
472 base_test(
473 path!("/test"),
474 path!("/test/text.txt"),
475 "def process_incoming_inventory(items, warehouse_id):\n pass\n",
476 "def process_outgoing_inventory(items, warehouse_id):\n passˇ\n",
477 &unindent(
478 "
479 - def process_incoming_inventory(items, warehouse_id):
480 + ˇdef process_outgoing_inventory(items, warehouse_id):
481 pass
482 ",
483 ),
484 "Clipboard ↔ text.txt @ L1:1-L3:1",
485 &format!("Clipboard ↔ {} @ L1:1-L3:1", path!("test/text.txt")),
486 cx,
487 )
488 .await;
489 }
490
491 #[gpui::test]
492 async fn test_diffing_clipboard_against_multiline_selection_expands_to_full_lines(
493 cx: &mut TestAppContext,
494 ) {
495 base_test(
496 path!("/test"),
497 path!("/test/text.txt"),
498 "def process_incoming_inventory(items, warehouse_id):\n pass\n",
499 "«def process_outgoing_inventory(items, warehouse_id):\n passˇ»\n",
500 &unindent(
501 "
502 - def process_incoming_inventory(items, warehouse_id):
503 + ˇdef process_outgoing_inventory(items, warehouse_id):
504 pass
505 ",
506 ),
507 "Clipboard ↔ text.txt @ L1:1-L3:1",
508 &format!("Clipboard ↔ {} @ L1:1-L3:1", path!("test/text.txt")),
509 cx,
510 )
511 .await;
512 }
513
514 #[gpui::test]
515 async fn test_diffing_clipboard_against_single_line_selection(cx: &mut TestAppContext) {
516 base_test(
517 path!("/test"),
518 path!("/test/text.txt"),
519 "a",
520 "«bbˇ»",
521 &unindent(
522 "
523 - a
524 + ˇbb",
525 ),
526 "Clipboard ↔ text.txt @ L1:1-3",
527 &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")),
528 cx,
529 )
530 .await;
531 }
532
533 #[gpui::test]
534 async fn test_diffing_clipboard_with_leading_whitespace_against_line(cx: &mut TestAppContext) {
535 base_test(
536 path!("/test"),
537 path!("/test/text.txt"),
538 " a",
539 "«bbˇ»",
540 &unindent(
541 "
542 - a
543 + ˇbb",
544 ),
545 "Clipboard ↔ text.txt @ L1:1-3",
546 &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")),
547 cx,
548 )
549 .await;
550 }
551
552 #[gpui::test]
553 async fn test_diffing_clipboard_against_line_with_leading_whitespace(cx: &mut TestAppContext) {
554 base_test(
555 path!("/test"),
556 path!("/test/text.txt"),
557 "a",
558 " «bbˇ»",
559 &unindent(
560 "
561 - a
562 + ˇ bb",
563 ),
564 "Clipboard ↔ text.txt @ L1:1-7",
565 &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")),
566 cx,
567 )
568 .await;
569 }
570
571 #[gpui::test]
572 async fn test_diffing_clipboard_against_line_with_leading_whitespace_included_in_selection(
573 cx: &mut TestAppContext,
574 ) {
575 base_test(
576 path!("/test"),
577 path!("/test/text.txt"),
578 "a",
579 "« bbˇ»",
580 &unindent(
581 "
582 - a
583 + ˇ bb",
584 ),
585 "Clipboard ↔ text.txt @ L1:1-7",
586 &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")),
587 cx,
588 )
589 .await;
590 }
591
592 #[gpui::test]
593 async fn test_diffing_clipboard_with_leading_whitespace_against_line_with_leading_whitespace(
594 cx: &mut TestAppContext,
595 ) {
596 base_test(
597 path!("/test"),
598 path!("/test/text.txt"),
599 " a",
600 " «bbˇ»",
601 &unindent(
602 "
603 - a
604 + ˇ bb",
605 ),
606 "Clipboard ↔ text.txt @ L1:1-7",
607 &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")),
608 cx,
609 )
610 .await;
611 }
612
613 #[gpui::test]
614 async fn test_diffing_clipboard_with_leading_whitespace_against_line_with_leading_whitespace_included_in_selection(
615 cx: &mut TestAppContext,
616 ) {
617 base_test(
618 path!("/test"),
619 path!("/test/text.txt"),
620 " a",
621 "« bbˇ»",
622 &unindent(
623 "
624 - a
625 + ˇ bb",
626 ),
627 "Clipboard ↔ text.txt @ L1:1-7",
628 &format!("Clipboard ↔ {} @ L1:1-7", path!("test/text.txt")),
629 cx,
630 )
631 .await;
632 }
633
634 #[gpui::test]
635 async fn test_diffing_clipboard_against_partial_selection_expands_to_include_trailing_characters(
636 cx: &mut TestAppContext,
637 ) {
638 base_test(
639 path!("/test"),
640 path!("/test/text.txt"),
641 "a",
642 "«bˇ»b",
643 &unindent(
644 "
645 - a
646 + ˇbb",
647 ),
648 "Clipboard ↔ text.txt @ L1:1-3",
649 &format!("Clipboard ↔ {} @ L1:1-3", path!("test/text.txt")),
650 cx,
651 )
652 .await;
653 }
654
655 async fn base_test(
656 project_root: &str,
657 file_path: &str,
658 clipboard_text: &str,
659 editor_text: &str,
660 expected_diff: &str,
661 expected_tab_title: &str,
662 expected_tab_tooltip: &str,
663 cx: &mut TestAppContext,
664 ) {
665 init_test(cx);
666
667 let file_name = std::path::Path::new(file_path)
668 .file_name()
669 .unwrap()
670 .to_str()
671 .unwrap();
672
673 let fs = FakeFs::new(cx.executor());
674 fs.insert_tree(
675 project_root,
676 json!({
677 file_name: editor_text
678 }),
679 )
680 .await;
681
682 let project = Project::test(fs, [project_root.as_ref()], cx).await;
683
684 let (workspace, cx) =
685 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
686
687 let buffer = project
688 .update(cx, |project, cx| project.open_local_buffer(file_path, cx))
689 .await
690 .unwrap();
691
692 let editor = cx.new_window_entity(|window, cx| {
693 let mut editor = Editor::for_buffer(buffer, None, window, cx);
694 let (unmarked_text, selection_ranges) = marked_text_ranges(editor_text, false);
695 editor.set_text(unmarked_text, window, cx);
696 editor.change_selections(Default::default(), window, cx, |s| {
697 s.select_ranges(
698 selection_ranges
699 .into_iter()
700 .map(|range| MultiBufferOffset(range.start)..MultiBufferOffset(range.end)),
701 )
702 });
703
704 editor
705 });
706
707 let diff_view = workspace
708 .update_in(cx, |workspace, window, cx| {
709 TextDiffView::open(
710 &DiffClipboardWithSelectionData {
711 clipboard_text: clipboard_text.to_string(),
712 editor,
713 },
714 workspace,
715 window,
716 cx,
717 )
718 })
719 .unwrap()
720 .await
721 .unwrap();
722
723 cx.executor().run_until_parked();
724
725 assert_state_with_diff(
726 &diff_view.read_with(cx, |diff_view, _| diff_view.diff_editor.clone()),
727 cx,
728 expected_diff,
729 );
730
731 diff_view.read_with(cx, |diff_view, cx| {
732 assert_eq!(diff_view.tab_content_text(0, cx), expected_tab_title);
733 assert_eq!(
734 diff_view.tab_tooltip_text(cx).unwrap(),
735 expected_tab_tooltip
736 );
737 });
738 }
739}