[WIP] file watching

helix-term/src/application.rs

@@ -1,6 +1,6 @@
 use helix_core::syntax;
 use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};
-use helix_view::{theme, Editor};
+use helix_view::{file_watcher, theme, Editor};
 
 use crate::{args::Args, compositor::Compositor, config::Config, job::Jobs, ui};
 
@@ -192,6 +192,9 @@ impl Application {
                     self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
                     self.render();
                 }
+                Some(msg) = self.editor.watcher.receiver.recv() => {
+                    self.handle_watcher_message(msg)
+                }
             }
         }
     }
@@ -490,6 +493,17 @@ impl Application {
         }
     }
 
+    fn handle_watcher_message(&mut self, msg: file_watcher::Message) {
+        match msg {
+            file_watcher::Message::NotifyEvent(event) => {
+                log::info!("handling file watcher event: {:?}", event);
+            }
+                // match event.unwrap() {
+                // _ => unimplemented!(),
+            // },
+        }
+    }
+
     async fn claim_term(&mut self) -> Result<(), Error> {
         terminal::enable_raw_mode()?;
         let mut stdout = stdout();

helix-view/Cargo.toml

@@ -28,6 +28,7 @@ tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std
 futures-util = { version = "0.3", features = ["std", "async-await"], default-features = false }
 
 slotmap = "1"
+rustc-hash = "1.1.0"
 
 encoding_rs = "0.8"
 chardetng = "0.1"
@@ -38,6 +39,10 @@ log = "~0.4"
 
 which = "4.2"
 
+crossbeam-channel = "0.5.1"
+notify = "=5.0.0-pre.11"    # check that it builds on NetBSD before upgrading
+jod-thread = "0.1.2"
+
 [target.'cfg(windows)'.dependencies]
 clipboard-win = { version = "4.2", features = ["std"] }
 

helix-view/src/editor.rs

@@ -1,5 +1,6 @@
 use crate::{
     clipboard::{get_clipboard_provider, ClipboardProvider},
+    file_watcher::{self, NotifyActor, NotifyHandle},
     graphics::{CursorKind, Rect},
     theme::{self, Theme},
     tree::Tree,
@@ -13,6 +14,7 @@ use std::{
     time::Duration,
 };
 
+use rustc_hash::FxHashMap;
 use slotmap::SlotMap;
 
 use anyhow::Error;
@@ -52,12 +54,14 @@ impl Default for Config {
 pub struct Editor {
     pub tree: Tree,
     pub documents: SlotMap<DocumentId, Document>,
+    pub path_to_doc: FxHashMap<PathBuf, DocumentId>,
     pub count: Option<std::num::NonZeroUsize>,
     pub selected_register: RegisterSelection,
     pub registers: Registers,
     pub theme: Theme,
     pub language_servers: helix_lsp::Registry,
     pub clipboard_provider: Box<dyn ClipboardProvider>,
+    pub watcher: NotifyHandle,
 
     pub syn_loader: Arc<syntax::Loader>,
     pub theme_loader: Arc<theme::Loader>,
@@ -90,6 +94,7 @@ impl Editor {
         Self {
             tree: Tree::new(area),
             documents: SlotMap::with_key(),
+            path_to_doc: FxHashMap::default(),
             count: None,
             selected_register: RegisterSelection::default(),
             theme: themes.default(),
@@ -98,6 +103,7 @@ impl Editor {
             theme_loader: themes,
             registers: Registers::default(),
             clipboard_provider: get_clipboard_provider(),
+            watcher: NotifyActor::spawn(),
             status_msg: None,
             config,
         }
@@ -218,10 +224,7 @@ impl Editor {
     pub fn open(&mut self, path: PathBuf, action: Action) -> Result<DocumentId, Error> {
         let path = crate::document::canonicalize_path(&path)?;
 
-        let id = self
-            .documents()
-            .find(|doc| doc.path() == Some(&path))
-            .map(|doc| doc.id);
+        let id = self.path_to_doc.get(&path).map(|it| *it);
 
         let id = if let Some(id) = id {
             id
@@ -253,6 +256,11 @@ impl Editor {
 
             let id = self.documents.insert(doc);
             self.documents[id].id = id;
+            self.watcher
+                .sender
+                .send(file_watcher::ActorMessage::Watch(path.clone()))
+                .unwrap();
+            self.path_to_doc.insert(path, id);
             id
         };
 

helix-view/src/file_watcher.rs

@@ -0,0 +1,97 @@
+use crossbeam_channel::unbounded;
+use crossbeam_channel::{select, Receiver};
+use notify::{recommended_watcher, RecommendedWatcher, RecursiveMode, Watcher};
+use std::path::PathBuf;
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
+
+pub struct NotifyActor {
+    sender: Sender,
+    watcher: (RecommendedWatcher, Receiver<NotifyEvent>),
+}
+
+impl NotifyActor {
+    pub fn spawn() -> NotifyHandle {
+        let (actor_tx, actor_rx) = crossbeam_channel::unbounded();
+        let (tx, rx) = unbounded_channel();
+        let actor = NotifyActor::new(Box::new(move |msg| tx.send(msg).unwrap()));
+        let thread = jod_thread::Builder::new()
+            .name("FileWatcher".to_string())
+            .spawn(move || actor.run(actor_rx))
+            .expect("Failed to spawn file watcher");
+        NotifyHandle {
+            sender: actor_tx,
+            receiver: rx,
+            thread,
+        }
+    }
+
+    fn next_event(
+        &mut self,
+        receiver: &crossbeam_channel::Receiver<ActorMessage>,
+    ) -> Option<ActorEvent> {
+        let watcher_receiver = &self.watcher.1;
+        select! {
+            recv(receiver) -> it => it.ok().map(ActorEvent::Message),
+            recv(watcher_receiver) -> it => Some(ActorEvent::NotifyEvent(it.unwrap())),
+        }
+    }
+
+    fn new(sender: Sender) -> NotifyActor {
+        let (tx, rx) = unbounded();
+        let watcher: RecommendedWatcher = recommended_watcher(move |e| tx.send(e).unwrap()).unwrap();
+        NotifyActor {
+            sender,
+            watcher: (watcher, rx),
+        }
+    }
+
+    fn run(mut self, inbox: crossbeam_channel::Receiver<ActorMessage>) {
+        while let Some(event) = self.next_event(&inbox) {
+            match event {
+                ActorEvent::Message(msg) => self.handle_message(msg),
+                ActorEvent::NotifyEvent(event) => self.send(Message::NotifyEvent(event)),
+            }
+        }
+    }
+
+    fn handle_message(&mut self, msg: ActorMessage) {
+        use ActorMessage::*;
+
+        // probably log errors
+        match msg {
+            Watch(path) => self.watcher.0.watch(&path, RecursiveMode::NonRecursive),
+            Unwatch(path) => self.watcher.0.unwatch(&path),
+        };
+    }
+
+    fn send(&mut self, msg: Message) {
+        (self.sender)(msg)
+    }
+}
+
+pub enum ActorMessage {
+    Watch(PathBuf),
+    Unwatch(PathBuf),
+}
+
+pub enum ActorEvent {
+    Message(ActorMessage),
+    NotifyEvent(NotifyEvent),
+}
+
+#[derive(Debug)]
+pub enum Message {
+    NotifyEvent(NotifyEvent),
+}
+
+type NotifyEvent = notify::Result<notify::Event>;
+
+type Sender = Box<dyn Fn(Message) + Send>;
+
+#[derive(Debug)]
+pub struct NotifyHandle {
+    // Relative order of fields below is significant.
+    pub sender: crossbeam_channel::Sender<ActorMessage>,
+    thread: jod_thread::JoinHandle,
+    pub receiver: UnboundedReceiver<Message>,
+}