simple watcher

Author: jfrolich

src/build.rs

@@ -438,7 +438,7 @@ fn gen_mlmap(
 pub fn generate_asts<'a>(
     version: &str,
     project_root: &str,
-    mut modules: &'a mut AHashMap<String, Module>,
+    modules: &'a mut AHashMap<String, Module>,
     all_modules: &AHashSet<String>,
 ) {
     modules

src/watcher.rs

@@ -1,68 +1,52 @@
 use crate::build;
-use crate::helpers;
-use futures::{
-    channel::mpsc::{channel, Receiver},
-    SinkExt, StreamExt,
-};
-use notify::{Config, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use notify::{Config, RecursiveMode};
+use notify_debouncer_mini::new_debouncer_opt;
 use std::path::PathBuf;
-use std::thread;
 use std::time::Duration;
-pub static FILE_TYPES: &[&str] = &["re", "res", "ml", "rei", "resi", "mli"];
 
-fn async_watcher() -> notify::Result<(RecommendedWatcher, Receiver<notify::Result<Event>>)> {
-    let (mut tx, rx) = channel(1);
+pub static FILE_EXTENSIONS: &[&str] = &["re", "res", "ml", "mli", "rei", "resi"];
 
-    // Automatically select the best implementation for your platform.
-    // You can also access each implementation directly e.g. INotifyWatcher.
-    let watcher = RecommendedWatcher::new(
-        move |res| {
-            futures::executor::block_on(async {
-                tx.send(res).await.unwrap();
-            })
-        },
-        Config::default(),
-    )?;
-
-    Ok((watcher, rx))
-}
-
-async fn async_watch(path: String) -> notify::Result<()> {
-    let (mut watcher, mut rx) = async_watcher()?;
-
-    // Add a path to be watched. All files and directories at that path and
-    // below will be monitored for changes.
-    watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;
+pub fn start(folder: &str) {
+    let (tx, rx) = std::sync::mpsc::channel();
 
-    while let Some(res) = rx.next().await {
-        let files_to_compile = res
-            .iter()
-            .map(|event| {
-                event
-                    .paths
+    let mut debouncer = new_debouncer_opt::<_, notify::RecommendedWatcher>(
+        Duration::from_millis(200),
+        None,
+        tx,
+        Config::default(),
+    )
+    .unwrap();
+
+    debouncer
+        .watcher()
+        .watch(folder.as_ref(), RecursiveMode::Recursive)
+        .unwrap();
+
+    for events in rx {
+        match events {
+            Ok(events) => {
+                let paths = events
                     .iter()
-                    .map(|path| path.to_path_buf())
-                    .filter(|path| helpers::string_ends_with_any(path, FILE_TYPES))
-                    .collect::<Vec<PathBuf>>()
-            })
-            .flatten()
-            .into_iter()
-            .collect::<Vec<PathBuf>>();
-
-        let delay = Duration::from_millis(10);
-        if files_to_compile.len() > 0 {
-            thread::sleep(delay);
-            build::build(&path);
+                    .filter_map(|event| {
+                        let path_buf = event.path.to_path_buf();
+                        let extension = path_buf.extension().and_then(|ext| ext.to_str());
+                        if let Some(extension) = extension {
+                            if FILE_EXTENSIONS.contains(&extension) {
+                                Some(path_buf)
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<PathBuf>>();
+
+                if paths.len() > 0 {
+                    build::build(&folder);
+                }
+            }
+            Err(_) => (),
         }
     }
-
-    Ok(())
-}
-
-pub fn start(folder: &str) {
-    futures::executor::block_on(async {
-        if let Err(e) = async_watch(folder.to_string()).await {
-            println!("error: {:?}", e)
-        }
-    });
 }