From 04c686367398ad9c75137b826c9898402ad0aad3 Mon Sep 17 00:00:00 2001
From: Daniel Faust <hessijames@gmail.com>
Date: Thu, 28 Jul 2016 17:28:48 +0200
Subject: [PATCH] Make debounce::Event unstructured enum

---
 src/debounce/mod.rs   |  76 ++++++++----------
 src/debounce/timer.rs |  14 ++--
 tests/debounce.rs     | 182 +++++++++++++++++++++---------------------
 3 files changed, 132 insertions(+), 140 deletions(-)

diff --git a/src/debounce/mod.rs b/src/debounce/mod.rs
index 9340c9ff..5f37bb0f 100644
--- a/src/debounce/mod.rs
+++ b/src/debounce/mod.rs
@@ -17,52 +17,50 @@ pub type OperationsBuffer = Arc<Mutex<HashMap<PathBuf, (Option<op::Op>, Option<P
 #[derive(Debug)]
 /// Events emitted by `notify` in _debounced_ mode.
 pub enum Event {
-    /// `NoticeWrite` is emitted imediatelly after the first write event for `path`.
+    /// `NoticeWrite` is emitted imediatelly after the first write event for the path.
     ///
-    /// If you are reading form that file, you should probably close it imediatelly and discard all data you read from it.
-    NoticeWrite{path: PathBuf},
-    /// `NoticeRemove` is emitted imediatelly after a remove or rename event for `path`.
+    /// If you are reading from that file, you should probably close it imediatelly and discard all data you read from it.
+    NoticeWrite(PathBuf),
+    /// `NoticeRemove` is emitted imediatelly after a remove or rename event for the path.
     ///
     /// The file will continue to exist until its last file handle is closed.
-    NoticeRemove{path: PathBuf},
-    /// `Create` is emitted when a file or directory has been created and no events were detected for the `path` within the specified time frame.
+    NoticeRemove(PathBuf),
+    /// `Create` is emitted when a file or directory has been created and no events were detected for the path within the specified time frame.
     ///
-    /// `Create` events have a higher priority over `Write` and `Chmod`.
+    /// `Create` events have a higher priority than `Write` and `Chmod`.
     /// These events will not be emitted if they are detected before the `Create` event has been emitted.
-    Create{path: PathBuf},
-    /// `Write` is emitted when a file has been written to and no events were detected for the `path` within the specified time frame.
+    Create(PathBuf),
+    /// `Write` is emitted when a file has been written to and no events were detected for the path within the specified time frame.
     ///
-    /// `Write` events have a higher priority over `Chmod`.
+    /// `Write` events have a higher priority than `Chmod`.
     /// `Chmod` will not be emitted if it's detected before the `Write` event has been emitted.
-    Write{path: PathBuf},
-    /// `Chmod` is emitted when attributes have been changed and no events were detected for the `path` within the specified time frame.
-    Chmod{path: PathBuf},
-    /// `Remove` is emitted when a file or directory has been removed and no events were detected for the `path` within the specified time frame.
-    Remove{path: PathBuf},
-    /// `Rename` is emitted when a file or directory has been moved within a watched directory and no events were detected for the `to` path within the specified time frame.
+    Write(PathBuf),
+    /// `Chmod` is emitted when attributes have been changed and no events were detected for the path within the specified time frame.
+    Chmod(PathBuf),
+    /// `Remove` is emitted when a file or directory has been removed and no events were detected for the path within the specified time frame.
+    Remove(PathBuf),
+    /// `Rename` is emitted when a file or directory has been moved within a watched directory and no events were detected for the new path within the specified time frame.
     ///
-    /// `from` contains the source path, `to` the destination path.
-    Rename{from: PathBuf, to: PathBuf},
+    /// The first path contains the source, the second path the destination.
+    Rename(PathBuf, PathBuf),
     /// `Rescan` is emitted imediatelly after a problem has been detected that makes it necessary to re-scan the watched directories.
     Rescan,
     /// `Error` is emitted imediatelly after a error has been detected.
     ///
-    /// `path` may contain a path for which the error was detected.
-    ///
-    /// `error` contains the error.
-    Error{path: Option<PathBuf>, error: Error},
+    ///  This event may contain a path for which the error was detected.
+    Error(Error, Option<PathBuf>),
 }
 
 impl PartialEq for Event {
     fn eq(&self, other: &Event) -> bool {
         match (self, other) {
-            (&Event::NoticeWrite{path: ref a}, &Event::NoticeWrite{path: ref b}) |
-            (&Event::NoticeRemove{path: ref a}, &Event::NoticeRemove{path: ref b}) |
-            (&Event::Create{path: ref a}, &Event::Create{path: ref b}) |
-            (&Event::Write{path: ref a}, &Event::Write{path: ref b}) |
-            (&Event::Chmod{path: ref a}, &Event::Chmod{path: ref b}) |
-            (&Event::Remove{path: ref a}, &Event::Remove{path: ref b}) => a == b,
-            (&Event::Rename{from: ref a1, to: ref a2}, &Event::Rename{from: ref b1, to: ref b2}) => (a1 == b1 && a2 == b2),
+            (&Event::NoticeWrite(ref a), &Event::NoticeWrite(ref b)) |
+            (&Event::NoticeRemove(ref a), &Event::NoticeRemove(ref b)) |
+            (&Event::Create(ref a), &Event::Create(ref b)) |
+            (&Event::Write(ref a), &Event::Write(ref b)) |
+            (&Event::Chmod(ref a), &Event::Chmod(ref b)) |
+            (&Event::Remove(ref a), &Event::Remove(ref b)) => a == b,
+            (&Event::Rename(ref a1, ref a2), &Event::Rename(ref b1, ref b2)) => (a1 == b1 && a2 == b2),
             (&Event::Rescan, &Event::Rescan) => true,
             _ => false,
         }
@@ -100,10 +98,7 @@ impl EventTx {
                         // TODO panic!("path is None: {:?} ({:?})", _op, _cookie);
                     }
                     (path, Err(e), _) => {
-                        let _ = tx.send(Event::Error {
-                            path: path,
-                            error: e,
-                        });
+                        let _ = tx.send(Event::Error(e, path));
                     }
                 }
             }
@@ -119,10 +114,7 @@ impl EventTx {
                         // TODO panic!("path is None: {:?} ({:?})", _op, _cookie);
                     }
                     (path, Err(e), _) => {
-                        let _ = tx.send(Event::Error {
-                            path: path,
-                            error: e,
-                        });
+                        let _ = tx.send(Event::Error(e, path));
                     }
                 }
             }
@@ -191,7 +183,7 @@ impl Debounce {
                             Some(op::WRITE) | // change to remove event
                             Some(op::CHMOD) => { // change to remove event
                                 *operation = Some(op::REMOVE);
-                                let _ = self.tx.send(Event::NoticeRemove{path: path.clone()});
+                                let _ = self.tx.send(Event::NoticeRemove(path.clone()));
                                 restart_timer(timer_id, path, &mut self.timer);
                             }
                             Some(op::RENAME) => {
@@ -269,7 +261,7 @@ impl Debounce {
                     Some(op::RENAME) | // file has been renamed before, upgrade to write event
                     None => { // operations_buffer entry didn't exist
                         *operation = Some(op::WRITE);
-                        let _ = self.tx.send(Event::NoticeWrite{path: path.clone()});
+                        let _ = self.tx.send(Event::NoticeWrite(path.clone()));
                         restart_timer(timer_id, path.clone(), &mut self.timer);
                     }
                     // writing to a deleted file is impossible
@@ -343,13 +335,13 @@ impl Debounce {
                         }
                         Some(op::WRITE) | // keep write event
                         Some(op::CHMOD) => { // keep chmod event
-                            let _ = self.tx.send(Event::NoticeRemove{path: path.clone()});
+                            let _ = self.tx.send(Event::NoticeRemove(path.clone()));
                             restart_timer(timer_id, path.clone(), &mut self.timer);
                         }
                         None => {
                             // operations_buffer entry didn't exist
                             *operation = Some(op::RENAME);
-                            let _ = self.tx.send(Event::NoticeRemove{path: path.clone()});
+                            let _ = self.tx.send(Event::NoticeRemove(path.clone()));
                             restart_timer(timer_id, path.clone(), &mut self.timer);
                         }
                         // renaming a deleted file is impossible
@@ -377,7 +369,7 @@ impl Debounce {
                         Some(op::CHMOD) | // change to remove event
                         None => { // operations_buffer entry didn't exist
                             *operation = Some(op::REMOVE);
-                            let _ = self.tx.send(Event::NoticeRemove{path: path.clone()});
+                            let _ = self.tx.send(Event::NoticeRemove(path.clone()));
                             restart_timer(timer_id, path.clone(), &mut self.timer);
                         }
                         Some(op::RENAME) => {
diff --git a/src/debounce/timer.rs b/src/debounce/timer.rs
index 1e4d3f0c..6b6c52b7 100644
--- a/src/debounce/timer.rs
+++ b/src/debounce/timer.rs
@@ -86,18 +86,18 @@ impl ScheduleWorker {
                     if let Some((op, from_path, _)) = op_buf.remove(&path) {
                         let is_partial_rename = from_path.is_none();
                         if let Some(from_path) = from_path {
-                            self.tx.send(debounce::Event::Rename{from: from_path, to: path.clone()}).unwrap();
+                            self.tx.send(debounce::Event::Rename(from_path, path.clone())).unwrap();
                         }
                         let message = match op {
-                            Some(op::CREATE) => Some(debounce::Event::Create{path: path}),
-                            Some(op::WRITE) => Some(debounce::Event::Write{path: path}),
-                            Some(op::CHMOD) => Some(debounce::Event::Chmod{path: path}),
-                            Some(op::REMOVE) => Some(debounce::Event::Remove{path: path}),
+                            Some(op::CREATE) => Some(debounce::Event::Create(path)),
+                            Some(op::WRITE) => Some(debounce::Event::Write(path)),
+                            Some(op::CHMOD) => Some(debounce::Event::Chmod(path)),
+                            Some(op::REMOVE) => Some(debounce::Event::Remove(path)),
                             Some(op::RENAME) if is_partial_rename => {
                                 if path.exists() {
-                                    Some(debounce::Event::Create{path: path})
+                                    Some(debounce::Event::Create(path))
                                 } else {
-                                    Some(debounce::Event::Remove{path: path})
+                                    Some(debounce::Event::Remove(path))
                                 }
                             },
                             _ => None
diff --git a/tests/debounce.rs b/tests/debounce.rs
index 2e6f949f..6665e1c5 100644
--- a/tests/debounce.rs
+++ b/tests/debounce.rs
@@ -48,7 +48,7 @@ fn create_file() {
     tdir.create("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::Create{path: tdir.mkpath("file1")},
+        debounce::Event::Create(tdir.mkpath("file1")),
     ]);
 }
 
@@ -69,8 +69,8 @@ fn write_file() {
     tdir.write("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeWrite{path: tdir.mkpath("file1")},
-        debounce::Event::Write{path: tdir.mkpath("file1")},
+        debounce::Event::NoticeWrite(tdir.mkpath("file1")),
+        debounce::Event::Write(tdir.mkpath("file1")),
     ]);
 }
 
@@ -98,8 +98,8 @@ fn write_long_file() {
     tdir.write("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeWrite{path: tdir.mkpath("file1")},
-        debounce::Event::Write{path: tdir.mkpath("file1")},
+        debounce::Event::NoticeWrite(tdir.mkpath("file1")),
+        debounce::Event::Write(tdir.mkpath("file1")),
     ]);
 }
 
@@ -122,12 +122,12 @@ fn modify_file() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeWrite{path: tdir.mkpath("file1")},
-            debounce::Event::Write{path: tdir.mkpath("file1")},
+            debounce::Event::NoticeWrite(tdir.mkpath("file1")),
+            debounce::Event::Write(tdir.mkpath("file1")),
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::Chmod{path: tdir.mkpath("file1")},
+            debounce::Event::Chmod(tdir.mkpath("file1")),
         ]);
     }
 }
@@ -149,8 +149,8 @@ fn delete_file() {
     tdir.remove("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::Remove{path: tdir.mkpath("file1")},
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::Remove(tdir.mkpath("file1")),
     ]);
 }
 
@@ -171,8 +171,8 @@ fn rename_file() {
     tdir.rename("file1", "file2");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
     ]);
 }
 
@@ -191,7 +191,7 @@ fn create_write_modify_file() {
     tdir.chmod("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::Create{path: tdir.mkpath("file1")},
+        debounce::Event::Create(tdir.mkpath("file1")),
     ]);
 }
 
@@ -231,8 +231,8 @@ fn delete_create_file() {
     tdir.create("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::Write{path: tdir.mkpath("file1")},
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::Write(tdir.mkpath("file1")),
     ]);
 }
 
@@ -250,7 +250,7 @@ fn create_rename_file() {
     tdir.rename("file1", "file2");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::Create{path: tdir.mkpath("file2")},
+        debounce::Event::Create(tdir.mkpath("file2")),
     ]);
 }
 
@@ -293,17 +293,17 @@ fn create_rename_overwrite_file() {
     if cfg!(target_os="windows") {
         // Windows interprets a move that overwrites a file as a delete of the source file and a write to the file that is being overwritten
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeWrite{path: tdir.mkpath("file2")},
-            debounce::Event::Write{path: tdir.mkpath("file2")},
+            debounce::Event::NoticeWrite(tdir.mkpath("file2")),
+            debounce::Event::Write(tdir.mkpath("file2")),
         ]);
     } else if cfg!(target_os="macos") {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("file2")},
-            debounce::Event::Create{path: tdir.mkpath("file2")}, // even though the file is being overwritten, that can't be detected
+            debounce::Event::NoticeRemove(tdir.mkpath("file2")),
+            debounce::Event::Create(tdir.mkpath("file2")), // even though the file is being overwritten, that can't be detected
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::Create{path: tdir.mkpath("file2")}, // even though the file is being overwritten, that can't be detected
+            debounce::Event::Create(tdir.mkpath("file2")), // even though the file is being overwritten, that can't be detected
         ]);
     }
 }
@@ -326,10 +326,10 @@ fn write_rename_file() {
     tdir.rename("file1", "file2");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeWrite{path: tdir.mkpath("file1")},
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
-        debounce::Event::Write{path: tdir.mkpath("file2")},
+        debounce::Event::NoticeWrite(tdir.mkpath("file1")),
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
+        debounce::Event::Write(tdir.mkpath("file2")),
     ]);
 }
 
@@ -352,10 +352,10 @@ fn rename_write_file() {
     tdir.write("file2");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::NoticeWrite{path: tdir.mkpath("file2")}, // TODO not necessary
-        debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
-        debounce::Event::Write{path: tdir.mkpath("file2")},
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::NoticeWrite(tdir.mkpath("file2")), // TODO not necessary
+        debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
+        debounce::Event::Write(tdir.mkpath("file2")),
     ]);
 }
 
@@ -379,16 +379,16 @@ fn modify_rename_file() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeWrite{path: tdir.mkpath("file1")},
-            debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-            debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
-            debounce::Event::Write{path: tdir.mkpath("file2")},
+            debounce::Event::NoticeWrite(tdir.mkpath("file1")),
+            debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+            debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
+            debounce::Event::Write(tdir.mkpath("file2")),
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-            debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
-            debounce::Event::Chmod{path: tdir.mkpath("file2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+            debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
+            debounce::Event::Chmod(tdir.mkpath("file2")),
         ]);
     }
 }
@@ -414,16 +414,16 @@ fn rename_modify_file() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-            debounce::Event::NoticeWrite{path: tdir.mkpath("file2")}, // TODO unnecessary
-            debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
-            debounce::Event::Write{path: tdir.mkpath("file2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+            debounce::Event::NoticeWrite(tdir.mkpath("file2")), // TODO unnecessary
+            debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
+            debounce::Event::Write(tdir.mkpath("file2")),
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-            debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file2")},
-            debounce::Event::Chmod{path: tdir.mkpath("file2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+            debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file2")),
+            debounce::Event::Chmod(tdir.mkpath("file2")),
         ]);
     }
 }
@@ -447,8 +447,8 @@ fn rename_rename_file() {
     tdir.rename("file2", "file3");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::Rename{from: tdir.mkpath("file1"), to: tdir.mkpath("file3")},
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::Rename(tdir.mkpath("file1"), tdir.mkpath("file3")),
     ]);
 }
 
@@ -470,9 +470,9 @@ fn write_delete_file() {
     tdir.remove("file1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeWrite{path: tdir.mkpath("file1")},
-        debounce::Event::NoticeRemove{path: tdir.mkpath("file1")},
-        debounce::Event::Remove{path: tdir.mkpath("file1")},
+        debounce::Event::NoticeWrite(tdir.mkpath("file1")),
+        debounce::Event::NoticeRemove(tdir.mkpath("file1")),
+        debounce::Event::Remove(tdir.mkpath("file1")),
     ]);
 }
 
@@ -489,7 +489,7 @@ fn create_directory() {
     tdir.create("dir1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::Create{path: tdir.mkpath("dir1")},
+        debounce::Event::Create(tdir.mkpath("dir1")),
     ]);
 }
 
@@ -512,12 +512,12 @@ fn modify_directory() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeWrite{path: tdir.mkpath("dir1")},
-            debounce::Event::Write{path: tdir.mkpath("dir1")},
+            debounce::Event::NoticeWrite(tdir.mkpath("dir1")),
+            debounce::Event::Write(tdir.mkpath("dir1")),
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::Chmod{path: tdir.mkpath("dir1")},
+            debounce::Event::Chmod(tdir.mkpath("dir1")),
         ]);
     }
 }
@@ -539,8 +539,8 @@ fn delete_directory() {
     tdir.remove("dir1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-        debounce::Event::Remove{path: tdir.mkpath("dir1")},
+        debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+        debounce::Event::Remove(tdir.mkpath("dir1")),
     ]);
 }
 
@@ -561,8 +561,8 @@ fn rename_directory() {
     tdir.rename("dir1", "dir2");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-        debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
+        debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+        debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
     ]);
 }
 
@@ -580,7 +580,7 @@ fn create_modify_directory() {
     tdir.chmod("dir1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::Create{path: tdir.mkpath("dir1")},
+        debounce::Event::Create(tdir.mkpath("dir1")),
     ]);
 }
 
@@ -620,8 +620,8 @@ fn delete_create_directory() {
     tdir.create("dir1");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-        debounce::Event::Write{path: tdir.mkpath("dir1")},
+        debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+        debounce::Event::Write(tdir.mkpath("dir1")),
     ]);
 }
 
@@ -639,7 +639,7 @@ fn create_rename_directory() {
     tdir.rename("dir1", "dir2");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::Create{path: tdir.mkpath("dir2")},
+        debounce::Event::Create(tdir.mkpath("dir2")),
     ]);
 }
 
@@ -687,12 +687,12 @@ fn create_rename_overwrite_directory() {
 
     if cfg!(target_os="macos") {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir2")}, // even though the directory is being overwritten, that can't be detected
-            debounce::Event::Create{path: tdir.mkpath("dir2")}, // even though the directory is being overwritten, that can't be detected
+            debounce::Event::NoticeRemove(tdir.mkpath("dir2")), // even though the directory is being overwritten, that can't be detected
+            debounce::Event::Create(tdir.mkpath("dir2")), // even though the directory is being overwritten, that can't be detected
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::Create{path: tdir.mkpath("dir2")}, // even though the directory is being overwritten, that can't be detected
+            debounce::Event::Create(tdir.mkpath("dir2")), // even though the directory is being overwritten, that can't be detected
         ]);
     }
 }
@@ -718,16 +718,16 @@ fn modify_rename_directory() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeWrite{path: tdir.mkpath("dir1")},
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
-            debounce::Event::Write{path: tdir.mkpath("dir2")},
+            debounce::Event::NoticeWrite(tdir.mkpath("dir1")),
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
+            debounce::Event::Write(tdir.mkpath("dir2")),
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
-            debounce::Event::Chmod{path: tdir.mkpath("dir2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
+            debounce::Event::Chmod(tdir.mkpath("dir2")),
         ]);
     }
 }
@@ -755,27 +755,27 @@ fn rename_modify_directory() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(actual, vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::NoticeWrite{path: tdir.mkpath("dir2")}, // TODO unnecessary
-            debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
-            debounce::Event::Write{path: tdir.mkpath("dir2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::NoticeWrite(tdir.mkpath("dir2")), // TODO unnecessary
+            debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
+            debounce::Event::Write(tdir.mkpath("dir2")),
         ]);
     } else if cfg!(target_os="linux") {
         assert_eq_any!(actual, vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
-            debounce::Event::Chmod{path: tdir.mkpath("dir2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
+            debounce::Event::Chmod(tdir.mkpath("dir2")),
         ], vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
-            debounce::Event::Chmod{path: tdir.mkpath("dir2")},
-            debounce::Event::Chmod{path: tdir.mkpath("dir1")}, // excessive chmod event
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
+            debounce::Event::Chmod(tdir.mkpath("dir2")),
+            debounce::Event::Chmod(tdir.mkpath("dir1")), // excessive chmod event
         ]);
     } else {
         assert_eq!(actual, vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir2")},
-            debounce::Event::Chmod{path: tdir.mkpath("dir2")},
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir2")),
+            debounce::Event::Chmod(tdir.mkpath("dir2")),
         ]);
     }
 }
@@ -799,8 +799,8 @@ fn rename_rename_directory() {
     tdir.rename("dir2", "dir3");
 
     assert_eq!(recv_events_debounced(&rx), vec![
-        debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-        debounce::Event::Rename{from: tdir.mkpath("dir1"), to: tdir.mkpath("dir3")},
+        debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+        debounce::Event::Rename(tdir.mkpath("dir1"), tdir.mkpath("dir3")),
     ]);
 }
 
@@ -825,14 +825,14 @@ fn modify_delete_directory() {
     if cfg!(target_os="windows") {
         // windows cannot distinguish between chmod and write
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeWrite{path: tdir.mkpath("dir1")},
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Remove{path: tdir.mkpath("dir1")},
+            debounce::Event::NoticeWrite(tdir.mkpath("dir1")),
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Remove(tdir.mkpath("dir1")),
         ]);
     } else {
         assert_eq!(recv_events_debounced(&rx), vec![
-            debounce::Event::NoticeRemove{path: tdir.mkpath("dir1")},
-            debounce::Event::Remove{path: tdir.mkpath("dir1")},
+            debounce::Event::NoticeRemove(tdir.mkpath("dir1")),
+            debounce::Event::Remove(tdir.mkpath("dir1")),
         ]);
     }
 }