Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'helix-term/src/ui/picker.rs')
| -rw-r--r-- | helix-term/src/ui/picker.rs | 992 |
1 files changed, 410 insertions, 582 deletions
diff --git a/helix-term/src/ui/picker.rs b/helix-term/src/ui/picker.rs index 4f77f8b9..4be5a11e 100644 --- a/helix-term/src/ui/picker.rs +++ b/helix-term/src/ui/picker.rs @@ -1,40 +1,33 @@ -mod handlers; -mod query; - use crate::{ alt, compositor::{self, Component, Compositor, Context, Event, EventResult}, - ctrl, key, shift, + ctrl, + job::Callback, + key, shift, ui::{ self, - document::{render_document, LinePos, TextRenderer}, - picker::query::PickerQuery, - text_decorations::DecorationManager, + document::{render_document, LineDecoration, LinePos, TextRenderer}, EditorView, }, }; -use futures_util::future::BoxFuture; -use helix_event::AsyncHook; -use nucleo::pattern::{CaseMatching, Normalization}; -use nucleo::{Config, Nucleo}; -use thiserror::Error; -use tokio::sync::mpsc::Sender; +use futures_util::{future::BoxFuture, FutureExt}; +use nucleo::pattern::CaseMatching; +use nucleo::{Config, Nucleo, Utf32String}; use tui::{ buffer::Buffer as Surface, layout::Constraint, text::{Span, Spans}, - widgets::{Block, BorderType, Cell, Row, Table}, + widgets::{Block, BorderType, Borders, Cell, Table}, }; use tui::widgets::Widget; use std::{ - borrow::Cow, collections::HashMap, io::Read, - path::Path, + path::PathBuf, sync::{ - atomic::{self, AtomicUsize}, + atomic::{self, AtomicBool}, Arc, }, }; @@ -43,6 +36,7 @@ use crate::ui::{Prompt, PromptEvent}; use helix_core::{ char_idx_at_visual_offset, fuzzy::MATCHER, movement::Direction, text_annotations::TextAnnotations, unicode::segmentation::UnicodeSegmentation, Position, + Syntax, }; use helix_view::{ editor::Action, @@ -52,40 +46,48 @@ use helix_view::{ Document, DocumentId, Editor, }; -use self::handlers::{DynamicQueryChange, DynamicQueryHandler, PreviewHighlightHandler}; - pub const ID: &str = "picker"; +use super::{menu::Item, overlay::Overlay}; pub const MIN_AREA_WIDTH_FOR_PREVIEW: u16 = 72; /// Biggest file size to preview in bytes pub const MAX_FILE_SIZE_FOR_PREVIEW: u64 = 10 * 1024 * 1024; #[derive(PartialEq, Eq, Hash)] -pub enum PathOrId<'a> { +pub enum PathOrId { Id(DocumentId), - Path(&'a Path), + Path(PathBuf), +} + +impl PathOrId { + fn get_canonicalized(self) -> Self { + use PathOrId::*; + match self { + Path(path) => Path(helix_stdx::path::canonicalize(path)), + Id(id) => Id(id), + } + } } -impl<'a> From<&'a Path> for PathOrId<'a> { - fn from(path: &'a Path) -> Self { - Self::Path(path) +impl From<PathBuf> for PathOrId { + fn from(v: PathBuf) -> Self { + Self::Path(v) } } -impl From<DocumentId> for PathOrId<'_> { +impl From<DocumentId> for PathOrId { fn from(v: DocumentId) -> Self { Self::Id(v) } } -type FileCallback<T> = Box<dyn for<'a> Fn(&'a Editor, &'a T) -> Option<FileLocation<'a>>>; +type FileCallback<T> = Box<dyn Fn(&Editor, &T) -> Option<FileLocation>>; /// File path and range of lines (used to align and highlight lines) -pub type FileLocation<'a> = (PathOrId<'a>, Option<(usize, usize)>); +pub type FileLocation = (PathOrId, Option<(usize, usize)>); pub enum CachedPreview { Document(Box<Document>), - Directory(Vec<(String, bool)>), Binary, LargeFile, NotFound, @@ -107,20 +109,12 @@ impl Preview<'_, '_> { } } - fn dir_content(&self) -> Option<&Vec<(String, bool)>> { - match self { - Preview::Cached(CachedPreview::Directory(dir_content)) => Some(dir_content), - _ => None, - } - } - /// Alternate text to show for the preview. fn placeholder(&self) -> &str { match *self { Self::EditorDocument(_) => "<Invalid file location>", Self::Cached(preview) => match preview { CachedPreview::Document(_) => "<Invalid file location>", - CachedPreview::Directory(_) => "<Invalid directory location>", CachedPreview::Binary => "<Binary file>", CachedPreview::LargeFile => "<File too large to preview>", CachedPreview::NotFound => "<File not found>", @@ -129,120 +123,62 @@ impl Preview<'_, '_> { } } -fn inject_nucleo_item<T, D>( - injector: &nucleo::Injector<T>, - columns: &[Column<T, D>], - item: T, - editor_data: &D, -) { - injector.push(item, |item, dst| { - for (column, text) in columns.iter().filter(|column| column.filter).zip(dst) { - *text = column.format_text(item, editor_data).into() +fn item_to_nucleo<T: Item>(item: T, editor_data: &T::Data) -> Option<(T, Utf32String)> { + let row = item.format(editor_data); + let mut cells = row.cells.iter(); + let mut text = String::with_capacity(row.cell_text().map(|cell| cell.len()).sum()); + let cell = cells.next()?; + if let Some(cell) = cell.content.lines.first() { + for span in &cell.0 { + text.push_str(&span.content); } - }); + } + + for cell in cells { + text.push(' '); + if let Some(cell) = cell.content.lines.first() { + for span in &cell.0 { + text.push_str(&span.content); + } + } + } + Some((item, text.into())) } -pub struct Injector<T, D> { +pub struct Injector<T: Item> { dst: nucleo::Injector<T>, - columns: Arc<[Column<T, D>]>, - editor_data: Arc<D>, - version: usize, - picker_version: Arc<AtomicUsize>, - /// A marker that requests a redraw when the injector drops. - /// This marker causes the "running" indicator to disappear when a background job - /// providing items is finished and drops. This could be wrapped in an [Arc] to ensure - /// that the redraw is only requested when all Injectors drop for a Picker (which removes - /// the "running" indicator) but the redraw handle is debounced so this is unnecessary. - _redraw: helix_event::RequestRedrawOnDrop, + editor_data: Arc<T::Data>, + shutown: Arc<AtomicBool>, } -impl<I, D> Clone for Injector<I, D> { +impl<T: Item> Clone for Injector<T> { fn clone(&self) -> Self { Injector { dst: self.dst.clone(), - columns: self.columns.clone(), editor_data: self.editor_data.clone(), - version: self.version, - picker_version: self.picker_version.clone(), - _redraw: helix_event::RequestRedrawOnDrop, + shutown: self.shutown.clone(), } } } -#[derive(Error, Debug)] -#[error("picker has been shut down")] pub struct InjectorShutdown; -impl<T, D> Injector<T, D> { +impl<T: Item> Injector<T> { pub fn push(&self, item: T) -> Result<(), InjectorShutdown> { - if self.version != self.picker_version.load(atomic::Ordering::Relaxed) { + if self.shutown.load(atomic::Ordering::Relaxed) { return Err(InjectorShutdown); } - inject_nucleo_item(&self.dst, &self.columns, item, &self.editor_data); - Ok(()) - } -} - -type ColumnFormatFn<T, D> = for<'a> fn(&'a T, &'a D) -> Cell<'a>; - -pub struct Column<T, D> { - name: Arc<str>, - format: ColumnFormatFn<T, D>, - /// Whether the column should be passed to nucleo for matching and filtering. - /// `DynamicPicker` uses this so that the dynamic column (for example regex in - /// global search) is not used for filtering twice. - filter: bool, - hidden: bool, -} - -impl<T, D> Column<T, D> { - pub fn new(name: impl Into<Arc<str>>, format: ColumnFormatFn<T, D>) -> Self { - Self { - name: name.into(), - format, - filter: true, - hidden: false, + if let Some((item, matcher_text)) = item_to_nucleo(item, &self.editor_data) { + self.dst.push(item, |dst| dst[0] = matcher_text); } - } - - /// A column which does not display any contents - pub fn hidden(name: impl Into<Arc<str>>) -> Self { - let format = |_: &T, _: &D| unreachable!(); - - Self { - name: name.into(), - format, - filter: false, - hidden: true, - } - } - - pub fn without_filtering(mut self) -> Self { - self.filter = false; - self - } - - fn format<'a>(&self, item: &'a T, data: &'a D) -> Cell<'a> { - (self.format)(item, data) - } - - fn format_text<'a>(&self, item: &'a T, data: &'a D) -> Cow<'a, str> { - let text: String = self.format(item, data).content.into(); - text.into() + Ok(()) } } -/// Returns a new list of options to replace the contents of the picker -/// when called with the current picker query, -type DynQueryCallback<T, D> = - fn(&str, &mut Editor, Arc<D>, &Injector<T, D>) -> BoxFuture<'static, anyhow::Result<()>>; - -pub struct Picker<T: 'static + Send + Sync, D: 'static> { - columns: Arc<[Column<T, D>]>, - primary_column: usize, - editor_data: Arc<D>, - version: Arc<AtomicUsize>, +pub struct Picker<T: Item> { + editor_data: Arc<T::Data>, + shutdown: Arc<AtomicBool>, matcher: Nucleo<T>, /// Current height of the completions box @@ -250,7 +186,7 @@ pub struct Picker<T: 'static + Send + Sync, D: 'static> { cursor: u32, prompt: Prompt, - query: PickerQuery, + previous_pattern: String, /// Whether to show the preview panel (default true) show_preview: bool, @@ -258,108 +194,70 @@ pub struct Picker<T: 'static + Send + Sync, D: 'static> { widths: Vec<Constraint>, callback_fn: PickerCallback<T>, - default_action: Action, pub truncate_start: bool, /// Caches paths to documents - preview_cache: HashMap<Arc<Path>, CachedPreview>, + preview_cache: HashMap<PathBuf, CachedPreview>, read_buffer: Vec<u8>, /// Given an item in the picker, return the file path and line number to display. file_fn: Option<FileCallback<T>>, - /// An event handler for syntax highlighting the currently previewed file. - preview_highlight_handler: Sender<Arc<Path>>, - dynamic_query_handler: Option<Sender<DynamicQueryChange>>, } -impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { - pub fn stream( - columns: impl IntoIterator<Item = Column<T, D>>, - editor_data: D, - ) -> (Nucleo<T>, Injector<T, D>) { - let columns: Arc<[_]> = columns.into_iter().collect(); - let matcher_columns = columns.iter().filter(|col| col.filter).count() as u32; - assert!(matcher_columns > 0); +impl<T: Item + 'static> Picker<T> { + pub fn stream(editor_data: T::Data) -> (Nucleo<T>, Injector<T>) { let matcher = Nucleo::new( Config::DEFAULT, Arc::new(helix_event::request_redraw), None, - matcher_columns, + 1, ); let streamer = Injector { dst: matcher.injector(), - columns, editor_data: Arc::new(editor_data), - version: 0, - picker_version: Arc::new(AtomicUsize::new(0)), - _redraw: helix_event::RequestRedrawOnDrop, + shutown: Arc::new(AtomicBool::new(false)), }; (matcher, streamer) } - pub fn new<C, O, F>( - columns: C, - primary_column: usize, - options: O, - editor_data: D, - callback_fn: F, - ) -> Self - where - C: IntoIterator<Item = Column<T, D>>, - O: IntoIterator<Item = T>, - F: Fn(&mut Context, &T, Action) + 'static, - { - let columns: Arc<[_]> = columns.into_iter().collect(); - let matcher_columns = columns - .iter() - .filter(|col: &&Column<T, D>| col.filter) - .count() as u32; - assert!(matcher_columns > 0); + pub fn new( + options: Vec<T>, + editor_data: T::Data, + callback_fn: impl Fn(&mut Context, &T, Action) + 'static, + ) -> Self { let matcher = Nucleo::new( Config::DEFAULT, Arc::new(helix_event::request_redraw), None, - matcher_columns, + 1, ); let injector = matcher.injector(); for item in options { - inject_nucleo_item(&injector, &columns, item, &editor_data); + if let Some((item, matcher_text)) = item_to_nucleo(item, &editor_data) { + injector.push(item, |dst| dst[0] = matcher_text); + } } Self::with( matcher, - columns, - primary_column, Arc::new(editor_data), - Arc::new(AtomicUsize::new(0)), + Arc::new(AtomicBool::new(false)), callback_fn, ) } pub fn with_stream( matcher: Nucleo<T>, - primary_column: usize, - injector: Injector<T, D>, + injector: Injector<T>, callback_fn: impl Fn(&mut Context, &T, Action) + 'static, ) -> Self { - Self::with( - matcher, - injector.columns, - primary_column, - injector.editor_data, - injector.picker_version, - callback_fn, - ) + Self::with(matcher, injector.editor_data, injector.shutown, callback_fn) } fn with( matcher: Nucleo<T>, - columns: Arc<[Column<T, D>]>, - default_column: usize, - editor_data: Arc<D>, - version: Arc<AtomicUsize>, + editor_data: Arc<T::Data>, + shutdown: Arc<AtomicBool>, callback_fn: impl Fn(&mut Context, &T, Action) + 'static, ) -> Self { - assert!(!columns.is_empty()); - let prompt = Prompt::new( "".into(), None, @@ -367,44 +265,29 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { |_editor: &mut Context, _pattern: &str, _event: PromptEvent| {}, ); - let widths = columns - .iter() - .map(|column| Constraint::Length(column.name.chars().count() as u16)) - .collect(); - - let query = PickerQuery::new(columns.iter().map(|col| &col.name).cloned(), default_column); - Self { - columns, - primary_column: default_column, matcher, editor_data, - version, + shutdown, cursor: 0, prompt, - query, + previous_pattern: String::new(), truncate_start: true, show_preview: true, callback_fn: Box::new(callback_fn), - default_action: Action::Replace, completion_height: 0, - widths, + widths: Vec::new(), preview_cache: HashMap::new(), read_buffer: Vec::with_capacity(1024), file_fn: None, - preview_highlight_handler: PreviewHighlightHandler::<T, D>::default().spawn(), - dynamic_query_handler: None, } } - pub fn injector(&self) -> Injector<T, D> { + pub fn injector(&self) -> Injector<T> { Injector { dst: self.matcher.injector(), - columns: self.columns.clone(), editor_data: self.editor_data.clone(), - version: self.version.load(atomic::Ordering::Relaxed), - picker_version: self.version.clone(), - _redraw: helix_event::RequestRedrawOnDrop, + shutown: self.shutdown.clone(), } } @@ -415,7 +298,7 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { pub fn with_preview( mut self, - preview_fn: impl for<'a> Fn(&'a Editor, &'a T) -> Option<FileLocation<'a>> + 'static, + preview_fn: impl Fn(&Editor, &T) -> Option<FileLocation> + 'static, ) -> Self { self.file_fn = Some(Box::new(preview_fn)); // assumption: if we have a preview we are matching paths... If this is ever @@ -424,35 +307,14 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { self } - pub fn with_history_register(mut self, history_register: Option<char>) -> Self { - self.prompt.with_history_register(history_register); - self - } - - pub fn with_initial_cursor(mut self, cursor: u32) -> Self { - self.cursor = cursor; - self - } - - pub fn with_dynamic_query( - mut self, - callback: DynQueryCallback<T, D>, - debounce_ms: Option<u64>, - ) -> Self { - let handler = DynamicQueryHandler::new(callback, debounce_ms).spawn(); - let event = DynamicQueryChange { - query: self.primary_query(), - // Treat the initial query as a paste. - is_paste: true, - }; - helix_event::send_blocking(&handler, event); - self.dynamic_query_handler = Some(handler); - self - } - - pub fn with_default_action(mut self, action: Action) -> Self { - self.default_action = action; - self + pub fn set_options(&mut self, new_options: Vec<T>) { + self.matcher.restart(false); + let injector = self.matcher.injector(); + for item in new_options { + if let Some((item, matcher_text)) = item_to_nucleo(item, &self.editor_data) { + injector.push(item, |dst| dst[0] = matcher_text); + } + } } /// Move the cursor by a number of lines, either down (`Forward`) or up (`Backward`) @@ -505,180 +367,155 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { .map(|item| item.data) } - fn primary_query(&self) -> Arc<str> { - self.query - .get(&self.columns[self.primary_column].name) - .cloned() - .unwrap_or_else(|| "".into()) - } - - fn header_height(&self) -> u16 { - if self.columns.len() > 1 { - 1 - } else { - 0 - } - } - pub fn toggle_preview(&mut self) { self.show_preview = !self.show_preview; } fn prompt_handle_event(&mut self, event: &Event, cx: &mut Context) -> EventResult { if let EventResult::Consumed(_) = self.prompt.handle_event(event, cx) { - self.handle_prompt_change(matches!(event, Event::Paste(_))); + let pattern = self.prompt.line(); + // TODO: better track how the pattern has changed + if pattern != &self.previous_pattern { + self.matcher.pattern.reparse( + 0, + pattern, + CaseMatching::Smart, + pattern.starts_with(&self.previous_pattern), + ); + self.previous_pattern = pattern.clone(); + } } EventResult::Consumed(None) } - fn handle_prompt_change(&mut self, is_paste: bool) { - // TODO: better track how the pattern has changed - let line = self.prompt.line(); - let old_query = self.query.parse(line); - if self.query == old_query { - return; - } - // If the query has meaningfully changed, reset the cursor to the top of the results. - self.cursor = 0; - // Have nucleo reparse each changed column. - for (i, column) in self - .columns - .iter() - .filter(|column| column.filter) - .enumerate() - { - let pattern = self - .query - .get(&column.name) - .map(|f| &**f) - .unwrap_or_default(); - let old_pattern = old_query - .get(&column.name) - .map(|f| &**f) - .unwrap_or_default(); - // Fastlane: most columns will remain unchanged after each edit. - if pattern == old_pattern { - continue; - } - let is_append = pattern.starts_with(old_pattern); - self.matcher.pattern.reparse( - i, - pattern, - CaseMatching::Smart, - Normalization::Smart, - is_append, - ); - } - // If this is a dynamic picker, notify the query hook that the primary - // query might have been updated. - if let Some(handler) = &self.dynamic_query_handler { - let event = DynamicQueryChange { - query: self.primary_query(), - is_paste, - }; - helix_event::send_blocking(handler, event); - } + fn current_file(&self, editor: &Editor) -> Option<FileLocation> { + self.selection() + .and_then(|current| (self.file_fn.as_ref()?)(editor, current)) + .map(|(path_or_id, line)| (path_or_id.get_canonicalized(), line)) } - /// Get (cached) preview for the currently selected item. If a document corresponding + /// Get (cached) preview for a given path. If a document corresponding /// to the path is already open in the editor, it is used instead. fn get_preview<'picker, 'editor>( &'picker mut self, + path_or_id: PathOrId, editor: &'editor Editor, - ) -> Option<(Preview<'picker, 'editor>, Option<(usize, usize)>)> { - let current = self.selection()?; - let (path_or_id, range) = (self.file_fn.as_ref()?)(editor, current)?; - + ) -> Preview<'picker, 'editor> { match path_or_id { PathOrId::Path(path) => { + let path = &path; if let Some(doc) = editor.document_by_path(path) { - return Some((Preview::EditorDocument(doc), range)); + return Preview::EditorDocument(doc); } if self.preview_cache.contains_key(path) { - // NOTE: we use `HashMap::get_key_value` here instead of indexing so we can - // retrieve the `Arc<Path>` key. The `path` in scope here is a `&Path` and - // we can cheaply clone the key for the preview highlight handler. - let (path, preview) = self.preview_cache.get_key_value(path).unwrap(); - if matches!(preview, CachedPreview::Document(doc) if doc.syntax().is_none()) { - helix_event::send_blocking(&self.preview_highlight_handler, path.clone()); - } - return Some((Preview::Cached(preview), range)); + return Preview::Cached(&self.preview_cache[path]); } - let path: Arc<Path> = path.into(); - let preview = std::fs::metadata(&path) - .and_then(|metadata| { - if metadata.is_dir() { - let files = super::directory_content(&path, editor)?; - let file_names: Vec<_> = files - .iter() - .filter_map(|(file_path, is_dir)| { - let name = file_path - .strip_prefix(&path) - .map(|p| Some(p.as_os_str())) - .unwrap_or_else(|_| file_path.file_name())? - .to_string_lossy(); - if *is_dir { - Some((format!("{}/", name), true)) - } else { - Some((name.into_owned(), false)) - } - }) - .collect(); - Ok(CachedPreview::Directory(file_names)) - } else if metadata.is_file() { - if metadata.len() > MAX_FILE_SIZE_FOR_PREVIEW { - return Ok(CachedPreview::LargeFile); + let data = std::fs::File::open(path).and_then(|file| { + let metadata = file.metadata()?; + // Read up to 1kb to detect the content type + let n = file.take(1024).read_to_end(&mut self.read_buffer)?; + let content_type = content_inspector::inspect(&self.read_buffer[..n]); + self.read_buffer.clear(); + Ok((metadata, content_type)) + }); + let preview = data + .map( + |(metadata, content_type)| match (metadata.len(), content_type) { + (_, content_inspector::ContentType::BINARY) => CachedPreview::Binary, + (size, _) if size > MAX_FILE_SIZE_FOR_PREVIEW => { + CachedPreview::LargeFile } - let content_type = std::fs::File::open(&path).and_then(|file| { - // Read up to 1kb to detect the content type - let n = file.take(1024).read_to_end(&mut self.read_buffer)?; - let content_type = - content_inspector::inspect(&self.read_buffer[..n]); - self.read_buffer.clear(); - Ok(content_type) - })?; - if content_type.is_binary() { - return Ok(CachedPreview::Binary); - } - let mut doc = Document::open( - &path, - None, - false, - editor.config.clone(), - editor.syn_loader.clone(), - ) - .or(Err(std::io::Error::new( - std::io::ErrorKind::NotFound, - "Cannot open document", - )))?; - let loader = editor.syn_loader.load(); - if let Some(language_config) = doc.detect_language_config(&loader) { - doc.language = Some(language_config); - // Asynchronously highlight the new document - helix_event::send_blocking( - &self.preview_highlight_handler, - path.clone(), - ); - } - Ok(CachedPreview::Document(Box::new(doc))) - } else { - Err(std::io::Error::new( - std::io::ErrorKind::NotFound, - "Neither a dir, nor a file", - )) - } - }) + _ => Document::open(path, None, None, editor.config.clone()) + .map(|doc| CachedPreview::Document(Box::new(doc))) + .unwrap_or(CachedPreview::NotFound), + }, + ) .unwrap_or(CachedPreview::NotFound); - self.preview_cache.insert(path.clone(), preview); - Some((Preview::Cached(&self.preview_cache[&path]), range)) + self.preview_cache.insert(path.to_owned(), preview); + Preview::Cached(&self.preview_cache[path]) } PathOrId::Id(id) => { let doc = editor.documents.get(&id).unwrap(); - Some((Preview::EditorDocument(doc), range)) + Preview::EditorDocument(doc) + } + } + } + + fn handle_idle_timeout(&mut self, cx: &mut Context) -> EventResult { + let Some((current_file, _)) = self.current_file(cx.editor) else { + return EventResult::Consumed(None); + }; + + // Try to find a document in the cache + let doc = match ¤t_file { + PathOrId::Id(doc_id) => doc_mut!(cx.editor, doc_id), + PathOrId::Path(path) => match self.preview_cache.get_mut(path) { + Some(CachedPreview::Document(ref mut doc)) => doc, + _ => return EventResult::Consumed(None), + }, + }; + + let mut callback: Option<compositor::Callback> = None; + + // Then attempt to highlight it if it has no language set + if doc.language_config().is_none() { + if let Some(language_config) = doc.detect_language_config(&cx.editor.syn_loader) { + doc.language = Some(language_config.clone()); + let text = doc.text().clone(); + let loader = cx.editor.syn_loader.clone(); + let job = tokio::task::spawn_blocking(move || { + let syntax = language_config.highlight_config(&loader.scopes()).and_then( + |highlight_config| Syntax::new(text.slice(..), highlight_config, loader), + ); + let callback = move |editor: &mut Editor, compositor: &mut Compositor| { + let Some(syntax) = syntax else { + log::info!("highlighting picker item failed"); + return; + }; + let picker = match compositor.find::<Overlay<Self>>() { + Some(Overlay { content, .. }) => Some(content), + None => compositor + .find::<Overlay<DynamicPicker<T>>>() + .map(|overlay| &mut overlay.content.file_picker), + }; + let Some(picker) = picker else { + log::info!("picker closed before syntax highlighting finished"); + return; + }; + // Try to find a document in the cache + let doc = match current_file { + PathOrId::Id(doc_id) => doc_mut!(editor, &doc_id), + PathOrId::Path(path) => match picker.preview_cache.get_mut(&path) { + Some(CachedPreview::Document(ref mut doc)) => { + let diagnostics = Editor::doc_diagnostics( + &editor.language_servers, + &editor.diagnostics, + doc, + ); + doc.replace_diagnostics(diagnostics, &[], None); + doc + } + _ => return, + }, + }; + doc.syntax = Some(syntax); + }; + Callback::EditorCompositor(Box::new(callback)) + }); + let tmp: compositor::Callback = Box::new(move |_, ctx| { + ctx.jobs + .callback(job.map(|res| res.map_err(anyhow::Error::from))) + }); + callback = Some(Box::new(tmp)) } } + + // QUESTION: do we want to compute inlay hints in pickers too ? Probably not for now + // but it could be interesting in the future + + EventResult::Consumed(callback) } fn render_picker(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) { @@ -699,32 +536,26 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { let background = cx.editor.theme.get("ui.background"); surface.clear_with(area, background); - const BLOCK: Block<'_> = Block::bordered(); + // don't like this but the lifetime sucks + let block = Block::default().borders(Borders::ALL); // calculate the inner area inside the box - let inner = BLOCK.inner(area); + let inner = block.inner(area); - BLOCK.render(area, surface); + block.render(area, surface); // -- Render the input bar: + let area = inner.clip_left(1).with_height(1); + // render the prompt first since it will clear its background + self.prompt.render(area, surface, cx); + let count = format!( "{}{}/{}", - if status.running || self.matcher.active_injectors() > 0 { - "(running) " - } else { - "" - }, + if status.running { "(running) " } else { "" }, snapshot.matched_item_count(), snapshot.item_count(), ); - - let area = inner.clip_left(1).with_height(1); - let line_area = area.clip_right(count.len() as u16 + 1); - - // render the prompt first since it will clear its background - self.prompt.render(line_area, surface, cx); - surface.set_stringn( (area.x + area.width).saturating_sub(count.len() as u16 + 1), area.y, @@ -745,7 +576,7 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { // -- Render the contents: // subtract area of prompt from top let inner = inner.clip_top(2); - let rows = inner.height.saturating_sub(self.header_height()) as u32; + let rows = inner.height as u32; let offset = self.cursor - (self.cursor % std::cmp::max(1, rows)); let cursor = self.cursor.saturating_sub(offset); let end = offset @@ -759,114 +590,83 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { } let options = snapshot.matched_items(offset..end).map(|item| { + snapshot.pattern().column_pattern(0).indices( + item.matcher_columns[0].slice(..), + &mut matcher, + &mut indices, + ); + indices.sort_unstable(); + indices.dedup(); + let mut row = item.data.format(&self.editor_data); + + let mut grapheme_idx = 0u32; + let mut indices = indices.drain(..); + let mut next_highlight_idx = indices.next().unwrap_or(u32::MAX); + if self.widths.len() < row.cells.len() { + self.widths.resize(row.cells.len(), Constraint::Length(0)); + } let mut widths = self.widths.iter_mut(); - let mut matcher_index = 0; - - Row::new(self.columns.iter().map(|column| { - if column.hidden { - return Cell::default(); - } - + for cell in &mut row.cells { let Some(Constraint::Length(max_width)) = widths.next() else { unreachable!(); }; - let mut cell = column.format(item.data, &self.editor_data); - let width = if column.filter { - snapshot.pattern().column_pattern(matcher_index).indices( - item.matcher_columns[matcher_index].slice(..), - &mut matcher, - &mut indices, - ); - indices.sort_unstable(); - indices.dedup(); - let mut indices = indices.drain(..); - let mut next_highlight_idx = indices.next().unwrap_or(u32::MAX); - let mut span_list = Vec::new(); - let mut current_span = String::new(); - let mut current_style = Style::default(); - let mut grapheme_idx = 0u32; - let mut width = 0; - - let spans: &[Span] = - cell.content.lines.first().map_or(&[], |it| it.0.as_slice()); - for span in spans { - // this looks like a bug on first glance, we are iterating - // graphemes but treating them as char indices. The reason that - // this is correct is that nucleo will only ever consider the first char - // of a grapheme (and discard the rest of the grapheme) so the indices - // returned by nucleo are essentially grapheme indecies - for grapheme in span.content.graphemes(true) { - let style = if grapheme_idx == next_highlight_idx { - next_highlight_idx = indices.next().unwrap_or(u32::MAX); - span.style.patch(highlight_style) - } else { - span.style - }; - if style != current_style { - if !current_span.is_empty() { - span_list.push(Span::styled(current_span, current_style)) - } - current_span = String::new(); - current_style = style; + + // merge index highlights on top of existing hightlights + let mut span_list = Vec::new(); + let mut current_span = String::new(); + let mut current_style = Style::default(); + let mut width = 0; + + let spans: &[Span] = cell.content.lines.first().map_or(&[], |it| it.0.as_slice()); + for span in spans { + // this looks like a bug on first glance, we are iterating + // graphemes but treating them as char indices. The reason that + // this is correct is that nucleo will only ever consider the first char + // of a grapheme (and discard the rest of the grapheme) so the indices + // returned by nucleo are essentially grapheme indecies + for grapheme in span.content.graphemes(true) { + let style = if grapheme_idx == next_highlight_idx { + next_highlight_idx = indices.next().unwrap_or(u32::MAX); + span.style.patch(highlight_style) + } else { + span.style + }; + if style != current_style { + if !current_span.is_empty() { + span_list.push(Span::styled(current_span, current_style)) } - current_span.push_str(grapheme); - grapheme_idx += 1; + current_span = String::new(); + current_style = style; } - width += span.width(); + current_span.push_str(grapheme); + grapheme_idx += 1; } + width += span.width(); + } - span_list.push(Span::styled(current_span, current_style)); - cell = Cell::from(Spans::from(span_list)); - matcher_index += 1; - width - } else { - cell.content - .lines - .first() - .map(|line| line.width()) - .unwrap_or_default() - }; - + span_list.push(Span::styled(current_span, current_style)); if width as u16 > *max_width { *max_width = width as u16; } + *cell = Cell::from(Spans::from(span_list)); + + // spacer + if grapheme_idx == next_highlight_idx { + next_highlight_idx = indices.next().unwrap_or(u32::MAX); + } + grapheme_idx += 1; + } - cell - })) + row }); - let mut table = Table::new(options) + let table = Table::new(options) .style(text_style) .highlight_style(selected) .highlight_symbol(" > ") .column_spacing(1) .widths(&self.widths); - // -- Header - if self.columns.len() > 1 { - let active_column = self.query.active_column(self.prompt.position()); - let header_style = cx.editor.theme.get("ui.picker.header"); - let header_column_style = cx.editor.theme.get("ui.picker.header.column"); - - table = table.header( - Row::new(self.columns.iter().map(|column| { - if column.hidden { - Cell::default() - } else { - let style = - if active_column.is_some_and(|name| Arc::ptr_eq(name, &column.name)) { - cx.editor.theme.get("ui.picker.header.column.active") - } else { - header_column_style - }; - - Cell::from(Span::styled(Cow::from(&*column.name), style)) - } - })) - .style(header_style), - ); - } - use tui::widgets::TableState; table.render_table( @@ -885,44 +685,29 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { // clear area let background = cx.editor.theme.get("ui.background"); let text = cx.editor.theme.get("ui.text"); - let directory = cx.editor.theme.get("ui.text.directory"); surface.clear_with(area, background); - const BLOCK: Block<'_> = Block::bordered(); + // don't like this but the lifetime sucks + let block = Block::default().borders(Borders::ALL); // calculate the inner area inside the box - let inner = BLOCK.inner(area); + let inner = block.inner(area); // 1 column gap on either side let margin = Margin::horizontal(1); - let inner = inner.inner(margin); - BLOCK.render(area, surface); + let inner = inner.inner(&margin); + block.render(area, surface); - if let Some((preview, range)) = self.get_preview(cx.editor) { + if let Some((path, range)) = self.current_file(cx.editor) { + let preview = self.get_preview(path, cx.editor); let doc = match preview.document() { Some(doc) - if range.is_none_or(|(start, end)| { + if range.map_or(true, |(start, end)| { start <= end && end <= doc.text().len_lines() }) => { doc } _ => { - if let Some(dir_content) = preview.dir_content() { - for (i, (path, is_dir)) in - dir_content.iter().take(inner.height as usize).enumerate() - { - let style = if *is_dir { directory } else { text }; - surface.set_stringn( - inner.x, - inner.y + i as u16, - path, - inner.width as usize, - style, - ); - } - return; - } - let alt_text = preview.placeholder(); let x = inner.x + inner.width.saturating_sub(alt_text.len() as u16) / 2; let y = inner.y + inner.height / 2; @@ -958,19 +743,22 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { } } - let loader = cx.editor.syn_loader.load(); - - let syntax_highlighter = - EditorView::doc_syntax_highlighter(doc, offset.anchor, area.height, &loader); - let mut overlay_highlights = Vec::new(); - - EditorView::doc_diagnostics_highlights_into( + let syntax_highlights = EditorView::doc_syntax_highlights( doc, + offset.anchor, + area.height, &cx.editor.theme, - &mut overlay_highlights, ); - let mut decorations = DecorationManager::default(); + let mut overlay_highlights = + EditorView::empty_highlight_iter(doc, offset.anchor, area.height); + for spans in EditorView::doc_diagnostics_highlights(doc, &cx.editor.theme) { + if spans.is_empty() { + continue; + } + overlay_highlights = Box::new(helix_core::syntax::merge(overlay_highlights, spans)); + } + let mut decorations: Vec<Box<dyn LineDecoration>> = Vec::new(); if let Some((start, end)) = range { let style = cx @@ -982,14 +770,14 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { if (start..=end).contains(&pos.doc_line) { let area = Rect::new( renderer.viewport.x, - pos.visual_line, + renderer.viewport.y + pos.visual_line, renderer.viewport.width, 1, ); - renderer.set_style(area, style) + renderer.surface.set_style(area, style) } }; - decorations.add_decoration(draw_highlight); + decorations.push(Box::new(draw_highlight)) } render_document( @@ -999,16 +787,17 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> { offset, // TODO: compute text annotations asynchronously here (like inlay hints) &TextAnnotations::default(), - syntax_highlighter, + syntax_highlights, overlay_highlights, &cx.editor.theme, - decorations, + &mut decorations, + &mut [], ); } } } -impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, D> { +impl<T: Item + 'static + Send + Sync> Component for Picker<T> { fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) { // +---------+ +---------+ // |prompt | |preview | @@ -1036,6 +825,9 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, } fn handle_event(&mut self, event: &Event, ctx: &mut Context) -> EventResult { + if let Event::IdleTimeout = event { + return self.handle_idle_timeout(ctx); + } // TODO: keybinds for scrolling preview let key_event = match event { @@ -1048,26 +840,29 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, let close_fn = |picker: &mut Self| { // if the picker is very large don't store it as last_picker to avoid // excessive memory consumption - let callback: compositor::Callback = - if picker.matcher.snapshot().item_count() > 1_000_000 { - Box::new(|compositor: &mut Compositor, _ctx| { - // remove the layer - compositor.pop(); - }) - } else { - // stop streaming in new items in the background, really we should - // be restarting the stream somehow once the picker gets - // reopened instead (like for an FS crawl) that would also remove the - // need for the special case above but that is pretty tricky - picker.version.fetch_add(1, atomic::Ordering::Relaxed); - Box::new(|compositor: &mut Compositor, _ctx| { - // remove the layer - compositor.last_picker = compositor.pop(); - }) - }; + let callback: compositor::Callback = if picker.matcher.snapshot().item_count() > 100_000 + { + Box::new(|compositor: &mut Compositor, _ctx| { + // remove the layer + compositor.pop(); + }) + } else { + // stop streaming in new items in the background, really we should + // be restarting the stream somehow once the picker gets + // reopened instead (like for an FS crawl) that would also remove the + // need for the special case above but that is pretty tricky + picker.shutdown.store(true, atomic::Ordering::Relaxed); + Box::new(|compositor: &mut Compositor, _ctx| { + // remove the layer + compositor.last_picker = compositor.pop(); + }) + }; EventResult::Consumed(Some(callback)) }; + // So that idle timeout retriggers + ctx.editor.reset_idle_timer(); + match key_event { shift!(Tab) | key!(Up) | ctrl!('p') => { self.move_by(1, Direction::Backward); @@ -1090,43 +885,14 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, key!(Esc) | ctrl!('c') => return close_fn(self), alt!(Enter) => { if let Some(option) = self.selection() { - (self.callback_fn)(ctx, option, self.default_action); + (self.callback_fn)(ctx, option, Action::Load); } } key!(Enter) => { - // If the prompt has a history completion and is empty, use enter to accept - // that completion - if let Some(completion) = self - .prompt - .first_history_completion(ctx.editor) - .filter(|_| self.prompt.line().is_empty()) - { - // The percent character is used by the query language and needs to be - // escaped with a backslash. - let completion = if completion.contains('%') { - completion.replace('%', "\\%") - } else { - completion.into_owned() - }; - self.prompt.set_line(completion, ctx.editor); - - // Inserting from the history register is a paste. - self.handle_prompt_change(true); - } else { - if let Some(option) = self.selection() { - (self.callback_fn)(ctx, option, self.default_action); - } - if let Some(history_register) = self.prompt.history_register() { - if let Err(err) = ctx - .editor - .registers - .push(history_register, self.primary_query().to_string()) - { - ctx.editor.set_error(err.to_string()); - } - } - return close_fn(self); + if let Some(option) = self.selection() { + (self.callback_fn)(ctx, option, Action::Replace); } + return close_fn(self); } ctrl!('s') => { if let Some(option) = self.selection() { @@ -1152,26 +918,18 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, } fn cursor(&self, area: Rect, editor: &Editor) -> (Option<Position>, CursorKind) { - let block = Block::bordered(); + let block = Block::default().borders(Borders::ALL); // calculate the inner area inside the box let inner = block.inner(area); // prompt area - let render_preview = - self.show_preview && self.file_fn.is_some() && area.width > MIN_AREA_WIDTH_FOR_PREVIEW; - - let picker_width = if render_preview { - area.width / 2 - } else { - area.width - }; - let area = inner.clip_left(1).with_height(1).with_width(picker_width); + let area = inner.clip_left(1).with_height(1); self.prompt.cursor(area, editor) } fn required_size(&mut self, (width, height): (u16, u16)) -> Option<(u16, u16)> { - self.completion_height = height.saturating_sub(4 + self.header_height()); + self.completion_height = height.saturating_sub(4); Some((width, height)) } @@ -1179,11 +937,81 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, Some(ID) } } -impl<T: 'static + Send + Sync, D> Drop for Picker<T, D> { +impl<T: Item> Drop for Picker<T> { fn drop(&mut self) { // ensure we cancel any ongoing background threads streaming into the picker - self.version.fetch_add(1, atomic::Ordering::Relaxed); + self.shutdown.store(true, atomic::Ordering::Relaxed) } } type PickerCallback<T> = Box<dyn Fn(&mut Context, &T, Action)>; + +/// Returns a new list of options to replace the contents of the picker +/// when called with the current picker query, +pub type DynQueryCallback<T> = + Box<dyn Fn(String, &mut Editor) -> BoxFuture<'static, anyhow::Result<Vec<T>>>>; + +/// A picker that updates its contents via a callback whenever the +/// query string changes. Useful for live grep, workspace symbols, etc. +pub struct DynamicPicker<T: ui::menu::Item + Send + Sync> { + file_picker: Picker<T>, + query_callback: DynQueryCallback<T>, + query: String, +} + +impl<T: ui::menu::Item + Send + Sync> DynamicPicker<T> { + pub fn new(file_picker: Picker<T>, query_callback: DynQueryCallback<T>) -> Self { + Self { + file_picker, + query_callback, + query: String::new(), + } + } +} + +impl<T: Item + Send + Sync + 'static> Component for DynamicPicker<T> { + fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) { + self.file_picker.render(area, surface, cx); + } + + fn handle_event(&mut self, event: &Event, cx: &mut Context) -> EventResult { + let event_result = self.file_picker.handle_event(event, cx); + let current_query = self.file_picker.prompt.line(); + + if !matches!(event, Event::IdleTimeout) || self.query == *current_query { + return event_result; + } + + self.query.clone_from(current_query); + + let new_options = (self.query_callback)(current_query.to_owned(), cx.editor); + + cx.jobs.callback(async move { + let new_options = new_options.await?; + let callback = Callback::EditorCompositor(Box::new(move |editor, compositor| { + // Wrapping of pickers in overlay is done outside the picker code, + // so this is fragile and will break if wrapped in some other widget. + let picker = match compositor.find_id::<Overlay<DynamicPicker<T>>>(ID) { + Some(overlay) => &mut overlay.content.file_picker, + None => return, + }; + picker.set_options(new_options); + editor.reset_idle_timer(); + })); + anyhow::Ok(callback) + }); + EventResult::Consumed(None) + } + + fn cursor(&self, area: Rect, ctx: &Editor) -> (Option<Position>, CursorKind) { + self.file_picker.cursor(area, ctx) + } + + fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> { + self.file_picker.required_size(viewport) + } + + fn id(&self) -> Option<&'static str> { + Some(ID) + } +} |