feat!: rename data to size

BREAKING CHANGE:
* Crate: The fields `data` and `get_data` are replaced by `size` and `size_getter` respectively.
* JSON: The field `data` is replaced by `size`; `schema-version` is changed.

Author: KSXGitHub

src/app.rs

@@ -8,7 +8,7 @@ use crate::{
     json_data::{JsonData, UnitAndTree},
     reporter::{ErrorOnlyReporter, ErrorReport, ProgressAndErrorReporter, ProgressReport},
     runtime_error::RuntimeError,
-    size::{Bytes, Size},
+    size::{self, Bytes},
     visualizer::{BarAlignment, Direction, Visualizer},
 };
 use clap::Parser;
@@ -99,19 +99,19 @@ impl App {
         };
 
         #[allow(clippy::extra_unused_type_parameters)]
-        fn error_only_reporter<Data>(
+        fn error_only_reporter<Size>(
             report_error: fn(ErrorReport),
         ) -> ErrorOnlyReporter<fn(ErrorReport)> {
             ErrorOnlyReporter::new(report_error)
         }
 
-        fn progress_and_error_reporter<Data>(
+        fn progress_and_error_reporter<Size>(
             report_error: fn(ErrorReport),
-        ) -> ProgressAndErrorReporter<Data, fn(ErrorReport)>
+        ) -> ProgressAndErrorReporter<Size, fn(ErrorReport)>
         where
-            Data: Size + Into<u64> + Send + Sync,
-            ProgressReport<Data>: Default + 'static,
-            u64: Into<Data>,
+            Size: size::Size + Into<u64> + Send + Sync,
+            ProgressReport<Size>: Default + 'static,
+            u64: Into<Size>,
         {
             ProgressAndErrorReporter::new(
                 ProgressReport::TEXT,
@@ -124,8 +124,8 @@ impl App {
             ($(
                 $(#[$variant_attrs:meta])*
                 {
-                    $data:ty => $format:expr;
-                    $quantity:ident => $get_data:ident;
+                    $size:ty => $format:expr;
+                    $quantity:ident => $size_getter:ident;
                     $progress:literal => $create_reporter:ident;
                 }
             )*) => { match self.args {$(
@@ -145,8 +145,8 @@ impl App {
                 } => Sub {
                     direction: Direction::from_top_down(top_down),
                     bar_alignment: BarAlignment::from_align_right(align_right),
-                    get_data: $get_data,
-                    reporter: $create_reporter::<$data>(report_error),
+                    size_getter: $size_getter,
+                    reporter: $create_reporter::<$size>(report_error),
                     bytes_format: $format(bytes_format),
                     files,
                     json_output,

src/app/sub.rs

@@ -7,27 +7,27 @@ use crate::{
     os_string_display::OsStringDisplay,
     reporter::ParallelReporter,
     runtime_error::RuntimeError,
-    size::Size,
+    size,
     status_board::GLOBAL_STATUS_BOARD,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
 };
 use serde::Serialize;
 use std::{io::stdout, iter::once, num::NonZeroUsize, path::PathBuf};
 
 /// The sub program of the main application.
-pub struct Sub<Data, GetData, Report>
+pub struct Sub<Size, SizeGetter, Report>
 where
-    Data: Size + Into<u64> + Serialize + Send + Sync,
-    Report: ParallelReporter<Data> + Sync,
-    GetData: GetSize<Size = Data> + Copy + Sync,
-    DataTreeReflection<String, Data>: Into<UnitAndTree>,
+    Report: ParallelReporter<Size> + Sync,
+    Size: size::Size + Into<u64> + Serialize + Send + Sync,
+    SizeGetter: GetSize<Size = Size> + Copy + Sync,
+    DataTreeReflection<String, Size>: Into<UnitAndTree>,
 {
     /// List of files and/or directories.
     pub files: Vec<PathBuf>,
     /// Print JSON data instead of an ASCII chart.
     pub json_output: bool,
-    /// Format to be used to [`display`](Size::display) the data.
-    pub bytes_format: Data::DisplayFormat,
+    /// Format to be used to [`display`](size::Size::display) the sizes returned by [`size_getter`](Self::size_getter).
+    pub bytes_format: Size::DisplayFormat,
     /// The direction of the visualization.
     pub direction: Direction,
     /// The alignment of the bars.
@@ -36,8 +36,8 @@ where
     pub column_width_distribution: ColumnWidthDistribution,
     /// Maximum number of levels that should be visualized.
     pub max_depth: NonZeroUsize,
-    /// Returns measured quantity of the files/directories.
-    pub get_data: GetData,
+    /// [Get the size](GetSize) of files/directories.
+    pub size_getter: SizeGetter,
     /// Reports measurement progress.
     pub reporter: Report,
     /// Minimal size proportion required to appear.
@@ -46,12 +46,12 @@ where
     pub no_sort: bool,
 }
 
-impl<Data, GetData, Report> Sub<Data, GetData, Report>
+impl<Size, SizeGetter, Report> Sub<Size, SizeGetter, Report>
 where
-    Data: Size + Into<u64> + Serialize + Send + Sync,
-    Report: ParallelReporter<Data> + Sync,
-    GetData: GetSize<Size = Data> + Copy + Sync,
-    DataTreeReflection<String, Data>: Into<UnitAndTree>,
+    Size: size::Size + Into<u64> + Serialize + Send + Sync,
+    Report: ParallelReporter<Size> + Sync,
+    SizeGetter: GetSize<Size = Size> + Copy + Sync,
+    DataTreeReflection<String, Size>: Into<UnitAndTree>,
 {
     /// Run the sub program.
     pub fn run(self) -> Result<(), RuntimeError> {
@@ -63,19 +63,19 @@ where
             bar_alignment,
             column_width_distribution,
             max_depth,
-            get_data,
+            size_getter,
             reporter,
             min_ratio,
             no_sort,
         } = self;
 
         let mut iter = files
             .into_iter()
-            .map(|root| -> DataTree<OsStringDisplay, Data> {
+            .map(|root| -> DataTree<OsStringDisplay, Size> {
                 FsTreeBuilder {
                     reporter: &reporter,
                     root,
-                    get_data,
+                    size_getter,
                 }
                 .into()
             });
@@ -98,7 +98,7 @@ where
             let children: Vec<_> = once(data_tree).chain(iter).collect();
             DataTree::dir(
                 OsStringDisplay::os_string_from("(total)"),
-                Data::default(),
+                Size::default(),
                 children,
             )
         };
@@ -114,7 +114,7 @@ where
                 data_tree.par_cull_insignificant_data(min_ratio);
             }
             if !no_sort {
-                data_tree.par_sort_by(|left, right| left.data().cmp(&right.data()).reverse());
+                data_tree.par_sort_by(|left, right| left.size().cmp(&right.size()).reverse());
             }
             data_tree
         };

src/args.rs

@@ -52,10 +52,10 @@ use text_block_macros::text_block;
         "    Show chart in apparent sizes instead of block sizes"
         "    $ pdu --quantity=apparent-size"
         ""
-        "    Show data in plain numbers instead of metric units"
+        "    Show sizes in plain numbers instead of metric units"
         "    $ pdu --bytes-format=plain"
         ""
-        "    Show data in base 2¹⁰ units (binary) instead of base 10³ units (metric)"
+        "    Show sizes in base 2¹⁰ units (binary) instead of base 10³ units (metric)"
         "    $ pdu --bytes-format=binary"
         ""
         "    Show disk usage chart of all entries regardless of size"

src/data_tree.rs

@@ -4,7 +4,7 @@ pub use reflection::Reflection;
 
 pub use Reflection as DataTreeReflection;
 
-use super::size::Size;
+use super::size;
 
 /// Disk usage data of a filesystem tree.
 ///
@@ -22,9 +22,9 @@ use super::size::Size;
 /// `Serialize` and `Deserialize` traits directly, instead, it can be converted into/from a
 /// [`Reflection`] which implements these traits.
 #[derive(Debug, PartialEq, Eq)]
-pub struct DataTree<Name, Data: Size> {
+pub struct DataTree<Name, Size: size::Size> {
     name: Name,
-    data: Data,
+    size: Size,
     children: Vec<Self>,
 }
 

src/data_tree/constructors.rs

@@ -1,30 +1,30 @@
 use super::DataTree;
-use crate::size::Size;
+use crate::size;
 
-impl<Name, Data: Size> DataTree<Name, Data> {
+impl<Name, Size: size::Size> DataTree<Name, Size> {
     /// Create a tree representation of a directory.
-    pub fn dir(name: Name, inode_size: Data, children: Vec<Self>) -> Self {
-        let data = inode_size + children.iter().map(DataTree::data).sum();
+    pub fn dir(name: Name, inode_size: Size, children: Vec<Self>) -> Self {
+        let size = inode_size + children.iter().map(DataTree::size).sum();
         DataTree {
             name,
-            data,
+            size,
             children,
         }
     }
 
     /// Create a tree representation of a file.
-    pub fn file(name: Name, data: Data) -> Self {
+    pub fn file(name: Name, size: Size) -> Self {
         DataTree {
             name,
-            data,
+            size,
             children: Vec::with_capacity(0),
         }
     }
 
     /// Create a directory constructor of fixed inode size.
-    pub fn fixed_size_dir_constructor(inode_size: Data) -> impl Fn(Name, Vec<Self>) -> Self
+    pub fn fixed_size_dir_constructor(inode_size: Size) -> impl Fn(Name, Vec<Self>) -> Self
     where
-        Data: Copy,
+        Size: Copy,
     {
         move |name, children| DataTree::dir(name, inode_size, children)
     }

src/data_tree/getters.rs

@@ -1,7 +1,7 @@
 use super::DataTree;
-use crate::size::Size;
+use crate::size;
 
-impl<Name, Data: Size> DataTree<Name, Data> {
+impl<Name, Size: size::Size> DataTree<Name, Size> {
     /// Extract name
     pub fn name(&self) -> &Name {
         &self.name
@@ -13,8 +13,8 @@ impl<Name, Data: Size> DataTree<Name, Data> {
     }
 
     /// Extract total disk usage
-    pub fn data(&self) -> Data {
-        self.data
+    pub fn size(&self) -> Size {
+        self.size
     }
 
     /// Extract children

src/data_tree/reflection.rs

@@ -1,4 +1,4 @@
-use crate::size::Size;
+use crate::size;
 use std::{
     collections::VecDeque,
     ffi::OsStr,
@@ -30,11 +30,11 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "json", derive(Deserialize, Serialize))]
 #[cfg_attr(feature = "json", serde(rename_all = "kebab-case"))]
-pub struct Reflection<Name, Data: Size> {
+pub struct Reflection<Name, Size: size::Size> {
     /// Name of the tree.
     pub name: Name,
     /// Disk usage of a file or total disk usage of a folder.
-    pub data: Data,
+    pub size: Size,
     /// Data of children filesystem subtrees.
     pub children: Vec<Self>,
 }
@@ -43,31 +43,31 @@ pub struct Reflection<Name, Data: Size> {
 /// [`DataTree`](crate::data_tree::DataTree) fails.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
-pub enum ConversionError<Name, Data: Size> {
-    /// When a node's data is less than the sum of its children.
+pub enum ConversionError<Name, Size: size::Size> {
+    /// When a node's size is less than the sum of its children.
     ExcessiveChildren {
         /// Path from root to the node.
         path: VecDeque<Name>,
-        /// Data hold by the node.
-        data: Data,
+        /// Size hold by the node.
+        size: Size,
         /// Children of the node.
-        children: Vec<Reflection<Name, Data>>,
-        /// Sum of data hold by children of the node.
-        children_sum: Data,
+        children: Vec<Reflection<Name, Size>>,
+        /// Sum of size hold by children of the node.
+        children_sum: Size,
     },
 }
 
-impl<Name, Data> Display for ConversionError<Name, Data>
+impl<Name, Size> Display for ConversionError<Name, Size>
 where
     Name: AsRef<OsStr> + Debug,
-    Data: Size,
+    Size: size::Size,
 {
     fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error> {
         use ConversionError::*;
         match self {
             ExcessiveChildren {
                 path,
-                data,
+                size,
                 children_sum,
                 ..
             } => {
@@ -77,10 +77,7 @@ where
                     .fold(PathBuf::new(), |acc, x| acc.join(x));
                 write!(
                     formatter,
-                    "ExcessiveChildren: {path:?}: {data:?} is less than {sum:?}",
-                    path = path,
-                    data = data,
-                    sum = children_sum,
+                    "ExcessiveChildren: {path:?}: {size:?} is less than {children_sum:?}",
                 )
             }
         }

src/data_tree/reflection/convert.rs

@@ -1,25 +1,25 @@
 use super::Reflection;
-use crate::{data_tree::DataTree, size::Size};
+use crate::{data_tree::DataTree, size};
 
-impl<Name, Data: Size> From<DataTree<Name, Data>> for Reflection<Name, Data> {
-    fn from(source: DataTree<Name, Data>) -> Self {
+impl<Name, Size: size::Size> From<DataTree<Name, Size>> for Reflection<Name, Size> {
+    fn from(source: DataTree<Name, Size>) -> Self {
         let DataTree {
             name,
-            data,
+            size,
             children,
         } = source;
         let children: Vec<_> = children.into_iter().map(Reflection::from).collect();
         Reflection {
             name,
-            data,
+            size,
             children,
         }
     }
 }
 
-impl<Name, Data: Size> DataTree<Name, Data> {
+impl<Name, Size: size::Size> DataTree<Name, Size> {
     /// Create reflection.
-    pub fn into_reflection(self) -> Reflection<Name, Data> {
+    pub fn into_reflection(self) -> Reflection<Name, Size> {
         self.into()
     }
 }