From 09999427ccfb822918fc6969e16d0fc656087ff1 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Thu, 7 Dec 2023 10:02:29 +0100
Subject: [PATCH 1/4] du: merge imports

---
 src/uu/du/src/du.rs | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index dc03a64f218..989e663e46c 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -3,35 +3,30 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use chrono::prelude::DateTime;
-use chrono::Local;
-use clap::ArgAction;
-use clap::{crate_version, Arg, ArgMatches, Command};
+use chrono::{DateTime, Local};
+use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
 use glob::Pattern;
 use std::collections::HashSet;
 use std::env;
-use std::fs;
-use std::fs::File;
+use std::error::Error;
+use std::fmt::Display;
 #[cfg(not(windows))]
 use std::fs::Metadata;
-use std::io::BufRead;
-use std::io::BufReader;
+use std::fs::{self, File};
+use std::io::{BufRead, BufReader};
 #[cfg(not(windows))]
 use std::os::unix::fs::MetadataExt;
 #[cfg(windows)]
 use std::os::windows::fs::MetadataExt;
 #[cfg(windows)]
 use std::os::windows::io::AsRawHandle;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::mpsc;
 use std::thread;
 use std::time::{Duration, UNIX_EPOCH};
-use std::{error::Error, fmt::Display};
 use uucore::display::{print_verbatim, Quotable};
-use uucore::error::FromIo;
-use uucore::error::{UError, UResult, USimpleError};
+use uucore::error::{FromIo, UError, UResult, USimpleError};
 use uucore::line_ending::LineEnding;
 use uucore::parse_glob;
 use uucore::parse_size::{parse_size_u64, ParseSizeError};

From 6cae19156926ef0ca68e1e3657dd51e2066d4e8b Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Thu, 7 Dec 2023 11:06:04 +0100
Subject: [PATCH 2/4] du: remove ArgMatches from StatPrinter

---
 src/uu/du/src/du.rs | 165 ++++++++++++++++++++++----------------------
 1 file changed, 84 insertions(+), 81 deletions(-)

diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index 989e663e46c..26e697abb46 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -87,6 +87,18 @@ struct Options {
     count_links: bool,
     inodes: bool,
     verbose: bool,
+    threshold: Option<Threshold>,
+    apparent_size: bool,
+    // TODO: the size conversion fields should be unified
+    si: bool,
+    bytes: bool,
+    human_readable: bool,
+    block_size_1k: bool,
+    block_size_1m: bool,
+    block_size: u64,
+    time: Option<Time>,
+    time_format: String,
+    line_ending: LineEnding,
 }
 
 #[derive(PartialEq, Clone)]
@@ -96,6 +108,13 @@ enum Deref {
     None,
 }
 
+#[derive(Clone, Copy)]
+enum Time {
+    Accessed,
+    Modified,
+    Created,
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 struct FileInfo {
     file_id: u128,
@@ -273,10 +292,10 @@ fn read_block_size(s: Option<&str>) -> UResult<u64> {
     }
 }
 
-fn choose_size(matches: &ArgMatches, stat: &Stat) -> u64 {
-    if matches.get_flag(options::INODES) {
+fn choose_size(options: &Options, stat: &Stat) -> u64 {
+    if options.inodes {
         stat.inodes
-    } else if matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES) {
+    } else if options.apparent_size || options.bytes {
         stat.size
     } else {
         // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
@@ -423,14 +442,14 @@ fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
     format!("{}", ((size as f64) / (block_size as f64)).ceil())
 }
 
-fn get_convert_size_fn(matches: &ArgMatches) -> Box<dyn Fn(u64, u64, u64) -> String + Send> {
-    if matches.get_flag(options::HUMAN_READABLE) || matches.get_flag(options::SI) {
+fn get_convert_size_fn(options: &Options) -> Box<dyn Fn(u64, u64, u64) -> String + Send> {
+    if options.human_readable || options.si {
         Box::new(convert_size_human)
-    } else if matches.get_flag(options::BYTES) {
+    } else if options.bytes {
         Box::new(convert_size_b)
-    } else if matches.get_flag(options::BLOCK_SIZE_1K) {
+    } else if options.block_size_1k {
         Box::new(convert_size_k)
-    } else if matches.get_flag(options::BLOCK_SIZE_1M) {
+    } else if options.block_size_1m {
         Box::new(convert_size_m)
     } else {
         Box::new(convert_size_other)
@@ -442,7 +461,7 @@ enum DuError {
     InvalidMaxDepthArg(String),
     SummarizeDepthConflict(String),
     InvalidTimeStyleArg(String),
-    InvalidTimeArg(String),
+    InvalidTimeArg,
     InvalidGlob(String),
 }
 
@@ -468,11 +487,9 @@ Try '{} --help' for more information.",
                 s.quote(),
                 uucore::execution_phrase()
             ),
-            Self::InvalidTimeArg(s) => write!(
+            Self::InvalidTimeArg => write!(
                 f,
-                "Invalid argument {} for --time.
-'birth' and 'creation' arguments are not supported on this platform.",
-                s.quote()
+                "'birth' and 'creation' arguments for --time are not supported on this platform.",
             ),
             Self::InvalidGlob(s) => write!(f, "Invalid exclude syntax: {s}"),
         }
@@ -487,7 +504,7 @@ impl UError for DuError {
             Self::InvalidMaxDepthArg(_)
             | Self::SummarizeDepthConflict(_)
             | Self::InvalidTimeStyleArg(_)
-            | Self::InvalidTimeArg(_)
+            | Self::InvalidTimeArg
             | Self::InvalidGlob(_) => 1,
         }
     }
@@ -535,62 +552,25 @@ struct StatPrintInfo {
 }
 
 struct StatPrinter {
-    matches: ArgMatches,
-    threshold: Option<Threshold>,
     summarize: bool,
-    time_format_str: String,
-    line_ending: LineEnding,
     options: Options,
     convert_size: Box<dyn Fn(u64) -> String + Send>,
 }
 
 impl StatPrinter {
-    fn new(matches: ArgMatches, options: Options, summarize: bool) -> UResult<Self> {
-        let block_size = read_block_size(
-            matches
-                .get_one::<String>(options::BLOCK_SIZE)
-                .map(|s| s.as_str()),
-        )?;
-
-        let multiplier: u64 = if matches.get_flag(options::SI) {
-            1000
-        } else {
-            1024
-        };
+    fn new(options: Options, summarize: bool) -> UResult<Self> {
+        let multiplier: u64 = if options.si { 1000 } else { 1024 };
 
-        let convert_size_fn = get_convert_size_fn(&matches);
+        let convert_size_fn = get_convert_size_fn(&options);
 
         let convert_size: Box<dyn Fn(u64) -> String + Send> = if options.inodes {
             Box::new(|size: u64| size.to_string())
         } else {
-            Box::new(move |size: u64| convert_size_fn(size, multiplier, block_size))
-        };
-
-        let threshold = match matches.get_one::<String>(options::THRESHOLD) {
-            Some(s) => match Threshold::from_str(s) {
-                Ok(t) => Some(t),
-                Err(e) => {
-                    return Err(USimpleError::new(
-                        1,
-                        format_error_message(&e, s, options::THRESHOLD),
-                    ))
-                }
-            },
-            None => None,
+            Box::new(move |size: u64| convert_size_fn(size, multiplier, options.block_size))
         };
 
-        let time_format_str =
-            parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?
-                .to_string();
-
-        let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::NULL));
-
         Ok(Self {
-            matches,
-            threshold,
             summarize,
-            time_format_str,
-            line_ending,
             options,
             convert_size,
         })
@@ -604,13 +584,14 @@ impl StatPrinter {
             match received {
                 Ok(message) => match message {
                     Ok(stat_info) => {
-                        let size = choose_size(&self.matches, &stat_info.stat);
+                        let size = choose_size(&self.options, &stat_info.stat);
 
                         if stat_info.depth == 0 {
                             grand_total += size;
                         }
 
                         if !self
+                            .options
                             .threshold
                             .map_or(false, |threshold| threshold.should_exclude(size))
                             && self
@@ -630,31 +611,24 @@ impl StatPrinter {
 
         if self.options.total {
             print!("{}\ttotal", (self.convert_size)(grand_total));
-            print!("{}", self.line_ending);
+            print!("{}", self.options.line_ending);
         }
 
         Ok(())
     }
 
     fn print_stat(&self, stat: &Stat, size: u64) -> UResult<()> {
-        if self.matches.contains_id(options::TIME) {
-            let tm = {
-                let secs = self
-                    .matches
-                    .get_one::<String>(options::TIME)
-                    .map(|s| get_time_secs(s, stat))
-                    .transpose()?
-                    .unwrap_or(stat.modified);
-                DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs))
-            };
-            let time_str = tm.format(&self.time_format_str).to_string();
+        if let Some(time) = self.options.time {
+            let secs = get_time_secs(time, stat)?;
+            let tm = DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs));
+            let time_str = tm.format(&self.options.time_format).to_string();
             print!("{}\t{}\t", (self.convert_size)(size), time_str);
         } else {
             print!("{}\t", (self.convert_size)(size));
         }
 
         print_verbatim(&stat.path).unwrap();
-        print!("{}", self.line_ending);
+        print!("{}", self.options.line_ending);
 
         Ok(())
     }
@@ -685,6 +659,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         None => vec![PathBuf::from(".")],
     };
 
+    let time = matches.contains_id(options::TIME).then(|| {
+        match matches.get_one::<String>(options::TIME).map(AsRef::as_ref) {
+            None | Some("ctime" | "status") => Time::Modified,
+            Some("access" | "atime" | "use") => Time::Accessed,
+            Some("birth" | "creation") => Time::Created,
+            _ => unreachable!("should be caught by clap"),
+        }
+    });
+
+    let block_size = read_block_size(
+        matches
+            .get_one::<String>(options::BLOCK_SIZE)
+            .map(|s| s.as_str()),
+    )?;
+
     let options = Options {
         all: matches.get_flag(options::ALL),
         max_depth,
@@ -702,6 +691,25 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         count_links: matches.get_flag(options::COUNT_LINKS),
         inodes: matches.get_flag(options::INODES),
         verbose: matches.get_flag(options::VERBOSE),
+        si: matches.get_flag(options::SI),
+        threshold: matches
+            .get_one::<String>(options::THRESHOLD)
+            .map(|s| {
+                Threshold::from_str(s).map_err(|e| {
+                    USimpleError::new(1, format_error_message(&e, s, options::THRESHOLD))
+                })
+            })
+            .transpose()?,
+        apparent_size: matches.get_flag(options::APPARENT_SIZE),
+        bytes: matches.get_flag(options::BYTES),
+        time,
+        block_size,
+        human_readable: matches.get_flag(options::HUMAN_READABLE),
+        block_size_1k: matches.get_flag(options::BLOCK_SIZE_1K),
+        block_size_1m: matches.get_flag(options::BLOCK_SIZE_1M),
+        time_format: parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?
+            .to_string(),
+        line_ending: LineEnding::from_zero_flag(matches.get_flag(options::NULL)),
     };
 
     if options.inodes
@@ -711,7 +719,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     // Use separate thread to print output, so we can print finished results while computation is still running
-    let stat_printer = StatPrinter::new(matches.clone(), options.clone(), summarize)?;
+    let stat_printer = StatPrinter::new(options.clone(), summarize)?;
     let (print_tx, rx) = mpsc::channel::<UResult<StatPrintInfo>>();
     let printing_thread = thread::spawn(move || stat_printer.print_stats(&rx));
 
@@ -767,17 +775,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-fn get_time_secs(s: &str, stat: &Stat) -> Result<u64, DuError> {
-    let secs = match s {
-        "ctime" | "status" => stat.modified,
-        "access" | "atime" | "use" => stat.accessed,
-        "birth" | "creation" => stat
-            .created
-            .ok_or_else(|| DuError::InvalidTimeArg(s.into()))?,
-        // below should never happen as clap already restricts the values.
-        _ => unreachable!("Invalid field for --time"),
-    };
-    Ok(secs)
+fn get_time_secs(time: Time, stat: &Stat) -> Result<u64, DuError> {
+    match time {
+        Time::Modified => Ok(stat.modified),
+        Time::Accessed => Ok(stat.accessed),
+        Time::Created => stat.created.ok_or_else(|| DuError::InvalidTimeArg),
+    }
 }
 
 fn parse_time_style(s: Option<&str>) -> UResult<&str> {

From d6b10d4d720df1dfb85340ed7cda531c0e8b45bf Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Thu, 7 Dec 2023 11:26:44 +0100
Subject: [PATCH 3/4] du: split traversal and printing options

---
 src/uu/du/src/du.rs | 57 ++++++++++++++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 22 deletions(-)

diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index 26e697abb46..14c7fe5d4b3 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -76,17 +76,20 @@ const USAGE: &str = help_usage!("du.md");
 // TODO: Support Z & Y (currently limited by size of u64)
 const UNITS: [(char, u32); 6] = [('E', 6), ('P', 5), ('T', 4), ('G', 3), ('M', 2), ('K', 1)];
 
-#[derive(Clone)]
-struct Options {
+struct TraversalOptions {
     all: bool,
-    max_depth: Option<usize>,
-    total: bool,
     separate_dirs: bool,
     one_file_system: bool,
     dereference: Deref,
     count_links: bool,
-    inodes: bool,
     verbose: bool,
+}
+
+#[derive(Clone)]
+struct PrintingOptions {
+    total: bool,
+    inodes: bool,
+    max_depth: Option<usize>,
     threshold: Option<Threshold>,
     apparent_size: bool,
     // TODO: the size conversion fields should be unified
@@ -134,7 +137,7 @@ struct Stat {
 }
 
 impl Stat {
-    fn new(path: &Path, options: &Options) -> std::io::Result<Self> {
+    fn new(path: &Path, options: &TraversalOptions) -> std::io::Result<Self> {
         // Determine whether to dereference (follow) the symbolic link
         let should_dereference = match &options.dereference {
             Deref::All => true,
@@ -292,7 +295,7 @@ fn read_block_size(s: Option<&str>) -> UResult<u64> {
     }
 }
 
-fn choose_size(options: &Options, stat: &Stat) -> u64 {
+fn choose_size(options: &PrintingOptions, stat: &Stat) -> u64 {
     if options.inodes {
         stat.inodes
     } else if options.apparent_size || options.bytes {
@@ -308,7 +311,7 @@ fn choose_size(options: &Options, stat: &Stat) -> u64 {
 #[allow(clippy::cognitive_complexity)]
 fn du(
     mut my_stat: Stat,
-    options: &Options,
+    options: &TraversalOptions,
     depth: usize,
     seen_inodes: &mut HashSet<FileInfo>,
     exclude: &[Pattern],
@@ -442,7 +445,7 @@ fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
     format!("{}", ((size as f64) / (block_size as f64)).ceil())
 }
 
-fn get_convert_size_fn(options: &Options) -> Box<dyn Fn(u64, u64, u64) -> String + Send> {
+fn get_convert_size_fn(options: &PrintingOptions) -> Box<dyn Fn(u64, u64, u64) -> String + Send> {
     if options.human_readable || options.si {
         Box::new(convert_size_human)
     } else if options.bytes {
@@ -553,12 +556,12 @@ struct StatPrintInfo {
 
 struct StatPrinter {
     summarize: bool,
-    options: Options,
+    options: PrintingOptions,
     convert_size: Box<dyn Fn(u64) -> String + Send>,
 }
 
 impl StatPrinter {
-    fn new(options: Options, summarize: bool) -> UResult<Self> {
+    fn new(options: PrintingOptions, summarize: bool) -> UResult<Self> {
         let multiplier: u64 = if options.si { 1000 } else { 1024 };
 
         let convert_size_fn = get_convert_size_fn(&options);
@@ -674,10 +677,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             .map(|s| s.as_str()),
     )?;
 
-    let options = Options {
+    let traversal_options = TraversalOptions {
         all: matches.get_flag(options::ALL),
-        max_depth,
-        total: matches.get_flag(options::TOTAL),
         separate_dirs: matches.get_flag(options::SEPARATE_DIRS),
         one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
         dereference: if matches.get_flag(options::DEREFERENCE) {
@@ -689,8 +690,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             Deref::None
         },
         count_links: matches.get_flag(options::COUNT_LINKS),
-        inodes: matches.get_flag(options::INODES),
         verbose: matches.get_flag(options::VERBOSE),
+    };
+
+    let printing_options = PrintingOptions {
+        max_depth,
+        total: matches.get_flag(options::TOTAL),
+        inodes: matches.get_flag(options::INODES),
         si: matches.get_flag(options::SI),
         threshold: matches
             .get_one::<String>(options::THRESHOLD)
@@ -712,14 +718,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         line_ending: LineEnding::from_zero_flag(matches.get_flag(options::NULL)),
     };
 
-    if options.inodes
+    if printing_options.inodes
         && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
     {
         show_warning!("options --apparent-size and -b are ineffective with --inodes");
     }
 
     // Use separate thread to print output, so we can print finished results while computation is still running
-    let stat_printer = StatPrinter::new(options.clone(), summarize)?;
+    let stat_printer = StatPrinter::new(printing_options.clone(), summarize)?;
     let (print_tx, rx) = mpsc::channel::<UResult<StatPrintInfo>>();
     let printing_thread = thread::spawn(move || stat_printer.print_stats(&rx));
 
@@ -732,7 +738,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             for pattern in &excludes {
                 if pattern.matches(&path_string) {
                     // if the directory is ignored, leave early
-                    if options.verbose {
+                    if traversal_options.verbose {
                         println!("{} ignored", path_string.quote());
                     }
                     continue 'loop_file;
@@ -741,14 +747,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
 
         // Check existence of path provided in argument
-        if let Ok(stat) = Stat::new(&path, &options) {
+        if let Ok(stat) = Stat::new(&path, &traversal_options) {
             // Kick off the computation of disk usage from the initial path
             let mut seen_inodes: HashSet<FileInfo> = HashSet::new();
             if let Some(inode) = stat.inode {
                 seen_inodes.insert(inode);
             }
-            let stat = du(stat, &options, 0, &mut seen_inodes, &excludes, &print_tx)
-                .map_err(|e| USimpleError::new(1, e.to_string()))?;
+            let stat = du(
+                stat,
+                &traversal_options,
+                0,
+                &mut seen_inodes,
+                &excludes,
+                &print_tx,
+            )
+            .map_err(|e| USimpleError::new(1, e.to_string()))?;
 
             print_tx
                 .send(Ok(StatPrintInfo { stat, depth: 0 }))
@@ -779,7 +792,7 @@ fn get_time_secs(time: Time, stat: &Stat) -> Result<u64, DuError> {
     match time {
         Time::Modified => Ok(stat.modified),
         Time::Accessed => Ok(stat.accessed),
-        Time::Created => stat.created.ok_or_else(|| DuError::InvalidTimeArg),
+        Time::Created => stat.created.ok_or(DuError::InvalidTimeArg),
     }
 }
 

From 7861559f880e6fff3576bf4ac00afbf0d5489807 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Thu, 7 Dec 2023 11:58:11 +0100
Subject: [PATCH 4/4] du: put excludes in traversaloptions and make size_format
 enum

---
 src/uu/du/src/du.rs | 223 +++++++++++++++++---------------------------
 1 file changed, 86 insertions(+), 137 deletions(-)

diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index 14c7fe5d4b3..7114ccc2668 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -83,25 +83,20 @@ struct TraversalOptions {
     dereference: Deref,
     count_links: bool,
     verbose: bool,
+    excludes: Vec<Pattern>,
 }
 
-#[derive(Clone)]
-struct PrintingOptions {
+struct StatPrinter {
     total: bool,
     inodes: bool,
     max_depth: Option<usize>,
     threshold: Option<Threshold>,
     apparent_size: bool,
-    // TODO: the size conversion fields should be unified
-    si: bool,
-    bytes: bool,
-    human_readable: bool,
-    block_size_1k: bool,
-    block_size_1m: bool,
-    block_size: u64,
+    size_format: SizeFormat,
     time: Option<Time>,
     time_format: String,
     line_ending: LineEnding,
+    summarize: bool,
 }
 
 #[derive(PartialEq, Clone)]
@@ -118,6 +113,12 @@ enum Time {
     Created,
 }
 
+#[derive(Clone)]
+enum SizeFormat {
+    Human(u64),
+    BlockSize(u64),
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 struct FileInfo {
     file_id: u128,
@@ -295,18 +296,6 @@ fn read_block_size(s: Option<&str>) -> UResult<u64> {
     }
 }
 
-fn choose_size(options: &PrintingOptions, stat: &Stat) -> u64 {
-    if options.inodes {
-        stat.inodes
-    } else if options.apparent_size || options.bytes {
-        stat.size
-    } else {
-        // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
-        // See: http://linux.die.net/man/2/stat
-        stat.blocks * 512
-    }
-}
-
 // this takes `my_stat` to avoid having to stat files multiple times.
 #[allow(clippy::cognitive_complexity)]
 fn du(
@@ -314,7 +303,6 @@ fn du(
     options: &TraversalOptions,
     depth: usize,
     seen_inodes: &mut HashSet<FileInfo>,
-    exclude: &[Pattern],
     print_tx: &mpsc::Sender<UResult<StatPrintInfo>>,
 ) -> Result<Stat, Box<mpsc::SendError<UResult<StatPrintInfo>>>> {
     if my_stat.is_dir {
@@ -334,7 +322,7 @@ fn du(
                     match Stat::new(&entry.path(), options) {
                         Ok(this_stat) => {
                             // We have an exclude list
-                            for pattern in exclude {
+                            for pattern in &options.excludes {
                                 // Look at all patterns with both short and long paths
                                 // if we have 'du foo' but search to exclude 'foo/bar'
                                 // we need the full path
@@ -370,14 +358,8 @@ fn du(
                                     }
                                 }
 
-                                let this_stat = du(
-                                    this_stat,
-                                    options,
-                                    depth + 1,
-                                    seen_inodes,
-                                    exclude,
-                                    print_tx,
-                                )?;
+                                let this_stat =
+                                    du(this_stat, options, depth + 1, seen_inodes, print_tx)?;
 
                                 if !options.separate_dirs {
                                     my_stat.size += this_stat.size;
@@ -413,52 +395,6 @@ fn du(
     Ok(my_stat)
 }
 
-fn convert_size_human(size: u64, multiplier: u64, _block_size: u64) -> String {
-    for &(unit, power) in &UNITS {
-        let limit = multiplier.pow(power);
-        if size >= limit {
-            return format!("{:.1}{}", (size as f64) / (limit as f64), unit);
-        }
-    }
-    if size == 0 {
-        return "0".to_string();
-    }
-    format!("{size}B")
-}
-
-fn convert_size_b(size: u64, _multiplier: u64, _block_size: u64) -> String {
-    format!("{}", ((size as f64) / (1_f64)).ceil())
-}
-
-fn convert_size_k(size: u64, multiplier: u64, _block_size: u64) -> String {
-    format!("{}", ((size as f64) / (multiplier as f64)).ceil())
-}
-
-fn convert_size_m(size: u64, multiplier: u64, _block_size: u64) -> String {
-    format!(
-        "{}",
-        ((size as f64) / ((multiplier * multiplier) as f64)).ceil()
-    )
-}
-
-fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
-    format!("{}", ((size as f64) / (block_size as f64)).ceil())
-}
-
-fn get_convert_size_fn(options: &PrintingOptions) -> Box<dyn Fn(u64, u64, u64) -> String + Send> {
-    if options.human_readable || options.si {
-        Box::new(convert_size_human)
-    } else if options.bytes {
-        Box::new(convert_size_b)
-    } else if options.block_size_1k {
-        Box::new(convert_size_k)
-    } else if options.block_size_1m {
-        Box::new(convert_size_m)
-    } else {
-        Box::new(convert_size_other)
-    }
-}
-
 #[derive(Debug)]
 enum DuError {
     InvalidMaxDepthArg(String),
@@ -554,29 +490,17 @@ struct StatPrintInfo {
     depth: usize,
 }
 
-struct StatPrinter {
-    summarize: bool,
-    options: PrintingOptions,
-    convert_size: Box<dyn Fn(u64) -> String + Send>,
-}
-
 impl StatPrinter {
-    fn new(options: PrintingOptions, summarize: bool) -> UResult<Self> {
-        let multiplier: u64 = if options.si { 1000 } else { 1024 };
-
-        let convert_size_fn = get_convert_size_fn(&options);
-
-        let convert_size: Box<dyn Fn(u64) -> String + Send> = if options.inodes {
-            Box::new(|size: u64| size.to_string())
+    fn choose_size(&self, stat: &Stat) -> u64 {
+        if self.inodes {
+            stat.inodes
+        } else if self.apparent_size {
+            stat.size
         } else {
-            Box::new(move |size: u64| convert_size_fn(size, multiplier, options.block_size))
-        };
-
-        Ok(Self {
-            summarize,
-            options,
-            convert_size,
-        })
+            // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
+            // See: http://linux.die.net/man/2/stat
+            stat.blocks * 512
+        }
     }
 
     fn print_stats(&self, rx: &mpsc::Receiver<UResult<StatPrintInfo>>) -> UResult<()> {
@@ -587,18 +511,16 @@ impl StatPrinter {
             match received {
                 Ok(message) => match message {
                     Ok(stat_info) => {
-                        let size = choose_size(&self.options, &stat_info.stat);
+                        let size = self.choose_size(&stat_info.stat);
 
                         if stat_info.depth == 0 {
                             grand_total += size;
                         }
 
                         if !self
-                            .options
                             .threshold
                             .map_or(false, |threshold| threshold.should_exclude(size))
                             && self
-                                .options
                                 .max_depth
                                 .map_or(true, |max_depth| stat_info.depth <= max_depth)
                             && (!self.summarize || stat_info.depth == 0)
@@ -612,31 +534,59 @@ impl StatPrinter {
             }
         }
 
-        if self.options.total {
-            print!("{}\ttotal", (self.convert_size)(grand_total));
-            print!("{}", self.options.line_ending);
+        if self.total {
+            print!("{}\ttotal", self.convert_size(grand_total));
+            print!("{}", self.line_ending);
         }
 
         Ok(())
     }
 
+    fn convert_size(&self, size: u64) -> String {
+        if self.inodes {
+            return size.to_string();
+        }
+        match self.size_format {
+            SizeFormat::Human(multiplier) => {
+                if size == 0 {
+                    return "0".to_string();
+                }
+                for &(unit, power) in &UNITS {
+                    let limit = multiplier.pow(power);
+                    if size >= limit {
+                        return format!("{:.1}{}", (size as f64) / (limit as f64), unit);
+                    }
+                }
+                format!("{size}B")
+            }
+            SizeFormat::BlockSize(block_size) => div_ceil(size, block_size).to_string(),
+        }
+    }
+
     fn print_stat(&self, stat: &Stat, size: u64) -> UResult<()> {
-        if let Some(time) = self.options.time {
+        if let Some(time) = self.time {
             let secs = get_time_secs(time, stat)?;
             let tm = DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs));
-            let time_str = tm.format(&self.options.time_format).to_string();
-            print!("{}\t{}\t", (self.convert_size)(size), time_str);
+            let time_str = tm.format(&self.time_format).to_string();
+            print!("{}\t{}\t", self.convert_size(size), time_str);
         } else {
-            print!("{}\t", (self.convert_size)(size));
+            print!("{}\t", self.convert_size(size));
         }
 
         print_verbatim(&stat.path).unwrap();
-        print!("{}", self.options.line_ending);
+        print!("{}", self.line_ending);
 
         Ok(())
     }
 }
 
+// This can be replaced with u64::div_ceil once it is stabilized.
+// This implementation approach is optimized for when `b` is a constant,
+// particularly a power of two.
+pub fn div_ceil(a: u64, b: u64) -> u64 {
+    (a + b - 1) / b
+}
+
 #[uucore::main]
 #[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
@@ -671,11 +621,23 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     });
 
-    let block_size = read_block_size(
-        matches
-            .get_one::<String>(options::BLOCK_SIZE)
-            .map(|s| s.as_str()),
-    )?;
+    let size_format = if matches.get_flag(options::HUMAN_READABLE) {
+        SizeFormat::Human(1024)
+    } else if matches.get_flag(options::SI) {
+        SizeFormat::Human(1000)
+    } else if matches.get_flag(options::BYTES) {
+        SizeFormat::BlockSize(1)
+    } else if matches.get_flag(options::BLOCK_SIZE_1K) {
+        SizeFormat::BlockSize(1024)
+    } else if matches.get_flag(options::BLOCK_SIZE_1M) {
+        SizeFormat::BlockSize(1024 * 1024)
+    } else {
+        SizeFormat::BlockSize(read_block_size(
+            matches
+                .get_one::<String>(options::BLOCK_SIZE)
+                .map(AsRef::as_ref),
+        )?)
+    };
 
     let traversal_options = TraversalOptions {
         all: matches.get_flag(options::ALL),
@@ -691,13 +653,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         },
         count_links: matches.get_flag(options::COUNT_LINKS),
         verbose: matches.get_flag(options::VERBOSE),
+        excludes: build_exclude_patterns(&matches)?,
     };
 
-    let printing_options = PrintingOptions {
+    let stat_printer = StatPrinter {
         max_depth,
+        size_format,
+        summarize,
         total: matches.get_flag(options::TOTAL),
         inodes: matches.get_flag(options::INODES),
-        si: matches.get_flag(options::SI),
         threshold: matches
             .get_one::<String>(options::THRESHOLD)
             .map(|s| {
@@ -706,36 +670,28 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 })
             })
             .transpose()?,
-        apparent_size: matches.get_flag(options::APPARENT_SIZE),
-        bytes: matches.get_flag(options::BYTES),
+        apparent_size: matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES),
         time,
-        block_size,
-        human_readable: matches.get_flag(options::HUMAN_READABLE),
-        block_size_1k: matches.get_flag(options::BLOCK_SIZE_1K),
-        block_size_1m: matches.get_flag(options::BLOCK_SIZE_1M),
         time_format: parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?
             .to_string(),
         line_ending: LineEnding::from_zero_flag(matches.get_flag(options::NULL)),
     };
 
-    if printing_options.inodes
+    if stat_printer.inodes
         && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
     {
         show_warning!("options --apparent-size and -b are ineffective with --inodes");
     }
 
     // Use separate thread to print output, so we can print finished results while computation is still running
-    let stat_printer = StatPrinter::new(printing_options.clone(), summarize)?;
     let (print_tx, rx) = mpsc::channel::<UResult<StatPrintInfo>>();
     let printing_thread = thread::spawn(move || stat_printer.print_stats(&rx));
 
-    let excludes = build_exclude_patterns(&matches)?;
-
     'loop_file: for path in files {
         // Skip if we don't want to ignore anything
-        if !&excludes.is_empty() {
+        if !&traversal_options.excludes.is_empty() {
             let path_string = path.to_string_lossy();
-            for pattern in &excludes {
+            for pattern in &traversal_options.excludes {
                 if pattern.matches(&path_string) {
                     // if the directory is ignored, leave early
                     if traversal_options.verbose {
@@ -753,15 +709,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             if let Some(inode) = stat.inode {
                 seen_inodes.insert(inode);
             }
-            let stat = du(
-                stat,
-                &traversal_options,
-                0,
-                &mut seen_inodes,
-                &excludes,
-                &print_tx,
-            )
-            .map_err(|e| USimpleError::new(1, e.to_string()))?;
+            let stat = du(stat, &traversal_options, 0, &mut seen_inodes, &print_tx)
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
 
             print_tx
                 .send(Ok(StatPrintInfo { stat, depth: 0 }))