Optimize the notify event handler

src/main.rs

@@ -144,23 +144,23 @@ fn main() -> Result<()> {
 
     match args.command {
         None => {
-            let notify_exercise_paths: Option<&'static [&'static str]> = if args.manual_run {
+            let notify_exercise_names = if args.manual_run {
                 None
             } else {
                 // For the the notify event handler thread.
                 // Leaking is not a problem because the slice lives until the end of the program.
                 Some(
-                    app_state
+                    &*app_state
                         .exercises()
                         .iter()
-                        .map(|exercise| exercise.path)
+                        .map(|exercise| exercise.name.as_bytes())
                         .collect::<Vec<_>>()
                         .leak(),
                 )
             };
 
             loop {
-                match watch::watch(&mut app_state, notify_exercise_paths)? {
+                match watch::watch(&mut app_state, notify_exercise_names)? {
                     WatchExit::Shutdown => break,
                     // It is much easier to exit the watch mode, launch the list mode and then restart
                     // the watch mode instead of trying to pause the watch threads and correct the

src/watch.rs

@@ -42,19 +42,19 @@ pub enum WatchExit {
 
 pub fn watch(
     app_state: &mut AppState,
-    notify_exercise_paths: Option<&'static [&'static str]>,
+    notify_exercise_names: Option<&'static [&'static [u8]]>,
 ) -> Result<WatchExit> {
     let (tx, rx) = channel();
 
     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_paths) = notify_exercise_paths {
+    let _debouncer_guard = if let Some(exercise_names) = notify_exercise_names {
         let mut debouncer = new_debouncer(
             Duration::from_millis(500),
             DebounceEventHandler {
                 tx: tx.clone(),
-                exercise_paths,
+                exercise_names,
             },
         )
         .inspect_err(|_| eprintln!("{NOTIFY_ERR}"))?;

src/watch/notify_event.rs

@@ -5,7 +5,7 @@ use super::WatchEvent;
 
 pub struct DebounceEventHandler {
     pub tx: Sender<WatchEvent>,
-    pub exercise_paths: &'static [&'static str],
+    pub exercise_names: &'static [&'static [u8]],
 }
 
 impl notify_debouncer_mini::DebounceEventHandler for DebounceEventHandler {
@@ -15,15 +15,24 @@ impl notify_debouncer_mini::DebounceEventHandler for DebounceEventHandler {
                 let Some(exercise_ind) = event
                     .iter()
                     .filter_map(|event| {
-                        if event.kind != DebouncedEventKind::Any
+                        if event.kind != DebouncedEventKind::Any {
-                            || !event.path.extension().is_some_and(|ext| ext == "rs")
-                        {
                             return None;
                         }
 
-                        self.exercise_paths
+                        let file_name = 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(|path| event.path.ends_with(path))
+                            .position(|exercise_name| *exercise_name == file_name_without_ext)
                     })
                     .min()
                 else {