mirror of
https://github.com/zed-industries/zed.git
synced 2024-09-20 02:47:34 +03:00
Previously replace_all amounted to what could be achieved by repeatedly mashing "Replace" button, which had a bunch of overhead related to buffer state syncing. This commit gets rid of the automated button mashing, processing all of the replacements in one go. Fixes #13455 Release Notes: - Improved performance of "replace all" in buffer search and project search
333 lines
10 KiB
Rust
333 lines
10 KiB
Rust
use std::{any::Any, sync::Arc};
|
|
|
|
use any_vec::AnyVec;
|
|
use gpui::{
|
|
AnyView, AnyWeakView, AppContext, EventEmitter, Subscription, Task, View, ViewContext,
|
|
WeakView, WindowContext,
|
|
};
|
|
use project::search::SearchQuery;
|
|
|
|
use crate::{
|
|
item::{Item, WeakItemHandle},
|
|
ItemHandle,
|
|
};
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum SearchEvent {
|
|
MatchesInvalidated,
|
|
ActiveMatchChanged,
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
|
|
pub enum Direction {
|
|
Prev,
|
|
#[default]
|
|
Next,
|
|
}
|
|
|
|
impl Direction {
|
|
pub fn opposite(&self) -> Self {
|
|
match self {
|
|
Direction::Prev => Direction::Next,
|
|
Direction::Next => Direction::Prev,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default)]
|
|
pub struct SearchOptions {
|
|
pub case: bool,
|
|
pub word: bool,
|
|
pub regex: bool,
|
|
/// Specifies whether the supports search & replace.
|
|
pub replacement: bool,
|
|
pub selection: bool,
|
|
}
|
|
|
|
pub trait SearchableItem: Item + EventEmitter<SearchEvent> {
|
|
type Match: Any + Sync + Send + Clone;
|
|
|
|
fn supported_options() -> SearchOptions {
|
|
SearchOptions {
|
|
case: true,
|
|
word: true,
|
|
regex: true,
|
|
replacement: true,
|
|
selection: true,
|
|
}
|
|
}
|
|
|
|
fn search_bar_visibility_changed(&mut self, _visible: bool, _cx: &mut ViewContext<Self>) {}
|
|
|
|
fn has_filtered_search_ranges(&mut self) -> bool {
|
|
Self::supported_options().selection
|
|
}
|
|
|
|
fn toggle_filtered_search_ranges(&mut self, _enabled: bool, _cx: &mut ViewContext<Self>) {}
|
|
|
|
fn clear_matches(&mut self, cx: &mut ViewContext<Self>);
|
|
fn update_matches(&mut self, matches: &[Self::Match], cx: &mut ViewContext<Self>);
|
|
fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String;
|
|
fn activate_match(&mut self, index: usize, matches: &[Self::Match], cx: &mut ViewContext<Self>);
|
|
fn select_matches(&mut self, matches: &[Self::Match], cx: &mut ViewContext<Self>);
|
|
fn replace(&mut self, _: &Self::Match, _: &SearchQuery, _: &mut ViewContext<Self>);
|
|
fn replace_all(
|
|
&mut self,
|
|
matches: &mut dyn Iterator<Item = &Self::Match>,
|
|
query: &SearchQuery,
|
|
cx: &mut ViewContext<Self>,
|
|
) {
|
|
for item in matches {
|
|
self.replace(item, query, cx);
|
|
}
|
|
}
|
|
fn match_index_for_direction(
|
|
&mut self,
|
|
matches: &[Self::Match],
|
|
current_index: usize,
|
|
direction: Direction,
|
|
count: usize,
|
|
_: &mut ViewContext<Self>,
|
|
) -> usize {
|
|
match direction {
|
|
Direction::Prev => {
|
|
let count = count % matches.len();
|
|
if current_index >= count {
|
|
current_index - count
|
|
} else {
|
|
matches.len() - (count - current_index)
|
|
}
|
|
}
|
|
Direction::Next => (current_index + count) % matches.len(),
|
|
}
|
|
}
|
|
fn find_matches(
|
|
&mut self,
|
|
query: Arc<SearchQuery>,
|
|
cx: &mut ViewContext<Self>,
|
|
) -> Task<Vec<Self::Match>>;
|
|
fn active_match_index(
|
|
&mut self,
|
|
matches: &[Self::Match],
|
|
cx: &mut ViewContext<Self>,
|
|
) -> Option<usize>;
|
|
}
|
|
|
|
pub trait SearchableItemHandle: ItemHandle {
|
|
fn downgrade(&self) -> Box<dyn WeakSearchableItemHandle>;
|
|
fn boxed_clone(&self) -> Box<dyn SearchableItemHandle>;
|
|
fn supported_options(&self) -> SearchOptions;
|
|
fn subscribe_to_search_events(
|
|
&self,
|
|
cx: &mut WindowContext,
|
|
handler: Box<dyn Fn(&SearchEvent, &mut WindowContext) + Send>,
|
|
) -> Subscription;
|
|
fn clear_matches(&self, cx: &mut WindowContext);
|
|
fn update_matches(&self, matches: &AnyVec<dyn Send>, cx: &mut WindowContext);
|
|
fn query_suggestion(&self, cx: &mut WindowContext) -> String;
|
|
fn activate_match(&self, index: usize, matches: &AnyVec<dyn Send>, cx: &mut WindowContext);
|
|
fn select_matches(&self, matches: &AnyVec<dyn Send>, cx: &mut WindowContext);
|
|
fn replace(
|
|
&self,
|
|
_: any_vec::element::ElementRef<'_, dyn Send>,
|
|
_: &SearchQuery,
|
|
_: &mut WindowContext,
|
|
);
|
|
fn replace_all(
|
|
&self,
|
|
matches: &mut dyn Iterator<Item = any_vec::element::ElementRef<'_, dyn Send>>,
|
|
query: &SearchQuery,
|
|
cx: &mut WindowContext,
|
|
);
|
|
fn match_index_for_direction(
|
|
&self,
|
|
matches: &AnyVec<dyn Send>,
|
|
current_index: usize,
|
|
direction: Direction,
|
|
count: usize,
|
|
cx: &mut WindowContext,
|
|
) -> usize;
|
|
fn find_matches(
|
|
&self,
|
|
query: Arc<SearchQuery>,
|
|
cx: &mut WindowContext,
|
|
) -> Task<AnyVec<dyn Send>>;
|
|
fn active_match_index(
|
|
&self,
|
|
matches: &AnyVec<dyn Send>,
|
|
cx: &mut WindowContext,
|
|
) -> Option<usize>;
|
|
fn search_bar_visibility_changed(&self, visible: bool, cx: &mut WindowContext);
|
|
|
|
fn toggle_filtered_search_ranges(&mut self, enabled: bool, cx: &mut WindowContext);
|
|
}
|
|
|
|
impl<T: SearchableItem> SearchableItemHandle for View<T> {
|
|
fn downgrade(&self) -> Box<dyn WeakSearchableItemHandle> {
|
|
Box::new(self.downgrade())
|
|
}
|
|
|
|
fn boxed_clone(&self) -> Box<dyn SearchableItemHandle> {
|
|
Box::new(self.clone())
|
|
}
|
|
|
|
fn supported_options(&self) -> SearchOptions {
|
|
T::supported_options()
|
|
}
|
|
|
|
fn subscribe_to_search_events(
|
|
&self,
|
|
cx: &mut WindowContext,
|
|
handler: Box<dyn Fn(&SearchEvent, &mut WindowContext) + Send>,
|
|
) -> Subscription {
|
|
cx.subscribe(self, move |_, event: &SearchEvent, cx| handler(event, cx))
|
|
}
|
|
|
|
fn clear_matches(&self, cx: &mut WindowContext) {
|
|
self.update(cx, |this, cx| this.clear_matches(cx));
|
|
}
|
|
fn update_matches(&self, matches: &AnyVec<dyn Send>, cx: &mut WindowContext) {
|
|
let matches = matches.downcast_ref().unwrap();
|
|
self.update(cx, |this, cx| this.update_matches(matches.as_slice(), cx));
|
|
}
|
|
fn query_suggestion(&self, cx: &mut WindowContext) -> String {
|
|
self.update(cx, |this, cx| this.query_suggestion(cx))
|
|
}
|
|
fn activate_match(&self, index: usize, matches: &AnyVec<dyn Send>, cx: &mut WindowContext) {
|
|
let matches = matches.downcast_ref().unwrap();
|
|
self.update(cx, |this, cx| {
|
|
this.activate_match(index, matches.as_slice(), cx)
|
|
});
|
|
}
|
|
|
|
fn select_matches(&self, matches: &AnyVec<dyn Send>, cx: &mut WindowContext) {
|
|
let matches = matches.downcast_ref().unwrap();
|
|
self.update(cx, |this, cx| this.select_matches(matches.as_slice(), cx));
|
|
}
|
|
|
|
fn match_index_for_direction(
|
|
&self,
|
|
matches: &AnyVec<dyn Send>,
|
|
current_index: usize,
|
|
direction: Direction,
|
|
count: usize,
|
|
cx: &mut WindowContext,
|
|
) -> usize {
|
|
let matches = matches.downcast_ref().unwrap();
|
|
self.update(cx, |this, cx| {
|
|
this.match_index_for_direction(matches.as_slice(), current_index, direction, count, cx)
|
|
})
|
|
}
|
|
fn find_matches(
|
|
&self,
|
|
query: Arc<SearchQuery>,
|
|
cx: &mut WindowContext,
|
|
) -> Task<AnyVec<dyn Send>> {
|
|
let matches = self.update(cx, |this, cx| this.find_matches(query, cx));
|
|
cx.spawn(|_| async {
|
|
let matches = matches.await;
|
|
let mut any_matches = AnyVec::with_capacity::<T::Match>(matches.len());
|
|
{
|
|
let mut any_matches = any_matches.downcast_mut::<T::Match>().unwrap();
|
|
for mat in matches {
|
|
any_matches.push(mat);
|
|
}
|
|
}
|
|
any_matches
|
|
})
|
|
}
|
|
fn active_match_index(
|
|
&self,
|
|
matches: &AnyVec<dyn Send>,
|
|
cx: &mut WindowContext,
|
|
) -> Option<usize> {
|
|
let matches = matches.downcast_ref()?;
|
|
self.update(cx, |this, cx| {
|
|
this.active_match_index(matches.as_slice(), cx)
|
|
})
|
|
}
|
|
|
|
fn replace(
|
|
&self,
|
|
mat: any_vec::element::ElementRef<'_, dyn Send>,
|
|
query: &SearchQuery,
|
|
cx: &mut WindowContext,
|
|
) {
|
|
let mat = mat.downcast_ref().unwrap();
|
|
self.update(cx, |this, cx| this.replace(mat, query, cx))
|
|
}
|
|
|
|
fn replace_all(
|
|
&self,
|
|
matches: &mut dyn Iterator<Item = any_vec::element::ElementRef<'_, dyn Send>>,
|
|
query: &SearchQuery,
|
|
cx: &mut WindowContext,
|
|
) {
|
|
self.update(cx, |this, cx| {
|
|
this.replace_all(&mut matches.map(|m| m.downcast_ref().unwrap()), query, cx);
|
|
})
|
|
}
|
|
|
|
fn search_bar_visibility_changed(&self, visible: bool, cx: &mut WindowContext) {
|
|
self.update(cx, |this, cx| {
|
|
this.search_bar_visibility_changed(visible, cx)
|
|
});
|
|
}
|
|
|
|
fn toggle_filtered_search_ranges(&mut self, enabled: bool, cx: &mut WindowContext) {
|
|
self.update(cx, |this, cx| {
|
|
this.toggle_filtered_search_ranges(enabled, cx)
|
|
});
|
|
}
|
|
}
|
|
|
|
impl From<Box<dyn SearchableItemHandle>> for AnyView {
|
|
fn from(this: Box<dyn SearchableItemHandle>) -> Self {
|
|
this.to_any().clone()
|
|
}
|
|
}
|
|
|
|
impl From<&Box<dyn SearchableItemHandle>> for AnyView {
|
|
fn from(this: &Box<dyn SearchableItemHandle>) -> Self {
|
|
this.to_any().clone()
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Box<dyn SearchableItemHandle> {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.item_id() == other.item_id()
|
|
}
|
|
}
|
|
|
|
impl Eq for Box<dyn SearchableItemHandle> {}
|
|
|
|
pub trait WeakSearchableItemHandle: WeakItemHandle {
|
|
fn upgrade(&self, cx: &AppContext) -> Option<Box<dyn SearchableItemHandle>>;
|
|
|
|
fn into_any(self) -> AnyWeakView;
|
|
}
|
|
|
|
impl<T: SearchableItem> WeakSearchableItemHandle for WeakView<T> {
|
|
fn upgrade(&self, _cx: &AppContext) -> Option<Box<dyn SearchableItemHandle>> {
|
|
Some(Box::new(self.upgrade()?))
|
|
}
|
|
|
|
fn into_any(self) -> AnyWeakView {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Box<dyn WeakSearchableItemHandle> {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.id() == other.id()
|
|
}
|
|
}
|
|
|
|
impl Eq for Box<dyn WeakSearchableItemHandle> {}
|
|
|
|
impl std::hash::Hash for Box<dyn WeakSearchableItemHandle> {
|
|
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
|
self.id().hash(state)
|
|
}
|
|
}
|