Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b

crates/editor/src/search.rs

@@ -0,0 +1,408 @@
+use std::ops::Range;
+
+use itertools::Itertools;
+use lazy_static::lazy_static;
+use pathfinder_color::ColorU;
+use warp_core::ui::theme::Fill;
+use warpui::{Entity, ModelContext, ModelHandle, r#async::SpawnedFutureHandle};
+
+use crate::{
+    content::{
+        anchor::Anchor,
+        buffer::{Buffer, BufferEvent},
+        find::{Query, SearchConfig, SearchResults},
+        selection_model::BufferSelectionModel,
+    },
+    render::model::Decoration,
+};
+use string_offset::CharOffset;
+
+#[cfg(test)]
+#[path = "search_tests.rs"]
+mod tests;
+
+pub struct Searcher {
+    query_text: String,
+    case_sensitive: bool,
+    regex: bool,
+    buffer: ModelHandle<Buffer>,
+    selection_model: ModelHandle<BufferSelectionModel>,
+    results: Option<SearchResults>,
+    selected_result: Option<SelectedResult>,
+    search_handle: Option<SpawnedFutureHandle>,
+    auto_select_on_search: bool,
+}
+
+/// A selected search result.
+#[derive(Debug, Clone)]
+pub struct SelectedResult {
+    /// The index of the selected result in the overall list of matches.
+    current_index: usize,
+    /// Handle to the start of the selected result, used to find it again when rerunning a search.
+    start: Anchor,
+}
+
+impl SelectedResult {
+    pub fn current_index(&self) -> usize {
+        self.current_index
+    }
+}
+
+pub trait RestorableSearchResults {
+    fn valid_matches(&self) -> impl Iterator<Item = (usize, CharOffset)>;
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum SearchEvent {
+    /// Search results have updated.
+    Updated,
+    /// The search query is invalid (i.e. a mistyped regex).
+    InvalidQuery,
+    /// The selected search result changed.
+    SelectedResultChanged,
+}
+
+lazy_static! {
+    pub static ref MATCH_FILL: Fill = Fill::Solid(ColorU::new(255, 254, 61, 180));
+    pub static ref SELECTED_MATCH_FILL: Fill = Fill::Solid(ColorU::new(238, 146, 59, 180));
+}
+
+impl Searcher {
+    pub fn new(
+        buffer: ModelHandle<Buffer>,
+        selection_model: ModelHandle<BufferSelectionModel>,
+        ctx: &mut ModelContext<Self>,
+    ) -> Self {
+        ctx.subscribe_to_model(&buffer, Self::handle_buffer_event);
+        Self {
+            query_text: String::new(),
+            case_sensitive: false,
+            regex: false,
+            buffer,
+            selection_model,
+            results: None,
+            selected_result: None,
+            search_handle: None,
+            auto_select_on_search: false,
+        }
+    }
+    /// Returns the index of the closest match at or after the cursor position.
+    /// If there are no matches after the cursor, wraps around to the first match.
+    pub fn next_match_index_from_cursor(&self, ctx: &ModelContext<Self>) -> Option<usize> {
+        let results = self.results.as_ref()?;
+        if results.matches.is_empty() {
+            return None;
+        }
+
+        let cursor_position = self.selection_model.as_ref(ctx).first_selection_head();
+        let final_cursor_position = self.buffer.as_ref(ctx).max_charoffset();
+
+        results
+            .matches
+            .iter()
+            .enumerate()
+            .min_by_key(|(_, m)| {
+                if m.start <= cursor_position {
+                    // Wrap around: add final position to make it come after matches >= cursor_position
+                    m.start + final_cursor_position
+                } else {
+                    // Normal distance for matches at or after cursor
+                    m.start - cursor_position
+                }
+            })
+            .map(|(index, _)| index)
+    }
+
+    /// Set the query text.
+    pub fn set_query(&mut self, query: impl Into<String>, ctx: &mut ModelContext<Self>) {
+        self.query_text = query.into();
+        self.selected_result = None;
+        self.run_search(ctx);
+    }
+
+    /// Whether or not there's a non-empty search query.
+    pub fn has_query(&self) -> bool {
+        !self.query_text.is_empty()
+    }
+
+    /// Set regex mode.
+    pub fn set_regex(&mut self, regex: bool, ctx: &mut ModelContext<Self>) {
+        self.regex = regex;
+        self.selected_result = None;
+        self.run_search(ctx);
+    }
+
+    /// Whether or not regex mode is on.
+    pub fn is_regex(&self) -> bool {
+        self.regex
+    }
+
+    /// Set case sensitivity.
+    pub fn set_case_sensitive(&mut self, case_sensitive: bool, ctx: &mut ModelContext<Self>) {
+        self.case_sensitive = case_sensitive;
+        self.selected_result = None;
+        self.run_search(ctx);
+    }
+
+    /// Whether or not the search is case-sensitive.
+    pub fn is_case_sensitive(&self) -> bool {
+        self.case_sensitive
+    }
+
+    pub fn set_auto_select(&mut self, should_auto_select: bool) {
+        self.auto_select_on_search = should_auto_select;
+    }
+
+    /// The count of search results.
+    pub fn match_count(&self) -> usize {
+        self.results
+            .as_ref()
+            .map_or(0, |results| results.matches.len())
+    }
+
+    /// The index of the currently-selected match within the overall search results.
+    pub fn selected_match(&self) -> Option<usize> {
+        self.selected_result
+            .as_ref()
+            .map(|result| result.current_index)
+    }
+
+    /// The text range of the currently-selected match.
+    pub fn selected_match_range(&self) -> Option<Range<CharOffset>> {
+        let match_index = self.selected_result.as_ref()?.current_index;
+        let match_result = self.results.as_ref()?.matches.get(match_index)?;
+        Some(match_result.start..match_result.end)
+    }
+
+    pub fn select_next_from_cursor(&mut self, ctx: &mut ModelContext<Self>) {
+        match &self.results {
+            Some(results) if !results.matches.is_empty() => {
+                if let Some(next_match_index) = self.next_match_index_from_cursor(ctx) {
+                    self.select_internal(next_match_index, ctx);
+                }
+            }
+            _ => self.clear_selected_result(ctx),
+        }
+    }
+
+    pub fn select_prev_from_cursor(&mut self, ctx: &mut ModelContext<Self>) {
+        match &self.results {
+            Some(results) if !results.matches.is_empty() => {
+                if let Some(next_match_index) = self.next_match_index_from_cursor(ctx) {
+                    let prev_match_index = next_match_index
+                        .checked_sub(1)
+                        .unwrap_or_else(|| results.matches.len() - 1);
+                    self.select_internal(prev_match_index, ctx);
+                }
+            }
+            _ => self.clear_selected_result(ctx),
+        }
+    }
+
+    pub fn select_next_result(&mut self, ctx: &mut ModelContext<Self>) {
+        let result_count = match &self.results {
+            Some(results) if !results.matches.is_empty() => results.matches.len(),
+            _ => return,
+        };
+
+        match self.selected_result.as_ref() {
+            Some(selected_result) => {
+                let target_index = (selected_result.current_index + 1) % result_count;
+                self.select_internal(target_index, ctx);
+            }
+            None => self.select_next_from_cursor(ctx),
+        }
+    }
+
+    pub fn select_previous_result(&mut self, ctx: &mut ModelContext<Self>) {
+        let result_count = match &self.results {
+            Some(results) if !results.matches.is_empty() => results.matches.len(),
+            _ => return,
+        };
+
+        match self.selected_result.as_ref() {
+            Some(selected_result) => {
+                let target_index = selected_result
+                    .current_index
+                    .checked_sub(1)
+                    .unwrap_or(result_count - 1);
+                self.select_internal(target_index, ctx);
+            }
+            None => self.select_prev_from_cursor(ctx),
+        }
+    }
+
+    /// Make `index` the selected search result. This will panic if there are no search results or
+    /// if `index` is out of bounds for the current result set.
+    fn select_internal(&mut self, index: usize, ctx: &mut ModelContext<Self>) {
+        let start_offset = self
+            .results
+            .as_ref()
+            .expect("Must have search results")
+            .matches[index]
+            .start;
+        self.selected_result = Some(self.select_match_at_offset(start_offset, index, ctx));
+        ctx.emit(SearchEvent::SelectedResultChanged);
+    }
+
+    pub fn select_match_at_offset(
+        &mut self,
+        start_offset: CharOffset,
+        index: usize,
+        ctx: &mut ModelContext<Self>,
+    ) -> SelectedResult {
+        let new_anchor = self.selection_model.update(ctx, |selection_model, ctx| {
+            selection_model.anchor(start_offset, ctx)
+        });
+        SelectedResult {
+            current_index: index,
+            start: new_anchor,
+        }
+    }
+
+    fn build_query(&self, ctx: &mut ModelContext<Self>) -> anyhow::Result<Query> {
+        let config = SearchConfig::new(&self.query_text)
+            .with_regex(self.regex)
+            .with_case_sensitive(self.case_sensitive);
+        self.buffer.as_ref(ctx).prepare_search(&config)
+    }
+
+    fn handle_buffer_event(&mut self, event: &BufferEvent, ctx: &mut ModelContext<Self>) {
+        if let BufferEvent::ContentChanged { .. } = event {
+            self.run_search(ctx);
+        }
+    }
+
+    #[cfg(test)]
+    pub fn search_finished(
+        &self,
+        ctx: &mut warpui::AppContext,
+    ) -> impl std::future::Future<Output = ()> + use<> {
+        let maybe_search = self
+            .search_handle
+            .as_ref()
+            .map(|handle| ctx.await_spawned_future(handle.future_id()));
+        async move {
+            if let Some(search) = maybe_search {
+                search.await;
+            }
+        }
+    }
+
+    /// Clear the search results.
+    pub fn reset_results(&mut self, ctx: &mut ModelContext<Self>) {
+        self.selected_result = None;
+        self.results = None;
+        ctx.emit(SearchEvent::Updated);
+    }
+
+    /// Clear the currently selected result without affecting the search results.
+    pub fn clear_selected_result(&mut self, ctx: &mut ModelContext<Self>) {
+        self.selected_result = None;
+        ctx.emit(SearchEvent::SelectedResultChanged);
+    }
+
+    fn run_search(&mut self, ctx: &mut ModelContext<Self>) {
+        if let Some(handle) = self.search_handle.take() {
+            handle.abort();
+        }
+
+        if self.query_text.is_empty() {
+            self.reset_results(ctx);
+            return;
+        }
+
+        // TODO(ben): Cache and reuse the query.
+        let search_future = match self.build_query(ctx) {
+            Ok(query) => self.buffer.as_ref(ctx).search(query),
+            Err(_) => {
+                // If we detect an invalid query, clear all existing results until the next successful query.
+                self.reset_results(ctx);
+                ctx.emit(SearchEvent::InvalidQuery);
+                return;
+            }
+        };
+
+        self.search_handle =
+            Some(
+                ctx.spawn(search_future, |me, (_query, results), ctx| match results {
+                    Ok(results) => {
+                        // If a result is currently selected, preserves it between searches
+                        if let Some(selected_result) = me.selected_result.take() {
+                            me.selected_result =
+                                me.restore_selected_result(selected_result, &results, ctx);
+                        }
+
+                        me.results = Some(results);
+                        if me.auto_select_on_search {
+                            me.select_next_from_cursor(ctx);
+                        }
+
+                        ctx.emit(SearchEvent::Updated);
+                    }
+                    Err(err) => {
+                        log::warn!("Search failed: {err:?}");
+                        // If the search fails, clear all existing results until the next successful query.
+                        me.reset_results(ctx);
+                        ctx.emit(SearchEvent::Updated);
+                    }
+                }),
+            );
+    }
+
+    pub fn restore_selected_result(
+        &self,
+        prev_selected_result: SelectedResult,
+        matches: impl RestorableSearchResults,
+        ctx: &mut ModelContext<Self>,
+    ) -> Option<SelectedResult> {
+        if let Some(start_offset) = self
+            .selection_model
+            .as_ref(ctx)
+            .resolve_anchor(&prev_selected_result.start)
+        {
+            let candidates = matches.valid_matches().collect_vec();
+            if let Ok(index) = candidates.binary_search_by_key(&start_offset, |(_, offset)| *offset)
+            {
+                return Some(SelectedResult {
+                    current_index: candidates[index].0,
+                    start: prev_selected_result.start,
+                });
+            }
+        }
+        None
+    }
+
+    /// Builds text decorations to highlight search results.
+    pub fn result_decorations(&self) -> Vec<Decoration> {
+        let matches = match &self.results {
+            Some(results) => &results.matches,
+            None => return Vec::new(),
+        };
+
+        let selected_match = self.selected_match();
+
+        matches
+            .iter()
+            .enumerate()
+            .map(|(index, m)| {
+                let fill = if Some(index) == selected_match {
+                    *SELECTED_MATCH_FILL
+                } else {
+                    *MATCH_FILL
+                };
+
+                // TODO(CLD-558): This matches how we shift the selection by 1.
+                Decoration::new(m.start - 1, m.end - 1).with_background(fill)
+            })
+            .collect()
+    }
+
+    pub fn results(&self) -> Option<&SearchResults> {
+        self.results.as_ref()
+    }
+}
+
+impl Entity for Searcher {
+    type Event = SearchEvent;
+}