feat: spare symlinks from deduplication

Author: KSXGitHub

src/app.rs

@@ -136,10 +136,6 @@ impl App {
             // Hardlinks deduplication doesn't work properly if there are more than 1 paths pointing to
             // the same tree or if a path points to a subtree of another path. Therefore, we must find
             // and remove such duplications before they cause problem.
-            //
-            // The current implementation has a quirk in which symbolic link to the real path of another
-            // argument would disappear. However, considering that nobody would use pdu to measure mere
-            // symbolic links, we trade this bug for a simpler codebase.
             use deduplicate_arguments::{deduplicate_arguments, RealApi};
             deduplicate_arguments::<RealApi>(&mut self.args.files);
         }

src/app/deduplicate_arguments.rs

@@ -1,12 +1,19 @@
 use pipe_trait::Pipe;
-use std::{collections::HashSet, fs::canonicalize, io, mem::take, path::PathBuf};
+use std::{
+    collections::HashSet,
+    fs::{canonicalize, symlink_metadata},
+    io,
+    mem::take,
+    path::PathBuf,
+};
 
 /// Mockable APIs to interact with the system.
 pub trait Api {
     type Argument;
     type RealPath: Eq;
     type RealPathError;
     fn canonicalize(path: &Self::Argument) -> Result<Self::RealPath, Self::RealPathError>;
+    fn is_real_dir(path: &Self::Argument) -> bool;
     fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool;
 }
 
@@ -21,6 +28,11 @@ impl Api for RealApi {
         canonicalize(path)
     }
 
+    fn is_real_dir(path: &Self::Argument) -> bool {
+        path.pipe(symlink_metadata)
+            .is_ok_and(|metadata| !metadata.is_symlink() && metadata.is_dir())
+    }
+
     fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {
         a.starts_with(b)
     }
@@ -43,13 +55,20 @@ pub fn deduplicate_arguments<Api: self::Api>(arguments: &mut Vec<Api::Argument>)
 pub fn find_argument_duplications_to_remove<Api: self::Api>(
     arguments: &[Api::Argument],
 ) -> HashSet<usize> {
-    let real_paths: Vec<_> = arguments.iter().map(Api::canonicalize).collect();
+    let real_paths: Vec<_> = arguments
+        .iter()
+        .map(|path| {
+            Api::is_real_dir(path)
+                .then(|| Api::canonicalize(path))
+                .and_then(Result::ok)
+        })
+        .collect();
     assert_eq!(arguments.len(), real_paths.len());
 
     let mut to_remove = HashSet::new();
     for left_index in 0..arguments.len() {
         for right_index in (left_index + 1)..arguments.len() {
-            if let (Ok(left), Ok(right)) = (&real_paths[left_index], &real_paths[right_index]) {
+            if let (Some(left), Some(right)) = (&real_paths[left_index], &real_paths[right_index]) {
                 // both paths are the same, remove the second one
                 if left == right {
                     to_remove.insert(right_index);
@@ -148,6 +167,13 @@ mod tests {
                 .pipe(Ok)
         }
 
+        fn is_real_dir(path: &Self::Argument) -> bool {
+            let path = PathBuf::from(path).normalize();
+            MOCKED_SYMLINKS
+                .iter()
+                .all(|(link, _)| PathBuf::from(link).normalize() != path)
+        }
+
         fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {
             a.starts_with(b)
         }