use crate::{ history::SearchHistory, mode::SearchMode, ActivateRegexMode, ActivateTextMode, CycleMode, NextHistoryQuery, PreviousHistoryQuery, ReplaceAll, ReplaceNext, SearchOptions, SelectNextMatch, SelectPrevMatch, ToggleCaseSensitive, ToggleReplace, ToggleWholeWord, }; use anyhow::{Context as _, Result}; use collections::HashMap; use editor::{ items::active_match_index, scroll::autoscroll::Autoscroll, Anchor, Editor, EditorEvent, MultiBuffer, SelectAll, MAX_TAB_TITLE_LEN, }; use gpui::{ actions, div, white, AnyElement, AnyView, AppContext, Context as _, Div, Element, EntityId, EventEmitter, FocusableView, InteractiveElement, IntoElement, KeyContext, Model, ModelContext, ParentElement, PromptLevel, Render, SharedString, Styled, Subscription, Task, View, ViewContext, VisualContext, WeakModel, WeakView, WindowContext, }; use menu::Confirm; use project::{ search::{SearchInputs, SearchQuery}, Entry, Project, }; use semantic_index::{SemanticIndex, SemanticIndexStatus}; use smol::stream::StreamExt; use std::{ any::{Any, TypeId}, collections::HashSet, mem, ops::{Not, Range}, path::PathBuf, time::Duration, }; use ui::{ h_stack, v_stack, Button, ButtonCommon, Clickable, Disableable, Icon, IconButton, IconElement, Label, LabelCommon, LabelSize, Selectable, Tooltip, }; use util::{paths::PathMatcher, ResultExt as _}; use workspace::{ item::{BreadcrumbText, Item, ItemEvent, ItemHandle}, searchable::{Direction, SearchableItem, SearchableItemHandle}, ItemNavHistory, Pane, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace, WorkspaceId, }; actions!( project_search, [SearchInNew, ToggleFocus, NextField, ToggleFilters] ); #[derive(Default)] struct ActiveSearches(HashMap, WeakView>); #[derive(Default)] struct ActiveSettings(HashMap, ProjectSearchSettings>); pub fn init(cx: &mut AppContext) { // todo!() po cx.set_global(ActiveSearches::default()); cx.set_global(ActiveSettings::default()); cx.observe_new_views(|workspace: &mut Workspace, _cx| { workspace .register_action(ProjectSearchView::deploy) .register_action(ProjectSearchBar::search_in_new); }) .detach(); } struct ProjectSearch { project: Model, excerpts: Model, pending_search: Option>>, match_ranges: Vec>, active_query: Option, search_id: usize, search_history: SearchHistory, no_results: Option, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] enum InputPanel { Query, Exclude, Include, } pub struct ProjectSearchView { model: Model, query_editor: View, replacement_editor: View, results_editor: View, semantic_state: Option, semantic_permissioned: Option, search_options: SearchOptions, panels_with_errors: HashSet, active_match_index: Option, search_id: usize, query_editor_was_focused: bool, included_files_editor: View, excluded_files_editor: View, filters_enabled: bool, replace_enabled: bool, current_mode: SearchMode, } struct SemanticState { index_status: SemanticIndexStatus, maintain_rate_limit: Option>, _subscription: Subscription, } #[derive(Debug, Clone)] struct ProjectSearchSettings { search_options: SearchOptions, filters_enabled: bool, current_mode: SearchMode, } pub struct ProjectSearchBar { active_project_search: Option>, subscription: Option, } impl ProjectSearch { fn new(project: Model, cx: &mut ModelContext) -> Self { let replica_id = project.read(cx).replica_id(); Self { project, excerpts: cx.build_model(|_| MultiBuffer::new(replica_id)), pending_search: Default::default(), match_ranges: Default::default(), active_query: None, search_id: 0, search_history: SearchHistory::default(), no_results: None, } } fn clone(&self, cx: &mut ModelContext) -> Model { cx.build_model(|cx| Self { project: self.project.clone(), excerpts: self .excerpts .update(cx, |excerpts, cx| cx.build_model(|cx| excerpts.clone(cx))), pending_search: Default::default(), match_ranges: self.match_ranges.clone(), active_query: self.active_query.clone(), search_id: self.search_id, search_history: self.search_history.clone(), no_results: self.no_results.clone(), }) } fn search(&mut self, query: SearchQuery, cx: &mut ModelContext) { let search = self .project .update(cx, |project, cx| project.search(query.clone(), cx)); self.search_id += 1; self.search_history.add(query.as_str().to_string()); self.active_query = Some(query); self.match_ranges.clear(); self.pending_search = Some(cx.spawn(|this, mut cx| async move { let mut matches = search; let this = this.upgrade()?; this.update(&mut cx, |this, cx| { this.match_ranges.clear(); this.excerpts.update(cx, |this, cx| this.clear(cx)); this.no_results = Some(true); }) .ok()?; while let Some((buffer, anchors)) = matches.next().await { let mut ranges = this .update(&mut cx, |this, cx| { this.no_results = Some(false); this.excerpts.update(cx, |excerpts, cx| { excerpts.stream_excerpts_with_context_lines(buffer, anchors, 1, cx) }) }) .ok()?; while let Some(range) = ranges.next().await { this.update(&mut cx, |this, _| this.match_ranges.push(range)) .ok()?; } this.update(&mut cx, |_, cx| cx.notify()).ok()?; } this.update(&mut cx, |this, cx| { this.pending_search.take(); cx.notify(); }) .ok()?; None })); cx.notify(); } fn semantic_search(&mut self, inputs: &SearchInputs, cx: &mut ModelContext) { let search = SemanticIndex::global(cx).map(|index| { index.update(cx, |semantic_index, cx| { semantic_index.search_project( self.project.clone(), inputs.as_str().to_owned(), 10, inputs.files_to_include().to_vec(), inputs.files_to_exclude().to_vec(), cx, ) }) }); self.search_id += 1; self.match_ranges.clear(); self.search_history.add(inputs.as_str().to_string()); self.no_results = None; self.pending_search = Some(cx.spawn(|this, mut cx| async move { let results = search?.await.log_err()?; let matches = results .into_iter() .map(|result| (result.buffer, vec![result.range.start..result.range.start])); this.update(&mut cx, |this, cx| { this.no_results = Some(true); this.excerpts.update(cx, |excerpts, cx| { excerpts.clear(cx); }); }) .ok()?; for (buffer, ranges) in matches { let mut match_ranges = this .update(&mut cx, |this, cx| { this.no_results = Some(false); this.excerpts.update(cx, |excerpts, cx| { excerpts.stream_excerpts_with_context_lines(buffer, ranges, 3, cx) }) }) .ok()?; while let Some(match_range) = match_ranges.next().await { this.update(&mut cx, |this, cx| { this.match_ranges.push(match_range); while let Ok(Some(match_range)) = match_ranges.try_next() { this.match_ranges.push(match_range); } cx.notify(); }) .ok()?; } } this.update(&mut cx, |this, cx| { this.pending_search.take(); cx.notify(); }) .ok()?; None })); cx.notify(); } } #[derive(Clone, Debug, PartialEq, Eq)] pub enum ViewEvent { UpdateTab, Activate, EditorEvent(editor::EditorEvent), Dismiss, } impl EventEmitter for ProjectSearchView {} impl Render for ProjectSearchView { type Element = Div; fn render(&mut self, cx: &mut ViewContext) -> Self::Element { if self.has_matches() { div() .flex_1() .size_full() .child(self.results_editor.clone()) } else { let model = self.model.read(cx); let has_no_results = model.no_results.unwrap_or(false); let is_search_underway = model.pending_search.is_some(); let major_text = if is_search_underway { Label::new("Searching...") } else if has_no_results { Label::new("No results for a given query") } else { Label::new(format!("{} search all files", self.current_mode.label())) }; let major_text = div().justify_center().max_w_96().child(major_text); let middle_text = div() .items_center() .max_w_96() .child(Label::new(self.landing_text_minor()).size(LabelSize::Small)); v_stack().flex_1().size_full().justify_center().child( h_stack() .size_full() .justify_center() .child(h_stack().flex_1()) .child(v_stack().child(major_text).child(middle_text)) .child(h_stack().flex_1()), ) } } } // impl Entity for ProjectSearchView { // type Event = ViewEvent; // } // impl View for ProjectSearchView { // fn ui_name() -> &'static str { // "ProjectSearchView" // } // fn render(&mut self, cx: &mut ViewContext) -> AnyElement { // let model = &self.model.read(cx); // if model.match_ranges.is_empty() { // enum Status {} // let theme = theme::current(cx).clone(); // // If Search is Active -> Major: Searching..., Minor: None // // If Semantic -> Major: "Search using Natural Language", Minor: {Status}/n{ex...}/n{ex...} // // If Regex -> Major: "Search using Regex", Minor: {ex...} // // If Text -> Major: "Text search all files and folders", Minor: {...} // let current_mode = self.current_mode; // let mut major_text = if model.pending_search.is_some() { // Cow::Borrowed("Searching...") // } else if model.no_results.is_some_and(|v| v) { // Cow::Borrowed("No Results") // } else { // match current_mode { // SearchMode::Text => Cow::Borrowed("Text search all files and folders"), // SearchMode::Semantic => { // Cow::Borrowed("Search all code objects using Natural Language") // } // SearchMode::Regex => Cow::Borrowed("Regex search all files and folders"), // } // }; // let mut show_minor_text = true; // let semantic_status = self.semantic_state.as_ref().and_then(|semantic| { // let status = semantic.index_status; // match status { // SemanticIndexStatus::NotAuthenticated => { // major_text = Cow::Borrowed("Not Authenticated"); // show_minor_text = false; // Some(vec![ // "API Key Missing: Please set 'OPENAI_API_KEY' in Environment Variables." // .to_string(), "If you authenticated using the Assistant Panel, please restart Zed to Authenticate.".to_string()]) // } // SemanticIndexStatus::Indexed => Some(vec!["Indexing complete".to_string()]), // SemanticIndexStatus::Indexing { // remaining_files, // rate_limit_expiry, // } => { // if remaining_files == 0 { // Some(vec![format!("Indexing...")]) // } else { // if let Some(rate_limit_expiry) = rate_limit_expiry { // let remaining_seconds = // rate_limit_expiry.duration_since(Instant::now()); // if remaining_seconds > Duration::from_secs(0) { // Some(vec![format!( // "Remaining files to index (rate limit resets in {}s): {}", // remaining_seconds.as_secs(), // remaining_files // )]) // } else { // Some(vec![format!("Remaining files to index: {}", remaining_files)]) // } // } else { // Some(vec![format!("Remaining files to index: {}", remaining_files)]) // } // } // } // SemanticIndexStatus::NotIndexed => None, // } // }); // let minor_text = if let Some(no_results) = model.no_results { // if model.pending_search.is_none() && no_results { // vec!["No results found in this project for the provided query".to_owned()] // } else { // vec![] // } // } else { // match current_mode { // SearchMode::Semantic => { // let mut minor_text: Vec = Vec::new(); // minor_text.push("".into()); // if let Some(semantic_status) = semantic_status { // minor_text.extend(semantic_status); // } // if show_minor_text { // minor_text // .push("Simply explain the code you are looking to find.".into()); // minor_text.push( // "ex. 'prompt user for permissions to index their project'".into(), // ); // } // minor_text // } // _ => vec![ // "".to_owned(), // "Include/exclude specific paths with the filter option.".to_owned(), // "Matching exact word and/or casing is available too.".to_owned(), // ], // } // }; // MouseEventHandler::new::(0, cx, |_, _| { // Flex::column() // .with_child(Flex::column().contained().flex(1., true)) // .with_child( // Flex::column() // .align_children_center() // .with_child(Label::new( // major_text, // theme.search.major_results_status.clone(), // )) // .with_children( // minor_text.into_iter().map(|x| { // Label::new(x, theme.search.minor_results_status.clone()) // }), // ) // .aligned() // .top() // .contained() // .flex(7., true), // ) // .contained() // .with_background_color(theme.editor.background) // }) // .on_down(MouseButton::Left, |_, _, cx| { // cx.focus_parent(); // }) // .into_any_named("project search view") // } else { // ChildView::new(&self.results_editor, cx) // .flex(1., true) // .into_any_named("project search view") // } // } // fn focus_in(&mut self, _: AnyView, cx: &mut ViewContext) { // let handle = cx.weak_handle(); // cx.update_global(|state: &mut ActiveSearches, cx| { // state // .0 // .insert(self.model.read(cx).project.downgrade(), handle) // }); // cx.update_global(|state: &mut ActiveSettings, cx| { // state.0.insert( // self.model.read(cx).project.downgrade(), // self.current_settings(), // ); // }); // if cx.is_self_focused() { // if self.query_editor_was_focused { // cx.focus(&self.query_editor); // } else { // cx.focus(&self.results_editor); // } // } // } // } impl FocusableView for ProjectSearchView { fn focus_handle(&self, cx: &AppContext) -> gpui::FocusHandle { self.results_editor.focus_handle(cx) } } impl Item for ProjectSearchView { type Event = ViewEvent; fn tab_tooltip_text(&self, cx: &AppContext) -> Option { let query_text = self.query_editor.read(cx).text(cx); query_text .is_empty() .not() .then(|| query_text.into()) .or_else(|| Some("Project Search".into())) } fn act_as_type<'a>( &'a self, type_id: TypeId, self_handle: &'a View, _: &'a AppContext, ) -> Option { if type_id == TypeId::of::() { Some(self_handle.clone().into()) } else if type_id == TypeId::of::() { Some(self.results_editor.clone().into()) } else { None } } fn deactivated(&mut self, cx: &mut ViewContext) { self.results_editor .update(cx, |editor, cx| editor.deactivated(cx)); } fn tab_content(&self, _: Option, cx: &WindowContext<'_>) -> AnyElement { let last_query: Option = self .model .read(cx) .search_history .current() .as_ref() .map(|query| { let query_text = util::truncate_and_trailoff(query, MAX_TAB_TITLE_LEN); query_text.into() }); let tab_name = last_query .filter(|query| !query.is_empty()) .unwrap_or_else(|| "Project search".into()); h_stack() .child(IconElement::new(Icon::MagnifyingGlass)) .child(Label::new(tab_name)) .into_any() } fn for_each_project_item( &self, cx: &AppContext, f: &mut dyn FnMut(EntityId, &dyn project::Item), ) { self.results_editor.for_each_project_item(cx, f) } fn is_singleton(&self, _: &AppContext) -> bool { false } fn can_save(&self, _: &AppContext) -> bool { true } fn is_dirty(&self, cx: &AppContext) -> bool { self.results_editor.read(cx).is_dirty(cx) } fn has_conflict(&self, cx: &AppContext) -> bool { self.results_editor.read(cx).has_conflict(cx) } fn save( &mut self, project: Model, cx: &mut ViewContext, ) -> Task> { self.results_editor .update(cx, |editor, cx| editor.save(project, cx)) } fn save_as( &mut self, _: Model, _: PathBuf, _: &mut ViewContext, ) -> Task> { unreachable!("save_as should not have been called") } fn reload( &mut self, project: Model, cx: &mut ViewContext, ) -> Task> { self.results_editor .update(cx, |editor, cx| editor.reload(project, cx)) } fn clone_on_split( &self, _workspace_id: WorkspaceId, cx: &mut ViewContext, ) -> Option> where Self: Sized, { let model = self.model.update(cx, |model, cx| model.clone(cx)); Some(cx.build_view(|cx| Self::new(model, cx, None))) } fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext) { self.results_editor .update(cx, |editor, cx| editor.added_to_workspace(workspace, cx)); } fn set_nav_history(&mut self, nav_history: ItemNavHistory, cx: &mut ViewContext) { self.results_editor.update(cx, |editor, _| { editor.set_nav_history(Some(nav_history)); }); } fn navigate(&mut self, data: Box, cx: &mut ViewContext) -> bool { self.results_editor .update(cx, |editor, cx| editor.navigate(data, cx)) } fn to_item_events(event: &Self::Event, mut f: impl FnMut(ItemEvent)) { match event { ViewEvent::UpdateTab => { f(ItemEvent::UpdateBreadcrumbs); f(ItemEvent::UpdateTab); } ViewEvent::EditorEvent(editor_event) => { Editor::to_item_events(editor_event, f); } ViewEvent::Dismiss => f(ItemEvent::CloseItem), _ => {} } } fn breadcrumb_location(&self) -> ToolbarItemLocation { if self.has_matches() { ToolbarItemLocation::Secondary } else { ToolbarItemLocation::Hidden } } fn breadcrumbs(&self, theme: &theme::Theme, cx: &AppContext) -> Option> { self.results_editor.breadcrumbs(theme, cx) } fn serialized_item_kind() -> Option<&'static str> { None } fn deserialize( _project: Model, _workspace: WeakView, _workspace_id: workspace::WorkspaceId, _item_id: workspace::ItemId, _cx: &mut ViewContext, ) -> Task>> { unimplemented!() } } impl ProjectSearchView { fn toggle_filters(&mut self, cx: &mut ViewContext) { self.filters_enabled = !self.filters_enabled; cx.update_global(|state: &mut ActiveSettings, cx| { state.0.insert( self.model.read(cx).project.downgrade(), self.current_settings(), ); }); } fn current_settings(&self) -> ProjectSearchSettings { ProjectSearchSettings { search_options: self.search_options, filters_enabled: self.filters_enabled, current_mode: self.current_mode, } } fn toggle_search_option(&mut self, option: SearchOptions, cx: &mut ViewContext) { self.search_options.toggle(option); cx.update_global(|state: &mut ActiveSettings, cx| { state.0.insert( self.model.read(cx).project.downgrade(), self.current_settings(), ); }); } fn index_project(&mut self, cx: &mut ViewContext) { if let Some(semantic_index) = SemanticIndex::global(cx) { // Semantic search uses no options self.search_options = SearchOptions::none(); let project = self.model.read(cx).project.clone(); semantic_index.update(cx, |semantic_index, cx| { semantic_index .index_project(project.clone(), cx) .detach_and_log_err(cx); }); self.semantic_state = Some(SemanticState { index_status: semantic_index.read(cx).status(&project), maintain_rate_limit: None, _subscription: cx.observe(&semantic_index, Self::semantic_index_changed), }); self.semantic_index_changed(semantic_index, cx); } } fn semantic_index_changed( &mut self, semantic_index: Model, cx: &mut ViewContext, ) { let project = self.model.read(cx).project.clone(); if let Some(semantic_state) = self.semantic_state.as_mut() { cx.notify(); semantic_state.index_status = semantic_index.read(cx).status(&project); if let SemanticIndexStatus::Indexing { rate_limit_expiry: Some(_), .. } = &semantic_state.index_status { if semantic_state.maintain_rate_limit.is_none() { semantic_state.maintain_rate_limit = Some(cx.spawn(|this, mut cx| async move { loop { cx.background_executor().timer(Duration::from_secs(1)).await; this.update(&mut cx, |_, cx| cx.notify()).log_err(); } })); return; } } else { semantic_state.maintain_rate_limit = None; } } } fn clear_search(&mut self, cx: &mut ViewContext) { self.model.update(cx, |model, cx| { model.pending_search = None; model.no_results = None; model.match_ranges.clear(); model.excerpts.update(cx, |excerpts, cx| { excerpts.clear(cx); }); }); } fn activate_search_mode(&mut self, mode: SearchMode, cx: &mut ViewContext) { let previous_mode = self.current_mode; if previous_mode == mode { return; } self.clear_search(cx); self.current_mode = mode; self.active_match_index = None; match mode { SearchMode::Semantic => { let has_permission = self.semantic_permissioned(cx); self.active_match_index = None; cx.spawn(|this, mut cx| async move { let has_permission = has_permission.await?; if !has_permission { let answer = this.update(&mut cx, |this, cx| { let project = this.model.read(cx).project.clone(); let project_name = project .read(cx) .worktree_root_names(cx) .collect::>() .join("/"); let is_plural = project_name.chars().filter(|letter| *letter == '/').count() > 0; let prompt_text = format!("Would you like to index the '{}' project{} for semantic search? This requires sending code to the OpenAI API", project_name, if is_plural { "s" } else {""}); cx.prompt( PromptLevel::Info, prompt_text.as_str(), &["Continue", "Cancel"], ) })?; if answer.await? == 0 { this.update(&mut cx, |this, _| { this.semantic_permissioned = Some(true); })?; } else { this.update(&mut cx, |this, cx| { this.semantic_permissioned = Some(false); debug_assert_ne!(previous_mode, SearchMode::Semantic, "Tried to re-enable semantic search mode after user modal was rejected"); this.activate_search_mode(previous_mode, cx); })?; return anyhow::Ok(()); } } this.update(&mut cx, |this, cx| { this.index_project(cx); })?; anyhow::Ok(()) }).detach_and_log_err(cx); } SearchMode::Regex | SearchMode::Text => { self.semantic_state = None; self.active_match_index = None; self.search(cx); } } cx.update_global(|state: &mut ActiveSettings, cx| { state.0.insert( self.model.read(cx).project.downgrade(), self.current_settings(), ); }); cx.notify(); } fn replace_next(&mut self, _: &ReplaceNext, cx: &mut ViewContext) { let model = self.model.read(cx); if let Some(query) = model.active_query.as_ref() { if model.match_ranges.is_empty() { return; } if let Some(active_index) = self.active_match_index { let query = query.clone().with_replacement(self.replacement(cx)); self.results_editor.replace( &(Box::new(model.match_ranges[active_index].clone()) as _), &query, cx, ); self.select_match(Direction::Next, cx) } } } pub fn replacement(&self, cx: &AppContext) -> String { self.replacement_editor.read(cx).text(cx) } fn replace_all(&mut self, _: &ReplaceAll, cx: &mut ViewContext) { let model = self.model.read(cx); if let Some(query) = model.active_query.as_ref() { if model.match_ranges.is_empty() { return; } if self.active_match_index.is_some() { let query = query.clone().with_replacement(self.replacement(cx)); let matches = model .match_ranges .iter() .map(|item| Box::new(item.clone()) as _) .collect::>(); for item in matches { self.results_editor.replace(&item, &query, cx); } } } } fn new( model: Model, cx: &mut ViewContext, settings: Option, ) -> Self { let project; let excerpts; let mut replacement_text = None; let mut query_text = String::new(); // Read in settings if available let (mut options, current_mode, filters_enabled) = if let Some(settings) = settings { ( settings.search_options, settings.current_mode, settings.filters_enabled, ) } else { (SearchOptions::NONE, Default::default(), false) }; { let model = model.read(cx); project = model.project.clone(); excerpts = model.excerpts.clone(); if let Some(active_query) = model.active_query.as_ref() { query_text = active_query.as_str().to_string(); replacement_text = active_query.replacement().map(ToOwned::to_owned); options = SearchOptions::from_query(active_query); } } cx.observe(&model, |this, _, cx| this.model_changed(cx)) .detach(); let query_editor = cx.build_view(|cx| { let mut editor = Editor::single_line(cx); editor.set_placeholder_text("Text search all files", cx); editor.set_text(query_text, cx); editor }); // Subscribe to query_editor in order to reraise editor events for workspace item activation purposes cx.subscribe(&query_editor, |_, _, event: &EditorEvent, cx| { cx.emit(ViewEvent::EditorEvent(event.clone())) }) .detach(); let replacement_editor = cx.build_view(|cx| { let mut editor = Editor::single_line(cx); editor.set_placeholder_text("Replace in project..", cx); if let Some(text) = replacement_text { editor.set_text(text, cx); } editor }); let results_editor = cx.build_view(|cx| { let mut editor = Editor::for_multibuffer(excerpts, Some(project.clone()), cx); editor.set_searchable(false); editor }); cx.observe(&results_editor, |_, _, cx| cx.emit(ViewEvent::UpdateTab)) .detach(); cx.subscribe(&results_editor, |this, _, event: &EditorEvent, cx| { if matches!(event, editor::EditorEvent::SelectionsChanged { .. }) { this.update_match_index(cx); } // Reraise editor events for workspace item activation purposes cx.emit(ViewEvent::EditorEvent(event.clone())); }) .detach(); let included_files_editor = cx.build_view(|cx| { let mut editor = Editor::single_line(cx); editor.set_placeholder_text("Include: crates/**/*.toml", cx); editor }); // Subscribe to include_files_editor in order to reraise editor events for workspace item activation purposes cx.subscribe(&included_files_editor, |_, _, event: &EditorEvent, cx| { cx.emit(ViewEvent::EditorEvent(event.clone())) }) .detach(); let excluded_files_editor = cx.build_view(|cx| { let mut editor = Editor::single_line(cx); editor.set_placeholder_text("Exclude: vendor/*, *.lock", cx); editor }); // Subscribe to excluded_files_editor in order to reraise editor events for workspace item activation purposes cx.subscribe(&excluded_files_editor, |_, _, event: &EditorEvent, cx| { cx.emit(ViewEvent::EditorEvent(event.clone())) }) .detach(); // Check if Worktrees have all been previously indexed let mut this = ProjectSearchView { replacement_editor, search_id: model.read(cx).search_id, model, query_editor, results_editor, semantic_state: None, semantic_permissioned: None, search_options: options, panels_with_errors: HashSet::new(), active_match_index: None, query_editor_was_focused: false, included_files_editor, excluded_files_editor, filters_enabled, current_mode, replace_enabled: false, }; this.model_changed(cx); this } fn semantic_permissioned(&mut self, cx: &mut ViewContext) -> Task> { if let Some(value) = self.semantic_permissioned { return Task::ready(Ok(value)); } SemanticIndex::global(cx) .map(|semantic| { let project = self.model.read(cx).project.clone(); semantic.update(cx, |this, cx| this.project_previously_indexed(&project, cx)) }) .unwrap_or(Task::ready(Ok(false))) } pub fn new_search_in_directory( workspace: &mut Workspace, dir_entry: &Entry, cx: &mut ViewContext, ) { if !dir_entry.is_dir() { return; } let Some(filter_str) = dir_entry.path.to_str() else { return; }; let model = cx.build_model(|cx| ProjectSearch::new(workspace.project().clone(), cx)); let search = cx.build_view(|cx| ProjectSearchView::new(model, cx, None)); workspace.add_item(Box::new(search.clone()), cx); search.update(cx, |search, cx| { search .included_files_editor .update(cx, |editor, cx| editor.set_text(filter_str, cx)); search.filters_enabled = true; search.focus_query_editor(cx) }); } // Add another search tab to the workspace. fn deploy( workspace: &mut Workspace, _: &workspace::NewSearch, cx: &mut ViewContext, ) { // Clean up entries for dropped projects cx.update_global(|state: &mut ActiveSearches, _cx| { state.0.retain(|project, _| project.is_upgradable()) }); let query = workspace.active_item(cx).and_then(|item| { let editor = item.act_as::(cx)?; let query = editor.query_suggestion(cx); if query.is_empty() { None } else { Some(query) } }); let settings = cx .global::() .0 .get(&workspace.project().downgrade()); let settings = if let Some(settings) = settings { Some(settings.clone()) } else { None }; let model = cx.build_model(|cx| ProjectSearch::new(workspace.project().clone(), cx)); let search = cx.build_view(|cx| ProjectSearchView::new(model, cx, settings)); workspace.add_item(Box::new(search.clone()), cx); search.update(cx, |search, cx| { if let Some(query) = query { search.set_query(&query, cx); } search.focus_query_editor(cx) }); } fn search(&mut self, cx: &mut ViewContext) { let mode = self.current_mode; match mode { SearchMode::Semantic => { if self.semantic_state.is_some() { if let Some(query) = self.build_search_query(cx) { self.model .update(cx, |model, cx| model.semantic_search(query.as_inner(), cx)); } } } _ => { if let Some(query) = self.build_search_query(cx) { self.model.update(cx, |model, cx| model.search(query, cx)); } } } } fn build_search_query(&mut self, cx: &mut ViewContext) -> Option { let text = self.query_editor.read(cx).text(cx); let included_files = match Self::parse_path_matches(&self.included_files_editor.read(cx).text(cx)) { Ok(included_files) => { self.panels_with_errors.remove(&InputPanel::Include); included_files } Err(_e) => { self.panels_with_errors.insert(InputPanel::Include); cx.notify(); return None; } }; let excluded_files = match Self::parse_path_matches(&self.excluded_files_editor.read(cx).text(cx)) { Ok(excluded_files) => { self.panels_with_errors.remove(&InputPanel::Exclude); excluded_files } Err(_e) => { self.panels_with_errors.insert(InputPanel::Exclude); cx.notify(); return None; } }; let current_mode = self.current_mode; match current_mode { SearchMode::Regex => { match SearchQuery::regex( text, self.search_options.contains(SearchOptions::WHOLE_WORD), self.search_options.contains(SearchOptions::CASE_SENSITIVE), self.search_options.contains(SearchOptions::INCLUDE_IGNORED), included_files, excluded_files, ) { Ok(query) => { self.panels_with_errors.remove(&InputPanel::Query); Some(query) } Err(_e) => { self.panels_with_errors.insert(InputPanel::Query); cx.notify(); None } } } _ => match SearchQuery::text( text, self.search_options.contains(SearchOptions::WHOLE_WORD), self.search_options.contains(SearchOptions::CASE_SENSITIVE), self.search_options.contains(SearchOptions::INCLUDE_IGNORED), included_files, excluded_files, ) { Ok(query) => { self.panels_with_errors.remove(&InputPanel::Query); Some(query) } Err(_e) => { self.panels_with_errors.insert(InputPanel::Query); cx.notify(); None } }, } } fn parse_path_matches(text: &str) -> anyhow::Result> { text.split(',') .map(str::trim) .filter(|maybe_glob_str| !maybe_glob_str.is_empty()) .map(|maybe_glob_str| { PathMatcher::new(maybe_glob_str) .with_context(|| format!("parsing {maybe_glob_str} as path matcher")) }) .collect() } fn select_match(&mut self, direction: Direction, cx: &mut ViewContext) { if let Some(index) = self.active_match_index { let match_ranges = self.model.read(cx).match_ranges.clone(); let new_index = self.results_editor.update(cx, |editor, cx| { editor.match_index_for_direction(&match_ranges, index, direction, 1, cx) }); let range_to_select = match_ranges[new_index].clone(); self.results_editor.update(cx, |editor, cx| { let range_to_select = editor.range_for_match(&range_to_select); editor.unfold_ranges([range_to_select.clone()], false, true, cx); editor.change_selections(Some(Autoscroll::fit()), cx, |s| { s.select_ranges([range_to_select]) }); }); } } fn focus_query_editor(&mut self, cx: &mut ViewContext) { self.query_editor.update(cx, |query_editor, cx| { query_editor.select_all(&SelectAll, cx); }); self.query_editor_was_focused = true; let editor_handle = self.query_editor.focus_handle(cx); cx.focus(&editor_handle); } fn set_query(&mut self, query: &str, cx: &mut ViewContext) { self.query_editor .update(cx, |query_editor, cx| query_editor.set_text(query, cx)); } fn focus_results_editor(&mut self, cx: &mut ViewContext) { self.query_editor.update(cx, |query_editor, cx| { let cursor = query_editor.selections.newest_anchor().head(); query_editor.change_selections(None, cx, |s| s.select_ranges([cursor.clone()..cursor])); }); self.query_editor_was_focused = false; let results_handle = self.results_editor.focus_handle(cx); cx.focus(&results_handle); } fn model_changed(&mut self, cx: &mut ViewContext) { let match_ranges = self.model.read(cx).match_ranges.clone(); if match_ranges.is_empty() { self.active_match_index = None; } else { self.active_match_index = Some(0); self.update_match_index(cx); let prev_search_id = mem::replace(&mut self.search_id, self.model.read(cx).search_id); let is_new_search = self.search_id != prev_search_id; self.results_editor.update(cx, |editor, cx| { if is_new_search { let range_to_select = match_ranges .first() .clone() .map(|range| editor.range_for_match(range)); editor.change_selections(Some(Autoscroll::fit()), cx, |s| { s.select_ranges(range_to_select) }); } editor.highlight_background::( match_ranges, |theme| theme.search_match_background, cx, ); }); if is_new_search && self.query_editor.focus_handle(cx).is_focused(cx) { self.focus_results_editor(cx); } } cx.emit(ViewEvent::UpdateTab); cx.notify(); } fn update_match_index(&mut self, cx: &mut ViewContext) { let results_editor = self.results_editor.read(cx); let new_index = active_match_index( &self.model.read(cx).match_ranges, &results_editor.selections.newest_anchor().head(), &results_editor.buffer().read(cx).snapshot(cx), ); if self.active_match_index != new_index { self.active_match_index = new_index; cx.notify(); } } pub fn has_matches(&self) -> bool { self.active_match_index.is_some() } fn landing_text_minor(&self) -> SharedString { match self.current_mode { SearchMode::Text | SearchMode::Regex => "Include/exclude specific paths with the filter option. Matching exact word and/or casing is available too.".into(), SearchMode::Semantic => ".Simply explain the code you are looking to find. ex. 'prompt user for permissions to index their project'".into() } } } impl Default for ProjectSearchBar { fn default() -> Self { Self::new() } } impl ProjectSearchBar { pub fn new() -> Self { Self { active_project_search: Default::default(), subscription: Default::default(), } } fn cycle_mode(&self, _: &CycleMode, cx: &mut ViewContext) { if let Some(view) = self.active_project_search.as_ref() { view.update(cx, |this, cx| { // todo: po: 2nd argument of `next_mode` should be `SemanticIndex::enabled(cx))`, but we need to flesh out port of semantic_index first. let new_mode = crate::mode::next_mode(&this.current_mode, false); this.activate_search_mode(new_mode, cx); let editor_handle = this.query_editor.focus_handle(cx); cx.focus(&editor_handle); }); } } fn confirm(&mut self, _: &Confirm, cx: &mut ViewContext) { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { if !search_view .replacement_editor .focus_handle(cx) .is_focused(cx) { cx.stop_propagation(); search_view.search(cx); } }); } } fn search_in_new(workspace: &mut Workspace, _: &SearchInNew, cx: &mut ViewContext) { if let Some(search_view) = workspace .active_item(cx) .and_then(|item| item.downcast::()) { let new_query = search_view.update(cx, |search_view, cx| { let new_query = search_view.build_search_query(cx); if new_query.is_some() { if let Some(old_query) = search_view.model.read(cx).active_query.clone() { search_view.query_editor.update(cx, |editor, cx| { editor.set_text(old_query.as_str(), cx); }); search_view.search_options = SearchOptions::from_query(&old_query); } } new_query }); if let Some(new_query) = new_query { let model = cx.build_model(|cx| { let mut model = ProjectSearch::new(workspace.project().clone(), cx); model.search(new_query, cx); model }); workspace.add_item( Box::new(cx.build_view(|cx| ProjectSearchView::new(model, cx, None))), cx, ); } } } fn tab(&mut self, _: &editor::Tab, cx: &mut ViewContext) { self.cycle_field(Direction::Next, cx); } fn tab_previous(&mut self, _: &editor::TabPrev, cx: &mut ViewContext) { self.cycle_field(Direction::Prev, cx); } fn cycle_field(&mut self, direction: Direction, cx: &mut ViewContext) { let active_project_search = match &self.active_project_search { Some(active_project_search) => active_project_search, None => { return; } }; active_project_search.update(cx, |project_view, cx| { let mut views = vec![&project_view.query_editor]; if project_view.filters_enabled { views.extend([ &project_view.included_files_editor, &project_view.excluded_files_editor, ]); } if project_view.replace_enabled { views.push(&project_view.replacement_editor); } let current_index = match views .iter() .enumerate() .find(|(_, view)| view.focus_handle(cx).is_focused(cx)) { Some((index, _)) => index, None => { return; } }; let new_index = match direction { Direction::Next => (current_index + 1) % views.len(), Direction::Prev if current_index == 0 => views.len() - 1, Direction::Prev => (current_index - 1) % views.len(), }; let next_focus_handle = views[new_index].focus_handle(cx); cx.focus(&next_focus_handle); cx.stop_propagation(); }); } fn toggle_search_option(&mut self, option: SearchOptions, cx: &mut ViewContext) -> bool { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { search_view.toggle_search_option(option, cx); search_view.search(cx); }); cx.notify(); true } else { false } } fn toggle_replace(&mut self, _: &ToggleReplace, cx: &mut ViewContext) { if let Some(search) = &self.active_project_search { search.update(cx, |this, cx| { this.replace_enabled = !this.replace_enabled; let editor_to_focus = if !this.replace_enabled { this.query_editor.focus_handle(cx) } else { this.replacement_editor.focus_handle(cx) }; cx.focus(&editor_to_focus); cx.notify(); }); } } fn toggle_filters(&mut self, cx: &mut ViewContext) -> bool { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { search_view.toggle_filters(cx); search_view .included_files_editor .update(cx, |_, cx| cx.notify()); search_view .excluded_files_editor .update(cx, |_, cx| cx.notify()); cx.refresh(); cx.notify(); }); cx.notify(); true } else { false } } fn activate_search_mode(&self, mode: SearchMode, cx: &mut ViewContext) { // Update Current Mode if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { search_view.activate_search_mode(mode, cx); }); cx.notify(); } } fn is_option_enabled(&self, option: SearchOptions, cx: &AppContext) -> bool { if let Some(search) = self.active_project_search.as_ref() { search.read(cx).search_options.contains(option) } else { false } } fn next_history_query(&mut self, _: &NextHistoryQuery, cx: &mut ViewContext) { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { let new_query = search_view.model.update(cx, |model, _| { if let Some(new_query) = model.search_history.next().map(str::to_string) { new_query } else { model.search_history.reset_selection(); String::new() } }); search_view.set_query(&new_query, cx); }); } } fn previous_history_query(&mut self, _: &PreviousHistoryQuery, cx: &mut ViewContext) { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { if search_view.query_editor.read(cx).text(cx).is_empty() { if let Some(new_query) = search_view .model .read(cx) .search_history .current() .map(str::to_string) { search_view.set_query(&new_query, cx); return; } } if let Some(new_query) = search_view.model.update(cx, |model, _| { model.search_history.previous().map(str::to_string) }) { search_view.set_query(&new_query, cx); } }); } } fn new_placeholder_text(&self, cx: &mut ViewContext) -> Option { let previous_query_keystrokes = cx .bindings_for_action(&PreviousHistoryQuery {}) .into_iter() .next() .map(|binding| { binding .keystrokes() .iter() .map(|k| k.to_string()) .collect::>() }); let next_query_keystrokes = cx .bindings_for_action(&NextHistoryQuery {}) .into_iter() .next() .map(|binding| { binding .keystrokes() .iter() .map(|k| k.to_string()) .collect::>() }); let new_placeholder_text = match (previous_query_keystrokes, next_query_keystrokes) { (Some(previous_query_keystrokes), Some(next_query_keystrokes)) => Some(format!( "Search ({}/{} for previous/next query)", previous_query_keystrokes.join(" "), next_query_keystrokes.join(" ") )), (None, Some(next_query_keystrokes)) => Some(format!( "Search ({} for next query)", next_query_keystrokes.join(" ") )), (Some(previous_query_keystrokes), None) => Some(format!( "Search ({} for previous query)", previous_query_keystrokes.join(" ") )), (None, None) => None, }; new_placeholder_text } } impl Render for ProjectSearchBar { type Element = Div; fn render(&mut self, cx: &mut ViewContext) -> Self::Element { let Some(search) = self.active_project_search.clone() else { return div(); }; let mut key_context = KeyContext::default(); key_context.add("ProjectSearchBar"); if let Some(placeholder_text) = self.new_placeholder_text(cx) { search.update(cx, |search, cx| { search.query_editor.update(cx, |this, cx| { this.set_placeholder_text(placeholder_text, cx) }) }); } let search = search.read(cx); let query_column = v_stack() //.flex_1() .child( h_stack() .min_w_80() .on_action(cx.listener(|this, action, cx| this.confirm(action, cx))) .on_action( cx.listener(|this, action, cx| this.previous_history_query(action, cx)), ) .on_action(cx.listener(|this, action, cx| this.next_history_query(action, cx))) .child(IconElement::new(Icon::MagnifyingGlass)) .child(search.query_editor.clone()) .child( h_stack() .child( IconButton::new("project-search-filter-button", Icon::Filter) .tooltip(|cx| { Tooltip::for_action("Toggle filters", &ToggleFilters, cx) }) .on_click(cx.listener(|this, _, cx| { this.toggle_filters(cx); })) .selected( self.active_project_search .as_ref() .map(|search| search.read(cx).filters_enabled) .unwrap_or_default(), ), ) .child( IconButton::new( "project-search-case-sensitive", Icon::CaseSensitive, ) .tooltip(|cx| { Tooltip::for_action( "Toggle case sensitive", &ToggleCaseSensitive, cx, ) }) .selected(self.is_option_enabled(SearchOptions::CASE_SENSITIVE, cx)) .on_click(cx.listener( |this, _, cx| { this.toggle_search_option( SearchOptions::CASE_SENSITIVE, cx, ); }, )), ) .child( IconButton::new("project-search-whole-word", Icon::WholeWord) .tooltip(|cx| { Tooltip::for_action( "Toggle whole word", &ToggleWholeWord, cx, ) }) .selected(self.is_option_enabled(SearchOptions::WHOLE_WORD, cx)) .on_click(cx.listener(|this, _, cx| { this.toggle_search_option(SearchOptions::WHOLE_WORD, cx); })), ), ) .border_2() .bg(white()) .rounded_lg(), ) .when(search.filters_enabled, |this| { this.child( h_stack() .mt_2() .flex_1() .justify_between() .child( h_stack() .flex_1() .border_1() .mr_2() .child(search.included_files_editor.clone()), ) .child( h_stack() .flex_1() .border_1() .ml_2() .child(search.excluded_files_editor.clone()), ), ) }); let mode_column = v_stack().items_start().justify_start().child( h_stack() .child( h_stack() .child( Button::new("project-search-text-button", "Text") .selected(search.current_mode == SearchMode::Text) .on_click(cx.listener(|this, _, cx| { this.activate_search_mode(SearchMode::Text, cx) })) .tooltip(|cx| { Tooltip::for_action("Toggle text search", &ActivateTextMode, cx) }), ) .child( Button::new("project-search-regex-button", "Regex") .selected(search.current_mode == SearchMode::Regex) .on_click(cx.listener(|this, _, cx| { this.activate_search_mode(SearchMode::Regex, cx) })) .tooltip(|cx| { Tooltip::for_action( "Toggle regular expression search", &ActivateRegexMode, cx, ) }), ), ) .child( IconButton::new("project-search-toggle-replace", Icon::Replace) .on_click(cx.listener(|this, _, cx| { this.toggle_replace(&ToggleReplace, cx); })) .tooltip(|cx| Tooltip::for_action("Toggle replace", &ToggleReplace, cx)), ), ); let replace_column = if search.replace_enabled { h_stack() .p_1() .flex_1() .border_2() .rounded_lg() .child(IconElement::new(Icon::Replace).size(ui::IconSize::Small)) .child(search.replacement_editor.clone()) } else { // Fill out the space if we don't have a replacement editor. h_stack().flex_1() }; let actions_column = h_stack() .when(search.replace_enabled, |this| { this.children([ IconButton::new("project-search-replace-next", Icon::ReplaceNext) .on_click(cx.listener(|this, _, cx| { if let Some(search) = this.active_project_search.as_ref() { search.update(cx, |this, cx| { this.replace_next(&ReplaceNext, cx); }) } })) .tooltip(|cx| Tooltip::for_action("Replace next match", &ReplaceNext, cx)), IconButton::new("project-search-replace-all", Icon::ReplaceAll) .on_click(cx.listener(|this, _, cx| { if let Some(search) = this.active_project_search.as_ref() { search.update(cx, |this, cx| { this.replace_all(&ReplaceAll, cx); }) } })) .tooltip(|cx| Tooltip::for_action("Replace all matches", &ReplaceAll, cx)), ]) }) .when_some(search.active_match_index, |mut this, index| { let index = index + 1; let match_quantity = search.model.read(cx).match_ranges.len(); if match_quantity > 0 { debug_assert!(match_quantity >= index); this = this.child(Label::new(format!("{index}/{match_quantity}"))) } this }) .children([ IconButton::new("project-search-prev-match", Icon::ChevronLeft) .disabled(search.active_match_index.is_none()) .on_click(cx.listener(|this, _, cx| { if let Some(search) = this.active_project_search.as_ref() { search.update(cx, |this, cx| { this.select_match(Direction::Prev, cx); }) } })) .tooltip(|cx| { Tooltip::for_action("Go to previous match", &SelectPrevMatch, cx) }), IconButton::new("project-search-next-match", Icon::ChevronRight) .disabled(search.active_match_index.is_none()) .on_click(cx.listener(|this, _, cx| { if let Some(search) = this.active_project_search.as_ref() { search.update(cx, |this, cx| { this.select_match(Direction::Next, cx); }) } })) .tooltip(|cx| Tooltip::for_action("Go to next match", &SelectNextMatch, cx)), ]); h_stack() .key_context(key_context) .size_full() .p_1() .m_2() .justify_between() .on_action(cx.listener(|this, _: &ToggleFilters, cx| { this.toggle_filters(cx); })) .on_action(cx.listener(|this, _: &ToggleWholeWord, cx| { this.toggle_search_option(SearchOptions::WHOLE_WORD, cx); })) .on_action(cx.listener(|this, _: &ToggleCaseSensitive, cx| { this.toggle_search_option(SearchOptions::CASE_SENSITIVE, cx); })) .on_action(cx.listener(|this, action, cx| { this.toggle_replace(action, cx); })) .on_action(cx.listener(|this, _: &ActivateTextMode, cx| { this.activate_search_mode(SearchMode::Text, cx) })) .on_action(cx.listener(|this, _: &ActivateRegexMode, cx| { this.activate_search_mode(SearchMode::Regex, cx) })) .on_action(cx.listener(|this, action, cx| { if let Some(search) = this.active_project_search.as_ref() { search.update(cx, |this, cx| { this.replace_next(action, cx); }) } })) .on_action(cx.listener(|this, action, cx| { if let Some(search) = this.active_project_search.as_ref() { search.update(cx, |this, cx| { this.replace_all(action, cx); }) } })) .on_action(cx.listener(|this, action, cx| { this.tab(action, cx); })) .on_action(cx.listener(|this, action, cx| { this.tab_previous(action, cx); })) .on_action(cx.listener(|this, action, cx| { this.cycle_mode(action, cx); })) .child(query_column) .child(mode_column) .child(replace_column) .child(actions_column) } } // impl Entity for ProjectSearchBar { // type Event = (); // } // impl View for ProjectSearchBar { // fn ui_name() -> &'static str { // "ProjectSearchBar" // } // fn update_keymap_context( // &self, // keymap: &mut gpui::keymap_matcher::KeymapContext, // cx: &AppContext, // ) { // Self::reset_to_default_keymap_context(keymap); // let in_replace = self // .active_project_search // .as_ref() // .map(|search| { // search // .read(cx) // .replacement_editor // .read_with(cx, |_, cx| cx.is_self_focused()) // }) // .flatten() // .unwrap_or(false); // if in_replace { // keymap.add_identifier("in_replace"); // } // } // fn render(&mut self, cx: &mut ViewContext) -> AnyElement { // if let Some(_search) = self.active_project_search.as_ref() { // let search = _search.read(cx); // let theme = theme::current(cx).clone(); // let query_container_style = if search.panels_with_errors.contains(&InputPanel::Query) { // theme.search.invalid_editor // } else { // theme.search.editor.input.container // }; // let search = _search.read(cx); // let filter_button = render_option_button_icon( // search.filters_enabled, // "icons/filter.svg", // 0, // "Toggle filters", // Box::new(ToggleFilters), // move |_, this, cx| { // this.toggle_filters(cx); // }, // cx, // ); // let search = _search.read(cx); // let is_semantic_available = SemanticIndex::enabled(cx); // let is_semantic_disabled = search.semantic_state.is_none(); // let icon_style = theme.search.editor_icon.clone(); // let is_active = search.active_match_index.is_some(); // let render_option_button_icon = |path, option, cx: &mut ViewContext| { // crate::search_bar::render_option_button_icon( // self.is_option_enabled(option, cx), // path, // option.bits as usize, // format!("Toggle {}", option.label()), // option.to_toggle_action(), // move |_, this, cx| { // this.toggle_search_option(option, cx); // }, // cx, // ) // }; // let case_sensitive = is_semantic_disabled.then(|| { // render_option_button_icon( // "icons/case_insensitive.svg", // SearchOptions::CASE_SENSITIVE, // cx, // ) // }); // let whole_word = is_semantic_disabled.then(|| { // render_option_button_icon("icons/word_search.svg", SearchOptions::WHOLE_WORD, cx) // }); // let include_ignored = is_semantic_disabled.then(|| { // render_option_button_icon( // "icons/file_icons/git.svg", // SearchOptions::INCLUDE_IGNORED, // cx, // ) // }); // let search_button_for_mode = |mode, side, cx: &mut ViewContext| { // let is_active = if let Some(search) = self.active_project_search.as_ref() { // let search = search.read(cx); // search.current_mode == mode // } else { // false // }; // render_search_mode_button( // mode, // side, // is_active, // move |_, this, cx| { // this.activate_search_mode(mode, cx); // }, // cx, // ) // }; // let search = _search.read(cx); // let include_container_style = // if search.panels_with_errors.contains(&InputPanel::Include) { // theme.search.invalid_include_exclude_editor // } else { // theme.search.include_exclude_editor.input.container // }; // let exclude_container_style = // if search.panels_with_errors.contains(&InputPanel::Exclude) { // theme.search.invalid_include_exclude_editor // } else { // theme.search.include_exclude_editor.input.container // }; // let matches = search.active_match_index.map(|match_ix| { // Label::new( // format!( // "{}/{}", // match_ix + 1, // search.model.read(cx).match_ranges.len() // ), // theme.search.match_index.text.clone(), // ) // .contained() // .with_style(theme.search.match_index.container) // .aligned() // }); // let should_show_replace_input = search.replace_enabled; // let replacement = should_show_replace_input.then(|| { // Flex::row() // .with_child( // Svg::for_style(theme.search.replace_icon.clone().icon) // .contained() // .with_style(theme.search.replace_icon.clone().container), // ) // .with_child(ChildView::new(&search.replacement_editor, cx).flex(1., true)) // .align_children_center() // .flex(1., true) // .contained() // .with_style(query_container_style) // .constrained() // .with_min_width(theme.search.editor.min_width) // .with_max_width(theme.search.editor.max_width) // .with_height(theme.search.search_bar_row_height) // .flex(1., false) // }); // let replace_all = should_show_replace_input.then(|| { // super::replace_action( // ReplaceAll, // "Replace all", // "icons/replace_all.svg", // theme.tooltip.clone(), // theme.search.action_button.clone(), // ) // }); // let replace_next = should_show_replace_input.then(|| { // super::replace_action( // ReplaceNext, // "Replace next", // "icons/replace_next.svg", // theme.tooltip.clone(), // theme.search.action_button.clone(), // ) // }); // let query_column = Flex::column() // .with_spacing(theme.search.search_row_spacing) // .with_child( // Flex::row() // .with_child( // Svg::for_style(icon_style.icon) // .contained() // .with_style(icon_style.container), // ) // .with_child(ChildView::new(&search.query_editor, cx).flex(1., true)) // .with_child( // Flex::row() // .with_child(filter_button) // .with_children(case_sensitive) // .with_children(whole_word) // .flex(1., false) // .constrained() // .contained(), // ) // .align_children_center() // .contained() // .with_style(query_container_style) // .constrained() // .with_min_width(theme.search.editor.min_width) // .with_max_width(theme.search.editor.max_width) // .with_height(theme.search.search_bar_row_height) // .flex(1., false), // ) // .with_children(search.filters_enabled.then(|| { // Flex::row() // .with_child( // Flex::row() // .with_child( // ChildView::new(&search.included_files_editor, cx) // .contained() // .constrained() // .with_height(theme.search.search_bar_row_height) // .flex(1., true), // ) // .with_children(include_ignored) // .contained() // .with_style(include_container_style) // .constrained() // .with_height(theme.search.search_bar_row_height) // .flex(1., true), // ) // .with_child( // ChildView::new(&search.excluded_files_editor, cx) // .contained() // .with_style(exclude_container_style) // .constrained() // .with_height(theme.search.search_bar_row_height) // .flex(1., true), // ) // .constrained() // .with_min_width(theme.search.editor.min_width) // .with_max_width(theme.search.editor.max_width) // .flex(1., false) // })) // .flex(1., false); // let switches_column = Flex::row() // .align_children_center() // .with_child(super::toggle_replace_button( // search.replace_enabled, // theme.tooltip.clone(), // theme.search.option_button_component.clone(), // )) // .constrained() // .with_height(theme.search.search_bar_row_height) // .contained() // .with_style(theme.search.option_button_group); // let mode_column = // Flex::row() // .with_child(search_button_for_mode( // SearchMode::Text, // Some(Side::Left), // cx, // )) // .with_child(search_button_for_mode( // SearchMode::Regex, // if is_semantic_available { // None // } else { // Some(Side::Right) // }, // cx, // )) // .with_children(is_semantic_available.then(|| { // search_button_for_mode(SearchMode::Semantic, Some(Side::Right), cx) // })) // .contained() // .with_style(theme.search.modes_container); // let nav_button_for_direction = |label, direction, cx: &mut ViewContext| { // render_nav_button( // label, // direction, // is_active, // move |_, this, cx| { // if let Some(search) = this.active_project_search.as_ref() { // search.update(cx, |search, cx| search.select_match(direction, cx)); // } // }, // cx, // ) // }; // let nav_column = Flex::row() // .with_children(replace_next) // .with_children(replace_all) // .with_child(Flex::row().with_children(matches)) // .with_child(nav_button_for_direction("<", Direction::Prev, cx)) // .with_child(nav_button_for_direction(">", Direction::Next, cx)) // .constrained() // .with_height(theme.search.search_bar_row_height) // .flex_float(); // Flex::row() // .with_child(query_column) // .with_child(mode_column) // .with_child(switches_column) // .with_children(replacement) // .with_child(nav_column) // .contained() // .with_style(theme.search.container) // .into_any_named("project search") // } else { // Empty::new().into_any() // } // } // } impl EventEmitter for ProjectSearchBar {} impl ToolbarItemView for ProjectSearchBar { fn set_active_pane_item( &mut self, active_pane_item: Option<&dyn ItemHandle>, cx: &mut ViewContext, ) -> ToolbarItemLocation { cx.notify(); self.subscription = None; self.active_project_search = None; if let Some(search) = active_pane_item.and_then(|i| i.downcast::()) { search.update(cx, |search, cx| { if search.current_mode == SearchMode::Semantic { search.index_project(cx); } }); self.subscription = Some(cx.observe(&search, |_, _, cx| cx.notify())); self.active_project_search = Some(search); ToolbarItemLocation::PrimaryLeft {} } else { ToolbarItemLocation::Hidden } } fn row_count(&self, cx: &WindowContext<'_>) -> usize { if let Some(search) = self.active_project_search.as_ref() { if search.read(cx).filters_enabled { return 2; } } 1 } } // #[cfg(test)] // pub mod tests { // use super::*; // use editor::DisplayPoint; // use gpui::{color::Color, executor::Deterministic, TestAppContext}; // use project::FakeFs; // use semantic_index::semantic_index_settings::SemanticIndexSettings; // use serde_json::json; // use settings::SettingsStore; // use std::sync::Arc; // use theme::ThemeSettings; // #[gpui::test] // async fn test_project_search(deterministic: Arc, cx: &mut TestAppContext) { // init_test(cx); // let fs = FakeFs::new(cx.background_executor()); // fs.insert_tree( // "/dir", // json!({ // "one.rs": "const ONE: usize = 1;", // "two.rs": "const TWO: usize = one::ONE + one::ONE;", // "three.rs": "const THREE: usize = one::ONE + two::TWO;", // "four.rs": "const FOUR: usize = one::ONE + three::THREE;", // }), // ) // .await; // let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await; // let search = cx.add_model(|cx| ProjectSearch::new(project, cx)); // let search_view = cx // .add_window(|cx| ProjectSearchView::new(search.clone(), cx, None)) // .root(cx); // search_view.update(cx, |search_view, cx| { // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("TWO", cx)); // search_view.search(cx); // }); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)), // "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;" // ); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.all_text_background_highlights(cx)), // &[ // ( // DisplayPoint::new(2, 32)..DisplayPoint::new(2, 35), // Color::red() // ), // ( // DisplayPoint::new(2, 37)..DisplayPoint::new(2, 40), // Color::red() // ), // ( // DisplayPoint::new(5, 6)..DisplayPoint::new(5, 9), // Color::red() // ) // ] // ); // assert_eq!(search_view.active_match_index, Some(0)); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.selections.display_ranges(cx)), // [DisplayPoint::new(2, 32)..DisplayPoint::new(2, 35)] // ); // search_view.select_match(Direction::Next, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.active_match_index, Some(1)); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.selections.display_ranges(cx)), // [DisplayPoint::new(2, 37)..DisplayPoint::new(2, 40)] // ); // search_view.select_match(Direction::Next, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.active_match_index, Some(2)); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.selections.display_ranges(cx)), // [DisplayPoint::new(5, 6)..DisplayPoint::new(5, 9)] // ); // search_view.select_match(Direction::Next, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.active_match_index, Some(0)); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.selections.display_ranges(cx)), // [DisplayPoint::new(2, 32)..DisplayPoint::new(2, 35)] // ); // search_view.select_match(Direction::Prev, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.active_match_index, Some(2)); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.selections.display_ranges(cx)), // [DisplayPoint::new(5, 6)..DisplayPoint::new(5, 9)] // ); // search_view.select_match(Direction::Prev, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.active_match_index, Some(1)); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.selections.display_ranges(cx)), // [DisplayPoint::new(2, 37)..DisplayPoint::new(2, 40)] // ); // }); // } // #[gpui::test] // async fn test_project_search_focus(deterministic: Arc, cx: &mut TestAppContext) { // init_test(cx); // let fs = FakeFs::new(cx.background_executor()); // fs.insert_tree( // "/dir", // json!({ // "one.rs": "const ONE: usize = 1;", // "two.rs": "const TWO: usize = one::ONE + one::ONE;", // "three.rs": "const THREE: usize = one::ONE + two::TWO;", // "four.rs": "const FOUR: usize = one::ONE + three::THREE;", // }), // ) // .await; // let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await; // let window = cx.add_window(|cx| Workspace::test_new(project, cx)); // let workspace = window.root(cx); // let active_item = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // }); // assert!( // active_item.is_none(), // "Expected no search panel to be active, but got: {active_item:?}" // ); // workspace.update(cx, |workspace, cx| { // ProjectSearchView::deploy(workspace, &workspace::NewSearch, cx) // }); // let Some(search_view) = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // }) else { // panic!("Search view expected to appear after new search event trigger") // }; // let search_view_id = search_view.id(); // cx.spawn(|mut cx| async move { // window.dispatch_action(search_view_id, &ToggleFocus, &mut cx); // }) // .detach(); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert!( // search_view.query_editor.is_focused(cx), // "Empty search view should be focused after the toggle focus event: no results panel to focus on", // ); // }); // search_view.update(cx, |search_view, cx| { // let query_editor = &search_view.query_editor; // assert!( // query_editor.is_focused(cx), // "Search view should be focused after the new search view is activated", // ); // let query_text = query_editor.read(cx).text(cx); // assert!( // query_text.is_empty(), // "New search query should be empty but got '{query_text}'", // ); // let results_text = search_view // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)); // assert!( // results_text.is_empty(), // "Empty search view should have no results but got '{results_text}'" // ); // }); // search_view.update(cx, |search_view, cx| { // search_view.query_editor.update(cx, |query_editor, cx| { // query_editor.set_text("sOMETHINGtHATsURELYdOESnOTeXIST", cx) // }); // search_view.search(cx); // }); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // let results_text = search_view // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)); // assert!( // results_text.is_empty(), // "Search view for mismatching query should have no results but got '{results_text}'" // ); // assert!( // search_view.query_editor.is_focused(cx), // "Search view should be focused after mismatching query had been used in search", // ); // }); // cx.spawn( // |mut cx| async move { window.dispatch_action(search_view_id, &ToggleFocus, &mut cx) }, // ) // .detach(); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert!( // search_view.query_editor.is_focused(cx), // "Search view with mismatching query should be focused after the toggle focus event: still no results panel to focus on", // ); // }); // search_view.update(cx, |search_view, cx| { // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("TWO", cx)); // search_view.search(cx); // }); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)), // "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;", // "Search view results should match the query" // ); // assert!( // search_view.results_editor.is_focused(cx), // "Search view with mismatching query should be focused after search results are available", // ); // }); // cx.spawn(|mut cx| async move { // window.dispatch_action(search_view_id, &ToggleFocus, &mut cx); // }) // .detach(); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert!( // search_view.results_editor.is_focused(cx), // "Search view with matching query should still have its results editor focused after the toggle focus event", // ); // }); // workspace.update(cx, |workspace, cx| { // ProjectSearchView::deploy(workspace, &workspace::NewSearch, cx) // }); // deterministic.run_until_parked(); // let Some(search_view_2) = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // }) else { // panic!("Search view expected to appear after new search event trigger") // }; // let search_view_id_2 = search_view_2.id(); // assert_ne!( // search_view_2, search_view, // "New search view should be open after `workspace::NewSearch` event" // ); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO", "First search view should not have an updated query"); // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)), // "\n\nconst THREE: usize = one::ONE + two::TWO;\n\n\nconst TWO: usize = one::ONE + one::ONE;", // "Results of the first search view should not update too" // ); // assert!( // !search_view.query_editor.is_focused(cx), // "Focus should be moved away from the first search view" // ); // }); // search_view_2.update(cx, |search_view_2, cx| { // assert_eq!( // search_view_2.query_editor.read(cx).text(cx), // "two", // "New search view should get the query from the text cursor was at during the event spawn (first search view's first result)" // ); // assert_eq!( // search_view_2 // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)), // "", // "No search results should be in the 2nd view yet, as we did not spawn a search for it" // ); // assert!( // search_view_2.query_editor.is_focused(cx), // "Focus should be moved into query editor fo the new window" // ); // }); // search_view_2.update(cx, |search_view_2, cx| { // search_view_2 // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("FOUR", cx)); // search_view_2.search(cx); // }); // deterministic.run_until_parked(); // search_view_2.update(cx, |search_view_2, cx| { // assert_eq!( // search_view_2 // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)), // "\n\nconst FOUR: usize = one::ONE + three::THREE;", // "New search view with the updated query should have new search results" // ); // assert!( // search_view_2.results_editor.is_focused(cx), // "Search view with mismatching query should be focused after search results are available", // ); // }); // cx.spawn(|mut cx| async move { // window.dispatch_action(search_view_id_2, &ToggleFocus, &mut cx); // }) // .detach(); // deterministic.run_until_parked(); // search_view_id_2.update(cx, |search_view_2, cx| { // assert!( // search_view_2.results_editor.is_focused(cx), // "Search view with matching query should switch focus to the results editor after the toggle focus event", // ); // }); // } // #[gpui::test] // async fn test_new_project_search_in_directory( // deterministic: Arc, // cx: &mut TestAppContext, // ) { // init_test(cx); // let fs = FakeFs::new(cx.background_executor()); // fs.insert_tree( // "/dir", // json!({ // "a": { // "one.rs": "const ONE: usize = 1;", // "two.rs": "const TWO: usize = one::ONE + one::ONE;", // }, // "b": { // "three.rs": "const THREE: usize = one::ONE + two::TWO;", // "four.rs": "const FOUR: usize = one::ONE + three::THREE;", // }, // }), // ) // .await; // let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await; // let worktree_id = project.read_with(cx, |project, cx| { // project.worktrees(cx).next().unwrap().read(cx).id() // }); // let workspace = cx // .add_window(|cx| Workspace::test_new(project, cx)) // .root(cx); // let active_item = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // }); // assert!( // active_item.is_none(), // "Expected no search panel to be active, but got: {active_item:?}" // ); // let one_file_entry = cx.update(|cx| { // workspace // .read(cx) // .project() // .read(cx) // .entry_for_path(&(worktree_id, "a/one.rs").into(), cx) // .expect("no entry for /a/one.rs file") // }); // assert!(one_file_entry.is_file()); // workspace.update(cx, |workspace, cx| { // ProjectSearchView::new_search_in_directory(workspace, &one_file_entry, cx) // }); // let active_search_entry = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // }); // assert!( // active_search_entry.is_none(), // "Expected no search panel to be active for file entry" // ); // let a_dir_entry = cx.update(|cx| { // workspace // .read(cx) // .project() // .read(cx) // .entry_for_path(&(worktree_id, "a").into(), cx) // .expect("no entry for /a/ directory") // }); // assert!(a_dir_entry.is_dir()); // workspace.update(cx, |workspace, cx| { // ProjectSearchView::new_search_in_directory(workspace, &a_dir_entry, cx) // }); // let Some(search_view) = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // }) else { // panic!("Search view expected to appear after new search in directory event trigger") // }; // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert!( // search_view.query_editor.is_focused(cx), // "On new search in directory, focus should be moved into query editor" // ); // search_view.excluded_files_editor.update(cx, |editor, cx| { // assert!( // editor.display_text(cx).is_empty(), // "New search in directory should not have any excluded files" // ); // }); // search_view.included_files_editor.update(cx, |editor, cx| { // assert_eq!( // editor.display_text(cx), // a_dir_entry.path.to_str().unwrap(), // "New search in directory should have included dir entry path" // ); // }); // }); // search_view.update(cx, |search_view, cx| { // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("const", cx)); // search_view.search(cx); // }); // deterministic.run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert_eq!( // search_view // .results_editor // .update(cx, |editor, cx| editor.display_text(cx)), // "\n\nconst ONE: usize = 1;\n\n\nconst TWO: usize = one::ONE + one::ONE;", // "New search in directory should have a filter that matches a certain directory" // ); // }); // } // #[gpui::test] // async fn test_search_query_history(cx: &mut TestAppContext) { // init_test(cx); // let fs = FakeFs::new(cx.background_executor()); // fs.insert_tree( // "/dir", // json!({ // "one.rs": "const ONE: usize = 1;", // "two.rs": "const TWO: usize = one::ONE + one::ONE;", // "three.rs": "const THREE: usize = one::ONE + two::TWO;", // "four.rs": "const FOUR: usize = one::ONE + three::THREE;", // }), // ) // .await; // let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await; // let window = cx.add_window(|cx| Workspace::test_new(project, cx)); // let workspace = window.root(cx); // workspace.update(cx, |workspace, cx| { // ProjectSearchView::deploy(workspace, &workspace::NewSearch, cx) // }); // let search_view = cx.read(|cx| { // workspace // .read(cx) // .active_pane() // .read(cx) // .active_item() // .and_then(|item| item.downcast::()) // .expect("Search view expected to appear after new search event trigger") // }); // let search_bar = window.add_view(cx, |cx| { // let mut search_bar = ProjectSearchBar::new(); // search_bar.set_active_pane_item(Some(&search_view), cx); // // search_bar.show(cx); // search_bar // }); // // Add 3 search items into the history + another unsubmitted one. // search_view.update(cx, |search_view, cx| { // search_view.search_options = SearchOptions::CASE_SENSITIVE; // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("ONE", cx)); // search_view.search(cx); // }); // cx.foreground().run_until_parked(); // search_view.update(cx, |search_view, cx| { // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("TWO", cx)); // search_view.search(cx); // }); // cx.foreground().run_until_parked(); // search_view.update(cx, |search_view, cx| { // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("THREE", cx)); // search_view.search(cx); // }); // cx.foreground().run_until_parked(); // search_view.update(cx, |search_view, cx| { // search_view.query_editor.update(cx, |query_editor, cx| { // query_editor.set_text("JUST_TEXT_INPUT", cx) // }); // }); // cx.foreground().run_until_parked(); // // Ensure that the latest input with search settings is active. // search_view.update(cx, |search_view, cx| { // assert_eq!( // search_view.query_editor.read(cx).text(cx), // "JUST_TEXT_INPUT" // ); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // // Next history query after the latest should set the query to the empty string. // search_bar.update(cx, |search_bar, cx| { // search_bar.next_history_query(&NextHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), ""); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_bar.update(cx, |search_bar, cx| { // search_bar.next_history_query(&NextHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), ""); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // // First previous query for empty current query should set the query to the latest submitted one. // search_bar.update(cx, |search_bar, cx| { // search_bar.previous_history_query(&PreviousHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "THREE"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // // Further previous items should go over the history in reverse order. // search_bar.update(cx, |search_bar, cx| { // search_bar.previous_history_query(&PreviousHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // // Previous items should never go behind the first history item. // search_bar.update(cx, |search_bar, cx| { // search_bar.previous_history_query(&PreviousHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "ONE"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_bar.update(cx, |search_bar, cx| { // search_bar.previous_history_query(&PreviousHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "ONE"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // // Next items should go over the history in the original order. // search_bar.update(cx, |search_bar, cx| { // search_bar.next_history_query(&NextHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_view.update(cx, |search_view, cx| { // search_view // .query_editor // .update(cx, |query_editor, cx| query_editor.set_text("TWO_NEW", cx)); // search_view.search(cx); // }); // cx.foreground().run_until_parked(); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO_NEW"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // // New search input should add another entry to history and move the selection to the end of the history. // search_bar.update(cx, |search_bar, cx| { // search_bar.previous_history_query(&PreviousHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "THREE"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_bar.update(cx, |search_bar, cx| { // search_bar.previous_history_query(&PreviousHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_bar.update(cx, |search_bar, cx| { // search_bar.next_history_query(&NextHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "THREE"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_bar.update(cx, |search_bar, cx| { // search_bar.next_history_query(&NextHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), "TWO_NEW"); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // search_bar.update(cx, |search_bar, cx| { // search_bar.next_history_query(&NextHistoryQuery, cx); // }); // search_view.update(cx, |search_view, cx| { // assert_eq!(search_view.query_editor.read(cx).text(cx), ""); // assert_eq!(search_view.search_options, SearchOptions::CASE_SENSITIVE); // }); // } // pub fn init_test(cx: &mut TestAppContext) { // cx.foreground().forbid_parking(); // let fonts = cx.font_cache(); // let mut theme = gpui::fonts::with_font_cache(fonts.clone(), theme::Theme::default); // theme.search.match_background = Color::red(); // cx.update(|cx| { // cx.set_global(SettingsStore::test(cx)); // cx.set_global(ActiveSearches::default()); // settings::register::(cx); // theme::init((), cx); // cx.update_global::(|store, _| { // let mut settings = store.get::(None).clone(); // settings.theme = Arc::new(theme); // store.override_global(settings) // }); // language::init(cx); // client::init_settings(cx); // editor::init(cx); // workspace::init_settings(cx); // Project::init_settings(cx); // super::init(cx); // }); // } // }