perf: use background task for worker

_

helix-term/src/handlers.rs

@@ -23,7 +23,7 @@ pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
     let event_tx = completion::CompletionHandler::new(config).spawn();
     let signature_hints = SignatureHelpHandler::new().spawn();
     let auto_save = AutoSaveHandler::new().spawn();
-    let blame = blame::BlameHandler.spawn();
+    let blame = blame::BlameHandler::default().spawn();
 
     let handlers = Handlers {
         completions: helix_view::handlers::completion::CompletionHandler::new(event_tx),

helix-term/src/handlers/blame.rs

@@ -1,71 +1,107 @@
+use std::{path::PathBuf, time::Duration};
+
 use helix_event::{register_hook, send_blocking};
-use helix_view::{
+use helix_vcs::DiffProviderRegistry;
-    handlers::{BlameEvent, Handlers},
+use helix_view::handlers::{BlameEvent, Handlers};
-    Editor,
+use tokio::{task::JoinHandle, time::Instant};
-};
 
 use crate::{events::PostCommand, job};
 
-pub struct BlameHandler;
+#[derive(Default)]
+pub struct BlameHandler {
+    worker: Option<JoinHandle<anyhow::Result<String>>>,
+}
+
+async fn compute_diff(
+    file: PathBuf,
+    line: u32,
+    diff_providers: DiffProviderRegistry,
+) -> anyhow::Result<String> {
+    // std::thread::sleep(Duration::from_secs(5));
+    // Ok("hhe".to_string())
+    diff_providers
+        .blame_line(&file, line)
+        .map(|s| s.to_string())
+}
 
 impl helix_event::AsyncHook for BlameHandler {
     type Event = BlameEvent;
 
     fn handle_event(
         &mut self,
-        _event: Self::Event,
+        event: Self::Event,
         _timeout: Option<tokio::time::Instant>,
     ) -> Option<tokio::time::Instant> {
-        self.finish_debounce();
+        if let Some(worker) = &self.worker {
-        None
+            if worker.is_finished() {
+                self.finish_debounce();
+                return None;
+            }
+            return Some(Instant::now() + Duration::from_millis(50));
+        }
+
+        let BlameEvent::PostCommand {
+            file,
+            cursor_line,
+            diff_providers,
+        } = event;
+
+        let worker = tokio::spawn(compute_diff(file, cursor_line, diff_providers));
+        self.worker = Some(worker);
+        Some(Instant::now() + Duration::from_millis(50))
     }
 
     fn finish_debounce(&mut self) {
-        // TODO: this blocks on the main thread. Figure out how not to do that
+        if let Some(worker) = &self.worker {
-        //
+            if worker.is_finished() {
-        // Attempts so far:
+                let worker = self.worker.take().unwrap();
-        // - tokio::spawn
+                tokio::spawn(handle_worker(worker));
-        // - std::thread::spawn
+            }
-        //
+        }
-        // For some reason none of the above fix the issue of blocking the UI.
-        job::dispatch_blocking(move |editor, _| {
-            request_git_blame(editor);
-        })
     }
 }
 
+async fn handle_worker(worker: JoinHandle<anyhow::Result<String>>) {
+    let Ok(Ok(outcome)) = worker.await else {
+        return;
+    };
+    job::dispatch(move |editor, _| {
+        let doc = doc_mut!(editor);
+        doc.blame = Some(outcome);
+    })
+    .await;
+}
+
 pub(super) fn register_hooks(handlers: &Handlers) {
     let tx = handlers.blame.clone();
     register_hook!(move |event: &mut PostCommand<'_, '_>| {
         if event.cx.editor.config().vcs.blame {
-            send_blocking(&tx, BlameEvent::PostCommand);
+            let blame_enabled = event.cx.editor.config().vcs.blame;
+            let (view, doc) = current!(event.cx.editor);
+            let text = doc.text();
+            let selection = doc.selection(view.id);
+            let Some(file) = doc.path() else {
+                panic!();
+            };
+            if !blame_enabled {
+                panic!();
+            }
+
+            let cursor_lin = text.char_to_line(selection.primary().cursor(doc.text().slice(..)));
+            let Ok(cursor_line) = TryInto::<u32>::try_into(cursor_lin) else {
+                panic!();
+            };
+
+            send_blocking(
+                &tx,
+                BlameEvent::PostCommand {
+                    file: file.to_path_buf(),
+                    cursor_line,
+                    diff_providers: event.cx.editor.diff_providers.clone(),
+                },
+            );
         }
 
         Ok(())
     });
 }
-
-fn request_git_blame(editor: &mut Editor) {
-    let blame_enabled = editor.config().vcs.blame;
-    let (view, doc) = current!(editor);
-    let text = doc.text();
-    let selection = doc.selection(view.id);
-    let Some(file) = doc.path() else {
-        return;
-    };
-    if !blame_enabled {
-        return;
-    }
-
-    let cursor_lin = text.char_to_line(selection.primary().cursor(doc.text().slice(..)));
-    let Ok(cursor_line) = TryInto::<u32>::try_into(cursor_lin) else {
-        return;
-    };
-
-    // 0-based into 1-based line number
-    let Ok(output) = editor.diff_providers.blame_line(file, cursor_line + 1) else {
-        return;
-    };
-
-    doc.blame = Some(output.to_string());
-}

helix-vcs/src/lib.rs

@@ -17,7 +17,7 @@ mod status;
 
 pub use status::FileChange;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct DiffProviderRegistry {
     providers: Vec<DiffProvider>,
 }
@@ -94,7 +94,7 @@ impl Default for DiffProviderRegistry {
 /// cloning [DiffProviderRegistry] as `Clone` cannot be used in trait objects.
 ///
 /// `Copy` is simply to ensure the `clone()` call is the simplest it can be.
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub enum DiffProvider {
     #[cfg(feature = "git")]
     Git,

helix-view/src/handlers.rs

@@ -1,5 +1,8 @@
+use std::path::PathBuf;
+
 use completion::{CompletionEvent, CompletionHandler};
 use helix_event::send_blocking;
+use helix_vcs::DiffProviderRegistry;
 use tokio::sync::mpsc::Sender;
 
 use crate::handlers::lsp::SignatureHelpInvoked;
@@ -18,7 +21,11 @@ pub enum AutoSaveEvent {
 
 #[derive(Debug)]
 pub enum BlameEvent {
-    PostCommand,
+    PostCommand {
+        file: PathBuf,
+        cursor_line: u32,
+        diff_providers: DiffProviderRegistry,
+    },
 }
 
 pub struct Handlers {