Skip to content

Commit

Permalink
Consolidate DynamicPicker into Picker
Browse files Browse the repository at this point in the history
DynamicPicker is a thin wrapper over Picker that holds some additional
state, similar to the old FilePicker type. Like with FilePicker, we want
to fold the two types together, having Picker optionally hold that
extra state.

The DynamicPicker is a little more complicated than FilePicker was
though - it holds a query callback and current query string in state and
provides some debounce for queries using the IdleTimeout event.
We can move all of that state and debounce logic into an AsyncHook
implementation, introduced here as `DynamicQueryHandler`. The hook
receives updates to the primary query and debounces those events so
that once a query has been idle for a short time (275ms) we re-run
the query.

A standard Picker created through `new` for example can be promoted into
a Dynamic picker by chaining the new `with_dynamic_query` function, very
similar to FilePicker's replacement `with_preview`.

The workspace symbol picker has been migrated to the new way of writing
dynamic pickers as an example. The child commit will promote global
search into a dynamic Picker as well.
  • Loading branch information
the-mikedavis committed Feb 17, 2024
1 parent a0c52d5 commit 63e5038
Show file tree
Hide file tree
Showing 4 changed files with 96 additions and 100 deletions.
2 changes: 1 addition & 1 deletion helix-term/src/commands/lsp.rs
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ use helix_view::{
use crate::{
compositor::{self, Compositor},
job::Callback,
ui::{self, overlay::overlaid, DynamicPicker, FileLocation, Picker, Popup, PromptEvent},
ui::{self, overlay::overlaid, FileLocation, Picker, Popup, PromptEvent},
};

use std::{
Expand Down
2 changes: 1 addition & 1 deletion helix-term/src/ui/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@ pub use completion::{Completion, CompletionItem};
pub use editor::EditorView;
pub use markdown::Markdown;
pub use menu::Menu;
pub use picker::{Column as PickerColumn, DynamicPicker, FileLocation, Picker};
pub use picker::{Column as PickerColumn, FileLocation, Picker};
pub use popup::Popup;
pub use prompt::{Prompt, PromptEvent};
pub use spinner::{ProgressSpinners, Spinner};
Expand Down
106 changes: 23 additions & 83 deletions helix-term/src/ui/picker.rs
Original file line number Diff line number Diff line change
Expand Up @@ -4,9 +4,7 @@ mod query;
use crate::{
alt,
compositor::{self, Component, Compositor, Context, Event, EventResult},
ctrl,
job::Callback,
key, shift,
ctrl, key, shift,
ui::{
self,
document::{render_document, LineDecoration, LinePos, TextRenderer},
Expand Down Expand Up @@ -52,8 +50,6 @@ use helix_view::{

pub const ID: &str = "picker";

use super::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;
Expand Down Expand Up @@ -223,6 +219,11 @@ impl<T, D> Column<T, D> {
}
}

/// 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(String, &mut Editor, Arc<D>, &Injector<T, D>) -> BoxFuture<'static, anyhow::Result<()>>;

pub struct Picker<T: 'static + Send + Sync, D: 'static> {
column_names: Vec<&'static str>,
columns: Arc<Vec<Column<T, D>>>,
Expand Down Expand Up @@ -253,6 +254,8 @@ pub struct Picker<T: 'static + Send + Sync, D: 'static> {
file_fn: Option<FileCallback<T>>,
/// An event handler for syntax highlighting the currently previewed file.
preview_highlight_handler: tokio::sync::mpsc::Sender<Arc<Path>>,
dynamic_query_running: bool,
dynamic_query_handler: Option<tokio::sync::mpsc::Sender<String>>,
}

impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
Expand Down Expand Up @@ -362,6 +365,8 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
read_buffer: Vec::with_capacity(1024),
file_fn: None,
preview_highlight_handler: handlers::PreviewHighlightHandler::<T, D>::default().spawn(),
dynamic_query_running: false,
dynamic_query_handler: None,
}
}

Expand Down Expand Up @@ -396,12 +401,11 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
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 {
inject_nucleo_item(&injector, &self.columns, item, &self.editor_data);
}
pub fn with_dynamic_query(mut self, callback: DynQueryCallback<T, D>) -> Self {
let handler = handlers::DynamicQueryHandler::new(callback).spawn();
helix_event::send_blocking(&handler, self.primary_query().to_string());
self.dynamic_query_handler = Some(handler);
self
}

/// Move the cursor by a number of lines, either down (`Forward`) or up (`Backward`)
Expand Down Expand Up @@ -504,6 +508,9 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
.reparse(i, pattern, CaseMatching::Smart, append);
}
self.query = new_query;
if let Some(handler) = &self.dynamic_query_handler {
helix_event::send_blocking(handler, self.primary_query().to_string());
}
}
}
EventResult::Consumed(None)
Expand Down Expand Up @@ -615,7 +622,11 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {

let count = format!(
"{}{}/{}",
if status.running { "(running) " } else { "" },
if status.running || self.dynamic_query_running {
"(running) "
} else {
""
},
snapshot.matched_item_count(),
snapshot.item_count(),
);
Expand Down Expand Up @@ -1027,74 +1038,3 @@ impl<T: 'static + Send + Sync, D> Drop for Picker<T, D> {
}

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: 'static + Send + Sync, D: 'static + Send + Sync> {
file_picker: Picker<T, D>,
query_callback: DynQueryCallback<T>,
query: String,
}

impl<T: Send + Sync, D: Send + Sync> DynamicPicker<T, D> {
pub fn new(file_picker: Picker<T, D>, query_callback: DynQueryCallback<T>) -> Self {
Self {
file_picker,
query_callback,
query: String::new(),
}
}
}

impl<T: Send + Sync + 'static, D: Send + Sync + 'static> Component for DynamicPicker<T, D> {
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 Some(current_query) = self.file_picker.primary_query() else {
return event_result;
};

if !matches!(event, Event::IdleTimeout) || self.query == *current_query {
return event_result;
}

self.query = current_query.to_string();

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<Self>>(ID) {
Some(overlay) => &mut overlay.content.file_picker,
None => return,
};
picker.set_options(new_options);
}));
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)
}
}
86 changes: 71 additions & 15 deletions helix-term/src/ui/picker/handlers.rs
Original file line number Diff line number Diff line change
@@ -1,11 +1,15 @@
use std::{path::Path, sync::Arc, time::Duration};
use std::{
path::Path,
sync::{atomic, Arc},
time::Duration,
};

use helix_event::AsyncHook;
use tokio::time::Instant;

use crate::ui::overlay::Overlay;

use super::{CachedPreview, DynamicPicker, Picker};
use super::{CachedPreview, DynQueryCallback, Picker};

pub(super) struct PreviewHighlightHandler<T: 'static + Send + Sync, D: 'static + Send + Sync> {
trigger: Option<Arc<Path>>,
Expand Down Expand Up @@ -48,12 +52,8 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> AsyncHook
let Some(path) = self.trigger.take() else { return };

crate::job::dispatch_blocking(move |editor, compositor| {
let picker = match compositor.find::<Overlay<Picker<T, D>>>() {
Some(Overlay { content, .. }) => content,
None => match compositor.find::<Overlay<DynamicPicker<T, D>>>() {
Some(Overlay { content, .. }) => &mut content.file_picker,
None => return,
},
let Some(Overlay { content: picker, .. }) = compositor.find::<Overlay<Picker<T, D>>>() else {
return;
};

let Some(CachedPreview::Document(ref mut doc)) = picker.preview_cache.get_mut(&*path) else {
Expand Down Expand Up @@ -85,13 +85,7 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> AsyncHook
};

crate::job::dispatch_blocking(move |editor, compositor| {
let picker = match compositor.find::<Overlay<Picker<T, D>>>() {
Some(Overlay { content, .. }) => Some(content),
None => compositor
.find::<Overlay<DynamicPicker<T, D>>>()
.map(|overlay| &mut overlay.content.file_picker),
};
let Some(picker) = picker else {
let Some(Overlay { content: picker, .. }) = compositor.find::<Overlay<Picker<T, D>>>() else {
log::info!("picker closed before syntax highlighting finished");
return;
};
Expand All @@ -110,3 +104,65 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> AsyncHook
});
}
}

pub(super) struct DynamicQueryHandler<T: 'static + Send + Sync, D: 'static + Send + Sync> {
callback: Arc<DynQueryCallback<T, D>>,
last_query: String,
query: Option<String>,
}

impl<T: 'static + Send + Sync, D: 'static + Send + Sync> DynamicQueryHandler<T, D> {
pub(super) fn new(callback: DynQueryCallback<T, D>) -> Self {
Self {
callback: Arc::new(callback),
last_query: Default::default(),
query: None,
}
}
}

impl<T: 'static + Send + Sync, D: 'static + Send + Sync> AsyncHook for DynamicQueryHandler<T, D> {
type Event = String;

fn handle_event(&mut self, query: Self::Event, _timeout: Option<Instant>) -> Option<Instant> {
if query == self.last_query {
// If the search query reverts to the last one we requested, no need to
// make a new request.
self.query = None;
None
} else {
self.query = Some(query);
Some(Instant::now() + Duration::from_millis(275))
}
}

fn finish_debounce(&mut self) {
let Some(query) = self.query.take() else { return };
self.last_query = query.clone();
let callback = self.callback.clone();

crate::job::dispatch_blocking(move |editor, compositor| {
let Some(Overlay { content: picker, .. }) = compositor.find::<Overlay<Picker<T, D>>>() else {
return;
};
// Increment the version number to cancel any ongoing requests.
picker.version.fetch_add(1, atomic::Ordering::Relaxed);
picker.matcher.restart(false);
picker.dynamic_query_running = true;
let injector = picker.injector();
let get_options = (callback)(query, editor, picker.editor_data.clone(), &injector);
tokio::spawn(async move {
if let Err(err) = get_options.await {
log::info!("Dynamic request failed: {err}");
}

crate::job::dispatch(|_editor, compositor| {
let Some(Overlay { content: picker, .. }) = compositor.find::<Overlay<Picker<T, D>>>() else {
return;
};
picker.dynamic_query_running = false;
}).await;
});
})
}
}

0 comments on commit 63e5038

Please sign in to comment.