1use crate::{
2 BufferSearchBar, FocusSearch, HighlightKey, NextHistoryQuery, PreviousHistoryQuery, ReplaceAll,
3 ReplaceNext, SearchOption, SearchOptions, SearchSource, SelectNextMatch, SelectPreviousMatch,
4 ToggleCaseSensitive, ToggleIncludeIgnored, ToggleRegex, ToggleReplace, ToggleWholeWord,
5 buffer_search::Deploy,
6 search_bar::{
7 ActionButtonState, HistoryNavigationDirection, alignment_element, input_base_styles,
8 render_action_button, render_text_input, should_navigate_history,
9 },
10};
11use anyhow::Context as _;
12use collections::HashMap;
13use editor::{
14 Anchor, Editor, EditorEvent, EditorSettings, MAX_TAB_TITLE_LEN, MultiBuffer, PathKey,
15 SelectionEffects,
16 actions::{Backtab, FoldAll, SelectAll, Tab, UnfoldAll},
17 items::active_match_index,
18 multibuffer_context_lines,
19 scroll::Autoscroll,
20};
21use futures::{StreamExt, stream::FuturesOrdered};
22use gpui::{
23 Action, AnyElement, App, Axis, Context, Entity, EntityId, EventEmitter, FocusHandle, Focusable,
24 Global, Hsla, InteractiveElement, IntoElement, KeyContext, ParentElement, Point, Render,
25 SharedString, Styled, Subscription, Task, TaskExt, UpdateGlobal, WeakEntity, Window, actions,
26 div,
27};
28use itertools::Itertools;
29use language::{Buffer, Language};
30use menu::Confirm;
31use multi_buffer;
32use project::{
33 Project, ProjectPath, SearchResults,
34 search::{SearchInputKind, SearchQuery},
35 search_history::SearchHistoryCursor,
36};
37use settings::Settings;
38use std::{
39 any::{Any, TypeId},
40 mem,
41 ops::{Not, Range},
42 pin::pin,
43 sync::Arc,
44};
45use ui::{
46 CommonAnimationExt, IconButtonShape, KeyBinding, Toggleable, Tooltip, prelude::*,
47 utils::SearchInputWidth,
48};
49use util::{ResultExt as _, paths::PathMatcher, rel_path::RelPath};
50use workspace::{
51 DeploySearch, ItemNavHistory, NewSearch, ToolbarItemEvent, ToolbarItemLocation,
52 ToolbarItemView, Workspace, WorkspaceId,
53 item::{Item, ItemEvent, ItemHandle, SaveOptions},
54 searchable::{Direction, SearchEvent, SearchToken, SearchableItem, SearchableItemHandle},
55};
56
57actions!(
58 project_search,
59 [
60 /// Searches in a new project search tab.
61 SearchInNew,
62 /// Toggles focus between the search bar and the search results.
63 ToggleFocus,
64 /// Moves to the next input field.
65 NextField,
66 /// Toggles the search filters panel.
67 ToggleFilters,
68 /// Toggles collapse/expand state of all search result excerpts.
69 ToggleAllSearchResults
70 ]
71);
72
73fn split_glob_patterns(text: &str) -> Vec<&str> {
74 let mut patterns = Vec::new();
75 let mut pattern_start = 0;
76 let mut brace_depth: usize = 0;
77 let mut escaped = false;
78
79 for (index, character) in text.char_indices() {
80 if escaped {
81 escaped = false;
82 continue;
83 }
84 match character {
85 '\\' => escaped = true,
86 '{' => brace_depth += 1,
87 '}' => brace_depth = brace_depth.saturating_sub(1),
88 ',' if brace_depth == 0 => {
89 patterns.push(&text[pattern_start..index]);
90 pattern_start = index + 1;
91 }
92 _ => {}
93 }
94 }
95 patterns.push(&text[pattern_start..]);
96 patterns
97}
98
99#[derive(Default)]
100struct ActiveSettings(HashMap<WeakEntity<Project>, ProjectSearchSettings>);
101
102impl Global for ActiveSettings {}
103
104pub fn init(cx: &mut App) {
105 cx.set_global(ActiveSettings::default());
106 cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
107 register_workspace_action(workspace, move |search_bar, _: &Deploy, window, cx| {
108 search_bar.focus_search(window, cx);
109 });
110 register_workspace_action(workspace, move |search_bar, _: &FocusSearch, window, cx| {
111 search_bar.focus_search(window, cx);
112 });
113 register_workspace_action(
114 workspace,
115 move |search_bar, _: &ToggleFilters, window, cx| {
116 search_bar.toggle_filters(window, cx);
117 },
118 );
119 register_workspace_action(
120 workspace,
121 move |search_bar, _: &ToggleCaseSensitive, window, cx| {
122 search_bar.toggle_search_option(SearchOptions::CASE_SENSITIVE, window, cx);
123 },
124 );
125 register_workspace_action(
126 workspace,
127 move |search_bar, _: &ToggleWholeWord, window, cx| {
128 search_bar.toggle_search_option(SearchOptions::WHOLE_WORD, window, cx);
129 },
130 );
131 register_workspace_action(workspace, move |search_bar, _: &ToggleRegex, window, cx| {
132 search_bar.toggle_search_option(SearchOptions::REGEX, window, cx);
133 });
134 register_workspace_action(
135 workspace,
136 move |search_bar, action: &ToggleReplace, window, cx| {
137 search_bar.toggle_replace(action, window, cx)
138 },
139 );
140 register_workspace_action(
141 workspace,
142 move |search_bar, action: &SelectPreviousMatch, window, cx| {
143 search_bar.select_prev_match(action, window, cx)
144 },
145 );
146 register_workspace_action(
147 workspace,
148 move |search_bar, action: &SelectNextMatch, window, cx| {
149 search_bar.select_next_match(action, window, cx)
150 },
151 );
152
153 // Only handle search_in_new if there is a search present
154 register_workspace_action_for_present_search(workspace, |workspace, action, window, cx| {
155 ProjectSearchView::search_in_new(workspace, action, window, cx)
156 });
157
158 register_workspace_action_for_present_search(
159 workspace,
160 |workspace, action: &ToggleAllSearchResults, window, cx| {
161 if let Some(search_view) = workspace
162 .active_item(cx)
163 .and_then(|item| item.downcast::<ProjectSearchView>())
164 {
165 search_view.update(cx, |search_view, cx| {
166 search_view.toggle_all_search_results(action, window, cx);
167 });
168 }
169 },
170 );
171
172 register_workspace_action_for_present_search(
173 workspace,
174 |workspace, _: &menu::Cancel, window, cx| {
175 if let Some(project_search_bar) = workspace
176 .active_pane()
177 .read(cx)
178 .toolbar()
179 .read(cx)
180 .item_of_type::<ProjectSearchBar>()
181 {
182 project_search_bar.update(cx, |project_search_bar, cx| {
183 let search_is_focused = project_search_bar
184 .active_project_search
185 .as_ref()
186 .is_some_and(|search_view| {
187 search_view
188 .read(cx)
189 .query_editor
190 .read(cx)
191 .focus_handle(cx)
192 .is_focused(window)
193 });
194 if search_is_focused {
195 project_search_bar.move_focus_to_results(window, cx);
196 } else {
197 project_search_bar.focus_search(window, cx)
198 }
199 });
200 } else {
201 cx.propagate();
202 }
203 },
204 );
205
206 // Both on present and dismissed search, we need to unconditionally handle those actions to focus from the editor.
207 workspace.register_action(move |workspace, action: &DeploySearch, window, cx| {
208 if workspace.has_active_modal(window, cx) && !workspace.hide_modal(window, cx) {
209 cx.propagate();
210 return;
211 }
212 ProjectSearchView::deploy_search(workspace, action, window, cx);
213 cx.notify();
214 });
215 workspace.register_action(move |workspace, action: &NewSearch, window, cx| {
216 if workspace.has_active_modal(window, cx) && !workspace.hide_modal(window, cx) {
217 cx.propagate();
218 return;
219 }
220 ProjectSearchView::new_search(workspace, action, window, cx);
221 cx.notify();
222 });
223 })
224 .detach();
225}
226
227fn contains_uppercase(str: &str) -> bool {
228 str.chars().any(|c| c.is_uppercase())
229}
230
231pub struct ProjectSearch {
232 project: Entity<Project>,
233 excerpts: Entity<MultiBuffer>,
234 pending_search: Option<Task<Option<()>>>,
235 match_ranges: Vec<Range<Anchor>>,
236 active_query: Option<SearchQuery>,
237 last_search_query_text: Option<String>,
238 search_id: usize,
239 no_results: Option<bool>,
240 limit_reached: bool,
241 search_history_cursor: SearchHistoryCursor,
242 search_included_history_cursor: SearchHistoryCursor,
243 search_excluded_history_cursor: SearchHistoryCursor,
244 _excerpts_subscription: Subscription,
245}
246
247#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
248enum InputPanel {
249 Query,
250 Replacement,
251 Exclude,
252 Include,
253}
254
255pub struct ProjectSearchView {
256 workspace: WeakEntity<Workspace>,
257 focus_handle: FocusHandle,
258 entity: Entity<ProjectSearch>,
259 query_editor: Entity<Editor>,
260 replacement_editor: Entity<Editor>,
261 results_editor: Entity<Editor>,
262 search_options: SearchOptions,
263 panels_with_errors: HashMap<InputPanel, String>,
264 active_match_index: Option<usize>,
265 search_id: usize,
266 included_files_editor: Entity<Editor>,
267 excluded_files_editor: Entity<Editor>,
268 filters_enabled: bool,
269 replace_enabled: bool,
270 pending_replace_all: bool,
271 included_opened_only: bool,
272 regex_language: Option<Arc<Language>>,
273 _subscriptions: Vec<Subscription>,
274}
275
276#[derive(Debug, Clone)]
277pub struct ProjectSearchSettings {
278 search_options: SearchOptions,
279 filters_enabled: bool,
280}
281
282pub struct ProjectSearchBar {
283 active_project_search: Option<Entity<ProjectSearchView>>,
284 subscription: Option<Subscription>,
285}
286
287impl ProjectSearch {
288 pub fn new(project: Entity<Project>, cx: &mut Context<Self>) -> Self {
289 let capability = project.read(cx).capability();
290 let excerpts = cx.new(|_| MultiBuffer::new(capability));
291 let subscription = Self::subscribe_to_excerpts(&excerpts, cx);
292
293 Self {
294 project,
295 excerpts,
296 pending_search: Default::default(),
297 match_ranges: Default::default(),
298 active_query: None,
299 last_search_query_text: None,
300 search_id: 0,
301 no_results: None,
302 limit_reached: false,
303 search_history_cursor: Default::default(),
304 search_included_history_cursor: Default::default(),
305 search_excluded_history_cursor: Default::default(),
306 _excerpts_subscription: subscription,
307 }
308 }
309
310 fn clone(&self, cx: &mut Context<Self>) -> Entity<Self> {
311 cx.new(|cx| {
312 let excerpts = self
313 .excerpts
314 .update(cx, |excerpts, cx| cx.new(|cx| excerpts.clone(cx)));
315 let subscription = Self::subscribe_to_excerpts(&excerpts, cx);
316
317 Self {
318 project: self.project.clone(),
319 excerpts,
320 pending_search: Default::default(),
321 match_ranges: self.match_ranges.clone(),
322 active_query: self.active_query.clone(),
323 last_search_query_text: self.last_search_query_text.clone(),
324 search_id: self.search_id,
325 no_results: self.no_results,
326 limit_reached: self.limit_reached,
327 search_history_cursor: self.search_history_cursor.clone(),
328 search_included_history_cursor: self.search_included_history_cursor.clone(),
329 search_excluded_history_cursor: self.search_excluded_history_cursor.clone(),
330 _excerpts_subscription: subscription,
331 }
332 })
333 }
334 fn subscribe_to_excerpts(
335 excerpts: &Entity<MultiBuffer>,
336 cx: &mut Context<Self>,
337 ) -> Subscription {
338 cx.subscribe(excerpts, |this, _, event, cx| {
339 if matches!(event, multi_buffer::Event::FileHandleChanged) {
340 this.remove_deleted_buffers(cx);
341 }
342 })
343 }
344
345 fn remove_deleted_buffers(&mut self, cx: &mut Context<Self>) {
346 let deleted_buffer_ids = self
347 .excerpts
348 .read(cx)
349 .all_buffers_iter()
350 .filter(|buffer| {
351 buffer
352 .read(cx)
353 .file()
354 .is_some_and(|file| file.disk_state().is_deleted())
355 })
356 .map(|buffer| buffer.read(cx).remote_id())
357 .collect::<Vec<_>>();
358
359 if deleted_buffer_ids.is_empty() {
360 return;
361 }
362
363 let snapshot = self.excerpts.update(cx, |excerpts, cx| {
364 for buffer_id in deleted_buffer_ids {
365 excerpts.remove_excerpts_for_buffer(buffer_id, cx);
366 }
367 excerpts.snapshot(cx)
368 });
369
370 self.match_ranges
371 .retain(|range| snapshot.anchor_to_buffer_anchor(range.start).is_some());
372
373 cx.notify();
374 }
375
376 fn cursor(&self, kind: SearchInputKind) -> &SearchHistoryCursor {
377 match kind {
378 SearchInputKind::Query => &self.search_history_cursor,
379 SearchInputKind::Include => &self.search_included_history_cursor,
380 SearchInputKind::Exclude => &self.search_excluded_history_cursor,
381 }
382 }
383 fn cursor_mut(&mut self, kind: SearchInputKind) -> &mut SearchHistoryCursor {
384 match kind {
385 SearchInputKind::Query => &mut self.search_history_cursor,
386 SearchInputKind::Include => &mut self.search_included_history_cursor,
387 SearchInputKind::Exclude => &mut self.search_excluded_history_cursor,
388 }
389 }
390
391 fn search(&mut self, query: SearchQuery, cx: &mut Context<Self>) {
392 let search = self.project.update(cx, |project, cx| {
393 project
394 .search_history_mut(SearchInputKind::Query)
395 .add(&mut self.search_history_cursor, query.as_str().to_string());
396 let included = query.as_inner().files_to_include().sources().join(",");
397 if !included.is_empty() {
398 project
399 .search_history_mut(SearchInputKind::Include)
400 .add(&mut self.search_included_history_cursor, included);
401 }
402 let excluded = query.as_inner().files_to_exclude().sources().join(",");
403 if !excluded.is_empty() {
404 project
405 .search_history_mut(SearchInputKind::Exclude)
406 .add(&mut self.search_excluded_history_cursor, excluded);
407 }
408 project.search(query.clone(), cx)
409 });
410 self.last_search_query_text = Some(query.as_str().to_string());
411 self.search_id += 1;
412 self.active_query = Some(query);
413 self.match_ranges.clear();
414 self.pending_search = Some(cx.spawn(async move |project_search, cx| {
415 let SearchResults { rx, _task_handle } = search;
416
417 let mut matches = pin!(rx.ready_chunks(1024));
418 project_search
419 .update(cx, |project_search, cx| {
420 project_search.match_ranges.clear();
421 project_search
422 .excerpts
423 .update(cx, |excerpts, cx| excerpts.clear(cx));
424 project_search.no_results = Some(true);
425 project_search.limit_reached = false;
426 })
427 .ok()?;
428
429 let mut limit_reached = false;
430 while let Some(results) = matches.next().await {
431 let (buffers_with_ranges, has_reached_limit) = cx
432 .background_executor()
433 .spawn(async move {
434 let mut limit_reached = false;
435 let mut buffers_with_ranges = Vec::with_capacity(results.len());
436 for result in results {
437 match result {
438 project::search::SearchResult::Buffer { buffer, ranges } => {
439 buffers_with_ranges.push((buffer, ranges));
440 }
441 project::search::SearchResult::LimitReached => {
442 limit_reached = true;
443 }
444 }
445 }
446 (buffers_with_ranges, limit_reached)
447 })
448 .await;
449 limit_reached |= has_reached_limit;
450 let mut new_ranges = project_search
451 .update(cx, |project_search, cx| {
452 project_search.excerpts.update(cx, |excerpts, cx| {
453 buffers_with_ranges
454 .into_iter()
455 .map(|(buffer, ranges)| {
456 excerpts.set_anchored_excerpts_for_path(
457 PathKey::for_buffer(&buffer, cx),
458 buffer,
459 ranges,
460 multibuffer_context_lines(cx),
461 cx,
462 )
463 })
464 .collect::<FuturesOrdered<_>>()
465 })
466 })
467 .ok()?;
468 while let Some(new_ranges) = new_ranges.next().await {
469 // `new_ranges.next().await` likely never gets hit while still pending so `async_task`
470 // will not reschedule, starving other front end tasks, insert a yield point for that here
471 smol::future::yield_now().await;
472 project_search
473 .update(cx, |project_search, cx| {
474 project_search.match_ranges.extend(new_ranges);
475 cx.notify();
476 })
477 .ok()?;
478 }
479 }
480
481 project_search
482 .update(cx, |project_search, cx| {
483 if !project_search.match_ranges.is_empty() {
484 project_search.no_results = Some(false);
485 }
486 project_search.limit_reached = limit_reached;
487 project_search.pending_search.take();
488 cx.notify();
489 })
490 .ok()?;
491
492 None
493 }));
494 cx.notify();
495 }
496}
497
498#[derive(Clone, Debug, PartialEq, Eq)]
499pub enum ViewEvent {
500 UpdateTab,
501 Activate,
502 EditorEvent(editor::EditorEvent),
503 Dismiss,
504}
505
506impl EventEmitter<ViewEvent> for ProjectSearchView {}
507
508impl Render for ProjectSearchView {
509 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
510 if self.has_matches() {
511 div()
512 .flex_1()
513 .size_full()
514 .track_focus(&self.focus_handle(cx))
515 .child(self.results_editor.clone())
516 } else {
517 let model = self.entity.read(cx);
518 let has_no_results = model.no_results.unwrap_or(false);
519 let is_search_underway = model.pending_search.is_some();
520
521 let heading_text = if is_search_underway {
522 "Searching…"
523 } else if has_no_results {
524 "No Results"
525 } else {
526 "Search All Files"
527 };
528
529 let heading_text = div()
530 .justify_center()
531 .child(Label::new(heading_text).size(LabelSize::Large));
532
533 let page_content: Option<AnyElement> = if let Some(no_results) = model.no_results {
534 if model.pending_search.is_none() && no_results {
535 Some(
536 Label::new("No results found in this project for the provided query")
537 .size(LabelSize::Small)
538 .into_any_element(),
539 )
540 } else {
541 None
542 }
543 } else {
544 Some(self.landing_text_minor(cx).into_any_element())
545 };
546
547 let page_content = page_content.map(|text| div().child(text));
548
549 h_flex()
550 .size_full()
551 .items_center()
552 .justify_center()
553 .overflow_hidden()
554 .bg(cx.theme().colors().editor_background)
555 .track_focus(&self.focus_handle(cx))
556 .child(
557 v_flex()
558 .id("project-search-landing-page")
559 .overflow_y_scroll()
560 .gap_1()
561 .child(heading_text)
562 .children(page_content),
563 )
564 }
565 }
566}
567
568impl Focusable for ProjectSearchView {
569 fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
570 self.focus_handle.clone()
571 }
572}
573
574impl Item for ProjectSearchView {
575 type Event = ViewEvent;
576 fn tab_tooltip_text(&self, cx: &App) -> Option<SharedString> {
577 let query_text = self.query_editor.read(cx).text(cx);
578
579 query_text
580 .is_empty()
581 .not()
582 .then(|| query_text.into())
583 .or_else(|| Some("Project Search".into()))
584 }
585
586 fn act_as_type<'a>(
587 &'a self,
588 type_id: TypeId,
589 self_handle: &'a Entity<Self>,
590 _: &'a App,
591 ) -> Option<gpui::AnyEntity> {
592 if type_id == TypeId::of::<Self>() {
593 Some(self_handle.clone().into())
594 } else if type_id == TypeId::of::<Editor>() {
595 Some(self.results_editor.clone().into())
596 } else {
597 None
598 }
599 }
600 fn as_searchable(&self, _: &Entity<Self>, _: &App) -> Option<Box<dyn SearchableItemHandle>> {
601 Some(Box::new(self.results_editor.clone()))
602 }
603
604 fn deactivated(&mut self, window: &mut Window, cx: &mut Context<Self>) {
605 self.results_editor
606 .update(cx, |editor, cx| editor.deactivated(window, cx));
607 }
608
609 fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
610 Some(Icon::new(IconName::MagnifyingGlass))
611 }
612
613 fn tab_content_text(&self, _detail: usize, cx: &App) -> SharedString {
614 let last_query: Option<SharedString> = self
615 .entity
616 .read(cx)
617 .last_search_query_text
618 .as_ref()
619 .map(|query| {
620 let query = query.replace('\n', "");
621 let query_text = util::truncate_and_trailoff(&query, MAX_TAB_TITLE_LEN);
622 query_text.into()
623 });
624
625 last_query
626 .filter(|query| !query.is_empty())
627 .unwrap_or_else(|| "Project Search".into())
628 }
629
630 fn telemetry_event_text(&self) -> Option<&'static str> {
631 Some("Project Search Opened")
632 }
633
634 fn for_each_project_item(
635 &self,
636 cx: &App,
637 f: &mut dyn FnMut(EntityId, &dyn project::ProjectItem),
638 ) {
639 self.results_editor.for_each_project_item(cx, f)
640 }
641
642 fn can_save(&self, _: &App) -> bool {
643 true
644 }
645
646 fn is_dirty(&self, cx: &App) -> bool {
647 self.results_editor.read(cx).is_dirty(cx)
648 }
649
650 fn has_conflict(&self, cx: &App) -> bool {
651 self.results_editor.read(cx).has_conflict(cx)
652 }
653
654 fn save(
655 &mut self,
656 options: SaveOptions,
657 project: Entity<Project>,
658 window: &mut Window,
659 cx: &mut Context<Self>,
660 ) -> Task<anyhow::Result<()>> {
661 self.results_editor
662 .update(cx, |editor, cx| editor.save(options, project, window, cx))
663 }
664
665 fn save_as(
666 &mut self,
667 _: Entity<Project>,
668 _: ProjectPath,
669 _window: &mut Window,
670 _: &mut Context<Self>,
671 ) -> Task<anyhow::Result<()>> {
672 unreachable!("save_as should not have been called")
673 }
674
675 fn reload(
676 &mut self,
677 project: Entity<Project>,
678 window: &mut Window,
679 cx: &mut Context<Self>,
680 ) -> Task<anyhow::Result<()>> {
681 self.results_editor
682 .update(cx, |editor, cx| editor.reload(project, window, cx))
683 }
684
685 fn can_split(&self) -> bool {
686 true
687 }
688
689 fn clone_on_split(
690 &self,
691 _workspace_id: Option<WorkspaceId>,
692 window: &mut Window,
693 cx: &mut Context<Self>,
694 ) -> Task<Option<Entity<Self>>>
695 where
696 Self: Sized,
697 {
698 let model = self.entity.update(cx, |model, cx| model.clone(cx));
699 Task::ready(Some(cx.new(|cx| {
700 Self::new(self.workspace.clone(), model, window, cx, None)
701 })))
702 }
703
704 fn added_to_workspace(
705 &mut self,
706 workspace: &mut Workspace,
707 window: &mut Window,
708 cx: &mut Context<Self>,
709 ) {
710 self.results_editor.update(cx, |editor, cx| {
711 editor.added_to_workspace(workspace, window, cx)
712 });
713 }
714
715 fn set_nav_history(
716 &mut self,
717 nav_history: ItemNavHistory,
718 _: &mut Window,
719 cx: &mut Context<Self>,
720 ) {
721 self.results_editor.update(cx, |editor, _| {
722 editor.set_nav_history(Some(nav_history));
723 });
724 }
725
726 fn navigate(
727 &mut self,
728 data: Arc<dyn Any + Send>,
729 window: &mut Window,
730 cx: &mut Context<Self>,
731 ) -> bool {
732 self.results_editor
733 .update(cx, |editor, cx| editor.navigate(data, window, cx))
734 }
735
736 fn to_item_events(event: &Self::Event, f: &mut dyn FnMut(ItemEvent)) {
737 match event {
738 ViewEvent::UpdateTab => {
739 f(ItemEvent::UpdateBreadcrumbs);
740 f(ItemEvent::UpdateTab);
741 }
742 ViewEvent::EditorEvent(editor_event) => {
743 Editor::to_item_events(editor_event, f);
744 }
745 ViewEvent::Dismiss => f(ItemEvent::CloseItem),
746 _ => {}
747 }
748 }
749}
750
751impl ProjectSearchView {
752 pub fn get_matches(&self, cx: &App) -> Vec<Range<Anchor>> {
753 self.entity.read(cx).match_ranges.clone()
754 }
755
756 fn toggle_filters(&mut self, cx: &mut Context<Self>) {
757 self.filters_enabled = !self.filters_enabled;
758 ActiveSettings::update_global(cx, |settings, cx| {
759 settings.0.insert(
760 self.entity.read(cx).project.downgrade(),
761 self.current_settings(),
762 );
763 });
764 }
765
766 fn current_settings(&self) -> ProjectSearchSettings {
767 ProjectSearchSettings {
768 search_options: self.search_options,
769 filters_enabled: self.filters_enabled,
770 }
771 }
772
773 fn set_search_option_enabled(
774 &mut self,
775 option: SearchOptions,
776 enabled: bool,
777 cx: &mut Context<Self>,
778 ) {
779 if self.search_options.contains(option) != enabled {
780 self.toggle_search_option(option, cx);
781 }
782 }
783
784 fn toggle_search_option(&mut self, option: SearchOptions, cx: &mut Context<Self>) {
785 self.search_options.toggle(option);
786 ActiveSettings::update_global(cx, |settings, cx| {
787 settings.0.insert(
788 self.entity.read(cx).project.downgrade(),
789 self.current_settings(),
790 );
791 });
792 self.adjust_query_regex_language(cx);
793 }
794
795 fn toggle_opened_only(&mut self, _window: &mut Window, _cx: &mut Context<Self>) {
796 self.included_opened_only = !self.included_opened_only;
797 }
798
799 pub fn replacement(&self, cx: &App) -> String {
800 self.replacement_editor.read(cx).text(cx)
801 }
802
803 fn replace_next(&mut self, _: &ReplaceNext, window: &mut Window, cx: &mut Context<Self>) {
804 if self.entity.read(cx).pending_search.is_some() {
805 return;
806 }
807 if let Some(last_search_query_text) = &self.entity.read(cx).last_search_query_text
808 && self.query_editor.read(cx).text(cx) != *last_search_query_text
809 {
810 // search query has changed, restart search and bail
811 self.search(cx);
812 return;
813 }
814 if self.entity.read(cx).match_ranges.is_empty() {
815 return;
816 }
817 let Some(active_index) = self.active_match_index else {
818 return;
819 };
820
821 let query = self.entity.read(cx).active_query.clone();
822 if let Some(query) = query {
823 let query = query.with_replacement(self.replacement(cx));
824
825 let mat = self.entity.read(cx).match_ranges.get(active_index).cloned();
826 self.results_editor.update(cx, |editor, cx| {
827 if let Some(mat) = mat.as_ref() {
828 editor.replace(mat, &query, SearchToken::default(), window, cx);
829 }
830 });
831 self.select_match(Direction::Next, window, cx)
832 }
833 }
834
835 fn replace_all(&mut self, _: &ReplaceAll, window: &mut Window, cx: &mut Context<Self>) {
836 if self.entity.read(cx).pending_search.is_some() {
837 self.pending_replace_all = true;
838 return;
839 }
840 let query_text = self.query_editor.read(cx).text(cx);
841 let query_is_stale =
842 self.entity.read(cx).last_search_query_text.as_deref() != Some(query_text.as_str());
843 if query_is_stale {
844 self.pending_replace_all = true;
845 self.search(cx);
846 if self.entity.read(cx).pending_search.is_none() {
847 self.pending_replace_all = false;
848 }
849 return;
850 }
851 self.pending_replace_all = false;
852 if self.active_match_index.is_none() {
853 return;
854 }
855 let Some(query) = self.entity.read(cx).active_query.as_ref() else {
856 return;
857 };
858 let query = query.clone().with_replacement(self.replacement(cx));
859
860 let match_ranges = self
861 .entity
862 .update(cx, |model, _| mem::take(&mut model.match_ranges));
863 if match_ranges.is_empty() {
864 return;
865 }
866
867 self.results_editor.update(cx, |editor, cx| {
868 editor.replace_all(
869 &mut match_ranges.iter(),
870 &query,
871 SearchToken::default(),
872 window,
873 cx,
874 );
875 });
876
877 self.entity.update(cx, |model, _cx| {
878 model.match_ranges = match_ranges;
879 });
880 }
881
882 fn toggle_all_search_results(
883 &mut self,
884 _: &ToggleAllSearchResults,
885 window: &mut Window,
886 cx: &mut Context<Self>,
887 ) {
888 self.update_results_visibility(window, cx);
889 }
890
891 fn update_results_visibility(&mut self, window: &mut Window, cx: &mut Context<Self>) {
892 let has_any_folded = self.results_editor.read(cx).has_any_buffer_folded(cx);
893 self.results_editor.update(cx, |editor, cx| {
894 if has_any_folded {
895 editor.unfold_all(&UnfoldAll, window, cx);
896 } else {
897 editor.fold_all(&FoldAll, window, cx);
898 }
899 });
900 cx.notify();
901 }
902
903 pub fn new(
904 workspace: WeakEntity<Workspace>,
905 entity: Entity<ProjectSearch>,
906 window: &mut Window,
907 cx: &mut Context<Self>,
908 settings: Option<ProjectSearchSettings>,
909 ) -> Self {
910 let project;
911 let excerpts;
912 let mut replacement_text = None;
913 let mut query_text = String::new();
914 let mut subscriptions = Vec::new();
915
916 // Read in settings if available
917 let (mut options, filters_enabled) = if let Some(settings) = settings {
918 (settings.search_options, settings.filters_enabled)
919 } else {
920 let search_options =
921 SearchOptions::from_settings(&EditorSettings::get_global(cx).search);
922 (search_options, false)
923 };
924
925 {
926 let entity = entity.read(cx);
927 project = entity.project.clone();
928 excerpts = entity.excerpts.clone();
929 if let Some(active_query) = entity.active_query.as_ref() {
930 query_text = active_query.as_str().to_string();
931 replacement_text = active_query.replacement().map(ToOwned::to_owned);
932 options = SearchOptions::from_query(active_query);
933 }
934 }
935 subscriptions.push(cx.observe_in(&entity, window, |this, _, window, cx| {
936 this.entity_changed(window, cx)
937 }));
938
939 let query_editor = cx.new(|cx| {
940 let mut editor = Editor::auto_height(1, 4, window, cx);
941 editor.set_placeholder_text("Search all files…", window, cx);
942 editor.set_use_autoclose(false);
943 editor.set_use_selection_highlight(false);
944 editor.set_text(query_text, window, cx);
945 editor
946 });
947 // Subscribe to query_editor in order to reraise editor events for workspace item activation purposes
948 subscriptions.push(
949 cx.subscribe(&query_editor, |this, _, event: &EditorEvent, cx| {
950 if let EditorEvent::Edited { .. } = event
951 && EditorSettings::get_global(cx).use_smartcase_search
952 {
953 let query = this.search_query_text(cx);
954 if !query.is_empty()
955 && this.search_options.contains(SearchOptions::CASE_SENSITIVE)
956 != contains_uppercase(&query)
957 {
958 this.toggle_search_option(SearchOptions::CASE_SENSITIVE, cx);
959 }
960 }
961 cx.emit(ViewEvent::EditorEvent(event.clone()))
962 }),
963 );
964 let replacement_editor = cx.new(|cx| {
965 let mut editor = Editor::auto_height(1, 4, window, cx);
966 editor.set_placeholder_text("Replace in project…", window, cx);
967 if let Some(text) = replacement_text {
968 editor.set_text(text, window, cx);
969 }
970 editor
971 });
972 let results_editor = cx.new(|cx| {
973 let mut editor = Editor::for_multibuffer(excerpts, Some(project.clone()), window, cx);
974 editor.set_searchable(false);
975 editor.set_in_project_search(true);
976 editor
977 });
978 subscriptions.push(cx.observe(&results_editor, |_, _, cx| cx.emit(ViewEvent::UpdateTab)));
979
980 subscriptions.push(
981 cx.subscribe(&results_editor, |this, _, event: &EditorEvent, cx| {
982 if matches!(event, editor::EditorEvent::SelectionsChanged { .. }) {
983 this.update_match_index(cx);
984 }
985 // Reraise editor events for workspace item activation purposes
986 cx.emit(ViewEvent::EditorEvent(event.clone()));
987 }),
988 );
989 subscriptions.push(cx.subscribe(
990 &results_editor,
991 |_this, _editor, _event: &SearchEvent, cx| cx.notify(),
992 ));
993
994 let included_files_editor = cx.new(|cx| {
995 let mut editor = Editor::single_line(window, cx);
996 editor.set_placeholder_text("Include: crates/**/*.toml", window, cx);
997
998 editor
999 });
1000 // Subscribe to include_files_editor in order to reraise editor events for workspace item activation purposes
1001 subscriptions.push(
1002 cx.subscribe(&included_files_editor, |_, _, event: &EditorEvent, cx| {
1003 cx.emit(ViewEvent::EditorEvent(event.clone()))
1004 }),
1005 );
1006
1007 let excluded_files_editor = cx.new(|cx| {
1008 let mut editor = Editor::single_line(window, cx);
1009 editor.set_placeholder_text("Exclude: vendor/*, *.lock", window, cx);
1010
1011 editor
1012 });
1013 // Subscribe to excluded_files_editor in order to reraise editor events for workspace item activation purposes
1014 subscriptions.push(
1015 cx.subscribe(&excluded_files_editor, |_, _, event: &EditorEvent, cx| {
1016 cx.emit(ViewEvent::EditorEvent(event.clone()))
1017 }),
1018 );
1019
1020 let focus_handle = cx.focus_handle();
1021 subscriptions.push(cx.on_focus(&focus_handle, window, |_, window, cx| {
1022 cx.on_next_frame(window, |this, window, cx| {
1023 if this.focus_handle.is_focused(window) {
1024 if this.has_matches() {
1025 this.results_editor.focus_handle(cx).focus(window, cx);
1026 } else {
1027 this.query_editor.focus_handle(cx).focus(window, cx);
1028 }
1029 }
1030 });
1031 }));
1032
1033 let languages = project.read(cx).languages().clone();
1034 cx.spawn(async move |project_search_view, cx| {
1035 let regex_language = languages
1036 .language_for_name("regex")
1037 .await
1038 .context("loading regex language")?;
1039 project_search_view
1040 .update(cx, |project_search_view, cx| {
1041 project_search_view.regex_language = Some(regex_language);
1042 project_search_view.adjust_query_regex_language(cx);
1043 })
1044 .ok();
1045 anyhow::Ok(())
1046 })
1047 .detach_and_log_err(cx);
1048
1049 // Check if Worktrees have all been previously indexed
1050 let mut this = ProjectSearchView {
1051 workspace,
1052 focus_handle,
1053 replacement_editor,
1054 search_id: entity.read(cx).search_id,
1055 entity,
1056 query_editor,
1057 results_editor,
1058 search_options: options,
1059 panels_with_errors: HashMap::default(),
1060 active_match_index: None,
1061 included_files_editor,
1062 excluded_files_editor,
1063 filters_enabled,
1064 replace_enabled: false,
1065 pending_replace_all: false,
1066 included_opened_only: false,
1067 regex_language: None,
1068 _subscriptions: subscriptions,
1069 };
1070
1071 this.entity_changed(window, cx);
1072 this
1073 }
1074
1075 pub fn new_search_in_directory(
1076 workspace: &mut Workspace,
1077 dir_path: &RelPath,
1078 window: &mut Window,
1079 cx: &mut Context<Workspace>,
1080 ) {
1081 let filter_str = dir_path.display(workspace.path_style(cx));
1082
1083 let weak_workspace = cx.entity().downgrade();
1084
1085 let entity = cx.new(|cx| ProjectSearch::new(workspace.project().clone(), cx));
1086 let search = cx.new(|cx| ProjectSearchView::new(weak_workspace, entity, window, cx, None));
1087 workspace.add_item_to_active_pane(Box::new(search.clone()), None, true, window, cx);
1088 search.update(cx, |search, cx| {
1089 search
1090 .included_files_editor
1091 .update(cx, |editor, cx| editor.set_text(filter_str, window, cx));
1092 search.filters_enabled = true;
1093 search.focus_query_editor(window, cx)
1094 });
1095 }
1096
1097 /// Re-activate the most recently activated search in this pane or the most recent if it has been closed.
1098 /// If no search exists in the workspace, create a new one.
1099 pub fn deploy_search(
1100 workspace: &mut Workspace,
1101 action: &workspace::DeploySearch,
1102 window: &mut Window,
1103 cx: &mut Context<Workspace>,
1104 ) {
1105 let existing = workspace
1106 .active_pane()
1107 .read(cx)
1108 .items()
1109 .find_map(|item| item.downcast::<ProjectSearchView>());
1110
1111 Self::existing_or_new_search(workspace, existing, action, window, cx);
1112 }
1113
1114 fn search_in_new(
1115 workspace: &mut Workspace,
1116 _: &SearchInNew,
1117 window: &mut Window,
1118 cx: &mut Context<Workspace>,
1119 ) {
1120 if let Some(search_view) = workspace
1121 .active_item(cx)
1122 .and_then(|item| item.downcast::<ProjectSearchView>())
1123 {
1124 let new_query = search_view.update(cx, |search_view, cx| {
1125 let open_buffers = if search_view.included_opened_only {
1126 Some(search_view.open_buffers(cx, workspace))
1127 } else {
1128 None
1129 };
1130 let new_query = search_view.build_search_query(cx, open_buffers);
1131 if new_query.is_some()
1132 && let Some(old_query) = search_view.entity.read(cx).active_query.clone()
1133 {
1134 search_view.query_editor.update(cx, |editor, cx| {
1135 editor.set_text(old_query.as_str(), window, cx);
1136 });
1137 search_view.search_options = SearchOptions::from_query(&old_query);
1138 search_view.adjust_query_regex_language(cx);
1139 }
1140 new_query
1141 });
1142 if let Some(new_query) = new_query {
1143 let entity = cx.new(|cx| {
1144 let mut entity = ProjectSearch::new(workspace.project().clone(), cx);
1145 entity.search(new_query, cx);
1146 entity
1147 });
1148 let weak_workspace = cx.entity().downgrade();
1149 workspace.add_item_to_active_pane(
1150 Box::new(cx.new(|cx| {
1151 ProjectSearchView::new(weak_workspace, entity, window, cx, None)
1152 })),
1153 None,
1154 true,
1155 window,
1156 cx,
1157 );
1158 }
1159 }
1160 }
1161
1162 // Add another search tab to the workspace.
1163 fn new_search(
1164 workspace: &mut Workspace,
1165 _: &workspace::NewSearch,
1166 window: &mut Window,
1167 cx: &mut Context<Workspace>,
1168 ) {
1169 Self::existing_or_new_search(workspace, None, &DeploySearch::default(), window, cx)
1170 }
1171
1172 fn existing_or_new_search(
1173 workspace: &mut Workspace,
1174 existing: Option<Entity<ProjectSearchView>>,
1175 action: &workspace::DeploySearch,
1176 window: &mut Window,
1177 cx: &mut Context<Workspace>,
1178 ) {
1179 let query = workspace.active_item(cx).and_then(|item| {
1180 if let Some(buffer_search_query) = buffer_search_query(workspace, item.as_ref(), cx) {
1181 return Some(buffer_search_query);
1182 }
1183
1184 let editor = item.act_as::<Editor>(cx)?;
1185 let query = editor.query_suggestion(window, cx);
1186 if query.is_empty() { None } else { Some(query) }
1187 });
1188
1189 let search = if let Some(existing) = existing {
1190 workspace.activate_item(&existing, true, true, window, cx);
1191 existing
1192 } else {
1193 let settings = cx
1194 .global::<ActiveSettings>()
1195 .0
1196 .get(&workspace.project().downgrade());
1197
1198 let settings = settings.cloned();
1199
1200 let weak_workspace = cx.entity().downgrade();
1201
1202 let project_search = cx.new(|cx| ProjectSearch::new(workspace.project().clone(), cx));
1203 let project_search_view = cx.new(|cx| {
1204 ProjectSearchView::new(weak_workspace, project_search, window, cx, settings)
1205 });
1206
1207 workspace.add_item_to_active_pane(
1208 Box::new(project_search_view.clone()),
1209 None,
1210 true,
1211 window,
1212 cx,
1213 );
1214 project_search_view
1215 };
1216
1217 search.update(cx, |search, cx| {
1218 search.replace_enabled |= action.replace_enabled;
1219 if let Some(regex) = action.regex {
1220 search.set_search_option_enabled(SearchOptions::REGEX, regex, cx);
1221 }
1222 if let Some(case_sensitive) = action.case_sensitive {
1223 search.set_search_option_enabled(SearchOptions::CASE_SENSITIVE, case_sensitive, cx);
1224 }
1225 if let Some(whole_word) = action.whole_word {
1226 search.set_search_option_enabled(SearchOptions::WHOLE_WORD, whole_word, cx);
1227 }
1228 if let Some(include_ignored) = action.include_ignored {
1229 search.set_search_option_enabled(
1230 SearchOptions::INCLUDE_IGNORED,
1231 include_ignored,
1232 cx,
1233 );
1234 }
1235 let query = action
1236 .query
1237 .as_deref()
1238 .filter(|q| !q.is_empty())
1239 .or(query.as_deref());
1240 if let Some(query) = query {
1241 search.set_query(query, window, cx);
1242 }
1243 if let Some(included_files) = action.included_files.as_deref() {
1244 search
1245 .included_files_editor
1246 .update(cx, |editor, cx| editor.set_text(included_files, window, cx));
1247 search.filters_enabled = true;
1248 }
1249 if let Some(excluded_files) = action.excluded_files.as_deref() {
1250 search
1251 .excluded_files_editor
1252 .update(cx, |editor, cx| editor.set_text(excluded_files, window, cx));
1253 search.filters_enabled = true;
1254 }
1255 search.focus_query_editor(window, cx)
1256 });
1257 }
1258
1259 fn prompt_to_save_if_dirty_then_search(
1260 &mut self,
1261 window: &mut Window,
1262 cx: &mut Context<Self>,
1263 ) -> Task<anyhow::Result<()>> {
1264 let project = self.entity.read(cx).project.clone();
1265
1266 let can_autosave = self.results_editor.can_autosave(cx);
1267 let autosave_setting = self.results_editor.workspace_settings(cx).autosave;
1268
1269 let will_autosave = can_autosave && autosave_setting.should_save_on_close();
1270
1271 let is_dirty = self.is_dirty(cx);
1272
1273 cx.spawn_in(window, async move |this, cx| {
1274 let skip_save_on_close = this
1275 .read_with(cx, |this, cx| {
1276 this.workspace.read_with(cx, |workspace, cx| {
1277 workspace::Pane::skip_save_on_close(&this.results_editor, workspace, cx)
1278 })
1279 })?
1280 .unwrap_or(false);
1281
1282 let should_prompt_to_save = !skip_save_on_close && !will_autosave && is_dirty;
1283
1284 let should_search = if should_prompt_to_save {
1285 let options = &["Save", "Don't Save", "Cancel"];
1286 let result_channel = this.update_in(cx, |_, window, cx| {
1287 window.prompt(
1288 gpui::PromptLevel::Warning,
1289 "Project search buffer contains unsaved edits. Do you want to save it?",
1290 None,
1291 options,
1292 cx,
1293 )
1294 })?;
1295 let result = result_channel.await?;
1296 let should_save = result == 0;
1297 if should_save {
1298 this.update_in(cx, |this, window, cx| {
1299 this.save(
1300 SaveOptions {
1301 format: true,
1302 autosave: false,
1303 },
1304 project,
1305 window,
1306 cx,
1307 )
1308 })?
1309 .await
1310 .log_err();
1311 }
1312
1313 result != 2
1314 } else {
1315 true
1316 };
1317 if should_search {
1318 this.update(cx, |this, cx| {
1319 this.search(cx);
1320 })?;
1321 }
1322 anyhow::Ok(())
1323 })
1324 }
1325
1326 fn search(&mut self, cx: &mut Context<Self>) {
1327 let open_buffers = if self.included_opened_only {
1328 self.workspace
1329 .update(cx, |workspace, cx| self.open_buffers(cx, workspace))
1330 .ok()
1331 } else {
1332 None
1333 };
1334 if let Some(query) = self.build_search_query(cx, open_buffers) {
1335 self.entity.update(cx, |model, cx| model.search(query, cx));
1336 }
1337 }
1338
1339 pub fn search_query_text(&self, cx: &App) -> String {
1340 self.query_editor.read(cx).text(cx)
1341 }
1342
1343 fn build_search_query(
1344 &mut self,
1345 cx: &mut Context<Self>,
1346 open_buffers: Option<Vec<Entity<Buffer>>>,
1347 ) -> Option<SearchQuery> {
1348 // Do not bail early in this function, as we want to fill out `self.panels_with_errors`.
1349
1350 let text = self.search_query_text(cx);
1351 let included_files = self
1352 .filters_enabled
1353 .then(|| {
1354 match self.parse_path_matches(self.included_files_editor.read(cx).text(cx), cx) {
1355 Ok(included_files) => {
1356 let should_unmark_error =
1357 self.panels_with_errors.remove(&InputPanel::Include);
1358 if should_unmark_error.is_some() {
1359 cx.notify();
1360 }
1361 included_files
1362 }
1363 Err(e) => {
1364 let should_mark_error = self
1365 .panels_with_errors
1366 .insert(InputPanel::Include, e.to_string());
1367 if should_mark_error.is_none() {
1368 cx.notify();
1369 }
1370 PathMatcher::default()
1371 }
1372 }
1373 })
1374 .unwrap_or(PathMatcher::default());
1375 let excluded_files = self
1376 .filters_enabled
1377 .then(|| {
1378 match self.parse_path_matches(self.excluded_files_editor.read(cx).text(cx), cx) {
1379 Ok(excluded_files) => {
1380 let should_unmark_error =
1381 self.panels_with_errors.remove(&InputPanel::Exclude);
1382 if should_unmark_error.is_some() {
1383 cx.notify();
1384 }
1385
1386 excluded_files
1387 }
1388 Err(e) => {
1389 let should_mark_error = self
1390 .panels_with_errors
1391 .insert(InputPanel::Exclude, e.to_string());
1392 if should_mark_error.is_none() {
1393 cx.notify();
1394 }
1395 PathMatcher::default()
1396 }
1397 }
1398 })
1399 .unwrap_or(PathMatcher::default());
1400
1401 // If the project contains multiple visible worktrees, we match the
1402 // include/exclude patterns against full paths to allow them to be
1403 // disambiguated. For single worktree projects we use worktree relative
1404 // paths for convenience.
1405 let match_full_paths = self
1406 .entity
1407 .read(cx)
1408 .project
1409 .read(cx)
1410 .visible_worktrees(cx)
1411 .count()
1412 > 1;
1413
1414 let query = if self.search_options.contains(SearchOptions::REGEX) {
1415 match SearchQuery::regex(
1416 text,
1417 self.search_options.contains(SearchOptions::WHOLE_WORD),
1418 self.search_options.contains(SearchOptions::CASE_SENSITIVE),
1419 self.search_options.contains(SearchOptions::INCLUDE_IGNORED),
1420 self.search_options
1421 .contains(SearchOptions::ONE_MATCH_PER_LINE),
1422 included_files,
1423 excluded_files,
1424 match_full_paths,
1425 open_buffers,
1426 ) {
1427 Ok(query) => {
1428 let should_unmark_error = self.panels_with_errors.remove(&InputPanel::Query);
1429 if should_unmark_error.is_some() {
1430 cx.notify();
1431 }
1432
1433 Some(query)
1434 }
1435 Err(e) => {
1436 let should_mark_error = self
1437 .panels_with_errors
1438 .insert(InputPanel::Query, e.to_string());
1439 if should_mark_error.is_none() {
1440 cx.notify();
1441 }
1442
1443 None
1444 }
1445 }
1446 } else {
1447 match SearchQuery::text(
1448 text,
1449 self.search_options.contains(SearchOptions::WHOLE_WORD),
1450 self.search_options.contains(SearchOptions::CASE_SENSITIVE),
1451 self.search_options.contains(SearchOptions::INCLUDE_IGNORED),
1452 included_files,
1453 excluded_files,
1454 match_full_paths,
1455 open_buffers,
1456 ) {
1457 Ok(query) => {
1458 let should_unmark_error = self.panels_with_errors.remove(&InputPanel::Query);
1459 if should_unmark_error.is_some() {
1460 cx.notify();
1461 }
1462
1463 Some(query)
1464 }
1465 Err(e) => {
1466 let should_mark_error = self
1467 .panels_with_errors
1468 .insert(InputPanel::Query, e.to_string());
1469 if should_mark_error.is_none() {
1470 cx.notify();
1471 }
1472
1473 None
1474 }
1475 }
1476 };
1477 if !self.panels_with_errors.is_empty() {
1478 return None;
1479 }
1480 if query.as_ref().is_some_and(|query| query.is_empty()) {
1481 return None;
1482 }
1483 query
1484 }
1485
1486 fn open_buffers(&self, cx: &App, workspace: &Workspace) -> Vec<Entity<Buffer>> {
1487 let mut buffers = Vec::new();
1488 for editor in workspace.items_of_type::<Editor>(cx) {
1489 if let Some(buffer) = editor.read(cx).buffer().read(cx).as_singleton() {
1490 buffers.push(buffer);
1491 }
1492 }
1493 buffers
1494 }
1495
1496 fn parse_path_matches(&self, text: String, cx: &App) -> anyhow::Result<PathMatcher> {
1497 let path_style = self.entity.read(cx).project.read(cx).path_style(cx);
1498 let queries = split_glob_patterns(&text)
1499 .into_iter()
1500 .map(str::trim)
1501 .filter(|maybe_glob_str| !maybe_glob_str.is_empty())
1502 .map(str::to_owned)
1503 .collect::<Vec<_>>();
1504 Ok(PathMatcher::new(&queries, path_style)?)
1505 }
1506
1507 fn select_match(&mut self, direction: Direction, window: &mut Window, cx: &mut Context<Self>) {
1508 if let Some(index) = self.active_match_index {
1509 let match_ranges = self.entity.read(cx).match_ranges.clone();
1510
1511 if !EditorSettings::get_global(cx).search_wrap
1512 && ((direction == Direction::Next && index + 1 >= match_ranges.len())
1513 || (direction == Direction::Prev && index == 0))
1514 {
1515 crate::show_no_more_matches(window, cx);
1516 return;
1517 }
1518
1519 let new_index = self.results_editor.update(cx, |editor, cx| {
1520 editor.match_index_for_direction(
1521 &match_ranges,
1522 index,
1523 direction,
1524 1,
1525 SearchToken::default(),
1526 window,
1527 cx,
1528 )
1529 });
1530
1531 let range_to_select = match_ranges[new_index].clone();
1532 self.results_editor.update(cx, |editor, cx| {
1533 let range_to_select = editor.range_for_match(&range_to_select);
1534 let autoscroll = if EditorSettings::get_global(cx).search.center_on_match {
1535 Autoscroll::center()
1536 } else {
1537 Autoscroll::fit()
1538 };
1539 editor.unfold_ranges(std::slice::from_ref(&range_to_select), false, true, cx);
1540 editor.change_selections(SelectionEffects::scroll(autoscroll), window, cx, |s| {
1541 s.select_ranges([range_to_select])
1542 });
1543 });
1544 self.highlight_matches(&match_ranges, Some(new_index), cx);
1545 }
1546 }
1547
1548 fn focus_query_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1549 self.query_editor.update(cx, |query_editor, cx| {
1550 query_editor.select_all(&SelectAll, window, cx);
1551 });
1552 let editor_handle = self.query_editor.focus_handle(cx);
1553 window.focus(&editor_handle, cx);
1554 }
1555
1556 fn set_query(&mut self, query: &str, window: &mut Window, cx: &mut Context<Self>) {
1557 self.set_search_editor(SearchInputKind::Query, query, window, cx);
1558 if EditorSettings::get_global(cx).use_smartcase_search
1559 && !query.is_empty()
1560 && self.search_options.contains(SearchOptions::CASE_SENSITIVE)
1561 != contains_uppercase(query)
1562 {
1563 self.toggle_search_option(SearchOptions::CASE_SENSITIVE, cx)
1564 }
1565 }
1566
1567 fn set_search_editor(
1568 &mut self,
1569 kind: SearchInputKind,
1570 text: &str,
1571 window: &mut Window,
1572 cx: &mut Context<Self>,
1573 ) {
1574 let editor = match kind {
1575 SearchInputKind::Query => &self.query_editor,
1576 SearchInputKind::Include => &self.included_files_editor,
1577
1578 SearchInputKind::Exclude => &self.excluded_files_editor,
1579 };
1580 editor.update(cx, |editor, cx| {
1581 editor.set_text(text, window, cx);
1582 editor.request_autoscroll(Autoscroll::fit(), cx);
1583 });
1584 }
1585
1586 fn focus_results_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1587 self.query_editor.update(cx, |query_editor, cx| {
1588 let cursor = query_editor.selections.newest_anchor().head();
1589 query_editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
1590 s.select_ranges([cursor..cursor])
1591 });
1592 });
1593 let results_handle = self.results_editor.focus_handle(cx);
1594 window.focus(&results_handle, cx);
1595 }
1596
1597 fn entity_changed(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1598 let match_ranges = self.entity.read(cx).match_ranges.clone();
1599
1600 if match_ranges.is_empty() {
1601 self.active_match_index = None;
1602 self.results_editor.update(cx, |editor, cx| {
1603 editor.clear_background_highlights(HighlightKey::ProjectSearchView, cx);
1604 });
1605 } else {
1606 self.active_match_index = Some(0);
1607 self.update_match_index(cx);
1608 let prev_search_id = mem::replace(&mut self.search_id, self.entity.read(cx).search_id);
1609 let is_new_search = self.search_id != prev_search_id;
1610 self.results_editor.update(cx, |editor, cx| {
1611 if is_new_search {
1612 let range_to_select = match_ranges
1613 .first()
1614 .map(|range| editor.range_for_match(range));
1615 editor.change_selections(Default::default(), window, cx, |s| {
1616 s.select_ranges(range_to_select)
1617 });
1618 editor.scroll(Point::default(), Some(Axis::Vertical), window, cx);
1619 }
1620 });
1621 if is_new_search && self.query_editor.focus_handle(cx).is_focused(window) {
1622 self.focus_results_editor(window, cx);
1623 }
1624 }
1625
1626 cx.emit(ViewEvent::UpdateTab);
1627 cx.notify();
1628
1629 if self.pending_replace_all && self.entity.read(cx).pending_search.is_none() {
1630 self.replace_all(&ReplaceAll, window, cx);
1631 }
1632 }
1633
1634 fn update_match_index(&mut self, cx: &mut Context<Self>) {
1635 let results_editor = self.results_editor.read(cx);
1636 let newest_anchor = results_editor.selections.newest_anchor().head();
1637 let buffer_snapshot = results_editor.buffer().read(cx).snapshot(cx);
1638 let new_index = self.entity.update(cx, |this, cx| {
1639 let new_index = active_match_index(
1640 Direction::Next,
1641 &this.match_ranges,
1642 &newest_anchor,
1643 &buffer_snapshot,
1644 );
1645
1646 self.highlight_matches(&this.match_ranges, new_index, cx);
1647 new_index
1648 });
1649
1650 if self.active_match_index != new_index {
1651 self.active_match_index = new_index;
1652 cx.notify();
1653 }
1654 }
1655
1656 #[ztracing::instrument(skip_all)]
1657 fn highlight_matches(
1658 &self,
1659 match_ranges: &[Range<Anchor>],
1660 active_index: Option<usize>,
1661 cx: &mut App,
1662 ) {
1663 self.results_editor.update(cx, |editor, cx| {
1664 editor.highlight_background(
1665 HighlightKey::ProjectSearchView,
1666 match_ranges,
1667 move |index, theme| {
1668 if active_index == Some(*index) {
1669 theme.colors().search_active_match_background
1670 } else {
1671 theme.colors().search_match_background
1672 }
1673 },
1674 cx,
1675 );
1676 });
1677 }
1678
1679 pub fn has_matches(&self) -> bool {
1680 self.active_match_index.is_some()
1681 }
1682
1683 fn landing_text_minor(&self, cx: &App) -> impl IntoElement {
1684 let focus_handle = self.focus_handle.clone();
1685 v_flex()
1686 .gap_1()
1687 .child(
1688 Label::new("Hit enter to search. For more options:")
1689 .color(Color::Muted)
1690 .mb_2(),
1691 )
1692 .child(
1693 Button::new("filter-paths", "Include/exclude specific paths")
1694 .start_icon(Icon::new(IconName::Filter).size(IconSize::Small))
1695 .key_binding(KeyBinding::for_action_in(&ToggleFilters, &focus_handle, cx))
1696 .on_click(|_event, window, cx| {
1697 window.dispatch_action(ToggleFilters.boxed_clone(), cx)
1698 }),
1699 )
1700 .child(
1701 Button::new("find-replace", "Find and replace")
1702 .start_icon(Icon::new(IconName::Replace).size(IconSize::Small))
1703 .key_binding(KeyBinding::for_action_in(&ToggleReplace, &focus_handle, cx))
1704 .on_click(|_event, window, cx| {
1705 window.dispatch_action(ToggleReplace.boxed_clone(), cx)
1706 }),
1707 )
1708 .child(
1709 Button::new("regex", "Match with regex")
1710 .start_icon(Icon::new(IconName::Regex).size(IconSize::Small))
1711 .key_binding(KeyBinding::for_action_in(&ToggleRegex, &focus_handle, cx))
1712 .on_click(|_event, window, cx| {
1713 window.dispatch_action(ToggleRegex.boxed_clone(), cx)
1714 }),
1715 )
1716 .child(
1717 Button::new("match-case", "Match case")
1718 .start_icon(Icon::new(IconName::CaseSensitive).size(IconSize::Small))
1719 .key_binding(KeyBinding::for_action_in(
1720 &ToggleCaseSensitive,
1721 &focus_handle,
1722 cx,
1723 ))
1724 .on_click(|_event, window, cx| {
1725 window.dispatch_action(ToggleCaseSensitive.boxed_clone(), cx)
1726 }),
1727 )
1728 .child(
1729 Button::new("match-whole-words", "Match whole words")
1730 .start_icon(Icon::new(IconName::WholeWord).size(IconSize::Small))
1731 .key_binding(KeyBinding::for_action_in(
1732 &ToggleWholeWord,
1733 &focus_handle,
1734 cx,
1735 ))
1736 .on_click(|_event, window, cx| {
1737 window.dispatch_action(ToggleWholeWord.boxed_clone(), cx)
1738 }),
1739 )
1740 }
1741
1742 fn border_color_for(&self, panel: InputPanel, cx: &App) -> Hsla {
1743 if self.panels_with_errors.contains_key(&panel) {
1744 Color::Error.color(cx)
1745 } else {
1746 cx.theme().colors().border
1747 }
1748 }
1749
1750 fn move_focus_to_results(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1751 if !self.results_editor.focus_handle(cx).is_focused(window)
1752 && !self.entity.read(cx).match_ranges.is_empty()
1753 {
1754 cx.stop_propagation();
1755 self.focus_results_editor(window, cx)
1756 }
1757 }
1758
1759 #[cfg(any(test, feature = "test-support"))]
1760 pub fn results_editor(&self) -> &Entity<Editor> {
1761 &self.results_editor
1762 }
1763
1764 fn adjust_query_regex_language(&self, cx: &mut App) {
1765 let enable = self.search_options.contains(SearchOptions::REGEX);
1766 let query_buffer = self
1767 .query_editor
1768 .read(cx)
1769 .buffer()
1770 .read(cx)
1771 .as_singleton()
1772 .expect("query editor should be backed by a singleton buffer");
1773 if enable {
1774 if let Some(regex_language) = self.regex_language.clone() {
1775 query_buffer.update(cx, |query_buffer, cx| {
1776 query_buffer.set_language(Some(regex_language), cx);
1777 })
1778 }
1779 } else {
1780 query_buffer.update(cx, |query_buffer, cx| {
1781 query_buffer.set_language(None, cx);
1782 })
1783 }
1784 }
1785}
1786
1787fn buffer_search_query(
1788 workspace: &mut Workspace,
1789 item: &dyn ItemHandle,
1790 cx: &mut Context<Workspace>,
1791) -> Option<String> {
1792 let buffer_search_bar = workspace
1793 .pane_for(item)
1794 .and_then(|pane| {
1795 pane.read(cx)
1796 .toolbar()
1797 .read(cx)
1798 .item_of_type::<BufferSearchBar>()
1799 })?
1800 .read(cx);
1801 if buffer_search_bar.query_editor_focused() {
1802 let buffer_search_query = buffer_search_bar.query(cx);
1803 if !buffer_search_query.is_empty() {
1804 return Some(buffer_search_query);
1805 }
1806 }
1807 None
1808}
1809
1810impl Default for ProjectSearchBar {
1811 fn default() -> Self {
1812 Self::new()
1813 }
1814}
1815
1816impl ProjectSearchBar {
1817 pub fn new() -> Self {
1818 Self {
1819 active_project_search: None,
1820 subscription: None,
1821 }
1822 }
1823
1824 fn confirm(&mut self, _: &Confirm, window: &mut Window, cx: &mut Context<Self>) {
1825 if let Some(search_view) = self.active_project_search.as_ref() {
1826 search_view.update(cx, |search_view, cx| {
1827 if !search_view
1828 .replacement_editor
1829 .focus_handle(cx)
1830 .is_focused(window)
1831 {
1832 cx.stop_propagation();
1833 search_view
1834 .prompt_to_save_if_dirty_then_search(window, cx)
1835 .detach_and_log_err(cx);
1836 }
1837 });
1838 }
1839 }
1840
1841 fn tab(&mut self, _: &Tab, window: &mut Window, cx: &mut Context<Self>) {
1842 self.cycle_field(Direction::Next, window, cx);
1843 }
1844
1845 fn backtab(&mut self, _: &Backtab, window: &mut Window, cx: &mut Context<Self>) {
1846 self.cycle_field(Direction::Prev, window, cx);
1847 }
1848
1849 fn focus_search(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1850 if let Some(search_view) = self.active_project_search.as_ref() {
1851 search_view.update(cx, |search_view, cx| {
1852 search_view.query_editor.focus_handle(cx).focus(window, cx);
1853 });
1854 }
1855 }
1856
1857 fn cycle_field(&mut self, direction: Direction, window: &mut Window, cx: &mut Context<Self>) {
1858 let active_project_search = match &self.active_project_search {
1859 Some(active_project_search) => active_project_search,
1860 None => return,
1861 };
1862
1863 active_project_search.update(cx, |project_view, cx| {
1864 let mut views = vec![project_view.query_editor.focus_handle(cx)];
1865 if project_view.replace_enabled {
1866 views.push(project_view.replacement_editor.focus_handle(cx));
1867 }
1868 if project_view.filters_enabled {
1869 views.extend([
1870 project_view.included_files_editor.focus_handle(cx),
1871 project_view.excluded_files_editor.focus_handle(cx),
1872 ]);
1873 }
1874 let current_index = match views.iter().position(|focus| focus.is_focused(window)) {
1875 Some(index) => index,
1876 None => return,
1877 };
1878
1879 let new_index = match direction {
1880 Direction::Next => (current_index + 1) % views.len(),
1881 Direction::Prev if current_index == 0 => views.len() - 1,
1882 Direction::Prev => (current_index - 1) % views.len(),
1883 };
1884 let next_focus_handle = &views[new_index];
1885 window.focus(next_focus_handle, cx);
1886 cx.stop_propagation();
1887 });
1888 }
1889
1890 pub(crate) fn toggle_search_option(
1891 &mut self,
1892 option: SearchOptions,
1893 window: &mut Window,
1894 cx: &mut Context<Self>,
1895 ) -> bool {
1896 if self.active_project_search.is_none() {
1897 return false;
1898 }
1899
1900 cx.spawn_in(window, async move |this, cx| {
1901 let task = this.update_in(cx, |this, window, cx| {
1902 let search_view = this.active_project_search.as_ref()?;
1903 search_view.update(cx, |search_view, cx| {
1904 search_view.toggle_search_option(option, cx);
1905 search_view
1906 .entity
1907 .read(cx)
1908 .active_query
1909 .is_some()
1910 .then(|| search_view.prompt_to_save_if_dirty_then_search(window, cx))
1911 })
1912 })?;
1913 if let Some(task) = task {
1914 task.await?;
1915 }
1916 this.update(cx, |_, cx| {
1917 cx.notify();
1918 })?;
1919 anyhow::Ok(())
1920 })
1921 .detach();
1922 true
1923 }
1924
1925 fn toggle_replace(&mut self, _: &ToggleReplace, window: &mut Window, cx: &mut Context<Self>) {
1926 if let Some(search) = &self.active_project_search {
1927 search.update(cx, |this, cx| {
1928 this.replace_enabled = !this.replace_enabled;
1929 let editor_to_focus = if this.replace_enabled {
1930 this.replacement_editor.focus_handle(cx)
1931 } else {
1932 this.query_editor.focus_handle(cx)
1933 };
1934 window.focus(&editor_to_focus, cx);
1935 cx.notify();
1936 });
1937 }
1938 }
1939
1940 fn toggle_filters(&mut self, window: &mut Window, cx: &mut Context<Self>) -> bool {
1941 if let Some(search_view) = self.active_project_search.as_ref() {
1942 search_view.update(cx, |search_view, cx| {
1943 search_view.toggle_filters(cx);
1944 search_view
1945 .included_files_editor
1946 .update(cx, |_, cx| cx.notify());
1947 search_view
1948 .excluded_files_editor
1949 .update(cx, |_, cx| cx.notify());
1950 window.refresh();
1951 cx.notify();
1952 });
1953 cx.notify();
1954 true
1955 } else {
1956 false
1957 }
1958 }
1959
1960 fn toggle_opened_only(&mut self, window: &mut Window, cx: &mut Context<Self>) -> bool {
1961 if self.active_project_search.is_none() {
1962 return false;
1963 }
1964
1965 cx.spawn_in(window, async move |this, cx| {
1966 let task = this.update_in(cx, |this, window, cx| {
1967 let search_view = this.active_project_search.as_ref()?;
1968 search_view.update(cx, |search_view, cx| {
1969 search_view.toggle_opened_only(window, cx);
1970 search_view
1971 .entity
1972 .read(cx)
1973 .active_query
1974 .is_some()
1975 .then(|| search_view.prompt_to_save_if_dirty_then_search(window, cx))
1976 })
1977 })?;
1978 if let Some(task) = task {
1979 task.await?;
1980 }
1981 this.update(cx, |_, cx| {
1982 cx.notify();
1983 })?;
1984 anyhow::Ok(())
1985 })
1986 .detach();
1987 true
1988 }
1989
1990 fn is_opened_only_enabled(&self, cx: &App) -> bool {
1991 if let Some(search_view) = self.active_project_search.as_ref() {
1992 search_view.read(cx).included_opened_only
1993 } else {
1994 false
1995 }
1996 }
1997
1998 fn move_focus_to_results(&self, window: &mut Window, cx: &mut Context<Self>) {
1999 if let Some(search_view) = self.active_project_search.as_ref() {
2000 search_view.update(cx, |search_view, cx| {
2001 search_view.move_focus_to_results(window, cx);
2002 });
2003 cx.notify();
2004 }
2005 }
2006
2007 fn next_history_query(
2008 &mut self,
2009 _: &NextHistoryQuery,
2010 window: &mut Window,
2011 cx: &mut Context<Self>,
2012 ) {
2013 if let Some(search_view) = self.active_project_search.as_ref() {
2014 search_view.update(cx, |search_view, cx| {
2015 for (editor, kind) in [
2016 (search_view.query_editor.clone(), SearchInputKind::Query),
2017 (
2018 search_view.included_files_editor.clone(),
2019 SearchInputKind::Include,
2020 ),
2021 (
2022 search_view.excluded_files_editor.clone(),
2023 SearchInputKind::Exclude,
2024 ),
2025 ] {
2026 if editor.focus_handle(cx).is_focused(window) {
2027 if !should_navigate_history(&editor, HistoryNavigationDirection::Next, cx) {
2028 cx.propagate();
2029 return;
2030 }
2031
2032 let new_query = search_view.entity.update(cx, |model, cx| {
2033 let project = model.project.clone();
2034
2035 if let Some(new_query) = project.update(cx, |project, _| {
2036 project
2037 .search_history_mut(kind)
2038 .next(model.cursor_mut(kind))
2039 .map(str::to_string)
2040 }) {
2041 Some(new_query)
2042 } else {
2043 model.cursor_mut(kind).take_draft()
2044 }
2045 });
2046 if let Some(new_query) = new_query {
2047 search_view.set_search_editor(kind, &new_query, window, cx);
2048 }
2049 }
2050 }
2051 });
2052 }
2053 }
2054
2055 fn previous_history_query(
2056 &mut self,
2057 _: &PreviousHistoryQuery,
2058 window: &mut Window,
2059 cx: &mut Context<Self>,
2060 ) {
2061 if let Some(search_view) = self.active_project_search.as_ref() {
2062 search_view.update(cx, |search_view, cx| {
2063 for (editor, kind) in [
2064 (search_view.query_editor.clone(), SearchInputKind::Query),
2065 (
2066 search_view.included_files_editor.clone(),
2067 SearchInputKind::Include,
2068 ),
2069 (
2070 search_view.excluded_files_editor.clone(),
2071 SearchInputKind::Exclude,
2072 ),
2073 ] {
2074 if editor.focus_handle(cx).is_focused(window) {
2075 if !should_navigate_history(
2076 &editor,
2077 HistoryNavigationDirection::Previous,
2078 cx,
2079 ) {
2080 cx.propagate();
2081 return;
2082 }
2083
2084 if editor.read(cx).text(cx).is_empty()
2085 && let Some(new_query) = search_view
2086 .entity
2087 .read(cx)
2088 .project
2089 .read(cx)
2090 .search_history(kind)
2091 .current(search_view.entity.read(cx).cursor(kind))
2092 .map(str::to_string)
2093 {
2094 search_view.set_search_editor(kind, &new_query, window, cx);
2095 return;
2096 }
2097
2098 let current_query = editor.read(cx).text(cx);
2099 if let Some(new_query) = search_view.entity.update(cx, |model, cx| {
2100 let project = model.project.clone();
2101 project.update(cx, |project, _| {
2102 project
2103 .search_history_mut(kind)
2104 .previous(model.cursor_mut(kind), ¤t_query)
2105 .map(str::to_string)
2106 })
2107 }) {
2108 search_view.set_search_editor(kind, &new_query, window, cx);
2109 }
2110 }
2111 }
2112 });
2113 }
2114 }
2115
2116 fn select_next_match(
2117 &mut self,
2118 _: &SelectNextMatch,
2119 window: &mut Window,
2120 cx: &mut Context<Self>,
2121 ) {
2122 if let Some(search) = self.active_project_search.as_ref() {
2123 search.update(cx, |this, cx| {
2124 this.select_match(Direction::Next, window, cx);
2125 })
2126 }
2127 }
2128
2129 fn select_prev_match(
2130 &mut self,
2131 _: &SelectPreviousMatch,
2132 window: &mut Window,
2133 cx: &mut Context<Self>,
2134 ) {
2135 if let Some(search) = self.active_project_search.as_ref() {
2136 search.update(cx, |this, cx| {
2137 this.select_match(Direction::Prev, window, cx);
2138 })
2139 }
2140 }
2141}
2142
2143impl Render for ProjectSearchBar {
2144 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
2145 let Some(search) = self.active_project_search.clone() else {
2146 return div().into_any_element();
2147 };
2148 let search = search.read(cx);
2149 let focus_handle = search.focus_handle(cx);
2150
2151 let container_width = window.viewport_size().width;
2152 let input_width = SearchInputWidth::calc_width(container_width);
2153
2154 let input_base_styles = |panel: InputPanel| {
2155 input_base_styles(search.border_color_for(panel, cx), |div| match panel {
2156 InputPanel::Query | InputPanel::Replacement => div.w(input_width),
2157 InputPanel::Include | InputPanel::Exclude => div.flex_grow(),
2158 })
2159 };
2160 let theme_colors = cx.theme().colors();
2161 let project_search = search.entity.read(cx);
2162 let limit_reached = project_search.limit_reached;
2163 let is_search_underway = project_search.pending_search.is_some();
2164
2165 let color_override = match (
2166 &project_search.pending_search,
2167 project_search.no_results,
2168 &project_search.active_query,
2169 &project_search.last_search_query_text,
2170 ) {
2171 (None, Some(true), Some(q), Some(p)) if q.as_str() == p => Some(Color::Error),
2172 _ => None,
2173 };
2174
2175 let match_text = search
2176 .active_match_index
2177 .and_then(|index| {
2178 let index = index + 1;
2179 let match_quantity = project_search.match_ranges.len();
2180 if match_quantity > 0 {
2181 debug_assert!(match_quantity >= index);
2182 if limit_reached {
2183 Some(format!("{index}/{match_quantity}+"))
2184 } else {
2185 Some(format!("{index}/{match_quantity}"))
2186 }
2187 } else {
2188 None
2189 }
2190 })
2191 .unwrap_or_else(|| "0/0".to_string());
2192
2193 let query_focus = search.query_editor.focus_handle(cx);
2194
2195 let query_column = input_base_styles(InputPanel::Query)
2196 .on_action(cx.listener(|this, action, window, cx| this.confirm(action, window, cx)))
2197 .on_action(cx.listener(|this, action, window, cx| {
2198 this.previous_history_query(action, window, cx)
2199 }))
2200 .on_action(
2201 cx.listener(|this, action, window, cx| this.next_history_query(action, window, cx)),
2202 )
2203 .child(div().flex_1().py_1().child(render_text_input(
2204 &search.query_editor,
2205 color_override,
2206 cx,
2207 )))
2208 .child(
2209 h_flex()
2210 .gap_1()
2211 .child(SearchOption::CaseSensitive.as_button(
2212 search.search_options,
2213 SearchSource::Project(cx),
2214 focus_handle.clone(),
2215 ))
2216 .child(SearchOption::WholeWord.as_button(
2217 search.search_options,
2218 SearchSource::Project(cx),
2219 focus_handle.clone(),
2220 ))
2221 .child(SearchOption::Regex.as_button(
2222 search.search_options,
2223 SearchSource::Project(cx),
2224 focus_handle.clone(),
2225 )),
2226 );
2227
2228 let matches_column = h_flex()
2229 .ml_1()
2230 .pl_1p5()
2231 .border_l_1()
2232 .border_color(theme_colors.border_variant)
2233 .child(render_action_button(
2234 "project-search-nav-button",
2235 IconName::ChevronLeft,
2236 search
2237 .active_match_index
2238 .is_none()
2239 .then_some(ActionButtonState::Disabled),
2240 "Select Previous Match",
2241 &SelectPreviousMatch,
2242 query_focus.clone(),
2243 ))
2244 .child(render_action_button(
2245 "project-search-nav-button",
2246 IconName::ChevronRight,
2247 search
2248 .active_match_index
2249 .is_none()
2250 .then_some(ActionButtonState::Disabled),
2251 "Select Next Match",
2252 &SelectNextMatch,
2253 query_focus.clone(),
2254 ))
2255 .child(
2256 div()
2257 .id("matches")
2258 .ml_2()
2259 .min_w(rems_from_px(40.))
2260 .child(
2261 h_flex()
2262 .gap_1p5()
2263 .child(
2264 Label::new(match_text)
2265 .size(LabelSize::Small)
2266 .when(search.active_match_index.is_some(), |this| {
2267 this.color(Color::Disabled)
2268 }),
2269 )
2270 .when(is_search_underway, |this| {
2271 this.child(
2272 Icon::new(IconName::ArrowCircle)
2273 .color(Color::Accent)
2274 .size(IconSize::Small)
2275 .with_rotate_animation(2)
2276 .into_any_element(),
2277 )
2278 }),
2279 )
2280 .when(limit_reached, |this| {
2281 this.tooltip(Tooltip::text(
2282 "Search Limits Reached\nTry narrowing your search",
2283 ))
2284 }),
2285 );
2286
2287 let mode_column = h_flex()
2288 .gap_1()
2289 .min_w_64()
2290 .child(
2291 IconButton::new("project-search-filter-button", IconName::Filter)
2292 .shape(IconButtonShape::Square)
2293 .tooltip(|_window, cx| {
2294 Tooltip::for_action("Toggle Filters", &ToggleFilters, cx)
2295 })
2296 .on_click(cx.listener(|this, _, window, cx| {
2297 this.toggle_filters(window, cx);
2298 }))
2299 .toggle_state(
2300 self.active_project_search
2301 .as_ref()
2302 .map(|search| search.read(cx).filters_enabled)
2303 .unwrap_or_default(),
2304 )
2305 .tooltip({
2306 let focus_handle = focus_handle.clone();
2307 move |_window, cx| {
2308 Tooltip::for_action_in(
2309 "Toggle Filters",
2310 &ToggleFilters,
2311 &focus_handle,
2312 cx,
2313 )
2314 }
2315 }),
2316 )
2317 .child(render_action_button(
2318 "project-search",
2319 IconName::Replace,
2320 self.active_project_search
2321 .as_ref()
2322 .map(|search| search.read(cx).replace_enabled)
2323 .and_then(|enabled| enabled.then_some(ActionButtonState::Toggled)),
2324 "Toggle Replace",
2325 &ToggleReplace,
2326 focus_handle.clone(),
2327 ))
2328 .child(matches_column);
2329
2330 let is_collapsed = search.results_editor.read(cx).has_any_buffer_folded(cx);
2331
2332 let (icon, tooltip_label) = if is_collapsed {
2333 (IconName::ChevronUpDown, "Expand All Search Results")
2334 } else {
2335 (IconName::ChevronDownUp, "Collapse All Search Results")
2336 };
2337
2338 let expand_button = IconButton::new("project-search-collapse-expand", icon)
2339 .shape(IconButtonShape::Square)
2340 .tooltip(move |_, cx| {
2341 Tooltip::for_action_in(
2342 tooltip_label,
2343 &ToggleAllSearchResults,
2344 &query_focus.clone(),
2345 cx,
2346 )
2347 })
2348 .on_click(cx.listener(|this, _, window, cx| {
2349 if let Some(active_view) = &this.active_project_search {
2350 active_view.update(cx, |active_view, cx| {
2351 active_view.toggle_all_search_results(&ToggleAllSearchResults, window, cx);
2352 })
2353 }
2354 }));
2355
2356 let search_line = h_flex()
2357 .pl_0p5()
2358 .w_full()
2359 .gap_2()
2360 .child(expand_button)
2361 .child(query_column)
2362 .child(mode_column);
2363
2364 let replace_line = search.replace_enabled.then(|| {
2365 let replace_column = input_base_styles(InputPanel::Replacement).child(
2366 div().flex_1().py_1().child(render_text_input(
2367 &search.replacement_editor,
2368 None,
2369 cx,
2370 )),
2371 );
2372
2373 let focus_handle = search.replacement_editor.read(cx).focus_handle(cx);
2374 let replace_actions = h_flex()
2375 .min_w_64()
2376 .gap_1()
2377 .child(render_action_button(
2378 "project-search-replace-button",
2379 IconName::ReplaceNext,
2380 is_search_underway.then_some(ActionButtonState::Disabled),
2381 "Replace Next Match",
2382 &ReplaceNext,
2383 focus_handle.clone(),
2384 ))
2385 .child(render_action_button(
2386 "project-search-replace-button",
2387 IconName::ReplaceAll,
2388 Default::default(),
2389 "Replace All Matches",
2390 &ReplaceAll,
2391 focus_handle,
2392 ));
2393
2394 h_flex()
2395 .w_full()
2396 .gap_2()
2397 .child(alignment_element())
2398 .child(replace_column)
2399 .child(replace_actions)
2400 });
2401
2402 let filter_line = search.filters_enabled.then(|| {
2403 let include = input_base_styles(InputPanel::Include)
2404 .on_action(cx.listener(|this, action, window, cx| {
2405 this.previous_history_query(action, window, cx)
2406 }))
2407 .on_action(cx.listener(|this, action, window, cx| {
2408 this.next_history_query(action, window, cx)
2409 }))
2410 .child(render_text_input(&search.included_files_editor, None, cx));
2411 let exclude = input_base_styles(InputPanel::Exclude)
2412 .on_action(cx.listener(|this, action, window, cx| {
2413 this.previous_history_query(action, window, cx)
2414 }))
2415 .on_action(cx.listener(|this, action, window, cx| {
2416 this.next_history_query(action, window, cx)
2417 }))
2418 .child(render_text_input(&search.excluded_files_editor, None, cx));
2419 let mode_column = h_flex()
2420 .gap_1()
2421 .min_w_64()
2422 .child(
2423 IconButton::new("project-search-opened-only", IconName::FolderSearch)
2424 .shape(IconButtonShape::Square)
2425 .toggle_state(self.is_opened_only_enabled(cx))
2426 .tooltip(Tooltip::text("Only Search Open Files"))
2427 .on_click(cx.listener(|this, _, window, cx| {
2428 this.toggle_opened_only(window, cx);
2429 })),
2430 )
2431 .child(SearchOption::IncludeIgnored.as_button(
2432 search.search_options,
2433 SearchSource::Project(cx),
2434 focus_handle,
2435 ));
2436
2437 h_flex()
2438 .w_full()
2439 .gap_2()
2440 .child(alignment_element())
2441 .child(
2442 h_flex()
2443 .w(input_width)
2444 .gap_2()
2445 .child(include)
2446 .child(exclude),
2447 )
2448 .child(mode_column)
2449 });
2450
2451 let mut key_context = KeyContext::default();
2452 key_context.add("ProjectSearchBar");
2453 if search
2454 .replacement_editor
2455 .focus_handle(cx)
2456 .is_focused(window)
2457 {
2458 key_context.add("in_replace");
2459 }
2460
2461 let query_error_line = search
2462 .panels_with_errors
2463 .get(&InputPanel::Query)
2464 .map(|error| {
2465 Label::new(error)
2466 .size(LabelSize::Small)
2467 .color(Color::Error)
2468 .mt_neg_1()
2469 .ml_2()
2470 });
2471
2472 let filter_error_line = search
2473 .panels_with_errors
2474 .get(&InputPanel::Include)
2475 .or_else(|| search.panels_with_errors.get(&InputPanel::Exclude))
2476 .map(|error| {
2477 Label::new(error)
2478 .size(LabelSize::Small)
2479 .color(Color::Error)
2480 .mt_neg_1()
2481 .ml_2()
2482 });
2483
2484 v_flex()
2485 .gap_2()
2486 .w_full()
2487 .key_context(key_context)
2488 .on_action(cx.listener(|this, _: &ToggleFocus, window, cx| {
2489 this.move_focus_to_results(window, cx)
2490 }))
2491 .on_action(cx.listener(|this, _: &ToggleFilters, window, cx| {
2492 this.toggle_filters(window, cx);
2493 }))
2494 .capture_action(cx.listener(Self::tab))
2495 .capture_action(cx.listener(Self::backtab))
2496 .on_action(cx.listener(|this, action, window, cx| this.confirm(action, window, cx)))
2497 .on_action(cx.listener(|this, action, window, cx| {
2498 this.toggle_replace(action, window, cx);
2499 }))
2500 .on_action(cx.listener(|this, _: &ToggleWholeWord, window, cx| {
2501 this.toggle_search_option(SearchOptions::WHOLE_WORD, window, cx);
2502 }))
2503 .on_action(cx.listener(|this, _: &ToggleCaseSensitive, window, cx| {
2504 this.toggle_search_option(SearchOptions::CASE_SENSITIVE, window, cx);
2505 }))
2506 .on_action(cx.listener(|this, action, window, cx| {
2507 if let Some(search) = this.active_project_search.as_ref() {
2508 search.update(cx, |this, cx| {
2509 this.replace_next(action, window, cx);
2510 })
2511 }
2512 }))
2513 .on_action(cx.listener(|this, action, window, cx| {
2514 if let Some(search) = this.active_project_search.as_ref() {
2515 search.update(cx, |this, cx| {
2516 this.replace_all(action, window, cx);
2517 })
2518 }
2519 }))
2520 .when(search.filters_enabled, |this| {
2521 this.on_action(cx.listener(|this, _: &ToggleIncludeIgnored, window, cx| {
2522 this.toggle_search_option(SearchOptions::INCLUDE_IGNORED, window, cx);
2523 }))
2524 })
2525 .on_action(cx.listener(Self::select_next_match))
2526 .on_action(cx.listener(Self::select_prev_match))
2527 .child(search_line)
2528 .children(query_error_line)
2529 .children(replace_line)
2530 .children(filter_line)
2531 .children(filter_error_line)
2532 .into_any_element()
2533 }
2534}
2535
2536impl EventEmitter<ToolbarItemEvent> for ProjectSearchBar {}
2537
2538impl ToolbarItemView for ProjectSearchBar {
2539 fn set_active_pane_item(
2540 &mut self,
2541 active_pane_item: Option<&dyn ItemHandle>,
2542 _: &mut Window,
2543 cx: &mut Context<Self>,
2544 ) -> ToolbarItemLocation {
2545 cx.notify();
2546 self.subscription = None;
2547 self.active_project_search = None;
2548 if let Some(search) = active_pane_item.and_then(|i| i.downcast::<ProjectSearchView>()) {
2549 self.subscription = Some(cx.observe(&search, |_, _, cx| cx.notify()));
2550 self.active_project_search = Some(search);
2551 ToolbarItemLocation::PrimaryLeft {}
2552 } else {
2553 ToolbarItemLocation::Hidden
2554 }
2555 }
2556}
2557
2558fn register_workspace_action<A: Action>(
2559 workspace: &mut Workspace,
2560 callback: fn(&mut ProjectSearchBar, &A, &mut Window, &mut Context<ProjectSearchBar>),
2561) {
2562 workspace.register_action(move |workspace, action: &A, window, cx| {
2563 if workspace.has_active_modal(window, cx) && !workspace.hide_modal(window, cx) {
2564 cx.propagate();
2565 return;
2566 }
2567
2568 workspace.active_pane().update(cx, |pane, cx| {
2569 pane.toolbar().update(cx, move |workspace, cx| {
2570 if let Some(search_bar) = workspace.item_of_type::<ProjectSearchBar>() {
2571 search_bar.update(cx, move |search_bar, cx| {
2572 if search_bar.active_project_search.is_some() {
2573 callback(search_bar, action, window, cx);
2574 cx.notify();
2575 } else {
2576 cx.propagate();
2577 }
2578 });
2579 }
2580 });
2581 })
2582 });
2583}
2584
2585fn register_workspace_action_for_present_search<A: Action>(
2586 workspace: &mut Workspace,
2587 callback: fn(&mut Workspace, &A, &mut Window, &mut Context<Workspace>),
2588) {
2589 workspace.register_action(move |workspace, action: &A, window, cx| {
2590 if workspace.has_active_modal(window, cx) && !workspace.hide_modal(window, cx) {
2591 cx.propagate();
2592 return;
2593 }
2594
2595 let should_notify = workspace
2596 .active_pane()
2597 .read(cx)
2598 .toolbar()
2599 .read(cx)
2600 .item_of_type::<ProjectSearchBar>()
2601 .map(|search_bar| search_bar.read(cx).active_project_search.is_some())
2602 .unwrap_or(false);
2603 if should_notify {
2604 callback(workspace, action, window, cx);
2605 cx.notify();
2606 } else {
2607 cx.propagate();
2608 }
2609 });
2610}
2611
2612#[cfg(any(test, feature = "test-support"))]
2613pub fn perform_project_search(
2614 search_view: &Entity<ProjectSearchView>,
2615 text: impl Into<std::sync::Arc<str>>,
2616 cx: &mut gpui::VisualTestContext,
2617) {
2618 cx.run_until_parked();
2619 search_view.update_in(cx, |search_view, window, cx| {
2620 search_view.query_editor.update(cx, |query_editor, cx| {
2621 query_editor.set_text(text, window, cx)
2622 });
2623 search_view.search(cx);
2624 });
2625 cx.run_until_parked();
2626}
2627
2628#[cfg(test)]
2629pub mod tests {
2630 use std::{
2631 path::PathBuf,
2632 sync::{
2633 Arc,
2634 atomic::{self, AtomicUsize},
2635 },
2636 time::Duration,
2637 };
2638
2639 use super::*;
2640 use editor::{DisplayPoint, display_map::DisplayRow};
2641 use gpui::{Action, TestAppContext, VisualTestContext, WindowHandle};
2642 use language::{FakeLspAdapter, rust_lang};
2643 use pretty_assertions::assert_eq;
2644 use project::{FakeFs, Fs};
2645 use serde_json::json;
2646 use settings::{
2647 InlayHintSettingsContent, SettingsStore, ThemeColorsContent, ThemeStyleContent,
2648 };
2649 use util::{path, paths::PathStyle, rel_path::rel_path};
2650 use util_macros::perf;
2651 use workspace::{DeploySearch, MultiWorkspace};
2652
2653 #[test]
2654 fn test_split_glob_patterns() {
2655 assert_eq!(split_glob_patterns("a,b,c"), vec!["a", "b", "c"]);
2656 assert_eq!(split_glob_patterns("a, b, c"), vec!["a", " b", " c"]);
2657 assert_eq!(
2658 split_glob_patterns("src/{a,b}/**/*.rs"),
2659 vec!["src/{a,b}/**/*.rs"]
2660 );
2661 assert_eq!(
2662 split_glob_patterns("src/{a,b}/*.rs, tests/**/*.rs"),
2663 vec!["src/{a,b}/*.rs", " tests/**/*.rs"]
2664 );
2665 assert_eq!(split_glob_patterns("{a,b},{c,d}"), vec!["{a,b}", "{c,d}"]);
2666 assert_eq!(split_glob_patterns("{{a,b},{c,d}}"), vec!["{{a,b},{c,d}}"]);
2667 assert_eq!(split_glob_patterns(""), vec![""]);
2668 assert_eq!(split_glob_patterns("a"), vec!["a"]);
2669 // Escaped characters should not be treated as special
2670 assert_eq!(split_glob_patterns(r"a\,b,c"), vec![r"a\,b", "c"]);
2671 assert_eq!(split_glob_patterns(r"\{a,b\}"), vec![r"\{a", r"b\}"]);
2672 assert_eq!(split_glob_patterns(r"a\\,b"), vec![r"a\\", "b"]);
2673 assert_eq!(split_glob_patterns(r"a\\\,b"), vec![r"a\\\,b"]);
2674 }
2675
2676 #[perf]
2677 #[gpui::test]
2678 async fn test_project_search(cx: &mut TestAppContext) {
2679 fn dp(row: u32, col: u32) -> DisplayPoint {
2680 DisplayPoint::new(DisplayRow(row), col)
2681 }
2682
2683 fn assert_active_match_index(
2684 search_view: &WindowHandle<ProjectSearchView>,
2685 cx: &mut TestAppContext,
2686 expected_index: usize,
2687 ) {
2688 search_view
2689 .update(cx, |search_view, _window, _cx| {
2690 assert_eq!(search_view.active_match_index, Some(expected_index));
2691 })
2692 .unwrap();
2693 }
2694
2695 fn assert_selection_range(
2696 search_view: &WindowHandle<ProjectSearchView>,
2697 cx: &mut TestAppContext,
2698 expected_range: Range<DisplayPoint>,
2699 ) {
2700 search_view
2701 .update(cx, |search_view, _window, cx| {
2702 assert_eq!(
2703 search_view.results_editor.update(cx, |editor, cx| editor
2704 .selections
2705 .display_ranges(&editor.display_snapshot(cx))),
2706 [expected_range]
2707 );
2708 })
2709 .unwrap();
2710 }
2711
2712 fn assert_highlights(
2713 search_view: &WindowHandle<ProjectSearchView>,
2714 cx: &mut TestAppContext,
2715 expected_highlights: Vec<(Range<DisplayPoint>, &str)>,
2716 ) {
2717 search_view
2718 .update(cx, |search_view, window, cx| {
2719 let match_bg = cx.theme().colors().search_match_background;
2720 let active_match_bg = cx.theme().colors().search_active_match_background;
2721 let selection_bg = cx
2722 .theme()
2723 .colors()
2724 .editor_document_highlight_bracket_background;
2725
2726 let highlights: Vec<_> = expected_highlights
2727 .into_iter()
2728 .map(|(range, color_type)| {
2729 let color = match color_type {
2730 "active" => active_match_bg,
2731 "match" => match_bg,
2732 "selection" => selection_bg,
2733 _ => panic!("Unknown color type"),
2734 };
2735 (range, color)
2736 })
2737 .collect();
2738
2739 assert_eq!(
2740 search_view.results_editor.update(cx, |editor, cx| editor
2741 .all_text_background_highlights(window, cx)),
2742 highlights.as_slice()
2743 );
2744 })
2745 .unwrap();
2746 }
2747
2748 fn select_match(
2749 search_view: &WindowHandle<ProjectSearchView>,
2750 cx: &mut TestAppContext,
2751 direction: Direction,
2752 ) {
2753 search_view
2754 .update(cx, |search_view, window, cx| {
2755 search_view.select_match(direction, window, cx);
2756 })
2757 .unwrap();
2758 }
2759
2760 init_test(cx);
2761
2762 // Override active search match color since the fallback theme uses the same color
2763 // for normal search match and active one, which can make this test less robust.
2764 cx.update(|cx| {
2765 SettingsStore::update_global(cx, |settings, cx| {
2766 settings.update_user_settings(cx, |settings| {
2767 settings.theme.experimental_theme_overrides = Some(ThemeStyleContent {
2768 colors: ThemeColorsContent {
2769 search_active_match_background: Some("#ff0000ff".to_string()),
2770 ..Default::default()
2771 },
2772 ..Default::default()
2773 });
2774 });
2775 });
2776 });
2777
2778 let fs = FakeFs::new(cx.background_executor.clone());
2779 fs.insert_tree(
2780 path!("/dir"),
2781 json!({
2782 "one.rs": "const ONE: usize = 1;",
2783 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
2784 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
2785 "four.rs": "const FOUR: usize = one::ONE + three::THREE;",
2786 }),
2787 )
2788 .await;
2789 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
2790 let window =
2791 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
2792 let workspace = window
2793 .read_with(cx, |mw, _| mw.workspace().clone())
2794 .unwrap();
2795 let search = cx.new(|cx| ProjectSearch::new(project.clone(), cx));
2796 let search_view = cx.add_window(|window, cx| {
2797 ProjectSearchView::new(workspace.downgrade(), search.clone(), window, cx, None)
2798 });
2799
2800 perform_search(search_view, "TWO", cx);
2801 cx.run_until_parked();
2802
2803 search_view
2804 .update(cx, |search_view, _window, cx| {
2805 assert_eq!(
2806 search_view
2807 .results_editor
2808 .update(cx, |editor, cx| editor.display_text(cx)),
2809 "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;"
2810 );
2811 })
2812 .unwrap();
2813
2814 assert_active_match_index(&search_view, cx, 0);
2815 assert_selection_range(&search_view, cx, dp(2, 32)..dp(2, 35));
2816 assert_highlights(
2817 &search_view,
2818 cx,
2819 vec![
2820 (dp(2, 32)..dp(2, 35), "active"),
2821 (dp(2, 37)..dp(2, 40), "selection"),
2822 (dp(2, 37)..dp(2, 40), "match"),
2823 (dp(5, 6)..dp(5, 9), "selection"),
2824 (dp(5, 6)..dp(5, 9), "match"),
2825 ],
2826 );
2827 select_match(&search_view, cx, Direction::Next);
2828 cx.run_until_parked();
2829
2830 assert_active_match_index(&search_view, cx, 1);
2831 assert_selection_range(&search_view, cx, dp(2, 37)..dp(2, 40));
2832 assert_highlights(
2833 &search_view,
2834 cx,
2835 vec![
2836 (dp(2, 32)..dp(2, 35), "selection"),
2837 (dp(2, 32)..dp(2, 35), "match"),
2838 (dp(2, 37)..dp(2, 40), "active"),
2839 (dp(5, 6)..dp(5, 9), "selection"),
2840 (dp(5, 6)..dp(5, 9), "match"),
2841 ],
2842 );
2843 select_match(&search_view, cx, Direction::Next);
2844 cx.run_until_parked();
2845
2846 assert_active_match_index(&search_view, cx, 2);
2847 assert_selection_range(&search_view, cx, dp(5, 6)..dp(5, 9));
2848 assert_highlights(
2849 &search_view,
2850 cx,
2851 vec![
2852 (dp(2, 32)..dp(2, 35), "selection"),
2853 (dp(2, 32)..dp(2, 35), "match"),
2854 (dp(2, 37)..dp(2, 40), "selection"),
2855 (dp(2, 37)..dp(2, 40), "match"),
2856 (dp(5, 6)..dp(5, 9), "active"),
2857 ],
2858 );
2859 select_match(&search_view, cx, Direction::Next);
2860 cx.run_until_parked();
2861
2862 assert_active_match_index(&search_view, cx, 0);
2863 assert_selection_range(&search_view, cx, dp(2, 32)..dp(2, 35));
2864 assert_highlights(
2865 &search_view,
2866 cx,
2867 vec![
2868 (dp(2, 32)..dp(2, 35), "active"),
2869 (dp(2, 37)..dp(2, 40), "selection"),
2870 (dp(2, 37)..dp(2, 40), "match"),
2871 (dp(5, 6)..dp(5, 9), "selection"),
2872 (dp(5, 6)..dp(5, 9), "match"),
2873 ],
2874 );
2875 select_match(&search_view, cx, Direction::Prev);
2876 cx.run_until_parked();
2877
2878 assert_active_match_index(&search_view, cx, 2);
2879 assert_selection_range(&search_view, cx, dp(5, 6)..dp(5, 9));
2880 assert_highlights(
2881 &search_view,
2882 cx,
2883 vec![
2884 (dp(2, 32)..dp(2, 35), "selection"),
2885 (dp(2, 32)..dp(2, 35), "match"),
2886 (dp(2, 37)..dp(2, 40), "selection"),
2887 (dp(2, 37)..dp(2, 40), "match"),
2888 (dp(5, 6)..dp(5, 9), "active"),
2889 ],
2890 );
2891 select_match(&search_view, cx, Direction::Prev);
2892 cx.run_until_parked();
2893
2894 assert_active_match_index(&search_view, cx, 1);
2895 assert_selection_range(&search_view, cx, dp(2, 37)..dp(2, 40));
2896 assert_highlights(
2897 &search_view,
2898 cx,
2899 vec![
2900 (dp(2, 32)..dp(2, 35), "selection"),
2901 (dp(2, 32)..dp(2, 35), "match"),
2902 (dp(2, 37)..dp(2, 40), "active"),
2903 (dp(5, 6)..dp(5, 9), "selection"),
2904 (dp(5, 6)..dp(5, 9), "match"),
2905 ],
2906 );
2907 search_view
2908 .update(cx, |search_view, window, cx| {
2909 search_view.results_editor.update(cx, |editor, cx| {
2910 editor.fold_all(&FoldAll, window, cx);
2911 })
2912 })
2913 .expect("Should fold fine");
2914 cx.run_until_parked();
2915
2916 let results_collapsed = search_view
2917 .read_with(cx, |search_view, cx| {
2918 search_view
2919 .results_editor
2920 .read(cx)
2921 .has_any_buffer_folded(cx)
2922 })
2923 .expect("got results_collapsed");
2924
2925 assert!(results_collapsed);
2926 search_view
2927 .update(cx, |search_view, window, cx| {
2928 search_view.results_editor.update(cx, |editor, cx| {
2929 editor.unfold_all(&UnfoldAll, window, cx);
2930 })
2931 })
2932 .expect("Should unfold fine");
2933 cx.run_until_parked();
2934
2935 let results_collapsed = search_view
2936 .read_with(cx, |search_view, cx| {
2937 search_view
2938 .results_editor
2939 .read(cx)
2940 .has_any_buffer_folded(cx)
2941 })
2942 .expect("got results_collapsed");
2943
2944 assert!(!results_collapsed);
2945 }
2946
2947 #[perf]
2948 #[gpui::test]
2949 async fn test_collapse_state_syncs_after_manual_buffer_fold(cx: &mut TestAppContext) {
2950 init_test(cx);
2951
2952 let fs = FakeFs::new(cx.background_executor.clone());
2953 fs.insert_tree(
2954 path!("/dir"),
2955 json!({
2956 "one.rs": "const ONE: usize = 1;",
2957 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
2958 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
2959 }),
2960 )
2961 .await;
2962 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
2963 let window =
2964 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
2965 let workspace = window
2966 .read_with(cx, |mw, _| mw.workspace().clone())
2967 .unwrap();
2968 let search = cx.new(|cx| ProjectSearch::new(project.clone(), cx));
2969 let search_view = cx.add_window(|window, cx| {
2970 ProjectSearchView::new(workspace.downgrade(), search.clone(), window, cx, None)
2971 });
2972
2973 // Search for "ONE" which appears in all 3 files
2974 perform_search(search_view, "ONE", cx);
2975
2976 // Verify initial state: no folds
2977 let has_any_folded = search_view
2978 .read_with(cx, |search_view, cx| {
2979 search_view
2980 .results_editor
2981 .read(cx)
2982 .has_any_buffer_folded(cx)
2983 })
2984 .expect("should read state");
2985 assert!(!has_any_folded, "No buffers should be folded initially");
2986
2987 // Fold all via fold_all
2988 search_view
2989 .update(cx, |search_view, window, cx| {
2990 search_view.results_editor.update(cx, |editor, cx| {
2991 editor.fold_all(&FoldAll, window, cx);
2992 })
2993 })
2994 .expect("Should fold fine");
2995 cx.run_until_parked();
2996
2997 let has_any_folded = search_view
2998 .read_with(cx, |search_view, cx| {
2999 search_view
3000 .results_editor
3001 .read(cx)
3002 .has_any_buffer_folded(cx)
3003 })
3004 .expect("should read state");
3005 assert!(
3006 has_any_folded,
3007 "All buffers should be folded after fold_all"
3008 );
3009
3010 // Manually unfold one buffer (simulating a chevron click)
3011 let first_buffer_id = search_view
3012 .read_with(cx, |search_view, cx| {
3013 search_view
3014 .results_editor
3015 .read(cx)
3016 .buffer()
3017 .read(cx)
3018 .snapshot(cx)
3019 .excerpts()
3020 .next()
3021 .unwrap()
3022 .context
3023 .start
3024 .buffer_id
3025 })
3026 .expect("should read buffer ids");
3027
3028 search_view
3029 .update(cx, |search_view, _window, cx| {
3030 search_view.results_editor.update(cx, |editor, cx| {
3031 editor.unfold_buffer(first_buffer_id, cx);
3032 })
3033 })
3034 .expect("Should unfold one buffer");
3035
3036 let has_any_folded = search_view
3037 .read_with(cx, |search_view, cx| {
3038 search_view
3039 .results_editor
3040 .read(cx)
3041 .has_any_buffer_folded(cx)
3042 })
3043 .expect("should read state");
3044 assert!(
3045 has_any_folded,
3046 "Should still report folds when only one buffer is unfolded"
3047 );
3048
3049 // Unfold all via unfold_all
3050 search_view
3051 .update(cx, |search_view, window, cx| {
3052 search_view.results_editor.update(cx, |editor, cx| {
3053 editor.unfold_all(&UnfoldAll, window, cx);
3054 })
3055 })
3056 .expect("Should unfold fine");
3057 cx.run_until_parked();
3058
3059 let has_any_folded = search_view
3060 .read_with(cx, |search_view, cx| {
3061 search_view
3062 .results_editor
3063 .read(cx)
3064 .has_any_buffer_folded(cx)
3065 })
3066 .expect("should read state");
3067 assert!(!has_any_folded, "No folds should remain after unfold_all");
3068
3069 // Manually fold one buffer back (simulating a chevron click)
3070 search_view
3071 .update(cx, |search_view, _window, cx| {
3072 search_view.results_editor.update(cx, |editor, cx| {
3073 editor.fold_buffer(first_buffer_id, cx);
3074 })
3075 })
3076 .expect("Should fold one buffer");
3077
3078 let has_any_folded = search_view
3079 .read_with(cx, |search_view, cx| {
3080 search_view
3081 .results_editor
3082 .read(cx)
3083 .has_any_buffer_folded(cx)
3084 })
3085 .expect("should read state");
3086 assert!(
3087 has_any_folded,
3088 "Should report folds after manually folding one buffer"
3089 );
3090 }
3091
3092 #[perf]
3093 #[gpui::test]
3094 async fn test_deploy_project_search_focus(cx: &mut TestAppContext) {
3095 init_test(cx);
3096
3097 let fs = FakeFs::new(cx.background_executor.clone());
3098 fs.insert_tree(
3099 "/dir",
3100 json!({
3101 "one.rs": "const ONE: usize = 1;",
3102 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
3103 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
3104 "four.rs": "const FOUR: usize = one::ONE + three::THREE;",
3105 }),
3106 )
3107 .await;
3108 let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
3109 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
3110 let workspace = window
3111 .read_with(cx, |mw, _| mw.workspace().clone())
3112 .unwrap();
3113 let cx = &mut VisualTestContext::from_window(window.into(), cx);
3114 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
3115
3116 let active_item = cx.read(|cx| {
3117 workspace
3118 .read(cx)
3119 .active_pane()
3120 .read(cx)
3121 .active_item()
3122 .and_then(|item| item.downcast::<ProjectSearchView>())
3123 });
3124 assert!(
3125 active_item.is_none(),
3126 "Expected no search panel to be active"
3127 );
3128
3129 workspace.update_in(cx, move |workspace, window, cx| {
3130 assert_eq!(workspace.panes().len(), 1);
3131 workspace.panes()[0].update(cx, |pane, cx| {
3132 pane.toolbar()
3133 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
3134 });
3135
3136 ProjectSearchView::deploy_search(
3137 workspace,
3138 &workspace::DeploySearch::default(),
3139 window,
3140 cx,
3141 )
3142 });
3143
3144 let Some(search_view) = cx.read(|cx| {
3145 workspace
3146 .read(cx)
3147 .active_pane()
3148 .read(cx)
3149 .active_item()
3150 .and_then(|item| item.downcast::<ProjectSearchView>())
3151 }) else {
3152 panic!("Search view expected to appear after new search event trigger")
3153 };
3154
3155 cx.spawn(|mut cx| async move {
3156 window
3157 .update(&mut cx, |_, window, cx| {
3158 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3159 })
3160 .unwrap();
3161 })
3162 .detach();
3163 cx.background_executor.run_until_parked();
3164 window
3165 .update(cx, |_, window, cx| {
3166 search_view.update(cx, |search_view, cx| {
3167 assert!(
3168 search_view.query_editor.focus_handle(cx).is_focused(window),
3169 "Empty search view should be focused after the toggle focus event: no results panel to focus on",
3170 );
3171 });
3172 }).unwrap();
3173
3174 window
3175 .update(cx, |_, window, cx| {
3176 search_view.update(cx, |search_view, cx| {
3177 let query_editor = &search_view.query_editor;
3178 assert!(
3179 query_editor.focus_handle(cx).is_focused(window),
3180 "Search view should be focused after the new search view is activated",
3181 );
3182 let query_text = query_editor.read(cx).text(cx);
3183 assert!(
3184 query_text.is_empty(),
3185 "New search query should be empty but got '{query_text}'",
3186 );
3187 let results_text = search_view
3188 .results_editor
3189 .update(cx, |editor, cx| editor.display_text(cx));
3190 assert!(
3191 results_text.is_empty(),
3192 "Empty search view should have no results but got '{results_text}'"
3193 );
3194 });
3195 })
3196 .unwrap();
3197
3198 window
3199 .update(cx, |_, window, cx| {
3200 search_view.update(cx, |search_view, cx| {
3201 search_view.query_editor.update(cx, |query_editor, cx| {
3202 query_editor.set_text("sOMETHINGtHATsURELYdOESnOTeXIST", window, cx)
3203 });
3204 search_view.search(cx);
3205 });
3206 })
3207 .unwrap();
3208 cx.background_executor.run_until_parked();
3209 window
3210 .update(cx, |_, window, cx| {
3211 search_view.update(cx, |search_view, cx| {
3212 let results_text = search_view
3213 .results_editor
3214 .update(cx, |editor, cx| editor.display_text(cx));
3215 assert!(
3216 results_text.is_empty(),
3217 "Search view for mismatching query should have no results but got '{results_text}'"
3218 );
3219 assert!(
3220 search_view.query_editor.focus_handle(cx).is_focused(window),
3221 "Search view should be focused after mismatching query had been used in search",
3222 );
3223 });
3224 }).unwrap();
3225
3226 cx.spawn(|mut cx| async move {
3227 window.update(&mut cx, |_, window, cx| {
3228 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3229 })
3230 })
3231 .detach();
3232 cx.background_executor.run_until_parked();
3233 window.update(cx, |_, window, cx| {
3234 search_view.update(cx, |search_view, cx| {
3235 assert!(
3236 search_view.query_editor.focus_handle(cx).is_focused(window),
3237 "Search view with mismatching query should be focused after the toggle focus event: still no results panel to focus on",
3238 );
3239 });
3240 }).unwrap();
3241
3242 window
3243 .update(cx, |_, window, cx| {
3244 search_view.update(cx, |search_view, cx| {
3245 search_view.query_editor.update(cx, |query_editor, cx| {
3246 query_editor.set_text("TWO", window, cx)
3247 });
3248 search_view.search(cx);
3249 });
3250 })
3251 .unwrap();
3252 cx.background_executor.run_until_parked();
3253 window.update(cx, |_, window, cx| {
3254 search_view.update(cx, |search_view, cx| {
3255 assert_eq!(
3256 search_view
3257 .results_editor
3258 .update(cx, |editor, cx| editor.display_text(cx)),
3259 "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;",
3260 "Search view results should match the query"
3261 );
3262 assert!(
3263 search_view.results_editor.focus_handle(cx).is_focused(window),
3264 "Search view with mismatching query should be focused after search results are available",
3265 );
3266 });
3267 }).unwrap();
3268 cx.spawn(|mut cx| async move {
3269 window
3270 .update(&mut cx, |_, window, cx| {
3271 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3272 })
3273 .unwrap();
3274 })
3275 .detach();
3276 cx.background_executor.run_until_parked();
3277 window.update(cx, |_, window, cx| {
3278 search_view.update(cx, |search_view, cx| {
3279 assert!(
3280 search_view.results_editor.focus_handle(cx).is_focused(window),
3281 "Search view with matching query should still have its results editor focused after the toggle focus event",
3282 );
3283 });
3284 }).unwrap();
3285
3286 workspace.update_in(cx, |workspace, window, cx| {
3287 ProjectSearchView::deploy_search(
3288 workspace,
3289 &workspace::DeploySearch::default(),
3290 window,
3291 cx,
3292 )
3293 });
3294 window.update(cx, |_, window, cx| {
3295 search_view.update(cx, |search_view, cx| {
3296 assert_eq!(search_view.query_editor.read(cx).text(cx), "two", "Query should be updated to first search result after search view 2nd open in a row");
3297 assert_eq!(
3298 search_view
3299 .results_editor
3300 .update(cx, |editor, cx| editor.display_text(cx)),
3301 "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;",
3302 "Results should be unchanged after search view 2nd open in a row"
3303 );
3304 assert!(
3305 search_view.query_editor.focus_handle(cx).is_focused(window),
3306 "Focus should be moved into query editor again after search view 2nd open in a row"
3307 );
3308 });
3309 }).unwrap();
3310
3311 cx.spawn(|mut cx| async move {
3312 window
3313 .update(&mut cx, |_, window, cx| {
3314 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3315 })
3316 .unwrap();
3317 })
3318 .detach();
3319 cx.background_executor.run_until_parked();
3320 window.update(cx, |_, window, cx| {
3321 search_view.update(cx, |search_view, cx| {
3322 assert!(
3323 search_view.results_editor.focus_handle(cx).is_focused(window),
3324 "Search view with matching query should switch focus to the results editor after the toggle focus event",
3325 );
3326 });
3327 }).unwrap();
3328 }
3329
3330 #[perf]
3331 #[gpui::test]
3332 async fn test_filters_consider_toggle_state(cx: &mut TestAppContext) {
3333 init_test(cx);
3334
3335 let fs = FakeFs::new(cx.background_executor.clone());
3336 fs.insert_tree(
3337 "/dir",
3338 json!({
3339 "one.rs": "const ONE: usize = 1;",
3340 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
3341 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
3342 "four.rs": "const FOUR: usize = one::ONE + three::THREE;",
3343 }),
3344 )
3345 .await;
3346 let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
3347 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
3348 let workspace = window
3349 .read_with(cx, |mw, _| mw.workspace().clone())
3350 .unwrap();
3351 let cx = &mut VisualTestContext::from_window(window.into(), cx);
3352 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
3353
3354 workspace.update_in(cx, move |workspace, window, cx| {
3355 workspace.panes()[0].update(cx, |pane, cx| {
3356 pane.toolbar()
3357 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
3358 });
3359
3360 ProjectSearchView::deploy_search(
3361 workspace,
3362 &workspace::DeploySearch::default(),
3363 window,
3364 cx,
3365 )
3366 });
3367
3368 let Some(search_view) = cx.read(|cx| {
3369 workspace
3370 .read(cx)
3371 .active_pane()
3372 .read(cx)
3373 .active_item()
3374 .and_then(|item| item.downcast::<ProjectSearchView>())
3375 }) else {
3376 panic!("Search view expected to appear after new search event trigger")
3377 };
3378
3379 cx.spawn(|mut cx| async move {
3380 window
3381 .update(&mut cx, |_, window, cx| {
3382 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3383 })
3384 .unwrap();
3385 })
3386 .detach();
3387 cx.background_executor.run_until_parked();
3388
3389 window
3390 .update(cx, |_, window, cx| {
3391 search_view.update(cx, |search_view, cx| {
3392 search_view.query_editor.update(cx, |query_editor, cx| {
3393 query_editor.set_text("const FOUR", window, cx)
3394 });
3395 search_view.toggle_filters(cx);
3396 search_view
3397 .excluded_files_editor
3398 .update(cx, |exclude_editor, cx| {
3399 exclude_editor.set_text("four.rs", window, cx)
3400 });
3401 search_view.search(cx);
3402 });
3403 })
3404 .unwrap();
3405 cx.background_executor.run_until_parked();
3406 window
3407 .update(cx, |_, _, cx| {
3408 search_view.update(cx, |search_view, cx| {
3409 let results_text = search_view
3410 .results_editor
3411 .update(cx, |editor, cx| editor.display_text(cx));
3412 assert!(
3413 results_text.is_empty(),
3414 "Search view for query with the only match in an excluded file should have no results but got '{results_text}'"
3415 );
3416 });
3417 }).unwrap();
3418
3419 cx.spawn(|mut cx| async move {
3420 window.update(&mut cx, |_, window, cx| {
3421 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3422 })
3423 })
3424 .detach();
3425 cx.background_executor.run_until_parked();
3426
3427 window
3428 .update(cx, |_, _, cx| {
3429 search_view.update(cx, |search_view, cx| {
3430 search_view.toggle_filters(cx);
3431 search_view.search(cx);
3432 });
3433 })
3434 .unwrap();
3435 cx.background_executor.run_until_parked();
3436 window
3437 .update(cx, |_, _, cx| {
3438 search_view.update(cx, |search_view, cx| {
3439 assert_eq!(
3440 search_view
3441 .results_editor
3442 .update(cx, |editor, cx| editor.display_text(cx)),
3443 "\n\nconst FOUR: usize = one::ONE + three::THREE;",
3444 "Search view results should contain the queried result in the previously excluded file with filters toggled off"
3445 );
3446 });
3447 })
3448 .unwrap();
3449 }
3450
3451 #[perf]
3452 #[gpui::test]
3453 async fn test_new_project_search_focus(cx: &mut TestAppContext) {
3454 init_test(cx);
3455
3456 let fs = FakeFs::new(cx.background_executor.clone());
3457 fs.insert_tree(
3458 path!("/dir"),
3459 json!({
3460 "one.rs": "const ONE: usize = 1;",
3461 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
3462 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
3463 "four.rs": "const FOUR: usize = one::ONE + three::THREE;",
3464 }),
3465 )
3466 .await;
3467 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
3468 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
3469 let workspace = window
3470 .read_with(cx, |mw, _| mw.workspace().clone())
3471 .unwrap();
3472 let cx = &mut VisualTestContext::from_window(window.into(), cx);
3473 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
3474
3475 let active_item = cx.read(|cx| {
3476 workspace
3477 .read(cx)
3478 .active_pane()
3479 .read(cx)
3480 .active_item()
3481 .and_then(|item| item.downcast::<ProjectSearchView>())
3482 });
3483 assert!(
3484 active_item.is_none(),
3485 "Expected no search panel to be active"
3486 );
3487
3488 workspace.update_in(cx, move |workspace, window, cx| {
3489 assert_eq!(workspace.panes().len(), 1);
3490 workspace.panes()[0].update(cx, |pane, cx| {
3491 pane.toolbar()
3492 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
3493 });
3494
3495 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
3496 });
3497
3498 let Some(search_view) = cx.read(|cx| {
3499 workspace
3500 .read(cx)
3501 .active_pane()
3502 .read(cx)
3503 .active_item()
3504 .and_then(|item| item.downcast::<ProjectSearchView>())
3505 }) else {
3506 panic!("Search view expected to appear after new search event trigger")
3507 };
3508
3509 cx.spawn(|mut cx| async move {
3510 window
3511 .update(&mut cx, |_, window, cx| {
3512 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3513 })
3514 .unwrap();
3515 })
3516 .detach();
3517 cx.background_executor.run_until_parked();
3518
3519 window.update(cx, |_, window, cx| {
3520 search_view.update(cx, |search_view, cx| {
3521 assert!(
3522 search_view.query_editor.focus_handle(cx).is_focused(window),
3523 "Empty search view should be focused after the toggle focus event: no results panel to focus on",
3524 );
3525 });
3526 }).unwrap();
3527
3528 window
3529 .update(cx, |_, window, cx| {
3530 search_view.update(cx, |search_view, cx| {
3531 let query_editor = &search_view.query_editor;
3532 assert!(
3533 query_editor.focus_handle(cx).is_focused(window),
3534 "Search view should be focused after the new search view is activated",
3535 );
3536 let query_text = query_editor.read(cx).text(cx);
3537 assert!(
3538 query_text.is_empty(),
3539 "New search query should be empty but got '{query_text}'",
3540 );
3541 let results_text = search_view
3542 .results_editor
3543 .update(cx, |editor, cx| editor.display_text(cx));
3544 assert!(
3545 results_text.is_empty(),
3546 "Empty search view should have no results but got '{results_text}'"
3547 );
3548 });
3549 })
3550 .unwrap();
3551
3552 window
3553 .update(cx, |_, window, cx| {
3554 search_view.update(cx, |search_view, cx| {
3555 search_view.query_editor.update(cx, |query_editor, cx| {
3556 query_editor.set_text("sOMETHINGtHATsURELYdOESnOTeXIST", window, cx)
3557 });
3558 search_view.search(cx);
3559 });
3560 })
3561 .unwrap();
3562
3563 cx.background_executor.run_until_parked();
3564 window
3565 .update(cx, |_, window, cx| {
3566 search_view.update(cx, |search_view, cx| {
3567 let results_text = search_view
3568 .results_editor
3569 .update(cx, |editor, cx| editor.display_text(cx));
3570 assert!(
3571 results_text.is_empty(),
3572 "Search view for mismatching query should have no results but got '{results_text}'"
3573 );
3574 assert!(
3575 search_view.query_editor.focus_handle(cx).is_focused(window),
3576 "Search view should be focused after mismatching query had been used in search",
3577 );
3578 });
3579 })
3580 .unwrap();
3581 cx.spawn(|mut cx| async move {
3582 window.update(&mut cx, |_, window, cx| {
3583 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3584 })
3585 })
3586 .detach();
3587 cx.background_executor.run_until_parked();
3588 window.update(cx, |_, window, cx| {
3589 search_view.update(cx, |search_view, cx| {
3590 assert!(
3591 search_view.query_editor.focus_handle(cx).is_focused(window),
3592 "Search view with mismatching query should be focused after the toggle focus event: still no results panel to focus on",
3593 );
3594 });
3595 }).unwrap();
3596
3597 window
3598 .update(cx, |_, window, cx| {
3599 search_view.update(cx, |search_view, cx| {
3600 search_view.query_editor.update(cx, |query_editor, cx| {
3601 query_editor.set_text("TWO", window, cx)
3602 });
3603 search_view.search(cx);
3604 })
3605 })
3606 .unwrap();
3607 cx.background_executor.run_until_parked();
3608 window.update(cx, |_, window, cx|
3609 search_view.update(cx, |search_view, cx| {
3610 assert_eq!(
3611 search_view
3612 .results_editor
3613 .update(cx, |editor, cx| editor.display_text(cx)),
3614 "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;",
3615 "Search view results should match the query"
3616 );
3617 assert!(
3618 search_view.results_editor.focus_handle(cx).is_focused(window),
3619 "Search view with mismatching query should be focused after search results are available",
3620 );
3621 })).unwrap();
3622 cx.spawn(|mut cx| async move {
3623 window
3624 .update(&mut cx, |_, window, cx| {
3625 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3626 })
3627 .unwrap();
3628 })
3629 .detach();
3630 cx.background_executor.run_until_parked();
3631 window.update(cx, |_, window, cx| {
3632 search_view.update(cx, |search_view, cx| {
3633 assert!(
3634 search_view.results_editor.focus_handle(cx).is_focused(window),
3635 "Search view with matching query should still have its results editor focused after the toggle focus event",
3636 );
3637 });
3638 }).unwrap();
3639
3640 workspace.update_in(cx, |workspace, window, cx| {
3641 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
3642 });
3643 cx.background_executor.run_until_parked();
3644 let Some(search_view_2) = cx.read(|cx| {
3645 workspace
3646 .read(cx)
3647 .active_pane()
3648 .read(cx)
3649 .active_item()
3650 .and_then(|item| item.downcast::<ProjectSearchView>())
3651 }) else {
3652 panic!("Search view expected to appear after new search event trigger")
3653 };
3654 assert!(
3655 search_view_2 != search_view,
3656 "New search view should be open after `workspace::NewSearch` event"
3657 );
3658
3659 window.update(cx, |_, window, cx| {
3660 search_view.update(cx, |search_view, cx| {
3661 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO", "First search view should not have an updated query");
3662 assert_eq!(
3663 search_view
3664 .results_editor
3665 .update(cx, |editor, cx| editor.display_text(cx)),
3666 "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;",
3667 "Results of the first search view should not update too"
3668 );
3669 assert!(
3670 !search_view.query_editor.focus_handle(cx).is_focused(window),
3671 "Focus should be moved away from the first search view"
3672 );
3673 });
3674 }).unwrap();
3675
3676 window.update(cx, |_, window, cx| {
3677 search_view_2.update(cx, |search_view_2, cx| {
3678 assert_eq!(
3679 search_view_2.query_editor.read(cx).text(cx),
3680 "two",
3681 "New search view should get the query from the text cursor was at during the event spawn (first search view's first result)"
3682 );
3683 assert_eq!(
3684 search_view_2
3685 .results_editor
3686 .update(cx, |editor, cx| editor.display_text(cx)),
3687 "",
3688 "No search results should be in the 2nd view yet, as we did not spawn a search for it"
3689 );
3690 assert!(
3691 search_view_2.query_editor.focus_handle(cx).is_focused(window),
3692 "Focus should be moved into query editor of the new window"
3693 );
3694 });
3695 }).unwrap();
3696
3697 window
3698 .update(cx, |_, window, cx| {
3699 search_view_2.update(cx, |search_view_2, cx| {
3700 search_view_2.query_editor.update(cx, |query_editor, cx| {
3701 query_editor.set_text("FOUR", window, cx)
3702 });
3703 search_view_2.search(cx);
3704 });
3705 })
3706 .unwrap();
3707
3708 cx.background_executor.run_until_parked();
3709 window.update(cx, |_, window, cx| {
3710 search_view_2.update(cx, |search_view_2, cx| {
3711 assert_eq!(
3712 search_view_2
3713 .results_editor
3714 .update(cx, |editor, cx| editor.display_text(cx)),
3715 "\n\nconst FOUR: usize = one::ONE + three::THREE;",
3716 "New search view with the updated query should have new search results"
3717 );
3718 assert!(
3719 search_view_2.results_editor.focus_handle(cx).is_focused(window),
3720 "Search view with mismatching query should be focused after search results are available",
3721 );
3722 });
3723 }).unwrap();
3724
3725 cx.spawn(|mut cx| async move {
3726 window
3727 .update(&mut cx, |_, window, cx| {
3728 window.dispatch_action(ToggleFocus.boxed_clone(), cx)
3729 })
3730 .unwrap();
3731 })
3732 .detach();
3733 cx.background_executor.run_until_parked();
3734 window.update(cx, |_, window, cx| {
3735 search_view_2.update(cx, |search_view_2, cx| {
3736 assert!(
3737 search_view_2.results_editor.focus_handle(cx).is_focused(window),
3738 "Search view with matching query should switch focus to the results editor after the toggle focus event",
3739 );
3740 });}).unwrap();
3741 }
3742
3743 #[perf]
3744 #[gpui::test]
3745 async fn test_new_project_search_in_directory(cx: &mut TestAppContext) {
3746 init_test(cx);
3747
3748 let fs = FakeFs::new(cx.background_executor.clone());
3749 fs.insert_tree(
3750 path!("/dir"),
3751 json!({
3752 "a": {
3753 "one.rs": "const ONE: usize = 1;",
3754 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
3755 },
3756 "b": {
3757 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
3758 "four.rs": "const FOUR: usize = one::ONE + three::THREE;",
3759 },
3760 }),
3761 )
3762 .await;
3763 let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
3764 let worktree_id = project.read_with(cx, |project, cx| {
3765 project.worktrees(cx).next().unwrap().read(cx).id()
3766 });
3767 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
3768 let workspace = window
3769 .read_with(cx, |mw, _| mw.workspace().clone())
3770 .unwrap();
3771 let cx = &mut VisualTestContext::from_window(window.into(), cx);
3772 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
3773
3774 let active_item = cx.read(|cx| {
3775 workspace
3776 .read(cx)
3777 .active_pane()
3778 .read(cx)
3779 .active_item()
3780 .and_then(|item| item.downcast::<ProjectSearchView>())
3781 });
3782 assert!(
3783 active_item.is_none(),
3784 "Expected no search panel to be active"
3785 );
3786
3787 workspace.update_in(cx, move |workspace, window, cx| {
3788 assert_eq!(workspace.panes().len(), 1);
3789 workspace.panes()[0].update(cx, move |pane, cx| {
3790 pane.toolbar()
3791 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
3792 });
3793 });
3794
3795 let a_dir_entry = cx.update(|_, cx| {
3796 workspace
3797 .read(cx)
3798 .project()
3799 .read(cx)
3800 .entry_for_path(&(worktree_id, rel_path("a")).into(), cx)
3801 .expect("no entry for /a/ directory")
3802 .clone()
3803 });
3804 assert!(a_dir_entry.is_dir());
3805 workspace.update_in(cx, |workspace, window, cx| {
3806 ProjectSearchView::new_search_in_directory(workspace, &a_dir_entry.path, window, cx)
3807 });
3808
3809 let Some(search_view) = cx.read(|cx| {
3810 workspace
3811 .read(cx)
3812 .active_pane()
3813 .read(cx)
3814 .active_item()
3815 .and_then(|item| item.downcast::<ProjectSearchView>())
3816 }) else {
3817 panic!("Search view expected to appear after new search in directory event trigger")
3818 };
3819 cx.background_executor.run_until_parked();
3820 window
3821 .update(cx, |_, window, cx| {
3822 search_view.update(cx, |search_view, cx| {
3823 assert!(
3824 search_view.query_editor.focus_handle(cx).is_focused(window),
3825 "On new search in directory, focus should be moved into query editor"
3826 );
3827 search_view.excluded_files_editor.update(cx, |editor, cx| {
3828 assert!(
3829 editor.display_text(cx).is_empty(),
3830 "New search in directory should not have any excluded files"
3831 );
3832 });
3833 search_view.included_files_editor.update(cx, |editor, cx| {
3834 assert_eq!(
3835 editor.display_text(cx),
3836 a_dir_entry.path.display(PathStyle::local()),
3837 "New search in directory should have included dir entry path"
3838 );
3839 });
3840 });
3841 })
3842 .unwrap();
3843 window
3844 .update(cx, |_, window, cx| {
3845 search_view.update(cx, |search_view, cx| {
3846 search_view.query_editor.update(cx, |query_editor, cx| {
3847 query_editor.set_text("const", window, cx)
3848 });
3849 search_view.search(cx);
3850 });
3851 })
3852 .unwrap();
3853 cx.background_executor.run_until_parked();
3854 window
3855 .update(cx, |_, _, cx| {
3856 search_view.update(cx, |search_view, cx| {
3857 assert_eq!(
3858 search_view
3859 .results_editor
3860 .update(cx, |editor, cx| editor.display_text(cx)),
3861 "\n\nconst ONE: usize = 1;\n\n\nconst TWO: usize = one::ONE + one::ONE;",
3862 "New search in directory should have a filter that matches a certain directory"
3863 );
3864 })
3865 })
3866 .unwrap();
3867 }
3868
3869 #[perf]
3870 #[gpui::test]
3871 async fn test_search_query_history(cx: &mut TestAppContext) {
3872 init_test(cx);
3873
3874 let fs = FakeFs::new(cx.background_executor.clone());
3875 fs.insert_tree(
3876 path!("/dir"),
3877 json!({
3878 "one.rs": "const ONE: usize = 1;",
3879 "two.rs": "const TWO: usize = one::ONE + one::ONE;",
3880 "three.rs": "const THREE: usize = one::ONE + two::TWO;",
3881 "four.rs": "const FOUR: usize = one::ONE + three::THREE;",
3882 }),
3883 )
3884 .await;
3885 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
3886 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
3887 let workspace = window
3888 .read_with(cx, |mw, _| mw.workspace().clone())
3889 .unwrap();
3890 let cx = &mut VisualTestContext::from_window(window.into(), cx);
3891 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
3892
3893 workspace.update_in(cx, {
3894 let search_bar = search_bar.clone();
3895 |workspace, window, cx| {
3896 assert_eq!(workspace.panes().len(), 1);
3897 workspace.panes()[0].update(cx, |pane, cx| {
3898 pane.toolbar()
3899 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
3900 });
3901
3902 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
3903 }
3904 });
3905
3906 let search_view = cx.read(|cx| {
3907 workspace
3908 .read(cx)
3909 .active_pane()
3910 .read(cx)
3911 .active_item()
3912 .and_then(|item| item.downcast::<ProjectSearchView>())
3913 .expect("Search view expected to appear after new search event trigger")
3914 });
3915
3916 // Add 3 search items into the history + another unsubmitted one.
3917 window
3918 .update(cx, |_, window, cx| {
3919 search_view.update(cx, |search_view, cx| {
3920 search_view.search_options = SearchOptions::CASE_SENSITIVE;
3921 search_view.query_editor.update(cx, |query_editor, cx| {
3922 query_editor.set_text("ONE", window, cx)
3923 });
3924 search_view.search(cx);
3925 });
3926 })
3927 .unwrap();
3928
3929 cx.background_executor.run_until_parked();
3930 window
3931 .update(cx, |_, window, cx| {
3932 search_view.update(cx, |search_view, cx| {
3933 search_view.query_editor.update(cx, |query_editor, cx| {
3934 query_editor.set_text("TWO", window, cx)
3935 });
3936 search_view.search(cx);
3937 });
3938 })
3939 .unwrap();
3940 cx.background_executor.run_until_parked();
3941 window
3942 .update(cx, |_, window, cx| {
3943 search_view.update(cx, |search_view, cx| {
3944 search_view.query_editor.update(cx, |query_editor, cx| {
3945 query_editor.set_text("THREE", window, cx)
3946 });
3947 search_view.search(cx);
3948 })
3949 })
3950 .unwrap();
3951 cx.background_executor.run_until_parked();
3952 window
3953 .update(cx, |_, window, cx| {
3954 search_view.update(cx, |search_view, cx| {
3955 search_view.query_editor.update(cx, |query_editor, cx| {
3956 query_editor.set_text("JUST_TEXT_INPUT", window, cx)
3957 });
3958 })
3959 })
3960 .unwrap();
3961 cx.background_executor.run_until_parked();
3962
3963 // Ensure that the latest input with search settings is active.
3964 window
3965 .update(cx, |_, _, cx| {
3966 search_view.update(cx, |search_view, cx| {
3967 assert_eq!(
3968 search_view.query_editor.read(cx).text(cx),
3969 "JUST_TEXT_INPUT"
3970 );
3971 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
3972 });
3973 })
3974 .unwrap();
3975
3976 // Next history query after the latest should preserve the current query.
3977 window
3978 .update(cx, |_, window, cx| {
3979 search_bar.update(cx, |search_bar, cx| {
3980 search_bar.focus_search(window, cx);
3981 search_bar.next_history_query(&NextHistoryQuery, window, cx);
3982 })
3983 })
3984 .unwrap();
3985 window
3986 .update(cx, |_, _, cx| {
3987 search_view.update(cx, |search_view, cx| {
3988 assert_eq!(
3989 search_view.query_editor.read(cx).text(cx),
3990 "JUST_TEXT_INPUT"
3991 );
3992 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
3993 });
3994 })
3995 .unwrap();
3996 window
3997 .update(cx, |_, window, cx| {
3998 search_bar.update(cx, |search_bar, cx| {
3999 search_bar.focus_search(window, cx);
4000 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4001 })
4002 })
4003 .unwrap();
4004 window
4005 .update(cx, |_, _, cx| {
4006 search_view.update(cx, |search_view, cx| {
4007 assert_eq!(
4008 search_view.query_editor.read(cx).text(cx),
4009 "JUST_TEXT_INPUT"
4010 );
4011 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4012 });
4013 })
4014 .unwrap();
4015
4016 // Previous query should navigate backwards through history.
4017 window
4018 .update(cx, |_, window, cx| {
4019 search_bar.update(cx, |search_bar, cx| {
4020 search_bar.focus_search(window, cx);
4021 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4022 });
4023 })
4024 .unwrap();
4025 window
4026 .update(cx, |_, _, cx| {
4027 search_view.update(cx, |search_view, cx| {
4028 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO");
4029 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4030 });
4031 })
4032 .unwrap();
4033
4034 // Further previous items should go over the history in reverse order.
4035 window
4036 .update(cx, |_, window, cx| {
4037 search_bar.update(cx, |search_bar, cx| {
4038 search_bar.focus_search(window, cx);
4039 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4040 });
4041 })
4042 .unwrap();
4043 window
4044 .update(cx, |_, _, cx| {
4045 search_view.update(cx, |search_view, cx| {
4046 assert_eq!(search_view.query_editor.read(cx).text(cx), "ONE");
4047 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4048 });
4049 })
4050 .unwrap();
4051
4052 // Previous items should never go behind the first history item.
4053 window
4054 .update(cx, |_, window, cx| {
4055 search_bar.update(cx, |search_bar, cx| {
4056 search_bar.focus_search(window, cx);
4057 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4058 });
4059 })
4060 .unwrap();
4061 window
4062 .update(cx, |_, _, cx| {
4063 search_view.update(cx, |search_view, cx| {
4064 assert_eq!(search_view.query_editor.read(cx).text(cx), "ONE");
4065 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4066 });
4067 })
4068 .unwrap();
4069 window
4070 .update(cx, |_, window, cx| {
4071 search_bar.update(cx, |search_bar, cx| {
4072 search_bar.focus_search(window, cx);
4073 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4074 });
4075 })
4076 .unwrap();
4077 window
4078 .update(cx, |_, _, cx| {
4079 search_view.update(cx, |search_view, cx| {
4080 assert_eq!(search_view.query_editor.read(cx).text(cx), "ONE");
4081 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4082 });
4083 })
4084 .unwrap();
4085
4086 // Next items should go over the history in the original order.
4087 window
4088 .update(cx, |_, window, cx| {
4089 search_bar.update(cx, |search_bar, cx| {
4090 search_bar.focus_search(window, cx);
4091 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4092 });
4093 })
4094 .unwrap();
4095 window
4096 .update(cx, |_, _, cx| {
4097 search_view.update(cx, |search_view, cx| {
4098 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO");
4099 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4100 });
4101 })
4102 .unwrap();
4103
4104 window
4105 .update(cx, |_, window, cx| {
4106 search_view.update(cx, |search_view, cx| {
4107 search_view.query_editor.update(cx, |query_editor, cx| {
4108 query_editor.set_text("TWO_NEW", window, cx)
4109 });
4110 search_view.search(cx);
4111 });
4112 })
4113 .unwrap();
4114 cx.background_executor.run_until_parked();
4115 window
4116 .update(cx, |_, _, cx| {
4117 search_view.update(cx, |search_view, cx| {
4118 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO_NEW");
4119 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4120 });
4121 })
4122 .unwrap();
4123
4124 // New search input should add another entry to history and move the selection to the end of the history.
4125 window
4126 .update(cx, |_, window, cx| {
4127 search_bar.update(cx, |search_bar, cx| {
4128 search_bar.focus_search(window, cx);
4129 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4130 });
4131 })
4132 .unwrap();
4133 window
4134 .update(cx, |_, _, cx| {
4135 search_view.update(cx, |search_view, cx| {
4136 assert_eq!(search_view.query_editor.read(cx).text(cx), "THREE");
4137 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4138 });
4139 })
4140 .unwrap();
4141 window
4142 .update(cx, |_, window, cx| {
4143 search_bar.update(cx, |search_bar, cx| {
4144 search_bar.focus_search(window, cx);
4145 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4146 });
4147 })
4148 .unwrap();
4149 window
4150 .update(cx, |_, _, cx| {
4151 search_view.update(cx, |search_view, cx| {
4152 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO");
4153 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4154 });
4155 })
4156 .unwrap();
4157 window
4158 .update(cx, |_, window, cx| {
4159 search_bar.update(cx, |search_bar, cx| {
4160 search_bar.focus_search(window, cx);
4161 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4162 });
4163 })
4164 .unwrap();
4165 window
4166 .update(cx, |_, _, cx| {
4167 search_view.update(cx, |search_view, cx| {
4168 assert_eq!(search_view.query_editor.read(cx).text(cx), "THREE");
4169 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4170 });
4171 })
4172 .unwrap();
4173 window
4174 .update(cx, |_, window, cx| {
4175 search_bar.update(cx, |search_bar, cx| {
4176 search_bar.focus_search(window, cx);
4177 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4178 });
4179 })
4180 .unwrap();
4181 window
4182 .update(cx, |_, _, cx| {
4183 search_view.update(cx, |search_view, cx| {
4184 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO_NEW");
4185 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4186 });
4187 })
4188 .unwrap();
4189 window
4190 .update(cx, |_, window, cx| {
4191 search_bar.update(cx, |search_bar, cx| {
4192 search_bar.focus_search(window, cx);
4193 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4194 });
4195 })
4196 .unwrap();
4197 window
4198 .update(cx, |_, _, cx| {
4199 search_view.update(cx, |search_view, cx| {
4200 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO_NEW");
4201 assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE);
4202 });
4203 })
4204 .unwrap();
4205
4206 // Typing text without running a search, then navigating history, should allow
4207 // restoring the draft when pressing next past the end.
4208 window
4209 .update(cx, |_, window, cx| {
4210 search_view.update(cx, |search_view, cx| {
4211 search_view.query_editor.update(cx, |query_editor, cx| {
4212 query_editor.set_text("unsaved draft", window, cx)
4213 });
4214 })
4215 })
4216 .unwrap();
4217 cx.background_executor.run_until_parked();
4218
4219 // Navigate up into history — the draft should be stashed.
4220 window
4221 .update(cx, |_, window, cx| {
4222 search_bar.update(cx, |search_bar, cx| {
4223 search_bar.focus_search(window, cx);
4224 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4225 });
4226 })
4227 .unwrap();
4228 window
4229 .update(cx, |_, _, cx| {
4230 search_view.update(cx, |search_view, cx| {
4231 assert_eq!(search_view.query_editor.read(cx).text(cx), "THREE");
4232 });
4233 })
4234 .unwrap();
4235
4236 // Navigate forward through history.
4237 window
4238 .update(cx, |_, window, cx| {
4239 search_bar.update(cx, |search_bar, cx| {
4240 search_bar.focus_search(window, cx);
4241 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4242 });
4243 })
4244 .unwrap();
4245 window
4246 .update(cx, |_, _, cx| {
4247 search_view.update(cx, |search_view, cx| {
4248 assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO_NEW");
4249 });
4250 })
4251 .unwrap();
4252
4253 // Navigate past the end — the draft should be restored.
4254 window
4255 .update(cx, |_, window, cx| {
4256 search_bar.update(cx, |search_bar, cx| {
4257 search_bar.focus_search(window, cx);
4258 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4259 });
4260 })
4261 .unwrap();
4262 window
4263 .update(cx, |_, _, cx| {
4264 search_view.update(cx, |search_view, cx| {
4265 assert_eq!(search_view.query_editor.read(cx).text(cx), "unsaved draft");
4266 });
4267 })
4268 .unwrap();
4269 }
4270
4271 #[perf]
4272 #[gpui::test]
4273 async fn test_search_query_history_with_multiple_views(cx: &mut TestAppContext) {
4274 init_test(cx);
4275
4276 let fs = FakeFs::new(cx.background_executor.clone());
4277 fs.insert_tree(
4278 path!("/dir"),
4279 json!({
4280 "one.rs": "const ONE: usize = 1;",
4281 }),
4282 )
4283 .await;
4284 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
4285 let worktree_id = project.update(cx, |this, cx| {
4286 this.worktrees(cx).next().unwrap().read(cx).id()
4287 });
4288
4289 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
4290 let workspace = window
4291 .read_with(cx, |mw, _| mw.workspace().clone())
4292 .unwrap();
4293 let cx = &mut VisualTestContext::from_window(window.into(), cx);
4294
4295 let panes: Vec<_> = workspace.update_in(cx, |this, _, _| this.panes().to_owned());
4296
4297 let search_bar_1 = window.build_entity(cx, |_, _| ProjectSearchBar::new());
4298 let search_bar_2 = window.build_entity(cx, |_, _| ProjectSearchBar::new());
4299
4300 assert_eq!(panes.len(), 1);
4301 let first_pane = panes.first().cloned().unwrap();
4302 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 0);
4303 workspace
4304 .update_in(cx, |workspace, window, cx| {
4305 workspace.open_path(
4306 (worktree_id, rel_path("one.rs")),
4307 Some(first_pane.downgrade()),
4308 true,
4309 window,
4310 cx,
4311 )
4312 })
4313 .await
4314 .unwrap();
4315 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 1);
4316
4317 // Add a project search item to the first pane
4318 workspace.update_in(cx, {
4319 let search_bar = search_bar_1.clone();
4320 |workspace, window, cx| {
4321 first_pane.update(cx, |pane, cx| {
4322 pane.toolbar()
4323 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
4324 });
4325
4326 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
4327 }
4328 });
4329 let search_view_1 = cx.read(|cx| {
4330 workspace
4331 .read(cx)
4332 .active_item(cx)
4333 .and_then(|item| item.downcast::<ProjectSearchView>())
4334 .expect("Search view expected to appear after new search event trigger")
4335 });
4336
4337 let second_pane = workspace
4338 .update_in(cx, |workspace, window, cx| {
4339 workspace.split_and_clone(
4340 first_pane.clone(),
4341 workspace::SplitDirection::Right,
4342 window,
4343 cx,
4344 )
4345 })
4346 .await
4347 .unwrap();
4348 assert_eq!(cx.update(|_, cx| second_pane.read(cx).items_len()), 1);
4349
4350 assert_eq!(cx.update(|_, cx| second_pane.read(cx).items_len()), 1);
4351 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 2);
4352
4353 // Add a project search item to the second pane
4354 workspace.update_in(cx, {
4355 let search_bar = search_bar_2.clone();
4356 let pane = second_pane.clone();
4357 move |workspace, window, cx| {
4358 assert_eq!(workspace.panes().len(), 2);
4359 pane.update(cx, |pane, cx| {
4360 pane.toolbar()
4361 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
4362 });
4363
4364 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
4365 }
4366 });
4367
4368 let search_view_2 = cx.read(|cx| {
4369 workspace
4370 .read(cx)
4371 .active_item(cx)
4372 .and_then(|item| item.downcast::<ProjectSearchView>())
4373 .expect("Search view expected to appear after new search event trigger")
4374 });
4375
4376 cx.run_until_parked();
4377 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 2);
4378 assert_eq!(cx.update(|_, cx| second_pane.read(cx).items_len()), 2);
4379
4380 let update_search_view =
4381 |search_view: &Entity<ProjectSearchView>, query: &str, cx: &mut TestAppContext| {
4382 window
4383 .update(cx, |_, window, cx| {
4384 search_view.update(cx, |search_view, cx| {
4385 search_view.query_editor.update(cx, |query_editor, cx| {
4386 query_editor.set_text(query, window, cx)
4387 });
4388 search_view.search(cx);
4389 });
4390 })
4391 .unwrap();
4392 };
4393
4394 let active_query =
4395 |search_view: &Entity<ProjectSearchView>, cx: &mut TestAppContext| -> String {
4396 window
4397 .update(cx, |_, _, cx| {
4398 search_view.update(cx, |search_view, cx| {
4399 search_view.query_editor.read(cx).text(cx)
4400 })
4401 })
4402 .unwrap()
4403 };
4404
4405 let select_prev_history_item =
4406 |search_bar: &Entity<ProjectSearchBar>, cx: &mut TestAppContext| {
4407 window
4408 .update(cx, |_, window, cx| {
4409 search_bar.update(cx, |search_bar, cx| {
4410 search_bar.focus_search(window, cx);
4411 search_bar.previous_history_query(&PreviousHistoryQuery, window, cx);
4412 })
4413 })
4414 .unwrap();
4415 };
4416
4417 let select_next_history_item =
4418 |search_bar: &Entity<ProjectSearchBar>, cx: &mut TestAppContext| {
4419 window
4420 .update(cx, |_, window, cx| {
4421 search_bar.update(cx, |search_bar, cx| {
4422 search_bar.focus_search(window, cx);
4423 search_bar.next_history_query(&NextHistoryQuery, window, cx);
4424 })
4425 })
4426 .unwrap();
4427 };
4428
4429 update_search_view(&search_view_1, "ONE", cx);
4430 cx.background_executor.run_until_parked();
4431
4432 update_search_view(&search_view_2, "TWO", cx);
4433 cx.background_executor.run_until_parked();
4434
4435 assert_eq!(active_query(&search_view_1, cx), "ONE");
4436 assert_eq!(active_query(&search_view_2, cx), "TWO");
4437
4438 // Selecting previous history item should select the query from search view 1.
4439 select_prev_history_item(&search_bar_2, cx);
4440 assert_eq!(active_query(&search_view_2, cx), "ONE");
4441
4442 // Selecting the previous history item should not change the query as it is already the first item.
4443 select_prev_history_item(&search_bar_2, cx);
4444 assert_eq!(active_query(&search_view_2, cx), "ONE");
4445
4446 // Changing the query in search view 2 should not affect the history of search view 1.
4447 assert_eq!(active_query(&search_view_1, cx), "ONE");
4448
4449 // Deploying a new search in search view 2
4450 update_search_view(&search_view_2, "THREE", cx);
4451 cx.background_executor.run_until_parked();
4452
4453 select_next_history_item(&search_bar_2, cx);
4454 assert_eq!(active_query(&search_view_2, cx), "THREE");
4455
4456 select_prev_history_item(&search_bar_2, cx);
4457 assert_eq!(active_query(&search_view_2, cx), "TWO");
4458
4459 select_prev_history_item(&search_bar_2, cx);
4460 assert_eq!(active_query(&search_view_2, cx), "ONE");
4461
4462 select_prev_history_item(&search_bar_2, cx);
4463 assert_eq!(active_query(&search_view_2, cx), "ONE");
4464
4465 select_prev_history_item(&search_bar_2, cx);
4466 assert_eq!(active_query(&search_view_2, cx), "ONE");
4467
4468 // Search view 1 should now see the query from search view 2.
4469 assert_eq!(active_query(&search_view_1, cx), "ONE");
4470
4471 select_next_history_item(&search_bar_2, cx);
4472 assert_eq!(active_query(&search_view_2, cx), "TWO");
4473
4474 // Here is the new query from search view 2
4475 select_next_history_item(&search_bar_2, cx);
4476 assert_eq!(active_query(&search_view_2, cx), "THREE");
4477
4478 select_next_history_item(&search_bar_2, cx);
4479 assert_eq!(active_query(&search_view_2, cx), "THREE");
4480
4481 select_next_history_item(&search_bar_1, cx);
4482 assert_eq!(active_query(&search_view_1, cx), "TWO");
4483
4484 select_next_history_item(&search_bar_1, cx);
4485 assert_eq!(active_query(&search_view_1, cx), "THREE");
4486
4487 select_next_history_item(&search_bar_1, cx);
4488 assert_eq!(active_query(&search_view_1, cx), "THREE");
4489 }
4490
4491 #[perf]
4492 #[gpui::test]
4493 async fn test_deploy_search_with_multiple_panes(cx: &mut TestAppContext) {
4494 init_test(cx);
4495
4496 // Setup 2 panes, both with a file open and one with a project search.
4497 let fs = FakeFs::new(cx.background_executor.clone());
4498 fs.insert_tree(
4499 path!("/dir"),
4500 json!({
4501 "one.rs": "const ONE: usize = 1;",
4502 }),
4503 )
4504 .await;
4505 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
4506 let worktree_id = project.update(cx, |this, cx| {
4507 this.worktrees(cx).next().unwrap().read(cx).id()
4508 });
4509 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
4510 let workspace = window
4511 .read_with(cx, |mw, _| mw.workspace().clone())
4512 .unwrap();
4513 let cx = &mut VisualTestContext::from_window(window.into(), cx);
4514 let panes: Vec<_> = workspace.update_in(cx, |this, _, _| this.panes().to_owned());
4515 assert_eq!(panes.len(), 1);
4516 let first_pane = panes.first().cloned().unwrap();
4517 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 0);
4518 workspace
4519 .update_in(cx, |workspace, window, cx| {
4520 workspace.open_path(
4521 (worktree_id, rel_path("one.rs")),
4522 Some(first_pane.downgrade()),
4523 true,
4524 window,
4525 cx,
4526 )
4527 })
4528 .await
4529 .unwrap();
4530 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 1);
4531 let second_pane = workspace
4532 .update_in(cx, |workspace, window, cx| {
4533 workspace.split_and_clone(
4534 first_pane.clone(),
4535 workspace::SplitDirection::Right,
4536 window,
4537 cx,
4538 )
4539 })
4540 .await
4541 .unwrap();
4542 assert_eq!(cx.update(|_, cx| second_pane.read(cx).items_len()), 1);
4543 assert!(
4544 window
4545 .update(cx, |_, window, cx| second_pane
4546 .focus_handle(cx)
4547 .contains_focused(window, cx))
4548 .unwrap()
4549 );
4550 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
4551 workspace.update_in(cx, {
4552 let search_bar = search_bar.clone();
4553 let pane = first_pane.clone();
4554 move |workspace, window, cx| {
4555 assert_eq!(workspace.panes().len(), 2);
4556 pane.update(cx, move |pane, cx| {
4557 pane.toolbar()
4558 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
4559 });
4560 }
4561 });
4562
4563 // Add a project search item to the second pane
4564 workspace.update_in(cx, {
4565 |workspace, window, cx| {
4566 assert_eq!(workspace.panes().len(), 2);
4567 second_pane.update(cx, |pane, cx| {
4568 pane.toolbar()
4569 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
4570 });
4571
4572 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
4573 }
4574 });
4575
4576 cx.run_until_parked();
4577 assert_eq!(cx.update(|_, cx| second_pane.read(cx).items_len()), 2);
4578 assert_eq!(cx.update(|_, cx| first_pane.read(cx).items_len()), 1);
4579
4580 // Focus the first pane
4581 workspace.update_in(cx, |workspace, window, cx| {
4582 assert_eq!(workspace.active_pane(), &second_pane);
4583 second_pane.update(cx, |this, cx| {
4584 assert_eq!(this.active_item_index(), 1);
4585 this.activate_previous_item(&Default::default(), window, cx);
4586 assert_eq!(this.active_item_index(), 0);
4587 });
4588 workspace.activate_pane_in_direction(workspace::SplitDirection::Left, window, cx);
4589 });
4590 workspace.update_in(cx, |workspace, _, cx| {
4591 assert_eq!(workspace.active_pane(), &first_pane);
4592 assert_eq!(first_pane.read(cx).items_len(), 1);
4593 assert_eq!(second_pane.read(cx).items_len(), 2);
4594 });
4595
4596 // Deploy a new search
4597 cx.dispatch_action(DeploySearch::default());
4598
4599 // Both panes should now have a project search in them
4600 workspace.update_in(cx, |workspace, window, cx| {
4601 assert_eq!(workspace.active_pane(), &first_pane);
4602 first_pane.read_with(cx, |this, _| {
4603 assert_eq!(this.active_item_index(), 1);
4604 assert_eq!(this.items_len(), 2);
4605 });
4606 second_pane.update(cx, |this, cx| {
4607 assert!(!cx.focus_handle().contains_focused(window, cx));
4608 assert_eq!(this.items_len(), 2);
4609 });
4610 });
4611
4612 // Focus the second pane's non-search item
4613 window
4614 .update(cx, |_workspace, window, cx| {
4615 second_pane.update(cx, |pane, cx| {
4616 pane.activate_next_item(&Default::default(), window, cx)
4617 });
4618 })
4619 .unwrap();
4620
4621 // Deploy a new search
4622 cx.dispatch_action(DeploySearch::default());
4623
4624 // The project search view should now be focused in the second pane
4625 // And the number of items should be unchanged.
4626 window
4627 .update(cx, |_workspace, _, cx| {
4628 second_pane.update(cx, |pane, _cx| {
4629 assert!(
4630 pane.active_item()
4631 .unwrap()
4632 .downcast::<ProjectSearchView>()
4633 .is_some()
4634 );
4635
4636 assert_eq!(pane.items_len(), 2);
4637 });
4638 })
4639 .unwrap();
4640 }
4641
4642 #[perf]
4643 #[gpui::test]
4644 async fn test_scroll_search_results_to_top(cx: &mut TestAppContext) {
4645 init_test(cx);
4646
4647 // We need many lines in the search results to be able to scroll the window
4648 let fs = FakeFs::new(cx.background_executor.clone());
4649 fs.insert_tree(
4650 path!("/dir"),
4651 json!({
4652 "1.txt": "\n\n\n\n\n A \n\n\n\n\n",
4653 "2.txt": "\n\n\n\n\n A \n\n\n\n\n",
4654 "3.rs": "\n\n\n\n\n A \n\n\n\n\n",
4655 "4.rs": "\n\n\n\n\n A \n\n\n\n\n",
4656 "5.rs": "\n\n\n\n\n A \n\n\n\n\n",
4657 "6.rs": "\n\n\n\n\n A \n\n\n\n\n",
4658 "7.rs": "\n\n\n\n\n A \n\n\n\n\n",
4659 "8.rs": "\n\n\n\n\n A \n\n\n\n\n",
4660 "9.rs": "\n\n\n\n\n A \n\n\n\n\n",
4661 "a.rs": "\n\n\n\n\n A \n\n\n\n\n",
4662 "b.rs": "\n\n\n\n\n B \n\n\n\n\n",
4663 "c.rs": "\n\n\n\n\n B \n\n\n\n\n",
4664 "d.rs": "\n\n\n\n\n B \n\n\n\n\n",
4665 "e.rs": "\n\n\n\n\n B \n\n\n\n\n",
4666 "f.rs": "\n\n\n\n\n B \n\n\n\n\n",
4667 "g.rs": "\n\n\n\n\n B \n\n\n\n\n",
4668 "h.rs": "\n\n\n\n\n B \n\n\n\n\n",
4669 "i.rs": "\n\n\n\n\n B \n\n\n\n\n",
4670 "j.rs": "\n\n\n\n\n B \n\n\n\n\n",
4671 "k.rs": "\n\n\n\n\n B \n\n\n\n\n",
4672 }),
4673 )
4674 .await;
4675 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
4676 let window =
4677 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
4678 let workspace = window
4679 .read_with(cx, |mw, _| mw.workspace().clone())
4680 .unwrap();
4681 let search = cx.new(|cx| ProjectSearch::new(project, cx));
4682 let search_view = cx.add_window(|window, cx| {
4683 ProjectSearchView::new(workspace.downgrade(), search.clone(), window, cx, None)
4684 });
4685
4686 // First search
4687 perform_search(search_view, "A", cx);
4688 search_view
4689 .update(cx, |search_view, window, cx| {
4690 search_view.results_editor.update(cx, |results_editor, cx| {
4691 // Results are correct and scrolled to the top
4692 assert_eq!(
4693 results_editor.display_text(cx).match_indices(" A ").count(),
4694 10
4695 );
4696 assert_eq!(results_editor.scroll_position(cx), Point::default());
4697
4698 // Scroll results all the way down
4699 results_editor.scroll(
4700 Point::new(0., f64::MAX),
4701 Some(Axis::Vertical),
4702 window,
4703 cx,
4704 );
4705 });
4706 })
4707 .expect("unable to update search view");
4708
4709 // Second search
4710 perform_search(search_view, "B", cx);
4711 search_view
4712 .update(cx, |search_view, _, cx| {
4713 search_view.results_editor.update(cx, |results_editor, cx| {
4714 // Results are correct...
4715 assert_eq!(
4716 results_editor.display_text(cx).match_indices(" B ").count(),
4717 10
4718 );
4719 // ...and scrolled back to the top
4720 assert_eq!(results_editor.scroll_position(cx), Point::default());
4721 });
4722 })
4723 .expect("unable to update search view");
4724 }
4725
4726 #[perf]
4727 #[gpui::test]
4728 async fn test_buffer_search_query_reused(cx: &mut TestAppContext) {
4729 init_test(cx);
4730
4731 let fs = FakeFs::new(cx.background_executor.clone());
4732 fs.insert_tree(
4733 path!("/dir"),
4734 json!({
4735 "one.rs": "const ONE: usize = 1;",
4736 }),
4737 )
4738 .await;
4739 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
4740 let worktree_id = project.update(cx, |this, cx| {
4741 this.worktrees(cx).next().unwrap().read(cx).id()
4742 });
4743 let window =
4744 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
4745 let workspace = window
4746 .read_with(cx, |mw, _| mw.workspace().clone())
4747 .unwrap();
4748 let mut cx = VisualTestContext::from_window(window.into(), cx);
4749
4750 let editor = workspace
4751 .update_in(&mut cx, |workspace, window, cx| {
4752 workspace.open_path((worktree_id, rel_path("one.rs")), None, true, window, cx)
4753 })
4754 .await
4755 .unwrap()
4756 .downcast::<Editor>()
4757 .unwrap();
4758
4759 // Wait for the unstaged changes to be loaded
4760 cx.run_until_parked();
4761
4762 let buffer_search_bar = cx.new_window_entity(|window, cx| {
4763 let mut search_bar =
4764 BufferSearchBar::new(Some(project.read(cx).languages().clone()), window, cx);
4765 search_bar.set_active_pane_item(Some(&editor), window, cx);
4766 search_bar.show(window, cx);
4767 search_bar
4768 });
4769
4770 let panes: Vec<_> = workspace.update_in(&mut cx, |this, _, _| this.panes().to_owned());
4771 assert_eq!(panes.len(), 1);
4772 let pane = panes.first().cloned().unwrap();
4773 pane.update_in(&mut cx, |pane, window, cx| {
4774 pane.toolbar().update(cx, |toolbar, cx| {
4775 toolbar.add_item(buffer_search_bar.clone(), window, cx);
4776 })
4777 });
4778
4779 let buffer_search_query = "search bar query";
4780 buffer_search_bar
4781 .update_in(&mut cx, |buffer_search_bar, window, cx| {
4782 buffer_search_bar.focus_handle(cx).focus(window, cx);
4783 buffer_search_bar.search(buffer_search_query, None, true, window, cx)
4784 })
4785 .await
4786 .unwrap();
4787
4788 workspace.update_in(&mut cx, |workspace, window, cx| {
4789 ProjectSearchView::new_search(workspace, &workspace::NewSearch, window, cx)
4790 });
4791 cx.run_until_parked();
4792 let project_search_view = pane
4793 .read_with(&cx, |pane, _| {
4794 pane.active_item()
4795 .and_then(|item| item.downcast::<ProjectSearchView>())
4796 })
4797 .expect("should open a project search view after spawning a new search");
4798 project_search_view.update(&mut cx, |search_view, cx| {
4799 assert_eq!(
4800 search_view.search_query_text(cx),
4801 buffer_search_query,
4802 "Project search should take the query from the buffer search bar since it got focused and had a query inside"
4803 );
4804 });
4805 }
4806
4807 #[gpui::test]
4808 async fn test_search_dismisses_modal(cx: &mut TestAppContext) {
4809 init_test(cx);
4810
4811 let fs = FakeFs::new(cx.background_executor.clone());
4812 fs.insert_tree(
4813 path!("/dir"),
4814 json!({
4815 "one.rs": "const ONE: usize = 1;",
4816 }),
4817 )
4818 .await;
4819 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
4820 let window =
4821 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
4822 let workspace = window
4823 .read_with(cx, |mw, _| mw.workspace().clone())
4824 .unwrap();
4825 let cx = &mut VisualTestContext::from_window(window.into(), cx);
4826
4827 struct EmptyModalView {
4828 focus_handle: gpui::FocusHandle,
4829 }
4830 impl EventEmitter<gpui::DismissEvent> for EmptyModalView {}
4831 impl Render for EmptyModalView {
4832 fn render(&mut self, _: &mut Window, _: &mut Context<'_, Self>) -> impl IntoElement {
4833 div()
4834 }
4835 }
4836 impl Focusable for EmptyModalView {
4837 fn focus_handle(&self, _cx: &App) -> gpui::FocusHandle {
4838 self.focus_handle.clone()
4839 }
4840 }
4841 impl workspace::ModalView for EmptyModalView {}
4842
4843 workspace.update_in(cx, |workspace, window, cx| {
4844 workspace.toggle_modal(window, cx, |_, cx| EmptyModalView {
4845 focus_handle: cx.focus_handle(),
4846 });
4847 assert!(workspace.has_active_modal(window, cx));
4848 });
4849
4850 cx.dispatch_action(Deploy::find());
4851
4852 workspace.update_in(cx, |workspace, window, cx| {
4853 assert!(!workspace.has_active_modal(window, cx));
4854 workspace.toggle_modal(window, cx, |_, cx| EmptyModalView {
4855 focus_handle: cx.focus_handle(),
4856 });
4857 assert!(workspace.has_active_modal(window, cx));
4858 });
4859
4860 cx.dispatch_action(DeploySearch::default());
4861
4862 workspace.update_in(cx, |workspace, window, cx| {
4863 assert!(!workspace.has_active_modal(window, cx));
4864 });
4865 }
4866
4867 #[perf]
4868 #[gpui::test]
4869 async fn test_search_with_inlays(cx: &mut TestAppContext) {
4870 init_test(cx);
4871 cx.update(|cx| {
4872 SettingsStore::update_global(cx, |store, cx| {
4873 store.update_user_settings(cx, |settings| {
4874 settings.project.all_languages.defaults.inlay_hints =
4875 Some(InlayHintSettingsContent {
4876 enabled: Some(true),
4877 ..InlayHintSettingsContent::default()
4878 })
4879 });
4880 });
4881 });
4882
4883 let fs = FakeFs::new(cx.background_executor.clone());
4884 fs.insert_tree(
4885 path!("/dir"),
4886 // `\n` , a trailing line on the end, is important for the test case
4887 json!({
4888 "main.rs": "fn main() { let a = 2; }\n",
4889 }),
4890 )
4891 .await;
4892
4893 let requests_count = Arc::new(AtomicUsize::new(0));
4894 let closure_requests_count = requests_count.clone();
4895 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
4896 let language_registry = project.read_with(cx, |project, _| project.languages().clone());
4897 let language = rust_lang();
4898 language_registry.add(language);
4899 let mut fake_servers = language_registry.register_fake_lsp(
4900 "Rust",
4901 FakeLspAdapter {
4902 capabilities: lsp::ServerCapabilities {
4903 inlay_hint_provider: Some(lsp::OneOf::Left(true)),
4904 ..lsp::ServerCapabilities::default()
4905 },
4906 initializer: Some(Box::new(move |fake_server| {
4907 let requests_count = closure_requests_count.clone();
4908 fake_server.set_request_handler::<lsp::request::InlayHintRequest, _, _>({
4909 move |_, _| {
4910 let requests_count = requests_count.clone();
4911 async move {
4912 requests_count.fetch_add(1, atomic::Ordering::Release);
4913 Ok(Some(vec![lsp::InlayHint {
4914 position: lsp::Position::new(0, 17),
4915 label: lsp::InlayHintLabel::String(": i32".to_owned()),
4916 kind: Some(lsp::InlayHintKind::TYPE),
4917 text_edits: None,
4918 tooltip: None,
4919 padding_left: None,
4920 padding_right: None,
4921 data: None,
4922 }]))
4923 }
4924 }
4925 });
4926 })),
4927 ..FakeLspAdapter::default()
4928 },
4929 );
4930
4931 let window =
4932 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
4933 let workspace = window
4934 .read_with(cx, |mw, _| mw.workspace().clone())
4935 .unwrap();
4936 let cx = &mut VisualTestContext::from_window(window.into(), cx);
4937 let search = cx.new(|cx| ProjectSearch::new(project.clone(), cx));
4938 let search_view = cx.add_window(|window, cx| {
4939 ProjectSearchView::new(workspace.downgrade(), search.clone(), window, cx, None)
4940 });
4941
4942 perform_search(search_view, "let ", cx);
4943 let fake_server = fake_servers.next().await.unwrap();
4944 cx.executor().advance_clock(Duration::from_secs(1));
4945 cx.executor().run_until_parked();
4946 search_view
4947 .update(cx, |search_view, _, cx| {
4948 assert_eq!(
4949 search_view
4950 .results_editor
4951 .update(cx, |editor, cx| editor.display_text(cx)),
4952 "\n\nfn main() { let a: i32 = 2; }\n"
4953 );
4954 })
4955 .unwrap();
4956 assert_eq!(
4957 requests_count.load(atomic::Ordering::Acquire),
4958 1,
4959 "New hints should have been queried",
4960 );
4961
4962 // Can do the 2nd search without any panics
4963 perform_search(search_view, "let ", cx);
4964 cx.executor().advance_clock(Duration::from_secs(1));
4965 cx.executor().run_until_parked();
4966 search_view
4967 .update(cx, |search_view, _, cx| {
4968 assert_eq!(
4969 search_view
4970 .results_editor
4971 .update(cx, |editor, cx| editor.display_text(cx)),
4972 "\n\nfn main() { let a: i32 = 2; }\n"
4973 );
4974 })
4975 .unwrap();
4976 assert_eq!(
4977 requests_count.load(atomic::Ordering::Acquire),
4978 2,
4979 "We did drop the previous buffer when cleared the old project search results, hence another query was made",
4980 );
4981
4982 let singleton_editor = workspace
4983 .update_in(cx, |workspace, window, cx| {
4984 workspace.open_abs_path(
4985 PathBuf::from(path!("/dir/main.rs")),
4986 workspace::OpenOptions::default(),
4987 window,
4988 cx,
4989 )
4990 })
4991 .await
4992 .unwrap()
4993 .downcast::<Editor>()
4994 .unwrap();
4995 cx.executor().advance_clock(Duration::from_millis(100));
4996 cx.executor().run_until_parked();
4997 singleton_editor.update(cx, |editor, cx| {
4998 assert_eq!(
4999 editor.display_text(cx),
5000 "fn main() { let a: i32 = 2; }\n",
5001 "Newly opened editor should have the correct text with hints",
5002 );
5003 });
5004 assert_eq!(
5005 requests_count.load(atomic::Ordering::Acquire),
5006 2,
5007 "Opening the same buffer again should reuse the cached hints",
5008 );
5009
5010 window
5011 .update(cx, |_, window, cx| {
5012 singleton_editor.update(cx, |editor, cx| {
5013 editor.handle_input("test", window, cx);
5014 });
5015 })
5016 .unwrap();
5017
5018 cx.executor().advance_clock(Duration::from_secs(1));
5019 cx.executor().run_until_parked();
5020 singleton_editor.update(cx, |editor, cx| {
5021 assert_eq!(
5022 editor.display_text(cx),
5023 "testfn main() { l: i32et a = 2; }\n",
5024 "Newly opened editor should have the correct text with hints",
5025 );
5026 });
5027 assert_eq!(
5028 requests_count.load(atomic::Ordering::Acquire),
5029 3,
5030 "We have edited the buffer and should send a new request",
5031 );
5032
5033 window
5034 .update(cx, |_, window, cx| {
5035 singleton_editor.update(cx, |editor, cx| {
5036 editor.undo(&editor::actions::Undo, window, cx);
5037 });
5038 })
5039 .unwrap();
5040 cx.executor().advance_clock(Duration::from_secs(1));
5041 cx.executor().run_until_parked();
5042 assert_eq!(
5043 requests_count.load(atomic::Ordering::Acquire),
5044 4,
5045 "We have edited the buffer again and should send a new request again",
5046 );
5047 singleton_editor.update(cx, |editor, cx| {
5048 assert_eq!(
5049 editor.display_text(cx),
5050 "fn main() { let a: i32 = 2; }\n",
5051 "Newly opened editor should have the correct text with hints",
5052 );
5053 });
5054 project.update(cx, |_, cx| {
5055 cx.emit(project::Event::RefreshInlayHints {
5056 server_id: fake_server.server.server_id(),
5057 request_id: Some(1),
5058 });
5059 });
5060 cx.executor().advance_clock(Duration::from_secs(1));
5061 cx.executor().run_until_parked();
5062 assert_eq!(
5063 requests_count.load(atomic::Ordering::Acquire),
5064 5,
5065 "After a simulated server refresh request, we should have sent another request",
5066 );
5067
5068 perform_search(search_view, "let ", cx);
5069 cx.executor().advance_clock(Duration::from_secs(1));
5070 cx.executor().run_until_parked();
5071 assert_eq!(
5072 requests_count.load(atomic::Ordering::Acquire),
5073 5,
5074 "New project search should reuse the cached hints",
5075 );
5076 search_view
5077 .update(cx, |search_view, _, cx| {
5078 assert_eq!(
5079 search_view
5080 .results_editor
5081 .update(cx, |editor, cx| editor.display_text(cx)),
5082 "\n\nfn main() { let a: i32 = 2; }\n"
5083 );
5084 })
5085 .unwrap();
5086 }
5087
5088 #[gpui::test]
5089 async fn test_deleted_file_removed_from_search_results(cx: &mut TestAppContext) {
5090 init_test(cx);
5091
5092 let fs = FakeFs::new(cx.background_executor.clone());
5093 fs.insert_tree(
5094 path!("/dir"),
5095 json!({
5096 "file_a.txt": "hello world",
5097 "file_b.txt": "hello universe",
5098 }),
5099 )
5100 .await;
5101
5102 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
5103 let window =
5104 cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
5105 let workspace = window
5106 .read_with(cx, |mw, _| mw.workspace().clone())
5107 .unwrap();
5108 let search = cx.new(|cx| ProjectSearch::new(project.clone(), cx));
5109 let search_view = cx.add_window(|window, cx| {
5110 ProjectSearchView::new(workspace.downgrade(), search.clone(), window, cx, None)
5111 });
5112
5113 perform_search(search_view, "hello", cx);
5114
5115 search_view
5116 .update(cx, |search_view, _window, cx| {
5117 let match_count = search_view.entity.read(cx).match_ranges.len();
5118 assert_eq!(match_count, 2, "Should have matches from both files");
5119 })
5120 .unwrap();
5121
5122 // Delete file_b.txt
5123 fs.remove_file(
5124 path!("/dir/file_b.txt").as_ref(),
5125 fs::RemoveOptions::default(),
5126 )
5127 .await
5128 .unwrap();
5129 cx.run_until_parked();
5130
5131 // Verify deleted file's results are removed proactively
5132 search_view
5133 .update(cx, |search_view, _window, cx| {
5134 let results_text = search_view
5135 .results_editor
5136 .update(cx, |editor, cx| editor.display_text(cx));
5137 assert!(
5138 !results_text.contains("universe"),
5139 "Deleted file's content should be removed from results, got: {results_text}"
5140 );
5141 assert!(
5142 results_text.contains("world"),
5143 "Remaining file's content should still be present, got: {results_text}"
5144 );
5145 })
5146 .unwrap();
5147
5148 // Re-run the search and verify deleted file stays gone
5149 perform_search(search_view, "hello", cx);
5150
5151 search_view
5152 .update(cx, |search_view, _window, cx| {
5153 let results_text = search_view
5154 .results_editor
5155 .update(cx, |editor, cx| editor.display_text(cx));
5156 assert!(
5157 !results_text.contains("universe"),
5158 "Deleted file should not reappear after re-search, got: {results_text}"
5159 );
5160 assert!(
5161 results_text.contains("world"),
5162 "Remaining file should still be found, got: {results_text}"
5163 );
5164 assert_eq!(
5165 search_view.entity.read(cx).match_ranges.len(),
5166 1,
5167 "Should only have match from the remaining file"
5168 );
5169 })
5170 .unwrap();
5171 }
5172
5173 #[gpui::test]
5174 async fn test_deploy_search_applies_and_resets_options(cx: &mut TestAppContext) {
5175 init_test(cx);
5176
5177 let fs = FakeFs::new(cx.background_executor.clone());
5178 fs.insert_tree(
5179 path!("/dir"),
5180 json!({
5181 "one.rs": "const ONE: usize = 1;",
5182 }),
5183 )
5184 .await;
5185 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
5186 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
5187 let workspace = window
5188 .read_with(cx, |mw, _| mw.workspace().clone())
5189 .unwrap();
5190 let cx = &mut VisualTestContext::from_window(window.into(), cx);
5191 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
5192
5193 workspace.update_in(cx, |workspace, window, cx| {
5194 workspace.panes()[0].update(cx, |pane, cx| {
5195 pane.toolbar()
5196 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
5197 });
5198
5199 ProjectSearchView::deploy_search(
5200 workspace,
5201 &workspace::DeploySearch {
5202 regex: Some(true),
5203 case_sensitive: Some(true),
5204 whole_word: Some(true),
5205 include_ignored: Some(true),
5206 query: Some("Test_Query".into()),
5207 ..Default::default()
5208 },
5209 window,
5210 cx,
5211 )
5212 });
5213
5214 let search_view = cx
5215 .read(|cx| {
5216 workspace
5217 .read(cx)
5218 .active_pane()
5219 .read(cx)
5220 .active_item()
5221 .and_then(|item| item.downcast::<ProjectSearchView>())
5222 })
5223 .expect("Search view should be active after deploy");
5224
5225 search_view.update_in(cx, |search_view, _window, cx| {
5226 assert!(
5227 search_view.search_options.contains(SearchOptions::REGEX),
5228 "Regex option should be enabled"
5229 );
5230 assert!(
5231 search_view
5232 .search_options
5233 .contains(SearchOptions::CASE_SENSITIVE),
5234 "Case sensitive option should be enabled"
5235 );
5236 assert!(
5237 search_view
5238 .search_options
5239 .contains(SearchOptions::WHOLE_WORD),
5240 "Whole word option should be enabled"
5241 );
5242 assert!(
5243 search_view
5244 .search_options
5245 .contains(SearchOptions::INCLUDE_IGNORED),
5246 "Include ignored option should be enabled"
5247 );
5248 let query_text = search_view.query_editor.read(cx).text(cx);
5249 assert_eq!(
5250 query_text, "Test_Query",
5251 "Query should be set from the action"
5252 );
5253 });
5254
5255 // Redeploy with only regex - unspecified options should be preserved.
5256 cx.dispatch_action(menu::Cancel);
5257 workspace.update_in(cx, |workspace, window, cx| {
5258 ProjectSearchView::deploy_search(
5259 workspace,
5260 &workspace::DeploySearch {
5261 regex: Some(true),
5262 ..Default::default()
5263 },
5264 window,
5265 cx,
5266 )
5267 });
5268
5269 search_view.update_in(cx, |search_view, _window, _cx| {
5270 assert!(
5271 search_view.search_options.contains(SearchOptions::REGEX),
5272 "Regex should still be enabled"
5273 );
5274 assert!(
5275 search_view
5276 .search_options
5277 .contains(SearchOptions::CASE_SENSITIVE),
5278 "Case sensitive should be preserved from previous deploy"
5279 );
5280 assert!(
5281 search_view
5282 .search_options
5283 .contains(SearchOptions::WHOLE_WORD),
5284 "Whole word should be preserved from previous deploy"
5285 );
5286 assert!(
5287 search_view
5288 .search_options
5289 .contains(SearchOptions::INCLUDE_IGNORED),
5290 "Include ignored should be preserved from previous deploy"
5291 );
5292 });
5293
5294 // Redeploy explicitly turning off options.
5295 cx.dispatch_action(menu::Cancel);
5296 workspace.update_in(cx, |workspace, window, cx| {
5297 ProjectSearchView::deploy_search(
5298 workspace,
5299 &workspace::DeploySearch {
5300 regex: Some(true),
5301 case_sensitive: Some(false),
5302 whole_word: Some(false),
5303 include_ignored: Some(false),
5304 ..Default::default()
5305 },
5306 window,
5307 cx,
5308 )
5309 });
5310
5311 search_view.update_in(cx, |search_view, _window, _cx| {
5312 assert_eq!(
5313 search_view.search_options,
5314 SearchOptions::REGEX,
5315 "Explicit Some(false) should turn off options"
5316 );
5317 });
5318
5319 // Redeploy with an empty query - should not overwrite the existing query.
5320 cx.dispatch_action(menu::Cancel);
5321 workspace.update_in(cx, |workspace, window, cx| {
5322 ProjectSearchView::deploy_search(
5323 workspace,
5324 &workspace::DeploySearch {
5325 query: Some("".into()),
5326 ..Default::default()
5327 },
5328 window,
5329 cx,
5330 )
5331 });
5332
5333 search_view.update_in(cx, |search_view, _window, cx| {
5334 let query_text = search_view.query_editor.read(cx).text(cx);
5335 assert_eq!(
5336 query_text, "Test_Query",
5337 "Empty query string should not overwrite the existing query"
5338 );
5339 });
5340 }
5341
5342 #[gpui::test]
5343 async fn test_smartcase_overrides_explicit_case_sensitive(cx: &mut TestAppContext) {
5344 init_test(cx);
5345
5346 cx.update(|cx| {
5347 cx.update_global::<SettingsStore, _>(|store, cx| {
5348 store.update_default_settings(cx, |settings| {
5349 settings.editor.use_smartcase_search = Some(true);
5350 });
5351 });
5352 });
5353
5354 let fs = FakeFs::new(cx.background_executor.clone());
5355 fs.insert_tree(
5356 path!("/dir"),
5357 json!({
5358 "one.rs": "const ONE: usize = 1;",
5359 }),
5360 )
5361 .await;
5362 let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
5363 let window = cx.add_window(|window, cx| MultiWorkspace::test_new(project, window, cx));
5364 let workspace = window
5365 .read_with(cx, |mw, _| mw.workspace().clone())
5366 .unwrap();
5367 let cx = &mut VisualTestContext::from_window(window.into(), cx);
5368 let search_bar = window.build_entity(cx, |_, _| ProjectSearchBar::new());
5369
5370 workspace.update_in(cx, |workspace, window, cx| {
5371 workspace.panes()[0].update(cx, |pane, cx| {
5372 pane.toolbar()
5373 .update(cx, |toolbar, cx| toolbar.add_item(search_bar, window, cx))
5374 });
5375
5376 ProjectSearchView::deploy_search(
5377 workspace,
5378 &workspace::DeploySearch {
5379 case_sensitive: Some(true),
5380 query: Some("lowercase_query".into()),
5381 ..Default::default()
5382 },
5383 window,
5384 cx,
5385 )
5386 });
5387
5388 let search_view = cx
5389 .read(|cx| {
5390 workspace
5391 .read(cx)
5392 .active_pane()
5393 .read(cx)
5394 .active_item()
5395 .and_then(|item| item.downcast::<ProjectSearchView>())
5396 })
5397 .expect("Search view should be active after deploy");
5398
5399 // Smartcase should override the explicit case_sensitive flag
5400 // because the query is all lowercase.
5401 search_view.update_in(cx, |search_view, _window, cx| {
5402 assert!(
5403 !search_view
5404 .search_options
5405 .contains(SearchOptions::CASE_SENSITIVE),
5406 "Smartcase should disable case sensitivity for a lowercase query, \
5407 even when case_sensitive was explicitly set in the action"
5408 );
5409 let query_text = search_view.query_editor.read(cx).text(cx);
5410 assert_eq!(query_text, "lowercase_query");
5411 });
5412
5413 // Now deploy with an uppercase query - smartcase should enable case sensitivity.
5414 workspace.update_in(cx, |workspace, window, cx| {
5415 ProjectSearchView::deploy_search(
5416 workspace,
5417 &workspace::DeploySearch {
5418 query: Some("Uppercase_Query".into()),
5419 ..Default::default()
5420 },
5421 window,
5422 cx,
5423 )
5424 });
5425
5426 search_view.update_in(cx, |search_view, _window, cx| {
5427 assert!(
5428 search_view
5429 .search_options
5430 .contains(SearchOptions::CASE_SENSITIVE),
5431 "Smartcase should enable case sensitivity for a query containing uppercase"
5432 );
5433 let query_text = search_view.query_editor.read(cx).text(cx);
5434 assert_eq!(query_text, "Uppercase_Query");
5435 });
5436 }
5437
5438 fn init_test(cx: &mut TestAppContext) {
5439 cx.update(|cx| {
5440 let settings = SettingsStore::test(cx);
5441 cx.set_global(settings);
5442
5443 theme_settings::init(theme::LoadThemes::JustBase, cx);
5444
5445 editor::init(cx);
5446 crate::init(cx);
5447 });
5448 }
5449
5450 fn perform_search(
5451 search_view: WindowHandle<ProjectSearchView>,
5452 text: impl Into<Arc<str>>,
5453 cx: &mut TestAppContext,
5454 ) {
5455 search_view
5456 .update(cx, |search_view, window, cx| {
5457 search_view.query_editor.update(cx, |query_editor, cx| {
5458 query_editor.set_text(text, window, cx)
5459 });
5460 search_view.search(cx);
5461 })
5462 .unwrap();
5463 // Ensure editor highlights appear after the search is done
5464 cx.executor().advance_clock(
5465 editor::SELECTION_HIGHLIGHT_DEBOUNCE_TIMEOUT + Duration::from_millis(100),
5466 );
5467 cx.background_executor.run_until_parked();
5468 }
5469}