don't emit units in minimal mode

src/args.rs

@@ -5,6 +5,7 @@ use rayon::ThreadPoolBuilder;
 use crate::unit::Unit;
 
 use std::fs::{symlink_metadata, Metadata};
+use std::os::unix::fs::MetadataExt;
 use std::path::{Component, Path};
 use std::slice::Iter;
 use std::iter::once_with;
@@ -31,7 +32,7 @@ pub struct Args {
     #[arg(
         short, long,
         help = "minimize output",
-        long_help = "print nothing but the total size for all directories, without a newline. Also supresses all error messages",
+        long_help = "print nothing but the total size for all directories, without a newline or units. Also supresses all error messages",
         conflicts_with = "total",
         default_value_t = false,
     )]
@@ -72,7 +73,7 @@ pub struct Args {
     #[arg(
         short, long,
         help = "unit to print in",
-        long_help = "printing unit (case insensitive): b = bytes, kb = kilobytes, ki = kibibytes, gb = gigabytes, gi = gibibytes, tb = terabytes, ti = tibibytes",
+        long_help = "printing unit (case insensitive): b = bytes, kb = kilobytes, ki = kibibytes, gb = gigabytes, gi = gibibytes, tb = terabytes, ti = tibibytes, blk/blks/blck/blcks/block/blocks = file system blocks",
         value_parser = Unit::parse,
         default_value_t = Unit::Byte,
         conflicts_with_all = ["base_two","si"],
@@ -129,7 +130,7 @@ pub struct Args {
         help = "items to summate",
         action = ArgAction::Append,
     )]
-    path: Vec<String>,
+    paths: Vec<String>,
 }
 impl Args {
     /// utility method to chuck default values on the end.
@@ -146,8 +147,8 @@ impl Args {
             self.exclude_print.clear();
         }
 
-        if self.path.is_empty() {
+        if self.paths.is_empty() {
-            self.path = vec![ ".".to_owned() ];
+            self.paths = vec![ ".".to_owned() ];
         }
 
         ThreadPoolBuilder::new()
@@ -158,6 +159,13 @@ impl Args {
         self
     }
 
+    pub fn len(&self, meta: &Metadata) -> u64 {
+        match self.unit {
+            Unit::Blocks => meta.blocks(),
+            _ => meta.len(),
+        }
+    }
+
     pub fn should_exclude(&self, path: &Path, file: &Metadata) -> bool {
         if !self.follow_links
         && file.is_symlink()
@@ -202,7 +210,7 @@ impl Args {
     }
 
     pub fn paths(&self) -> Iter<'_, String> {
-        self.path.iter()
+        self.paths.iter()
     }
 }
 
@@ -228,7 +236,7 @@ fn any_pattern_matches_any_component(patterns: &[Pattern], path: &Path) -> bool
                 continue
             };
             let Some(s) = cmp.to_str() else {
-                // this is a code smell
+                // TODO: this is a code smell
                 // I don't believe it, but I can't think
                 // of anything worthwhile to do when
                 // you can't get a usable &str

src/directory.rs

@@ -21,11 +21,6 @@ impl Directory {
         self.size
     }
 
-    #[inline]
-    pub fn path(&self) -> &Path {
-        self.name.as_ref()
-    }
-
     pub fn new< P: AsRef<Path> >(path: P, args: &Args) -> Result<Option<Self>> {
         let path = path.as_ref();
         // NOTE: I go back and forth on canonicalize()ing all the time.
@@ -46,6 +41,7 @@ impl Directory {
 
         // symlink_metadata() is the same as metadata() but it doesn't
         // traverse symlinks, so that we can exclude them if necessary
+        // note: sizeof(Metadata) == 176
         let meta = match path.symlink_metadata() {
             Ok(md) => md,
             Err(_) if args.persistant() => return Ok(None),
@@ -66,7 +62,7 @@ impl Directory {
                     return Ok(Some(
                         Self {
                             name,
-                            size: meta.len(),
+                            size: args.len(&meta),
                             children: Vec::new()
                         }
                     ))
@@ -85,7 +81,7 @@ impl Directory {
                 (Err(e), false) => return Err(e),
             };
             size += dir.size;
-            if args.tree() && args.should_print(dir.path()) {
+            if args.tree() && args.should_print(&dir.name) {
                 // since size was increased, this just prevents
                 // the directory from appearing in printing
                 children.push(dir);
@@ -144,7 +140,7 @@ impl Directory {
     pub fn tree(self, unit: Unit) -> String {
         // since self.size is definitionally the greatest value, the tab length
         // is just the length of self.len, plus two for a tab width
-        let tab_size = unit.convert(self.size).len() + 2;
+        let tab_size = unit.convert_with_units(self.size).len() + 2;
         self.vectorise(unit)
             .iter()
             .map(|e| e.stringify_tabbed(tab_size))
@@ -209,7 +205,7 @@ impl TreeEntry {
     }
 
     fn stringify_tabbed(&self, tab_size: usize) -> String {
-        let mut result = format!("{:<tab_size$}", self.unit.convert(self.size));
+        let mut result = format!("{:<tab_size$}", self.unit.convert_with_units(self.size));
 
         for part in self.parts.iter().rev() {
             result += part.display();

src/main.rs

@@ -42,17 +42,17 @@ fn main() -> ExitCode {
             println!(
                 "{}: {}",
                 path,
-                args.unit().convert(dir_structure.size())
+                args.unit().convert_with_units(dir_structure.size())
             );
         }
     }
 
-    let total = args.unit().convert(total);
-
     if args.total() {
+        let total = args.unit().convert_with_units(total);
         println!("total: {total}");
     }
     else if args.minimal() {
+        let total = args.unit().convert(total);
         print!("{total}");
     }
 

src/unit.rs

@@ -34,19 +34,22 @@ impl Unit {
             "blk" | "blks"
             | "blck" |"blcks"
             | "block" | "blocks" => Ok(Self::Blocks),
-            _ => Err(s),
+            _ => Err("use --help to get a list of units".into()),
         }
     }
 
     pub fn convert(self, n: u64) -> String {
-        let n = if self == Self::Blocks {
+        format!("{}", n/self.integer_value())
-            n.next_multiple_of(self.integer_value())
+    }
-        } else {
+    
-            n
+    pub fn convert_with_units(self, n: u64) -> String {
-        };
+        self.convert(n) + self.units_pretty()
-        format!("{}{}", n/self.integer_value(), self.units_pretty())
     }
 
+    /// Units to print for each different unit.
+    /// They all have a space between at the front
+    /// for style reasons, except for bytes which are
+    /// basically unindicated
     const fn units_pretty(self) -> &'static str {
         match self {
             Self::Byte => "",
@@ -62,9 +65,16 @@ impl Unit {
         }
     }
 
+    /// The size is always held in bytes, so
+    /// this returns the scale factor.
+    /// A special case is made for
+    /// blocks, because the number of blocks
+    /// is repeatedly queried throughout
+    /// the search process, it needn't be
+    /// altered here
     const fn integer_value(self) -> u64 {
         match self {
-            Self::Byte => 1,
+            Self::Byte | Self::Blocks => 1,
             Self::Kilo => 1_000,
             Self::Kibi => 1_024,
             Self::Mega => 1_000_000,
@@ -73,7 +83,6 @@ impl Unit {
             Self::Gibi => 1_073_741_824,
             Self::Tera => 1_000_000_000_000,
             Self::Tibi => 1_099_511_627_776,
-            Self::Blocks => 512,
         }
     }
 }