Auto Save All Buffers After A Delay

helix-term/src/handlers.rs

@@ -7,24 +7,31 @@ use crate::config::Config;
 use crate::events;
 use crate::handlers::completion::CompletionHandler;
 use crate::handlers::signature_help::SignatureHelpHandler;
+use crate::handlers::auto_save::AutoSaveHandler;
 
 pub use completion::trigger_auto_completion;
 pub use helix_view::handlers::lsp::SignatureHelpInvoked;
 pub use helix_view::handlers::Handlers;
 
 mod completion;
 mod signature_help;
+mod auto_save;
 
 pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
     events::register();
 
     let completions = CompletionHandler::new(config).spawn();
     let signature_hints = SignatureHelpHandler::new().spawn();
+    let auto_save = AutoSaveHandler::new().spawn();
+
     let handlers = Handlers {
         completions,
         signature_hints,
+        auto_save,
     };
+
     completion::register_hooks(&handlers);
     signature_help::register_hooks(&handlers);
+    auto_save::register_hooks(&handlers);
     handlers
 }

helix-term/src/handlers/auto_save.rs

@@ -0,0 +1,101 @@
+use std::time::Duration;
+
+use anyhow::Ok;
+use arc_swap::access::Access;
+
+use helix_event::{register_hook, send_blocking};
+use helix_view::{
+    editor::SaveStyle,
+    events::DocumentDidChange,
+    handlers::{
+        lsp::{AutoSaveEvent, AutoSaveInvoked},
+        Handlers,
+    },
+    Editor,
+};
+use tokio::time::Instant;
+
+use crate::{
+    commands, compositor,
+    job::{self, Jobs},
+};
+
+#[derive(Debug)]
+enum State {
+    Closed,
+}
+
+#[derive(Debug)]
+pub(super) struct AutoSaveHandler {
+    trigger: Option<AutoSaveInvoked>,
+    state: State,
+}
+
+impl AutoSaveHandler {
+    pub fn new() -> AutoSaveHandler {
+        AutoSaveHandler {
+            trigger: None,
+            state: State::Closed,
+        }
+    }
+}
+
+impl helix_event::AsyncHook for AutoSaveHandler {
+    type Event = AutoSaveEvent;
+
+    fn handle_event(
+        &mut self,
+        event: Self::Event,
+        _: Option<tokio::time::Instant>,
+    ) -> Option<Instant> {
+        match event {
+            AutoSaveEvent::Trigger => {
+                if matches!(self.state, State::Closed) {
+                    self.trigger = Some(AutoSaveInvoked::Automatic);
+                    return Some(Instant::now() + Duration::from_millis(1000));
+                }
+            }
+            AutoSaveEvent::Cancel => {
+                self.state = State::Closed;
+                return None;
+            }
+        }
+
+        if self.trigger.is_none() {
+            self.trigger = Some(AutoSaveInvoked::Automatic)
+        }
+
+        Some(Instant::now() + Duration::from_millis(1000))
+    }
+
+    fn finish_debounce(&mut self) {
+        job::dispatch_blocking(move |editor, _| request_auto_save(editor))
+    }
+}
+
+fn request_auto_save(editor: &mut Editor) {
+    let context = &mut compositor::Context {
+        editor,
+        scroll: Some(0),
+        jobs: &mut Jobs::new(),
+    };
+
+    if let Err(e) = commands::typed::write_all_impl(context, false, false) {
+        context.editor.set_error(format!("{}", e));
+    }
+
+    if let Err(e) = context.block_try_flush_writes() {
+        context.editor.set_error(format!("{}", e));
+    }
+}
+
+pub(super) fn register_hooks(handlers: &Handlers) {
+    let tx = handlers.auto_save.clone();
+    register_hook!(move |event: &mut DocumentDidChange<'_>| {
+        let config = event.doc.config.load();
+        if config.auto_save && config.save_style == SaveStyle::AfterDelay {
+            send_blocking(&tx, AutoSaveEvent::Trigger);
+        }
+        Ok(())
+    });
+}

helix-term/src/ui/editor.rs

@@ -23,7 +23,7 @@ use helix_core::{
 };
 use helix_view::{
     document::{Mode, SavePoint, SCRATCH_BUFFER_NAME},
-    editor::{CompleteAction, CursorShapeConfig},
+    editor::{CompleteAction, CursorShapeConfig, SaveStyle},
     graphics::{Color, CursorKind, Modifier, Rect, Style},
     input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
     keyboard::{KeyCode, KeyModifiers},
@@ -1408,7 +1408,9 @@ impl Component for EditorView {
                 EventResult::Consumed(None)
             }
             Event::FocusLost => {
-                if context.editor.config().auto_save {
+                if context.editor.config().auto_save
+                    && context.editor.config().save_style == SaveStyle::FocusLost
+                {
                     if let Err(e) = commands::typed::write_all_impl(context, false, false) {
                         context.editor.set_error(format!("{}", e));
                     }

helix-view/src/editor.rs

@@ -243,6 +243,8 @@ pub struct Config {
     pub auto_format: bool,
     /// Automatic save on focus lost. Defaults to false.
     pub auto_save: bool,
+    /// When saves are performed. Defaults to on focus lost.
+    pub save_style: SaveStyle,
     /// Set a global text_width
     pub text_width: usize,
     /// Time in milliseconds since last keypress before idle timers trigger.
@@ -252,6 +254,13 @@ pub struct Config {
         deserialize_with = "deserialize_duration_millis"
     )]
     pub idle_timeout: Duration,
+    /// Time in milliseconds since last keypress before auto save timers trigger.
+    /// Used for various UI timeouts. Defaults to 1000ms.
+    #[serde(
+        serialize_with = "serialize_duration_millis",
+        deserialize_with = "deserialize_duration_millis"
+    )]
+    pub save_delay_timeout: Duration,
     /// Time in milliseconds after typing a word character before auto completions
     /// are shown, set to 5 for instant. Defaults to 250ms.
     #[serde(
@@ -731,6 +740,13 @@ impl WhitespaceRender {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum SaveStyle {
+    FocusLost,
+    AfterDelay,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(default)]
 pub struct WhitespaceCharacters {
@@ -840,7 +856,9 @@ impl Default for Config {
             auto_completion: true,
             auto_format: true,
             auto_save: false,
+            save_style: SaveStyle::FocusLost,
             idle_timeout: Duration::from_millis(250),
+            save_delay_timeout: Duration::from_millis(1000),
             completion_timeout: Duration::from_millis(250),
             preview_completion_insert: true,
             completion_trigger_len: 2,

helix-view/src/handlers.rs

@@ -11,6 +11,7 @@ pub struct Handlers {
     // only public because most of the actual implementation is in helix-term right now :/
     pub completions: Sender<lsp::CompletionEvent>,
     pub signature_hints: Sender<lsp::SignatureHelpEvent>,
+    pub auto_save: Sender<lsp::AutoSaveEvent>,
 }
 
 impl Handlers {

helix-view/src/handlers/lsp.rs

@@ -44,6 +44,16 @@ pub enum SignatureHelpEvent {
     RequestComplete { open: bool },
 }
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum AutoSaveInvoked {
+    Automatic,
+}
+
+pub enum AutoSaveEvent {
+    Trigger,
+    Cancel,
+}
+
 #[derive(Debug)]
 pub struct ApplyEditError {
     pub kind: ApplyEditErrorKind,