use relative path in symlink (wip)

Author: nunsez

Cargo.lock

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 clap = { version = "4.5.42", features = ["derive"] }
+pathdiff = "0.2.3"
 
 [dev-dependencies]
 tempfile = "3.20.0"

Cargo.toml

@@ -1,4 +1,6 @@
+use pathdiff::diff_paths;
 use std::{
+    env,
     os::unix::fs::symlink,
     path::{Path, PathBuf},
 };
@@ -31,39 +33,54 @@ impl Link {
         let package_path = self.dir.join(package);
 
         if !package_path.exists() {
-            println!("WARNING: Package '{}' not found", package);
+            println!("Package '{}' not found", package);
             return;
         }
 
         self.traverse(&package_path, &self.target);
     }
 
     fn traverse(&self, source_path: &Path, destination_path: &Path) {
-        if source_path.is_file() || !destination_path.exists() {
+        if !destination_path.exists() || source_path.is_file() {
             self.create_symlink(source_path, destination_path);
             return;
         }
 
         traverse(source_path, destination_path, |s, d| self.traverse(s, d));
     }
 
-    fn create_symlink(&self, src: &Path, dst: &Path) {
-        if dst.exists() {
-            let warning = "WARNING: File exists and will not be symlinked";
-            println!("{}: {}", warning, dst.display());
+    fn create_symlink(&self, original: &Path, link: &Path) {
+        if link.exists() {
+            println!("File exists and will not be symlinked: {}", link.display());
             return;
         }
 
-        let message = format!("LINK: {} => {}", dst.display(), src.display());
+        let Some(link_parent) = link.parent() else {
+            println!("Failed to get parent directory for {}", link.display());
+            return;
+        };
+
+        // for relative path exists check
+        if let Err(e) = env::set_current_dir(link_parent) {
+            println!("{e}");
+            return;
+        }
+
+        let original_relative = diff_paths(original, link_parent)
+            .filter(|p| p.exists())
+            .unwrap_or_else(|| original.to_path_buf());
+
+        println!(
+            "LINK: {} => {}",
+            link.display(),
+            original_relative.display()
+        );
 
         if self.simulate {
-            println!("[SIMULATE] {message}");
             return;
         };
 
-        println!("{message}");
-
-        if let Err(e) = symlink(src, dst) {
+        if let Err(e) = symlink(original_relative, link) {
             println!("LINK ERROR: {e}");
         }
     }

src/link.rs

@@ -1,5 +1,5 @@
 use std::{
-    fs,
+    env, fs,
     path::{Path, PathBuf},
 };
 
@@ -40,29 +40,44 @@ impl Unlink {
         traverse(source_path, destination_path, |s, d| self.traverse(s, d));
     }
 
-    fn remove_symlink(&self, src: &Path, dst: &Path) {
-        if !dst.exists() || !dst.is_symlink() {
+    fn remove_symlink(&self, original: &Path, link: &Path) {
+        if !link.exists() || !link.is_symlink() {
             return;
         }
 
-        let Ok(link_target) = fs::read_link(dst) else {
+        let Ok(link_target) = fs::read_link(link) else {
             return;
         };
 
-        if link_target != src {
+        let Some(link_parent) = link.parent() else {
+            println!("Failed to get parent directory for {}", link.display());
+            return;
+        };
+
+        if let Err(e) = env::set_current_dir(link_parent) {
+            println!("{e}");
             return;
         }
 
-        let message = format!("UNLINK: {}", dst.display());
+        match fs::canonicalize(link_target) {
+            Ok(link_target) => {
+                if link_target != original {
+                    return;
+                }
+            }
+            Err(e) => {
+                println!("{e}");
+                return;
+            }
+        }
+
+        println!("UNLINK: {}", link.display());
 
         if self.simulate {
-            println!("[SIMULATE] {}", message);
             return;
         }
 
-        println!("{message}");
-
-        if let Err(e) = fs::remove_file(dst) {
+        if let Err(e) = fs::remove_file(link) {
             println!("UNLINK ERROR: {e}");
         }
     }