Fix config watching

cosmic-config/Cargo.toml

@@ -26,7 +26,6 @@ dirs.workspace = true
 tokio = { version = "1.44", optional = true, features = ["time"] }
 async-std = { version = "1.13", optional = true }
 tracing = "0.1"
-notify-debouncer-full = "0.5.0"
 
 [target.'cfg(unix)'.dependencies]
 xdg = "2.5"

cosmic-config/src/lib.rs

@@ -4,7 +4,6 @@ use notify::{
     event::{EventKind, ModifyKind},
     RecommendedWatcher, Watcher,
 };
-use notify_debouncer_full::{DebouncedEvent, Debouncer, RecommendedCache};
 use serde::{de::DeserializeOwned, Serialize};
 use std::{
     fmt, fs,
@@ -246,7 +245,7 @@ impl Config {
     // This may end up being an mpsc channel instead of a function
     // See EventHandler in the notify crate: https://docs.rs/notify/latest/notify/trait.EventHandler.html
     // Having a callback allows for any application abstraction to be used
-    pub fn watch<F>(&self, f: F) -> Result<Debouncer<RecommendedWatcher, RecommendedCache>, Error>
+    pub fn watch<F>(&self, f: F) -> Result<RecommendedWatcher, Error>
     // Argument is an array of all keys that changed in that specific transaction
     //TODO: simplify F requirements
     where
@@ -257,51 +256,47 @@ impl Config {
             return Err(Error::NoConfigDirectory);
         };
         let user_path_clone = user_path.clone();
-        let mut watcher = notify_debouncer_full::new_debouncer(
+        let mut watcher = notify::recommended_watcher(
-            Duration::from_secs(1),
+            move |event_res: Result<notify::Event, notify::Error>| {
-            None,
-            move |event_res: Result<Vec<DebouncedEvent>, Vec<notify::Error>>| {
                 match event_res {
-                    Ok(events) => {
+                    Ok(event) => {
-                        for event in events {
+                        match &event.kind {
-                            match &event.event.kind {
+                            EventKind::Access(_)
-                                EventKind::Access(_)
+                            | EventKind::Modify(ModifyKind::Metadata(_)) => {
-                                | EventKind::Modify(ModifyKind::Metadata(_)) => {
+                                // Data not mutated
-                                    // Data not mutated
+                                return;
-                                    return;
-                                }
-                                _ => {}
                             }
+                            _ => {}
+                        }
 
-                            let mut keys = Vec::new();
+                        let mut keys = Vec::new();
-                            for path in &event.paths {
+                        for path in &event.paths {
-                                match path.strip_prefix(&user_path_clone) {
+                            match path.strip_prefix(&user_path_clone) {
-                                    Ok(key_path) => {
+                                Ok(key_path) => {
-                                        if let Some(key) = key_path.to_str() {
+                                    if let Some(key) = key_path.to_str() {
-                                            // Skip any .atomicwrite temporary files
+                                        // Skip any .atomicwrite temporary files
-                                            if key.starts_with(".atomicwrite") {
+                                        if key.starts_with(".atomicwrite") {
-                                                continue;
+                                            continue;
-                                            }
-                                            keys.push(key.to_string());
                                         }
-                                    }
+                                        keys.push(key.to_string());
-                                    Err(_err) => {
-                                        //TODO: handle errors
                                     }
                                 }
-                            }
+                                Err(_err) => {
-                            if !keys.is_empty() {
+                                    //TODO: handle errors
-                                f(&watch_config, &keys);
+                                }
                             }
                         }
+                        if !keys.is_empty() {
+                            f(&watch_config, &keys);
+                        }
                     }
-                    Err(_errs) => {
+                    Err(_err) => {
                         //TODO: handle errors
                     }
                 }
             },
         )?;
-        watcher.watch(user_path, notify::RecursiveMode::NonRecursive)?;
+        watcher.watch(user_path, notify::RecursiveMode::Recursive)?;
         Ok(watcher)
     }
 

cosmic-config/src/subscription.rs

@@ -1,7 +1,6 @@
 use iced_futures::futures::{SinkExt, Stream};
 use iced_futures::{futures::channel::mpsc, stream};
 use notify::RecommendedWatcher;
-use notify_debouncer_full::{Debouncer, RecommendedCache};
 use std::{borrow::Cow, hash::Hash};
 
 use crate::{Config, CosmicConfigEntry};
@@ -10,7 +9,7 @@ pub enum ConfigState<T> {
     Init(Cow<'static, str>, u64, bool),
     Waiting(
         T,
-        Debouncer<RecommendedWatcher, RecommendedCache>,
+        RecommendedWatcher,
         mpsc::Receiver<Vec<String>>,
         Config,
     ),