hopefully fix symlink creation on windows (#301)

The windows file check needs to handle relative links properly when checking for file type.

Author: Byron

git-worktree/src/fs.rs

@@ -90,14 +90,14 @@ impl Capabilities {
             .write(true)
             .open(&src_path)?;
         let link_path = root.join("__file_link");
-        if symlink::symlink_file(&src_path, &link_path).is_err() {
+        if crate::os::create_symlink(&src_path, &link_path).is_err() {
             std::fs::remove_file(&src_path)?;
             return Ok(false);
         }
 
         let res = std::fs::symlink_metadata(&link_path).map(|m| m.is_symlink());
         let cleanup = std::fs::remove_file(&src_path);
-        symlink::remove_symlink_file(&link_path)
+        crate::os::remove_symlink(&link_path)
             .or_else(|_| std::fs::remove_file(&link_path))
             .and(cleanup)?;
         res

git-worktree/src/index/checkout.rs

@@ -21,6 +21,11 @@ pub struct Options {
     /// This should be enabled when cloning to avoid checks for freshness of files. This also enables
     /// detection of collisions based on whether or not exclusive file creation succeeds or fails.
     pub destination_is_initially_empty: bool,
+    /// If true, default false, worktree entries on disk will be overwritten with content from the index
+    /// even if they appear to be changed. When creating directories that clash with existing worktree entries,
+    /// these will try to delete the existing entry.
+    /// This is similar in behaviour as `git checkout --force`.
+    pub overwrite_existing: bool,
     /// If true, default false, try to checkout as much as possible and don't abort on first error which isn't
     /// due to a conflict.
     /// The operation will never fail, but count the encountered errors instead along with their paths.
@@ -46,6 +51,7 @@ impl Default for Options {
             keep_going: false,
             trust_ctime: true,
             check_stat: true,
+            overwrite_existing: false,
         }
     }
 }

git-worktree/src/index/entry.rs

@@ -36,7 +36,9 @@ where
             path: entry_path.to_owned(),
         }
     })?);
-    create_dir_all(dest.parent().expect("entry paths are never empty"))?; // TODO: can this be avoided to create dirs when needed only?
+
+    let dest_dir = dest.parent().expect("entry paths are never empty");
+    create_dir_all(dest_dir)?; // TODO: can this be avoided to create dirs when needed only?
 
     match entry.mode {
         git_index::entry::Mode::FILE | git_index::entry::Mode::FILE_EXECUTABLE => {
@@ -72,7 +74,7 @@ where
             // TODO: how to deal with mode changes? Maybe this info can be passed once we check for whether
             // a checkout is needed at all.
             if symlink {
-                symlink::symlink_auto(symlink_destination, &dest)?;
+                crate::os::create_symlink(symlink_destination, &dest)?;
             } else {
                 std::fs::write(&dest, obj.data)?;
             }

git-worktree/src/lib.rs

@@ -10,3 +10,5 @@
 pub mod fs;
 
 pub mod index;
+
+pub(crate) mod os;

git-worktree/src/os.rs

@@ -0,0 +1,28 @@
+use std::io;
+use std::path::Path;
+
+#[cfg(not(windows))]
+pub fn create_symlink(original: &Path, link: &Path) -> io::Result<()> {
+    std::os::unix::fs::symlink(original, link)
+}
+
+#[cfg(not(windows))]
+pub fn remove_symlink(path: &Path) -> io::Result<()> {
+    std::fs::remove_file(path)
+}
+
+#[cfg(windows)]
+pub fn remove_symlink(path: &Path) -> io::Result<()> {
+    symlink::remove_symlink_auto(path)
+}
+
+#[cfg(windows)]
+pub fn create_symlink(original: &Path, link: &Path) -> io::Result<()> {
+    use std::os::windows::fs::{symlink_dir, symlink_file};
+    // TODO: figure out if links to links count as files or whatever they point at
+    if std::fs::metadata(link.parent().expect("dir for link").join(original))?.is_dir() {
+        symlink_dir(original, link)
+    } else {
+        symlink_file(original, original)
+    }
+}