refactor: use mockable trait

Author: KSXGitHub

src/app.rs

@@ -16,7 +16,7 @@ use crate::{
 use clap::Parser;
 use hdd::any_path_is_in_hdd;
 use pipe_trait::Pipe;
-use std::{fs::canonicalize, io::stdin, time::Duration};
+use std::{io::stdin, time::Duration};
 use sub::JsonOutputParam;
 use sysinfo::Disks;
 
@@ -140,11 +140,8 @@ impl App {
             // 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.
-            deduplicate_arguments::deduplicate_arguments(
-                &mut self.args.files,
-                |path| canonicalize(path),
-                |a, b| a.starts_with(b),
-            );
+            use deduplicate_arguments::{deduplicate_arguments, RealApi};
+            deduplicate_arguments::<RealApi>(&mut self.args.files);
         }
 
         let report_error = if self.args.silent_errors {

src/app/deduplicate_arguments.rs

@@ -1,19 +1,36 @@
 use pipe_trait::Pipe;
-use std::{collections::HashSet, mem::take};
+use std::{collections::HashSet, fs::canonicalize, 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 starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool;
+}
+
+/// Implementation of [`Api`] that interacts with the real system.
+pub struct RealApi;
+impl Api for RealApi {
+    type Argument = PathBuf;
+    type RealPath = PathBuf;
+    type RealPathError = io::Error;
+
+    fn canonicalize(path: &Self::Argument) -> Result<Self::RealPath, Self::RealPathError> {
+        canonicalize(path)
+    }
+
+    fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {
+        a.starts_with(b)
+    }
+}
 
 /// 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.
-pub fn deduplicate_arguments<'a, Argument, Canonicalize, StartsWith, RealPath, CanonicalizeError>(
-    arguments: &'a mut Vec<Argument>,
-    canonicalize: Canonicalize,
-    starts_with: StartsWith,
-) where
-    Canonicalize: for<'r> FnMut(&Argument) -> Result<RealPath, CanonicalizeError>,
-    StartsWith: for<'r> FnMut(&'r RealPath, &'r RealPath) -> bool,
-    RealPath: Eq,
-{
-    let to_remove = find_argument_duplications_to_remove(arguments, canonicalize, starts_with);
+pub fn deduplicate_arguments<Api: self::Api>(arguments: &mut Vec<Api::Argument>) {
+    let to_remove = find_argument_duplications_to_remove::<Api>(arguments);
     remove_items_from_vec_by_indices(arguments, &to_remove);
 }
 
@@ -23,23 +40,10 @@ pub fn deduplicate_arguments<'a, Argument, Canonicalize, StartsWith, RealPath, C
 ///
 /// Prefer keeping the first instance of the path over the later instances (returning the indices of
 /// the later instances).
-pub fn find_argument_duplications_to_remove<
-    Argument,
-    Canonicalize,
-    StartsWith,
-    RealPath,
-    CanonicalizeError,
->(
-    arguments: &[Argument],
-    canonicalize: Canonicalize,
-    mut starts_with: StartsWith,
-) -> HashSet<usize>
-where
-    Canonicalize: for<'r> FnMut(&Argument) -> Result<RealPath, CanonicalizeError>,
-    StartsWith: for<'r> FnMut(&'r RealPath, &'r RealPath) -> bool,
-    RealPath: Eq,
-{
-    let real_paths: Vec<_> = arguments.iter().map(canonicalize).collect();
+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();
     assert_eq!(arguments.len(), real_paths.len());
 
     let mut to_remove = HashSet::new();
@@ -53,13 +57,13 @@ where
                 }
 
                 // `left` starts with `right` means `left` is subtree of `right`, remove `left`
-                if starts_with(left, right) {
+                if Api::starts_with(left, right) {
                     to_remove.insert(left_index);
                     continue;
                 }
 
                 // `right` starts with `left` means `right` is subtree of `left`, remove `right`
-                if starts_with(right, left) {
+                if Api::starts_with(right, left) {
                     to_remove.insert(right_index);
                     continue;
                 }