Optimize the file watcher

Author: mo8it

Cargo.lock

@@ -50,7 +50,7 @@ ahash = { version = "0.8.11", default-features = false }
 anyhow = "1.0.89"
 clap = { version = "4.5.17", features = ["derive"] }
 crossterm = { version = "0.28.1", default-features = false, features = ["windows", "events"] }
-notify-debouncer-mini = { version = "0.4.1", default-features = false }
+notify = { version = "6.1.1", default-features = false, features = ["macos_fsevent"] }
 os_pipe = "1.2.1"
 rustlings-macros = { path = "rustlings-macros", version = "=6.3.0" }
 serde_json = "1.0.128"

Cargo.toml

@@ -1,12 +1,12 @@
 use anyhow::{Error, Result};
-use notify_debouncer_mini::{
-    new_debouncer,
-    notify::{self, RecursiveMode},
-};
+use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
 use std::{
     io::{self, Write},
     path::Path,
-    sync::mpsc::channel,
+    sync::{
+        atomic::{AtomicBool, Ordering::Relaxed},
+        mpsc::channel,
+    },
     time::Duration,
 };
 
@@ -21,6 +21,27 @@ mod notify_event;
 mod state;
 mod terminal_event;
 
+static EXERCISE_RUNNING: AtomicBool = AtomicBool::new(false);
+
+// Private unit type to force using the constructor function.
+#[must_use = "When the guard is dropped, the input is unpaused"]
+pub struct InputPauseGuard(());
+
+impl InputPauseGuard {
+    #[inline]
+    pub fn scoped_pause() -> Self {
+        EXERCISE_RUNNING.store(true, Relaxed);
+        Self(())
+    }
+}
+
+impl Drop for InputPauseGuard {
+    #[inline]
+    fn drop(&mut self) {
+        EXERCISE_RUNNING.store(false, Relaxed);
+    }
+}
+
 enum WatchEvent {
     Input(InputEvent),
     FileChange { exercise_ind: usize },
@@ -47,21 +68,21 @@ fn run_watch(
     let mut manual_run = false;
     // Prevent dropping the guard until the end of the function.
     // Otherwise, the file watcher exits.
-    let _debouncer_guard = if let Some(exercise_names) = notify_exercise_names {
-        let mut debouncer = new_debouncer(
-            Duration::from_millis(200),
+    let _watcher_guard = if let Some(exercise_names) = notify_exercise_names {
+        let mut watcher = RecommendedWatcher::new(
             NotifyEventHandler {
                 sender: watch_event_sender.clone(),
                 exercise_names,
             },
+            Config::default().with_poll_interval(Duration::from_secs(1)),
         )
         .inspect_err(|_| eprintln!("{NOTIFY_ERR}"))?;
-        debouncer
-            .watcher()
+
+        watcher
             .watch(Path::new("exercises"), RecursiveMode::Recursive)
             .inspect_err(|_| eprintln!("{NOTIFY_ERR}"))?;
 
-        Some(debouncer)
+        Some(watcher)
     } else {
         manual_run = true;
         None

src/watch.rs

@@ -1,52 +1,67 @@
-use notify_debouncer_mini::{DebounceEventResult, DebouncedEventKind};
-use std::sync::mpsc::Sender;
+use notify::{
+    event::{MetadataKind, ModifyKind},
+    Event, EventKind,
+};
+use std::sync::{atomic::Ordering::Relaxed, mpsc::Sender};
 
-use super::WatchEvent;
+use super::{WatchEvent, EXERCISE_RUNNING};
 
 pub struct NotifyEventHandler {
     pub sender: Sender<WatchEvent>,
     /// Used to report which exercise was modified.
     pub exercise_names: &'static [&'static [u8]],
 }
 
-impl notify_debouncer_mini::DebounceEventHandler for NotifyEventHandler {
-    fn handle_event(&mut self, input_event: DebounceEventResult) {
-        let output_event = match input_event {
-            Ok(input_event) => {
-                let Some(exercise_ind) = input_event
-                    .iter()
-                    .filter_map(|input_event| {
-                        if input_event.kind != DebouncedEventKind::Any {
-                            return None;
-                        }
-
-                        let file_name = input_event.path.file_name()?.to_str()?.as_bytes();
-
-                        if file_name.len() < 4 {
-                            return None;
-                        }
-                        let (file_name_without_ext, ext) = file_name.split_at(file_name.len() - 3);
-
-                        if ext != b".rs" {
-                            return None;
-                        }
-
-                        self.exercise_names
-                            .iter()
-                            .position(|exercise_name| *exercise_name == file_name_without_ext)
-                    })
-                    .min()
-                else {
-                    return;
-                };
+impl notify::EventHandler for NotifyEventHandler {
+    fn handle_event(&mut self, input_event: notify::Result<Event>) {
+        if EXERCISE_RUNNING.load(Relaxed) {
+            return;
+        }
 
-                WatchEvent::FileChange { exercise_ind }
+        let input_event = match input_event {
+            Ok(v) => v,
+            Err(e) => {
+                // An error occurs when the receiver is dropped.
+                // After dropping the receiver, the debouncer guard should also be dropped.
+                let _ = self.sender.send(WatchEvent::NotifyErr(e));
+                return;
             }
-            Err(e) => WatchEvent::NotifyErr(e),
         };
 
-        // An error occurs when the receiver is dropped.
-        // After dropping the receiver, the debouncer guard should also be dropped.
-        let _ = self.sender.send(output_event);
+        match input_event.kind {
+            EventKind::Any => (),
+            EventKind::Modify(modify_kind) => match modify_kind {
+                ModifyKind::Any | ModifyKind::Data(_) => (),
+                ModifyKind::Metadata(metadata_kind) => match metadata_kind {
+                    MetadataKind::Any | MetadataKind::WriteTime => (),
+                    MetadataKind::AccessTime
+                    | MetadataKind::Permissions
+                    | MetadataKind::Ownership
+                    | MetadataKind::Extended
+                    | MetadataKind::Other => return,
+                },
+                ModifyKind::Name(_) | ModifyKind::Other => return,
+            },
+            EventKind::Access(_)
+            | EventKind::Create(_)
+            | EventKind::Remove(_)
+            | EventKind::Other => return,
+        }
+
+        let _ = input_event
+            .paths
+            .into_iter()
+            .filter_map(|path| {
+                let file_name = path.file_name()?.to_str()?.as_bytes();
+
+                let [file_name_without_ext @ .., b'.', b'r', b's'] = file_name else {
+                    return None;
+                };
+
+                self.exercise_names
+                    .iter()
+                    .position(|exercise_name| *exercise_name == file_name_without_ext)
+            })
+            .try_for_each(|exercise_ind| self.sender.send(WatchEvent::FileChange { exercise_ind }));
     }
 }

src/watch/notify_event.rs

@@ -18,10 +18,7 @@ use crate::{
     term::progress_bar,
 };
 
-use super::{
-    terminal_event::{terminal_event_handler, InputPauseGuard},
-    WatchEvent,
-};
+use super::{terminal_event::terminal_event_handler, InputPauseGuard, WatchEvent};
 
 #[derive(PartialEq, Eq)]
 enum DoneStatus {

src/watch/state.rs

@@ -1,31 +1,7 @@
 use crossterm::event::{self, Event, KeyCode, KeyEventKind};
-use std::sync::{
-    atomic::{AtomicBool, Ordering::Relaxed},
-    mpsc::Sender,
-};
+use std::sync::{atomic::Ordering::Relaxed, mpsc::Sender};
 
-use super::WatchEvent;
-
-static INPUT_PAUSED: AtomicBool = AtomicBool::new(false);
-
-// Private unit type to force using the constructor function.
-#[must_use = "When the guard is dropped, the input is unpaused"]
-pub struct InputPauseGuard(());
-
-impl InputPauseGuard {
-    #[inline]
-    pub fn scoped_pause() -> Self {
-        INPUT_PAUSED.store(true, Relaxed);
-        Self(())
-    }
-}
-
-impl Drop for InputPauseGuard {
-    #[inline]
-    fn drop(&mut self) {
-        INPUT_PAUSED.store(false, Relaxed);
-    }
-}
+use super::{WatchEvent, EXERCISE_RUNNING};
 
 pub enum InputEvent {
     Run,
@@ -44,7 +20,7 @@ pub fn terminal_event_handler(sender: Sender<WatchEvent>, manual_run: bool) {
                     KeyEventKind::Press => (),
                 }
 
-                if INPUT_PAUSED.load(Relaxed) {
+                if EXERCISE_RUNNING.load(Relaxed) {
                     continue;
                 }