refactor!: replace closures with traits

KSXGitHub · KSXGitHub · commit 700c0d75c1a0 · 2024-11-02T01:32:10.000+07:00
diff --git a/src/app.rs b/src/app.rs
@@ -4,11 +4,11 @@ pub use sub::Sub;
 
 use crate::{
     args::{Args, Quantity},
+    get_size::GetApparentSize,
     json_data::{JsonData, UnitAndTree},
     reporter::{ErrorOnlyReporter, ErrorReport, ProgressAndErrorReporter, ProgressReport},
     runtime_error::RuntimeError,
     size::{Bytes, Size},
-    size_getters::GET_APPARENT_SIZE,
     visualizer::{BarAlignment, Direction, Visualizer},
 };
 use clap::Parser;
@@ -17,8 +17,8 @@ use std::{io::stdin, time::Duration};
 
 #[cfg(unix)]
 use crate::{
+    get_size::{GetBlockCount, GetBlockSize},
     size::Blocks,
-    size_getters::{GET_BLOCK_COUNT, GET_BLOCK_SIZE},
 };
 
 /// The main application.
@@ -162,41 +162,41 @@ impl App {
         run! {
             {
                 Bytes => |x| x;
-                ApparentSize => GET_APPARENT_SIZE;
+                ApparentSize => GetApparentSize;
                 false => error_only_reporter;
             }
 
             {
                 Bytes => |x| x;
-                ApparentSize => GET_APPARENT_SIZE;
+                ApparentSize => GetApparentSize;
                 true => progress_and_error_reporter;
             }
 
             #[cfg(unix)]
             {
                 Bytes => |x| x;
-                BlockSize => GET_BLOCK_SIZE;
+                BlockSize => GetBlockSize;
                 false => error_only_reporter;
             }
 
             #[cfg(unix)]
             {
                 Bytes => |x| x;
-                BlockSize => GET_BLOCK_SIZE;
+                BlockSize => GetBlockSize;
                 true => progress_and_error_reporter;
             }
 
             #[cfg(unix)]
             {
                 Blocks => |_| ();
-                BlockCount => GET_BLOCK_COUNT;
+                BlockCount => GetBlockCount;
                 false => error_only_reporter;
             }
 
             #[cfg(unix)]
             {
                 Blocks => |_| ();
-                BlockCount => GET_BLOCK_COUNT;
+                BlockCount => GetBlockCount;
                 true => progress_and_error_reporter;
             }
         }
diff --git a/src/app/sub.rs b/src/app/sub.rs
@@ -2,6 +2,7 @@ use crate::{
     args::Fraction,
     data_tree::{DataTree, DataTreeReflection},
     fs_tree_builder::FsTreeBuilder,
+    get_size::GetSize,
     json_data::{BinaryVersion, JsonData, SchemaVersion, UnitAndTree},
     os_string_display::OsStringDisplay,
     reporter::ParallelReporter,
@@ -11,14 +12,14 @@ use crate::{
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
 };
 use serde::Serialize;
-use std::{fs::Metadata, io::stdout, iter::once, num::NonZeroUsize, path::PathBuf};
+use std::{io::stdout, iter::once, num::NonZeroUsize, path::PathBuf};
 
 /// The sub program of the main application.
 pub struct Sub<Data, GetData, Report>
 where
     Data: Size + Into<u64> + Serialize + Send + Sync,
     Report: ParallelReporter<Data> + Sync,
-    GetData: Fn(&Metadata) -> Data + Copy + Sync,
+    GetData: GetSize<Size = Data> + Copy + Sync,
     DataTreeReflection<String, Data>: Into<UnitAndTree>,
 {
     /// List of files and/or directories.
@@ -49,7 +50,7 @@ impl<Data, GetData, Report> Sub<Data, GetData, Report>
 where
     Data: Size + Into<u64> + Serialize + Send + Sync,
     Report: ParallelReporter<Data> + Sync,
-    GetData: Fn(&Metadata) -> Data + Copy + Sync,
+    GetData: GetSize<Size = Data> + Copy + Sync,
     DataTreeReflection<String, Data>: Into<UnitAndTree>,
 {
     /// Run the sub program.
diff --git a/src/fs_tree_builder.rs b/src/fs_tree_builder.rs
@@ -1,13 +1,14 @@
 use super::{
     data_tree::DataTree,
+    get_size::GetSize,
     os_string_display::OsStringDisplay,
     reporter::{error_report::Operation::*, ErrorReport, Event, Reporter},
     size::Size,
     tree_builder::{Info, TreeBuilder},
 };
 use pipe_trait::Pipe;
 use std::{
-    fs::{read_dir, symlink_metadata, Metadata},
+    fs::{read_dir, symlink_metadata},
     path::PathBuf,
 };
 
@@ -19,14 +20,14 @@ use std::{
 /// # use parallel_disk_usage::fs_tree_builder::FsTreeBuilder;
 /// use parallel_disk_usage::{
 ///     data_tree::DataTree,
+///     get_size::GetApparentSize,
 ///     os_string_display::OsStringDisplay,
 ///     reporter::{ErrorOnlyReporter, ErrorReport},
 ///     size::Bytes,
-///     size_getters::GET_APPARENT_SIZE,
 /// };
 /// let builder = FsTreeBuilder {
 ///     root: std::env::current_dir().unwrap(),
-///     get_data: GET_APPARENT_SIZE,
+///     get_data: GetApparentSize,
 ///     reporter: ErrorOnlyReporter::new(ErrorReport::SILENT),
 /// };
 /// let data_tree: DataTree<OsStringDisplay, Bytes> = builder.into();
@@ -35,7 +36,7 @@ use std::{
 pub struct FsTreeBuilder<Data, GetData, Report>
 where
     Data: Size + Send + Sync,
-    GetData: Fn(&Metadata) -> Data + Sync,
+    GetData: GetSize<Size = Data> + Sync,
     Report: Reporter<Data> + Sync,
 {
     /// Root of the directory tree.
@@ -50,7 +51,7 @@ impl<Data, GetData, Report> From<FsTreeBuilder<Data, GetData, Report>>
     for DataTree<OsStringDisplay, Data>
 where
     Data: Size + Send + Sync,
-    GetData: Fn(&Metadata) -> Data + Sync,
+    GetData: GetSize<Size = Data> + Sync,
     Report: Reporter<Data> + Sync,
 {
     /// Create a [`DataTree`] from an [`FsTreeBuilder`].
@@ -110,7 +111,7 @@ where
                     Vec::new()
                 };
 
-                let data = get_data(&stats);
+                let data = get_data.get_size(&stats);
                 reporter.report(Event::ReceiveData(data));
 
                 Info { data, children }
diff --git a/src/get_size.rs b/src/get_size.rs
@@ -0,0 +1,47 @@
+use super::size::Bytes;
+use std::fs::Metadata;
+
+#[cfg(unix)]
+use super::size::Blocks;
+#[cfg(unix)]
+use std::os::unix::prelude::MetadataExt;
+
+/// Infers size from a [`Metadata`].
+pub trait GetSize {
+    type Size;
+    fn get_size(&self, metadata: &Metadata) -> Self::Size;
+}
+
+/// Returns [`metadata.len()`](Metadata::len).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct GetApparentSize;
+impl GetSize for GetApparentSize {
+    type Size = Bytes;
+    fn get_size(&self, metadata: &Metadata) -> Self::Size {
+        metadata.len().into()
+    }
+}
+
+/// Returns [`metadata.blocks() * 512`](Metadata::blksize) (POSIX only).
+#[cfg(unix)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct GetBlockSize;
+#[cfg(unix)]
+impl GetSize for GetBlockSize {
+    type Size = Bytes;
+    fn get_size(&self, metadata: &Metadata) -> Self::Size {
+        (metadata.blocks() * 512).into()
+    }
+}
+
+/// Returns [`metadata.blocks()`](Metadata::blocks) (POSIX only).
+#[cfg(unix)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct GetBlockCount;
+#[cfg(unix)]
+impl GetSize for GetBlockCount {
+    type Size = Blocks;
+    fn get_size(&self, metadata: &Metadata) -> Self::Size {
+        metadata.blocks().into()
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -32,11 +32,11 @@ pub use clap_utilities;
 pub mod bytes_format;
 pub mod data_tree;
 pub mod fs_tree_builder;
+pub mod get_size;
 pub mod json_data;
 pub mod os_string_display;
 pub mod reporter;
 pub mod size;
-pub mod size_getters;
 pub mod status_board;
 pub mod tree_builder;
 pub mod visualizer;
diff --git a/src/size_getters.rs b/src/size_getters.rs
diff --git a/tests/_utils.rs b/tests/_utils.rs
@@ -4,29 +4,29 @@ use derive_more::{AsRef, Deref};
 use parallel_disk_usage::{
     data_tree::{DataTree, DataTreeReflection},
     fs_tree_builder::FsTreeBuilder,
+    get_size::{self, GetSize},
     os_string_display::OsStringDisplay,
     reporter::ErrorOnlyReporter,
-    size::{Bytes, Size},
-    size_getters::{self, SizeGetter},
+    size::Size,
 };
 use pipe_trait::Pipe;
 use pretty_assertions::assert_eq;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use rayon::prelude::*;
 use std::{
     env::temp_dir,
-    fs::{create_dir, metadata, remove_dir_all, Metadata},
+    fs::{create_dir, metadata, remove_dir_all},
     io::Error,
     path::{Path, PathBuf},
     process::{Command, Output},
 };
 
 /// Default size getter method.
 #[cfg(unix)]
-pub const DEFAULT_GET_SIZE: SizeGetter<Bytes> = size_getters::GET_BLOCK_SIZE;
+pub const DEFAULT_GET_SIZE: get_size::GetBlockSize = get_size::GetBlockSize;
 /// Default size getter method.
 #[cfg(not(unix))]
-pub const DEFAULT_GET_SIZE: SizeGetter<Bytes> = size_getters::GET_APPARENT_SIZE;
+pub const DEFAULT_GET_SIZE: get_size::GetApparentSize = get_size::GetApparentSize;
 
 /// Representation of a temporary filesystem item.
 ///
@@ -125,17 +125,16 @@ where
 }
 
 /// Test the result of tree builder on the sample workspace.
-pub fn test_sample_tree<Data, SizeFromMetadata>(root: &Path, size_from_metadata: SizeFromMetadata)
+pub fn test_sample_tree<Data, SizeGetter>(root: &Path, size_getter: SizeGetter)
 where
     Data: Size<Inner = u64> + From<u64> + Send + Sync,
-    SizeFromMetadata: Fn(&Metadata) -> u64 + Copy + Sync,
+    SizeGetter: GetSize<Size = Data> + Copy + Sync,
 {
     let suffix_size = |suffix: &str| -> Data {
         root.join(suffix)
             .pipe(metadata)
             .unwrap_or_else(|error| panic!("get_size {}: {}", suffix, error))
-            .pipe_ref(size_from_metadata)
-            .into()
+            .pipe(|ref metadata| size_getter.get_size(metadata))
     };
 
     macro_rules! suffix_size {
@@ -149,7 +148,7 @@ where
 
     let measure = |suffix: &str| {
         FsTreeBuilder {
-            get_data: |metadata| size_from_metadata(metadata).into(),
+            get_data: size_getter,
             reporter: ErrorOnlyReporter::new(|error| {
                 panic!("Unexpected call to report_error: {:?}", error)
             }),
diff --git a/tests/cli_errors.rs b/tests/cli_errors.rs
@@ -9,9 +9,9 @@ use parallel_disk_usage::{
     bytes_format::BytesFormat,
     data_tree::DataTree,
     fs_tree_builder::FsTreeBuilder,
+    get_size::GetApparentSize,
     os_string_display::OsStringDisplay,
     reporter::{ErrorOnlyReporter, ErrorReport},
-    size_getters::GET_APPARENT_SIZE,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
 };
 use pipe_trait::Pipe;
@@ -131,7 +131,7 @@ fn fs_errors() {
 
     let builder = FsTreeBuilder {
         root: workspace.to_path_buf(),
-        get_data: GET_APPARENT_SIZE,
+        get_data: GetApparentSize,
         reporter: ErrorOnlyReporter::new(ErrorReport::SILENT),
     };
     let mut data_tree: DataTree<OsStringDisplay, _> = builder.into();
diff --git a/tests/fs_tree_builder.rs b/tests/fs_tree_builder.rs
@@ -1,29 +1,30 @@
 pub mod _utils;
 pub use _utils::*;
 
-use parallel_disk_usage::size::Bytes;
+use parallel_disk_usage::{
+    get_size::{GetApparentSize, GetBlockCount, GetBlockSize},
+    size::Bytes,
+};
 
 #[cfg(unix)]
 use parallel_disk_usage::size::Blocks;
-#[cfg(unix)]
-use std::os::unix::fs::MetadataExt;
 
 #[test]
 fn len_as_bytes() {
     let workspace = SampleWorkspace::default();
-    test_sample_tree::<Bytes, _>(&workspace, |metadata| metadata.len());
+    test_sample_tree::<Bytes, _>(&workspace, GetApparentSize);
 }
 
 #[cfg(unix)]
 #[test]
 fn blocks_as_bytes() {
     let workspace = SampleWorkspace::default();
-    test_sample_tree::<Bytes, _>(&workspace, |metadata| metadata.blocks() * 512);
+    test_sample_tree::<Bytes, _>(&workspace, GetBlockSize);
 }
 
 #[cfg(unix)]
 #[test]
 fn blocks_as_blocks() {
     let workspace = SampleWorkspace::default();
-    test_sample_tree::<Blocks, _>(&workspace, |metadata| metadata.blocks());
+    test_sample_tree::<Blocks, _>(&workspace, GetBlockCount);
 }
diff --git a/tests/json.rs b/tests/json.rs
@@ -9,10 +9,10 @@ use parallel_disk_usage::{
     bytes_format::BytesFormat,
     data_tree::{DataTree, Reflection},
     fs_tree_builder::FsTreeBuilder,
+    get_size::GetApparentSize,
     json_data::{JsonData, SchemaVersion},
     reporter::{ErrorOnlyReporter, ErrorReport},
     size::Bytes,
-    size_getters::GET_APPARENT_SIZE,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
 };
 use pipe_trait::Pipe;
@@ -80,7 +80,7 @@ fn json_output() {
     dbg!(&actual);
     let builder = FsTreeBuilder {
         root: workspace.to_path_buf(),
-        get_data: GET_APPARENT_SIZE,
+        get_data: GetApparentSize,
         reporter: ErrorOnlyReporter::new(ErrorReport::SILENT),
     };
     let expected = builder
diff --git a/tests/usual_cli.rs b/tests/usual_cli.rs

Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ pub use sub::Sub;`
`4`	`4`
`5`	`5`	`use crate::{`
`6`	`6`	`args::{Args, Quantity},`
	`7`	`+ get_size::GetApparentSize,`
`7`	`8`	`json_data::{JsonData, UnitAndTree},`
`8`	`9`	`reporter::{ErrorOnlyReporter, ErrorReport, ProgressAndErrorReporter, ProgressReport},`
`9`	`10`	`runtime_error::RuntimeError,`
`10`	`11`	`size::{Bytes, Size},`
`11`		`- size_getters::GET_APPARENT_SIZE,`
`12`	`12`	`visualizer::{BarAlignment, Direction, Visualizer},`
`13`	`13`	`};`
`14`	`14`	`use clap::Parser;`
`@@ -17,8 +17,8 @@ use std::{io::stdin, time::Duration};`
`17`	`17`
`18`	`18`	`#[cfg(unix)]`
`19`	`19`	`use crate::{`
	`20`	`+ get_size::{GetBlockCount, GetBlockSize},`
`20`	`21`	`size::Blocks,`
`21`		`- size_getters::{GET_BLOCK_COUNT, GET_BLOCK_SIZE},`
`22`	`22`	`};`
`23`	`23`
`24`	`24`	`/// The main application.`
`@@ -162,41 +162,41 @@ impl App {`
`162`	`162`	`run! {`
`163`	`163`	`{`
`164`	`164`	`Bytes => \|x\| x;`
`165`		`- ApparentSize => GET_APPARENT_SIZE;`
	`165`	`+ ApparentSize => GetApparentSize;`
`166`	`166`	`false => error_only_reporter;`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`{`
`170`	`170`	`Bytes => \|x\| x;`
`171`		`- ApparentSize => GET_APPARENT_SIZE;`
	`171`	`+ ApparentSize => GetApparentSize;`
`172`	`172`	`true => progress_and_error_reporter;`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`#[cfg(unix)]`
`176`	`176`	`{`
`177`	`177`	`Bytes => \|x\| x;`
`178`		`- BlockSize => GET_BLOCK_SIZE;`
	`178`	`+ BlockSize => GetBlockSize;`
`179`	`179`	`false => error_only_reporter;`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`#[cfg(unix)]`
`183`	`183`	`{`
`184`	`184`	`Bytes => \|x\| x;`
`185`		`- BlockSize => GET_BLOCK_SIZE;`
	`185`	`+ BlockSize => GetBlockSize;`
`186`	`186`	`true => progress_and_error_reporter;`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`#[cfg(unix)]`
`190`	`190`	`{`
`191`	`191`	`Blocks => \|_\| ();`
`192`		`- BlockCount => GET_BLOCK_COUNT;`
	`192`	`+ BlockCount => GetBlockCount;`
`193`	`193`	`false => error_only_reporter;`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`#[cfg(unix)]`
`197`	`197`	`{`
`198`	`198`	`Blocks => \|_\| ();`
`199`		`- BlockCount => GET_BLOCK_COUNT;`
	`199`	`+ BlockCount => GetBlockCount;`
`200`	`200`	`true => progress_and_error_reporter;`
`201`	`201`	`}`
`202`	`202`	`}`