Recursive poll impl

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "notify"
-version = "0.0.1"
+version = "1.0.0"
 authors = ["Félix Saparelli <[email protected]>"]
 
 [dependencies]

src/inotify/flags.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
 bitflags! {
-  #[deriving(Copy)] flags Mask: u32 {
+  flags Mask: u32 {
     #[doc = " Event: File was accessed."]
     #[doc = " "]
     #[doc = " When monitoring a directory, the event may occur both for the"]

src/inotify/mod.rs

@@ -21,7 +21,7 @@ impl INotifyWatcher {
     let mut ino = self.inotify.clone();
     let tx = self.tx.clone();
     let paths = self.paths.clone();
-    spawn(proc() {
+    spawn(move || {
       loop {
         match ino.event() {
           Ok(e) => {
@@ -105,7 +105,7 @@ impl Watcher for INotifyWatcher {
     match self.watches.get(path) {
       None => {},
       Some(p) => {
-        watching.insert(p.ref1().clone());
+        watching.insert((&p.1).clone());
         watching.insert(flags::IN_MASK_ADD);
       }
     }
@@ -125,7 +125,7 @@ impl Watcher for INotifyWatcher {
     match self.watches.remove(path) {
       None => Err(Error::WatchNotFound),
       Some(p) => {
-        let w = p.ref0();
+        let w = &p.0;
         match self.inotify.rm_watch(w.clone()) {
           Err(e) => Err(Error::Io(e)),
           Ok(_) => {

src/lib.rs

@@ -12,7 +12,7 @@ pub mod poll;
 
 pub mod op {
   bitflags! {
-    #[deriving(Copy)] flags Op: u32 {
+    flags Op: u32 {
       const CHMOD   = 0b00001,
       const CREATE  = 0b00010,
       const REMOVE  = 0b00100,
@@ -71,4 +71,4 @@ fn new_poll() {
     Ok(_) => assert!(true),
     Err(_) => assert!(false)
   }
-}
+}

src/poll.rs

@@ -1,7 +1,7 @@
 use std::collections::{HashMap, HashSet};
-use std::io::fs::PathExtensions;
+use std::io::fs::{mod, PathExtensions};
 use std::sync::{Arc, RWLock};
-use super::{Error, Event, op, Op, Watcher};
+use super::{Error, Event, op, Watcher};
 
 pub struct PollWatcher {
   tx: Sender<Event>,
@@ -14,7 +14,13 @@ impl PollWatcher {
     let tx = self.tx.clone();
     let watches = self.watches.clone();
     let open = self.open.clone();
-    spawn(proc() {
+    spawn(move || {
+      // In order of priority:
+      // TODO: populate mtimes before loop, and then handle creation events
+      // TODO: handle deletion events
+      // TODO: handle chmod events
+      // TODO: handle renames
+      // TODO: DRY it up
       let mut mtimes: HashMap<Path, u64> = HashMap::new();
       loop {
         if !(*open.read()) {
@@ -55,6 +61,43 @@ impl PollWatcher {
           }
 
           // TODO: recurse into the dir
+          // TODO: more efficient implementation where the dir tree is cached?
+          match fs::walk_dir(watch) {
+            Err(e) => {
+              tx.send(Event {
+                path: Some(watch.clone()),
+                op: Err(Error::Io(e))
+              });
+              continue
+            },
+            Ok(mut iter) => {
+              for path in iter {
+                match path.lstat() {
+                  Err(e) => {
+                    tx.send(Event {
+                      path: Some(path.clone()),
+                      op: Err(Error::Io(e))
+                    });
+                    continue
+                  },
+                  Ok(stat) => {
+                    match mtimes.insert(path.clone(), stat.modified) {
+                      None => continue, // First run
+                      Some(old) => {
+                        if stat.modified > old {
+                          tx.send(Event {
+                            path: Some(path.clone()),
+                            op: Ok(op::WRITE)
+                          });
+                          continue
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
     })