better test, avoid duplicated events

diff --git a/crates/ra_vfs/src/io.rs b/crates/ra_vfs/src/io.rs
index 3ab52ac3d458df334f109c59b9148d0fea22b63f..335f4f2e1f7e29e6e511a2866ba976b5724d759f 100644 (file)
--- a/crates/ra_vfs/src/io.rs
+++ b/crates/ra_vfs/src/io.rs
@@ -55,7 +55,12 @@ pub enum TaskResult {
 
 impl fmt::Debug for TaskResult {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("TaskResult { ... }")
+        match self {
+            TaskResult::AddRoot(..) => f.write_str("TaskResult::AddRoot(..)"),
+            TaskResult::HandleChange(c) => write!(f, "TaskResult::HandleChange({:?})", c),
+            TaskResult::LoadChange(c) => write!(f, "TaskResult::LoadChange({:?})", c),
+            TaskResult::NoOp => f.write_str("TaskResult::NoOp"),
+        }
     }
 }
 

diff --git a/crates/ra_vfs/src/io/watcher.rs b/crates/ra_vfs/src/io/watcher.rs
index b370c5fbcd16408ab6f296b02da038a93f80ca0f..68bb6b6925d9d4c9adf4c6bacae2cd9c2cb4b97c 100644 (file)
--- a/crates/ra_vfs/src/io/watcher.rs
+++ b/crates/ra_vfs/src/io/watcher.rs
@@ -100,16 +100,18 @@ pub fn watch_recursive(&mut self, dir: &Path, filter: &RootFilter, emit_for_cont
                                 log::warn!("could not watch \"{}\": {}", entry.path().display(), e)
                             }
                         }
-                    }
-                    if emit_for_contents && entry.depth() > 0 {
-                        // emit as create because we haven't seen it yet
-                        if let Err(e) =
-                            self.sender
-                                .send(io::Task::HandleChange(WatcherChange::Create(
-                                    entry.path().to_path_buf(),
-                                )))
-                        {
-                            log::warn!("watcher error: {}", e)
+                    } else {
+                        if emit_for_contents && entry.depth() > 0 {
+                            // emit only for files otherwise we will cause watch_recursive to be called again with a dir that we are already watching
+                            // emit as create because we haven't seen it yet
+                            if let Err(e) =
+                                self.sender
+                                    .send(io::Task::HandleChange(WatcherChange::Create(
+                                        entry.path().to_path_buf(),
+                                    )))
+                            {
+                                log::warn!("watcher error: {}", e)
+                            }
                         }
                     }
                 }

diff --git a/crates/ra_vfs/tests/vfs.rs b/crates/ra_vfs/tests/vfs.rs
index b18ea74a32abcb77e2449d5c84e240175b3c6625..d3271570a9701bd5bbdf1ee26728e142f50030cd 100644 (file)
--- a/crates/ra_vfs/tests/vfs.rs
+++ b/crates/ra_vfs/tests/vfs.rs
@@ -1,12 +1,13 @@
 use std::{collections::HashSet, fs};
 
-// use flexi_logger::Logger;
+use flexi_logger::Logger;
 use ra_vfs::{Vfs, VfsChange};
 use tempfile::tempdir;
 
 fn process_tasks(vfs: &mut Vfs, num_tasks: u32) {
     for _ in 0..num_tasks {
         let task = vfs.task_receiver().recv().unwrap();
+        log::debug!("{:?}", task);
         vfs.handle_task(task);
     }
 }
@@ -25,7 +26,7 @@ macro_rules! assert_match {
 
 #[test]
 fn test_vfs_works() -> std::io::Result<()> {
-    // Logger::with_str("vfs=debug,ra_vfs=debug").start().unwrap();
+    Logger::with_str("vfs=debug,ra_vfs=debug").start().unwrap();
 
     let files = [
         ("a/foo.rs", "hello"),
@@ -114,21 +115,21 @@ fn test_vfs_works() -> std::io::Result<()> {
         assert_eq!(path, "spam.rs")
     );
 
-    fs::create_dir_all(dir.path().join("a/c")).unwrap();
-    fs::write(dir.path().join("a/c/new.rs"), "new hello").unwrap();
+    fs::create_dir_all(dir.path().join("a/sub1/sub2")).unwrap();
+    fs::write(dir.path().join("a/sub1/sub2/new.rs"), "new hello").unwrap();
     process_tasks(&mut vfs, 4);
     assert_match!(
         vfs.commit_changes().as_slice(),
         [VfsChange::AddFile { text, path, .. }],
         {
             assert_eq!(text.as_str(), "new hello");
-            assert_eq!(path, "c/new.rs");
+            assert_eq!(path, "sub1/sub2/new.rs");
         }
     );
 
     fs::rename(
-        &dir.path().join("a/c/new.rs"),
-        &dir.path().join("a/c/new1.rs"),
+        &dir.path().join("a/sub1/sub2/new.rs"),
+        &dir.path().join("a/sub1/sub2/new1.rs"),
     )
     .unwrap();
     process_tasks(&mut vfs, 4);
@@ -142,18 +143,18 @@ fn test_vfs_works() -> std::io::Result<()> {
             ..
         }],
         {
-            assert_eq!(removed_path, "c/new.rs");
-            assert_eq!(added_path, "c/new1.rs");
+            assert_eq!(removed_path, "sub1/sub2/new.rs");
+            assert_eq!(added_path, "sub1/sub2/new1.rs");
             assert_eq!(text.as_str(), "new hello");
         }
     );
 
-    fs::remove_file(&dir.path().join("a/c/new1.rs")).unwrap();
+    fs::remove_file(&dir.path().join("a/sub1/sub2/new1.rs")).unwrap();
     process_tasks(&mut vfs, 2);
     assert_match!(
         vfs.commit_changes().as_slice(),
         [VfsChange::RemoveFile { path, .. }],
-        assert_eq!(path, "c/new1.rs")
+        assert_eq!(path, "sub1/sub2/new1.rs")
     );
 
     fs::create_dir_all(dir.path().join("a/target")).unwrap();