Support for forceful removal of symlinks or files during dir creation (#301)

Author: Byron

git-worktree/src/index/checkout.rs

@@ -27,6 +27,9 @@ pub struct PathCache {
     /// The amount of path components of 'valid' beyond the roots components. If `root` has 2, and this is 2, `valid` has 4 components.
     valid_components: usize,
 
+    /// If there is a symlink or a file in our path, try to unlink it before creating the directory.
+    pub unlink_on_collision: bool,
+
     /// just for testing
     #[cfg(debug_assertions)]
     pub test_mkdir_calls: usize,
@@ -46,7 +49,9 @@ mod cache {
                 valid_relative: PathBuf::with_capacity(128),
                 valid_components: 0,
                 root,
+                #[cfg(debug_assertions)]
                 test_mkdir_calls: 0,
+                unlink_on_collision: false,
             }
         }
 
@@ -90,11 +95,28 @@ mod cache {
                 self.valid_relative.push(comp);
                 self.valid_components += 1;
                 if components.peek().is_some() || target_is_dir {
-                    self.test_mkdir_calls += 1;
+                    #[cfg(debug_assertions)]
+                    {
+                        self.test_mkdir_calls += 1;
+                    }
                     match std::fs::create_dir(&self.valid) {
                         Ok(()) => {}
                         Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
-                            if !self.valid.symlink_metadata()?.is_dir() {
+                            let meta = self.valid.symlink_metadata()?;
+                            if !meta.is_dir() {
+                                if self.unlink_on_collision {
+                                    if meta.is_symlink() {
+                                        symlink::remove_symlink_auto(&self.valid)?;
+                                    } else {
+                                        std::fs::remove_file(&self.valid)?;
+                                    }
+                                    #[cfg(debug_assertions)]
+                                    {
+                                        self.test_mkdir_calls += 1;
+                                    }
+                                    std::fs::create_dir(&self.valid)?;
+                                    continue;
+                                }
                                 return Err(err);
                             }
                         }

git-worktree/src/index/mod.rs

@@ -24,7 +24,10 @@ where
 
     use std::io::ErrorKind::AlreadyExists;
     let dir = dir.into();
+
     let mut path_cache = PathCache::new(dir.clone());
+    path_cache.unlink_on_collision = options.overwrite_existing;
+
     let mut buf = Vec::new();
     let mut collisions = Vec::new();
 

git-worktree/tests/index/mod.rs

@@ -48,6 +48,7 @@ mod checkout {
                 .unwrap();
             assert!(path.parent().unwrap().is_dir(), "directory is still present");
             assert!(!path.exists(), "it won't create the file");
+            assert_eq!(cache.test_mkdir_calls, 1);
         }
 
         #[test]
@@ -59,14 +60,24 @@ mod checkout {
             std::fs::write(tmp.path().join("file-in-dir"), &[]).unwrap();
 
             for dirname in &["link-to-dir", "file-in-dir"] {
+                cache.unlink_on_collision = false;
+                let relative_path = format!("{}/file", dirname);
                 assert_eq!(
                     cache
-                        .append_relative_path_assure_leading_dir(format!("{}/file", dirname), Mode::FILE)
+                        .append_relative_path_assure_leading_dir(&relative_path, Mode::FILE)
                         .unwrap_err()
                         .kind(),
                     std::io::ErrorKind::AlreadyExists
                 );
+                cache.unlink_on_collision = true;
+
+                let path = cache
+                    .append_relative_path_assure_leading_dir(&relative_path, Mode::FILE)
+                    .unwrap();
+                assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");
+                assert!(!path.exists());
             }
+            assert_eq!(cache.test_mkdir_calls, 4);
         }
 
         fn new_cache() -> (PathCache, TempDir) {