feat(api)!: remove hook

Author: KSXGitHub

src/app.rs

@@ -6,7 +6,7 @@ use crate::{
     args::{Args, Quantity, Threads},
     bytes_format::BytesFormat,
     get_size::{GetApparentSize, GetSize},
-    hook,
+    hardlink,
     json_data::{JsonData, JsonDataBody},
     reporter::{ErrorOnlyReporter, ErrorReport, ProgressAndErrorReporter, ProgressReport},
     runtime_error::RuntimeError,
@@ -195,13 +195,13 @@ impl App {
             const REPORT_PROGRESS: bool,
         >: CreateReporter<REPORT_PROGRESS>
         {
-            type Hook: hook::Hook<Self::Size, Self::Reporter>
+            type HardlinksHandler: hardlink::RecordHardlinks<Self::Size, Self::Reporter>
                 + sub::DeduplicateHardlinkSizes<Self::Size>;
-            fn create_hook(
-                record: <Self::Hook as sub::DeduplicateHardlinkSizes<Self::Size>>::HardlinkRecord,
-            ) -> Self::Hook;
+            fn create_hardlinks_handler(
+                record: <Self::HardlinksHandler as sub::DeduplicateHardlinkSizes<Self::Size>>::HardlinkRecord,
+            ) -> Self::HardlinksHandler;
             fn init_hardlink_record(
-            ) -> <Self::Hook as sub::DeduplicateHardlinkSizes<Self::Size>>::HardlinkRecord;
+            ) -> <Self::HardlinksHandler as sub::DeduplicateHardlinkSizes<Self::Size>>::HardlinkRecord;
         }
 
         impl<const REPORT_PROGRESS: bool, SizeGetter>
@@ -210,9 +210,9 @@ impl App {
             SizeGetter: CreateReporter<REPORT_PROGRESS>,
             SizeGetter::Size: Send + Sync,
         {
-            type Hook = hook::DoNothing;
-            fn create_hook((): ()) -> Self::Hook {
-                hook::DoNothing
+            type HardlinksHandler = hardlink::HardlinkIgnorant;
+            fn create_hardlinks_handler((): ()) -> Self::HardlinksHandler {
+                hardlink::HardlinkIgnorant
             }
             fn init_hardlink_record() {}
         }
@@ -225,9 +225,11 @@ impl App {
             SizeGetter::Size: Send + Sync + 'static,
             SizeGetter::Reporter: crate::reporter::Reporter<SizeGetter::Size>,
         {
-            type Hook = hook::RecordHardlink<'static, Self::Size>;
-            fn create_hook(record: &'static HardlinkList<Self::Size>) -> Self::Hook {
-                hook::RecordHardlink::new(record)
+            type HardlinksHandler = hardlink::HardlinkAware<'static, Self::Size>;
+            fn create_hardlinks_handler(
+                record: &'static HardlinkList<Self::Size>,
+            ) -> Self::HardlinksHandler {
+                hardlink::HardlinkAware::new(record)
             }
             fn init_hardlink_record() -> &'static HardlinkList<Self::Size> {
                 HardlinkList::new().pipe(Box::new).pipe(Box::leak)
@@ -257,13 +259,15 @@ impl App {
                 } => {
                     const DEDUPLICATE_HARDLINKS: bool = cfg!(unix) && $deduplicate_hardlinks;
                     let hardlink_record = <$size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS, $progress>>::init_hardlink_record();
-                    let hook = <$size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS, $progress>>::create_hook(hardlink_record);
+                    let hardlinks_handler = <
+                        $size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS, $progress>
+                    >::create_hardlinks_handler(hardlink_record);
 
                     Sub {
                         direction: Direction::from_top_down(top_down),
                         bar_alignment: BarAlignment::from_align_right(align_right),
                         size_getter: <$size_getter as GetSizeUtils>::INSTANCE,
-                        hook,
+                        hardlinks_handler,
                         hardlink_record,
                         reporter: <$size_getter as CreateReporter<$progress>>::create_reporter(report_error),
                         bytes_format: <$size_getter as GetSizeUtils>::formatter(bytes_format),

src/app/sub.rs

@@ -3,8 +3,7 @@ use crate::{
     data_tree::DataTree,
     fs_tree_builder::FsTreeBuilder,
     get_size::GetSize,
-    hardlink::HardlinkListReflection,
-    hook,
+    hardlink::{HardlinkIgnorant, HardlinkListReflection, RecordHardlinks},
     json_data::{BinaryVersion, JsonData, JsonDataBody, JsonTree, SchemaVersion},
     os_string_display::OsStringDisplay,
     reporter::ParallelReporter,
@@ -18,12 +17,12 @@ use serde::Serialize;
 use std::{io::stdout, iter::once, num::NonZeroU64, path::PathBuf};
 
 /// The sub program of the main application.
-pub struct Sub<Size, SizeGetter, Hook, Report>
+pub struct Sub<Size, SizeGetter, HardlinksHandler, Report>
 where
     Report: ParallelReporter<Size> + Sync,
     Size: size::Size + Into<u64> + Serialize + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Copy + Sync,
-    Hook: hook::Hook<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
+    HardlinksHandler: RecordHardlinks<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
     JsonTree<Size>: Into<JsonDataBody>,
 {
     /// List of files and/or directories.
@@ -42,10 +41,10 @@ where
     pub max_depth: NonZeroU64,
     /// [Get the size](GetSize) of files/directories.
     pub size_getter: SizeGetter,
-    /// Hook to run after [`Self::size_getter`].
-    pub hook: Hook,
+    /// Handle to detect, record, and deduplicate hardlinks.
+    pub hardlinks_handler: HardlinksHandler,
     /// Record of detected hardlinks.
-    pub hardlink_record: Hook::HardlinkRecord,
+    pub hardlink_record: HardlinksHandler::HardlinkRecord,
     /// Reports measurement progress.
     pub reporter: Report,
     /// Minimal size proportion required to appear.
@@ -54,12 +53,12 @@ where
     pub no_sort: bool,
 }
 
-impl<Size, SizeGetter, Hook, Report> Sub<Size, SizeGetter, Hook, Report>
+impl<Size, SizeGetter, HardlinksHandler, Report> Sub<Size, SizeGetter, HardlinksHandler, Report>
 where
     Size: size::Size + Into<u64> + Serialize + Send + Sync,
     Report: ParallelReporter<Size> + Sync,
     SizeGetter: GetSize<Size = Size> + Copy + Sync,
-    Hook: hook::Hook<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
+    HardlinksHandler: RecordHardlinks<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
     JsonTree<Size>: Into<JsonDataBody>,
 {
     /// Run the sub program.
@@ -73,7 +72,7 @@ where
             column_width_distribution,
             max_depth,
             size_getter,
-            hook,
+            hardlinks_handler,
             hardlink_record,
             reporter,
             min_ratio,
@@ -89,7 +88,7 @@ where
                     reporter: &reporter,
                     root,
                     size_getter,
-                    hook,
+                    hardlinks_recorder: hardlinks_handler,
                     max_depth,
                 }
                 .into()
@@ -100,7 +99,7 @@ where
         } else {
             return Sub {
                 files: vec![".".into()],
-                hook,
+                hardlinks_handler,
                 hardlink_record,
                 reporter,
                 ..self
@@ -135,7 +134,7 @@ where
                 data_tree.par_sort_by(|left, right| left.size().cmp(&right.size()).reverse());
             }
             let deduplication_record =
-                Hook::deduplicate_hardlink_sizes(&mut data_tree, hardlink_record);
+                HardlinksHandler::deduplicate_hardlink_sizes(&mut data_tree, hardlink_record);
             (data_tree, deduplication_record)
         };
 
@@ -146,7 +145,8 @@ where
                 .into_reflection() // I really want to use std::mem::transmute here but can't.
                 .par_convert_names_to_utf8() // TODO: allow non-UTF8 somehow.
                 .expect("convert all names from raw string to UTF-8");
-            let shared = deduplication_record?.pipe(Hook::reflect_deduplication_results)?;
+            let shared =
+                deduplication_record?.pipe(HardlinksHandler::reflect_deduplication_results)?;
             let json_tree = JsonTree { tree, shared };
             let json_data = JsonData {
                 schema_version: SchemaVersion,
@@ -166,7 +166,7 @@ where
         };
 
         print!("{visualizer}"); // visualizer already ends with "\n", println! isn't needed here.
-        Hook::report_deduplication_results(deduplication_record?, bytes_format)?;
+        HardlinksHandler::report_deduplication_results(deduplication_record?, bytes_format)?;
         Ok(())
     }
 }
@@ -194,7 +194,7 @@ pub trait DeduplicateHardlinkSizes<Size: size::Size> {
 }
 
 #[cfg(unix)]
-impl<'a, Size> DeduplicateHardlinkSizes<Size> for hook::RecordHardlink<'a, Size>
+impl<'a, Size> DeduplicateHardlinkSizes<Size> for crate::hardlink::HardlinkAware<'a, Size>
 where
     DataTree<OsStringDisplay, Size>: Send,
     Size: size::Size + Sync,
@@ -256,7 +256,7 @@ where
     }
 }
 
-impl<Size> DeduplicateHardlinkSizes<Size> for hook::DoNothing
+impl<Size> DeduplicateHardlinkSizes<Size> for HardlinkIgnorant
 where
     DataTree<OsStringDisplay, Size>: Send,
     Size: size::Size + Sync,

src/fs_tree_builder.rs

@@ -1,7 +1,7 @@
 use super::{
     data_tree::DataTree,
     get_size::GetSize,
-    hook::{self, HookArgument},
+    hardlink::record::{RecordHardlinks, RecordHardlinksArgument},
     os_string_display::OsStringDisplay,
     reporter::{error_report::Operation::*, ErrorReport, Event, Reporter},
     size,
@@ -25,51 +25,52 @@ use std::{
 ///     os_string_display::OsStringDisplay,
 ///     reporter::{ErrorOnlyReporter, ErrorReport},
 ///     size::Bytes,
-///     hook,
+///     hardlink::HardlinkIgnorant,
 /// };
 /// let builder = FsTreeBuilder {
 ///     root: std::env::current_dir().unwrap(),
-///     hook: hook::DoNothing,
+///     hardlinks_recorder: HardlinkIgnorant,
 ///     size_getter: GetApparentSize,
 ///     reporter: &ErrorOnlyReporter::new(ErrorReport::SILENT),
 ///     max_depth: 10,
 /// };
 /// let data_tree: DataTree<OsStringDisplay, Bytes> = builder.into();
 /// ```
 #[derive(Debug)]
-pub struct FsTreeBuilder<'a, Size, SizeGetter, Hook, Report>
+pub struct FsTreeBuilder<'a, Size, SizeGetter, HardlinksRecorder, Report>
 where
     Report: Reporter<Size> + Sync + ?Sized,
     Size: size::Size + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Sync,
-    Hook: hook::Hook<Size, Report> + Sync,
+    HardlinksRecorder: RecordHardlinks<Size, Report> + Sync,
 {
     /// Root of the directory tree.
     pub root: PathBuf,
     /// Returns size of an item.
     pub size_getter: SizeGetter,
-    /// Hook to run after [`Self::size_getter`].
-    pub hook: Hook,
+    /// Handle to detect and record hardlinks.
+    pub hardlinks_recorder: HardlinksRecorder,
     /// Reports progress to external system.
     pub reporter: &'a Report,
     /// Deepest level of descendent display in the graph. The sizes beyond the max depth still count toward total.
     pub max_depth: u64,
 }
 
-impl<'a, Size, SizeGetter, Hook, Report> From<FsTreeBuilder<'a, Size, SizeGetter, Hook, Report>>
+impl<'a, Size, SizeGetter, HardlinksRecorder, Report>
+    From<FsTreeBuilder<'a, Size, SizeGetter, HardlinksRecorder, Report>>
     for DataTree<OsStringDisplay, Size>
 where
     Report: Reporter<Size> + Sync + ?Sized,
     Size: size::Size + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Sync,
-    Hook: hook::Hook<Size, Report> + Sync,
+    HardlinksRecorder: RecordHardlinks<Size, Report> + Sync,
 {
     /// Create a [`DataTree`] from an [`FsTreeBuilder`].
-    fn from(builder: FsTreeBuilder<Size, SizeGetter, Hook, Report>) -> Self {
+    fn from(builder: FsTreeBuilder<Size, SizeGetter, HardlinksRecorder, Report>) -> Self {
         let FsTreeBuilder {
             root,
             size_getter,
-            hook,
+            hardlinks_recorder,
             reporter,
             max_depth,
         } = builder;
@@ -97,7 +98,9 @@ where
                         let is_dir = stats.is_dir();
                         let size = size_getter.get_size(&stats);
                         reporter.report(Event::ReceiveData(size));
-                        hook.run_hook(HookArgument::new(path, &stats, size, reporter));
+                        hardlinks_recorder.record_hardlinks(RecordHardlinksArgument::new(
+                            path, &stats, size, reporter,
+                        ));
                         (is_dir, size)
                     }
                 };

src/hardlink.rs

@@ -1,5 +1,16 @@
+mod ignorant;
+pub use ignorant::HardlinkIgnorant;
+
+// `RecordHardlink` is POSIX-exclusive, because whilst Windows does have `MetadataExt::number_of_links`, it requires Nightly.
+#[cfg(unix)]
+mod aware;
+#[cfg(unix)]
+pub use aware::HardlinkAware;
+
 pub mod hardlink_list;
 pub mod link_path_list;
+pub mod record;
 
 pub use hardlink_list::{HardlinkList, HardlinkListReflection};
 pub use link_path_list::{LinkPathList, LinkPathListReflection};
+pub use record::RecordHardlinks;

src/hardlink/aware.rs

@@ -0,0 +1,59 @@
+use super::record::{RecordHardlinks, RecordHardlinksArgument};
+use crate::{
+    hardlink::HardlinkList,
+    inode::InodeNumber,
+    reporter::{event::HardlinkDetection, Event, Reporter},
+    size,
+};
+use std::{fmt::Debug, os::unix::fs::MetadataExt};
+
+/// Be aware of hardlinks. Treat them as links that share space.
+/// Detect files with more than 1 links and record them.
+/// Deduplicate them (remove duplicated size) from total size to
+/// accurately reflect the real size of their containers.
+#[derive(Debug, Clone, Copy)]
+pub struct HardlinkAware<'a, Size> {
+    /// Map an inode number to its size and detected paths.
+    record: &'a HardlinkList<Size>,
+}
+
+impl<'a, Size> HardlinkAware<'a, Size> {
+    /// Create a detector/recorder of hardlinks.
+    pub fn new(record: &'a HardlinkList<Size>) -> Self {
+        HardlinkAware { record }
+    }
+}
+
+impl<'a, Size, Report> RecordHardlinks<Size, Report> for HardlinkAware<'a, Size>
+where
+    Size: size::Size + Eq + Debug,
+    Report: Reporter<Size> + ?Sized,
+{
+    fn record_hardlinks(&self, argument: RecordHardlinksArgument<Size, Report>) {
+        let RecordHardlinksArgument {
+            path,
+            stats,
+            size,
+            reporter,
+        } = argument;
+
+        if stats.is_dir() {
+            return;
+        }
+
+        let links = stats.nlink();
+        if links <= 1 {
+            return;
+        }
+
+        reporter.report(Event::DetectHardlink(HardlinkDetection {
+            path,
+            stats,
+            size,
+            links,
+        }));
+
+        let ino = InodeNumber::get(stats);
+        self.record.add(ino, size, path).unwrap(); // TODO: propagate the error
+    }
+}

src/hardlink/hardlink_list.rs

@@ -10,7 +10,7 @@ use derive_more::{Display, Error};
 use pipe_trait::Pipe;
 use std::{fmt::Debug, path::Path};
 
-/// Storage to be used by [`crate::hook::RecordHardlink`].
+/// Storage to be used by [`crate::hardlink::RecordHardlinks`].
 ///
 /// **Serialization and deserialization:** _(feature: `json`)_ `HardlinkList` does not implement
 /// `Serialize` and `Deserialize` traits directly, instead, it can be converted into/from a

src/hardlink/ignorant.rs

@@ -0,0 +1,13 @@
+use super::record::{RecordHardlinks, RecordHardlinksArgument};
+
+/// Be ignorant of hardlinks. Treat them as real files.
+/// Do not detect it. Do not deduplicate it.
+/// Essentially no-op.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct HardlinkIgnorant;
+
+/// Do nothing to detect nor record any hardlink.
+impl<Size, Reporter> RecordHardlinks<Size, Reporter> for HardlinkIgnorant {
+    /// Do nothing.
+    fn record_hardlinks(&self, _: RecordHardlinksArgument<Size, Reporter>) {}
+}