From 101e64d35eb122669ed02a15dd0d960d19e25678 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Thu, 18 May 2023 00:14:17 -0700
Subject: [PATCH 1/7] beginning of file size refactor

---
 src/disk_usage/block.rs     |  0
 src/disk_usage/file_size.rs | 40 +++++++++----------
 src/disk_usage/logical.rs   | 77 +++++++++++++++++++++++++++++++++++++
 src/disk_usage/mod.rs       | 50 +++++++++++++++++++++++-
 src/disk_usage/physical.rs  | 68 ++++++++++++++++++++++++++++++++
 src/tree/mod.rs             |  2 +-
 src/tree/node/cmp.rs        |  4 +-
 7 files changed, 217 insertions(+), 24 deletions(-)
 create mode 100644 src/disk_usage/block.rs
 create mode 100644 src/disk_usage/logical.rs
 create mode 100644 src/disk_usage/physical.rs

diff --git a/src/disk_usage/block.rs b/src/disk_usage/block.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/src/disk_usage/file_size.rs b/src/disk_usage/file_size.rs
index 7305e8ed..d7a1efb8 100644
--- a/src/disk_usage/file_size.rs
+++ b/src/disk_usage/file_size.rs
@@ -11,7 +11,7 @@ use std::{borrow::Cow, fs::Metadata, ops::AddAssign, path::Path};
 /// Represents either logical or physical size and handles presentation.
 #[derive(Clone, Debug)]
 pub struct FileSize {
-    pub bytes: u64,
+    pub value: u64,
     #[allow(dead_code)]
     disk_usage: DiskUsage,
     prefix_kind: PrefixKind,
@@ -34,7 +34,7 @@ pub enum DiskUsage {
     /// How many bytes does a file contain
     Logical,
 
-    /// How much actual space on disk, taking into account sparse files and compression.
+    /// How much actual space on disk in bytes, taking into account sparse files and compression.
     #[default]
     Physical,
 }
@@ -42,13 +42,13 @@ pub enum DiskUsage {
 impl FileSize {
     /// Initializes a [`FileSize`].
     pub const fn new(
-        bytes: u64,
+        value: u64,
         disk_usage: DiskUsage,
         human_readable: bool,
         prefix_kind: PrefixKind,
     ) -> Self {
         Self {
-            bytes,
+            value,
             disk_usage,
             human_readable,
             prefix_kind,
@@ -84,22 +84,22 @@ impl FileSize {
     /// Precompute the raw (unpadded) display and sets the number of columns the size (without
     /// the prefix) will occupy. Also sets the [Style] to use in advance to style the size output.
     pub fn precompute_unpadded_display(&mut self) {
-        let fbytes = self.bytes as f64;
+        let value = self.value as f64;
 
         match self.prefix_kind {
             PrefixKind::Si => {
-                let unit = SiPrefix::from(fbytes);
+                let unit = SiPrefix::from(value);
                 let base_value = unit.base_value();
 
                 if !self.human_readable {
-                    self.unpadded_display = Some(format!("{} B", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
+                    self.unpadded_display = Some(format!("{} B", self.value));
+                    self.size_columns = utils::num_integral(self.value);
                 } else if matches!(unit, SiPrefix::Base) {
-                    self.unpadded_display = Some(format!("{} {unit}", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
+                    self.unpadded_display = Some(format!("{} {unit}", self.value));
+                    self.size_columns = utils::num_integral(self.value);
                     self.uses_base_unit = Some(());
                 } else {
-                    let size = fbytes / (base_value as f64);
+                    let size = value / (base_value as f64);
                     self.unpadded_display = Some(format!("{size:.2} {unit}"));
                     self.size_columns = utils::num_integral((size * 100.0).floor() as u64) + 1;
                 }
@@ -110,18 +110,18 @@ impl FileSize {
                 }
             }
             PrefixKind::Bin => {
-                let unit = BinPrefix::from(fbytes);
+                let unit = BinPrefix::from(value);
                 let base_value = unit.base_value();
 
                 if !self.human_readable {
-                    self.unpadded_display = Some(format!("{} B", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
+                    self.unpadded_display = Some(format!("{} B", self.value));
+                    self.size_columns = utils::num_integral(self.value);
                 } else if matches!(unit, BinPrefix::Base) {
-                    self.unpadded_display = Some(format!("{} {unit}", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
+                    self.unpadded_display = Some(format!("{} {unit}", self.value));
+                    self.size_columns = utils::num_integral(self.value);
                     self.uses_base_unit = Some(());
                 } else {
-                    let size = fbytes / (base_value as f64);
+                    let size = value / (base_value as f64);
                     self.unpadded_display = Some(format!("{size:.2} {unit}"));
                     self.size_columns = utils::num_integral((size * 100.0).floor() as u64) + 1;
                 }
@@ -144,13 +144,13 @@ impl FileSize {
             if self.uses_base_unit.is_some() {
                 format!(
                     "{:>max_size_width$} {unit:>max_size_unit_width$}",
-                    self.bytes
+                    self.value
                 )
             } else {
                 format!("{size:>max_size_width$} {unit:>max_size_unit_width$}")
             }
         } else {
-            format!("{:<max_size_width$} B", self.bytes)
+            format!("{:<max_size_width$} B", self.value)
         };
 
         if let Some(style) = self.style {
@@ -186,6 +186,6 @@ impl FileSize {
 
 impl AddAssign<&Self> for FileSize {
     fn add_assign(&mut self, rhs: &Self) {
-        self.bytes += rhs.bytes;
+        self.value += rhs.value;
     }
 }
diff --git a/src/disk_usage/logical.rs b/src/disk_usage/logical.rs
new file mode 100644
index 00000000..6818cd49
--- /dev/null
+++ b/src/disk_usage/logical.rs
@@ -0,0 +1,77 @@
+use super::{
+    ByteDisplay,
+    DuMetric,
+    units::PrefixKind,
+};
+use std::{
+    fmt::{self, Display},
+    fs::Metadata,
+};
+
+pub struct Size {
+    pub value: u64,
+    pub prefix_kind: PrefixKind,
+    pub human_readable: bool,
+}
+
+impl DuMetric for Size {}
+
+impl Size {
+    pub fn new(metadata: &Metadata, prefix_kind: PrefixKind, human_readable: bool) -> Self {
+        let value = metadata.len();
+
+        Self {
+            value,
+            prefix_kind,
+            human_readable,
+        }
+    }
+}
+
+impl ByteDisplay for Size {
+    fn human_readable(&self) -> bool {
+        self.human_readable
+    }
+
+    fn prefix_kind(&self) -> PrefixKind {
+        self.prefix_kind
+    }
+
+    fn value(&self) -> u64 {
+        self.value
+    }
+}
+
+impl Display for Size {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <Self as ByteDisplay>::fmt(self, f)
+    }
+}
+
+#[test]
+fn test_logical_size() -> std::io::Result<()> {
+    use std::fs;
+
+    let md = fs::metadata("./tests/data/nemesis.txt")?;
+
+    let logical_size = Size::new(&md, PrefixKind::Bin, false);
+
+    let display = format!("{logical_size}");
+
+    assert_eq!(logical_size.value, 161);
+    assert_eq!(display, "161 B");
+
+    assert_eq!(
+        format!(
+            "{}",
+            Size {
+                value: 1_024,
+                prefix_kind: PrefixKind::Bin,
+                human_readable: true
+            }
+        ),
+        "1.00 KiB"
+    );
+
+    Ok(())
+}
diff --git a/src/disk_usage/mod.rs b/src/disk_usage/mod.rs
index 5c325e2e..ba94ac2e 100644
--- a/src/disk_usage/mod.rs
+++ b/src/disk_usage/mod.rs
@@ -1,5 +1,53 @@
+use std::fmt;
+use units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
+
 /// Binary and SI prefixes
 pub mod units;
 
-/// Rules to display disk usage for individual files
+/// Rules to display disk usage for individual files.
 pub mod file_size;
+
+pub mod block;
+
+pub mod logical;
+
+pub mod physical;
+
+pub trait DuMetric {}
+
+pub trait ByteDisplay {
+    fn prefix_kind(&self) -> PrefixKind;
+
+    fn value(&self) -> u64;
+
+    fn human_readable(&self) -> bool;
+
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = self.value() as f64;
+
+        match self.prefix_kind() {
+            PrefixKind::Si => {
+                let unit = SiPrefix::from(value);
+                let base_value = unit.base_value();
+
+                if !self.human_readable() || matches!(unit, SiPrefix::Base) {
+                    write!(f, "{} {unit}", self.value())
+                } else {
+                    let size = value / (base_value as f64);
+                    write!(f, "{size:.2} {unit}")
+                }
+            }
+            PrefixKind::Bin => {
+                let unit = BinPrefix::from(value);
+                let base_value = unit.base_value();
+
+                if !self.human_readable() || matches!(unit, BinPrefix::Base) {
+                    write!(f, "{} {unit}", self.value())
+                } else {
+                    let size = value / (base_value as f64);
+                    write!(f, "{size:.2} {unit}")
+                }
+            }
+        }
+    }
+}
diff --git a/src/disk_usage/physical.rs b/src/disk_usage/physical.rs
new file mode 100644
index 00000000..d31174bf
--- /dev/null
+++ b/src/disk_usage/physical.rs
@@ -0,0 +1,68 @@
+use filesize::PathExt;
+use super::{
+    units::PrefixKind,
+    ByteDisplay,
+    DuMetric,
+};
+use std::{
+    path::Path,
+    fmt::{self, Display},
+    fs::Metadata,
+};
+
+pub struct Size {
+    pub value: u64,
+    pub prefix_kind: PrefixKind,
+    pub human_readable: bool,
+}
+
+impl DuMetric for Size {}
+
+impl Size {
+    pub fn new(path: &Path, metadata: &Metadata, prefix_kind: PrefixKind, human_readable: bool) -> Self {
+        let value = path.size_on_disk_fast(metadata).unwrap_or(0);
+
+        Self {
+            value,
+            prefix_kind,
+            human_readable,
+        }
+    }
+}
+
+impl ByteDisplay for Size {
+    fn human_readable(&self) -> bool {
+        self.human_readable
+    }
+
+    fn prefix_kind(&self) -> PrefixKind {
+        self.prefix_kind
+    }
+
+    fn value(&self) -> u64 {
+        self.value
+    }
+}
+
+impl Display for Size {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <Self as ByteDisplay>::fmt(self, f)
+    }
+}
+
+#[test]
+fn test_physical_size() -> std::io::Result<()> {
+    assert_eq!(
+        format!(
+            "{}",
+            Size {
+                value: 1_024,
+                prefix_kind: PrefixKind::Bin,
+                human_readable: true
+            }
+        ),
+        "1.00 KiB"
+    );
+
+    Ok(())
+}
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index e5d4939c..02a99ae5 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -228,7 +228,7 @@ impl Tree {
             }
         }
 
-        if dir_size.bytes > 0 {
+        if dir_size.value > 0 {
             let dir = tree[current_node_id].get_mut();
 
             dir_size.precompute_unpadded_display();
diff --git a/src/tree/node/cmp.rs b/src/tree/node/cmp.rs
index d9e371dd..78613f73 100644
--- a/src/tree/node/cmp.rs
+++ b/src/tree/node/cmp.rs
@@ -132,8 +132,8 @@ mod sizing {
 
     /// Comparator that sorts [Node]s by size, largest to smallest.
     pub fn comparator(a: &Node, b: &Node) -> Ordering {
-        let a_size = a.file_size().map_or(0, |fs| fs.bytes);
-        let b_size = b.file_size().map_or(0, |fs| fs.bytes);
+        let a_size = a.file_size().map_or(0, |fs| fs.value);
+        let b_size = b.file_size().map_or(0, |fs| fs.value);
         b_size.cmp(&a_size)
     }
     /// Comparator that sorts [Node]s by size, smallest to largest.

From a1abab5f013dcc8ca416d8eb50f54fd386a8b6bb Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sun, 21 May 2023 21:07:53 -0700
Subject: [PATCH 2/7] refactor file size

---
 src/context/output.rs                  |   5 +-
 src/disk_usage/block.rs                |   0
 src/disk_usage/file_size.rs            | 191 -------------------------
 src/disk_usage/file_size/block.rs      |   3 +
 src/disk_usage/file_size/byte.rs       | 163 +++++++++++++++++++++
 src/disk_usage/file_size/line_count.rs |   3 +
 src/disk_usage/file_size/mod.rs        |  51 +++++++
 src/disk_usage/file_size/word_count.rs |   3 +
 src/disk_usage/logical.rs              |  77 ----------
 src/disk_usage/mod.rs                  |  49 -------
 src/disk_usage/physical.rs             |  68 ---------
 src/disk_usage/units.rs                |  12 +-
 src/icons/fs.rs                        |  95 ++++++++++++
 src/{icons.rs => icons/mod.rs}         |  97 +------------
 src/render/grid/cell.rs                |  54 ++++++-
 src/render/theme.rs                    |   3 +-
 src/tree/mod.rs                        |  61 ++++++--
 src/tree/node/cmp.rs                   |   5 +-
 src/tree/node/mod.rs                   |  19 ++-
 tests/dirs_only.rs                     |  10 +-
 tests/flat.rs                          |  58 ++++----
 tests/glob.rs                          |  70 ++++-----
 tests/hardlink.rs                      |   6 +-
 tests/level.rs                         |  16 +--
 tests/prune.rs                         |  18 +--
 tests/regex.rs                         |  34 ++---
 tests/sort.rs                          |  88 ++++++------
 tests/suppress_size.rs                 |  20 +--
 28 files changed, 599 insertions(+), 680 deletions(-)
 delete mode 100644 src/disk_usage/block.rs
 delete mode 100644 src/disk_usage/file_size.rs
 create mode 100644 src/disk_usage/file_size/block.rs
 create mode 100644 src/disk_usage/file_size/byte.rs
 create mode 100644 src/disk_usage/file_size/line_count.rs
 create mode 100644 src/disk_usage/file_size/mod.rs
 create mode 100644 src/disk_usage/file_size/word_count.rs
 delete mode 100644 src/disk_usage/logical.rs
 delete mode 100644 src/disk_usage/physical.rs
 create mode 100644 src/icons/fs.rs
 rename src/{icons.rs => icons/mod.rs} (88%)

diff --git a/src/context/output.rs b/src/context/output.rs
index 8b7582b2..79f6c680 100644
--- a/src/context/output.rs
+++ b/src/context/output.rs
@@ -20,8 +20,9 @@ pub struct ColumnProperties {
 impl From<&Context> for ColumnProperties {
     fn from(ctx: &Context) -> Self {
         let unit_width = match ctx.unit {
-            PrefixKind::Si => 2,
-            PrefixKind::Bin => 3,
+            PrefixKind::Bin if ctx.human => 3,
+            PrefixKind::Si if ctx.human => 2,
+            _ => 1,
         };
 
         Self {
diff --git a/src/disk_usage/block.rs b/src/disk_usage/block.rs
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/disk_usage/file_size.rs b/src/disk_usage/file_size.rs
deleted file mode 100644
index d7a1efb8..00000000
--- a/src/disk_usage/file_size.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-use super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
-use crate::{
-    styles::{self, get_du_theme, get_placeholder_style},
-    utils, Context,
-};
-use ansi_term::Style;
-use clap::ValueEnum;
-use filesize::PathExt;
-use std::{borrow::Cow, fs::Metadata, ops::AddAssign, path::Path};
-
-/// Represents either logical or physical size and handles presentation.
-#[derive(Clone, Debug)]
-pub struct FileSize {
-    pub value: u64,
-    #[allow(dead_code)]
-    disk_usage: DiskUsage,
-    prefix_kind: PrefixKind,
-    human_readable: bool,
-    unpadded_display: Option<String>,
-
-    // Precomputed style to use
-    style: Option<&'static Style>,
-
-    // Does this file size use `B` without a prefix?
-    uses_base_unit: Option<()>,
-
-    // How many columns are required for the size (without prefix).
-    pub size_columns: usize,
-}
-
-/// Determines between logical or physical size for display
-#[derive(Copy, Clone, Debug, ValueEnum, Default)]
-pub enum DiskUsage {
-    /// How many bytes does a file contain
-    Logical,
-
-    /// How much actual space on disk in bytes, taking into account sparse files and compression.
-    #[default]
-    Physical,
-}
-
-impl FileSize {
-    /// Initializes a [`FileSize`].
-    pub const fn new(
-        value: u64,
-        disk_usage: DiskUsage,
-        human_readable: bool,
-        prefix_kind: PrefixKind,
-    ) -> Self {
-        Self {
-            value,
-            disk_usage,
-            human_readable,
-            prefix_kind,
-            unpadded_display: None,
-            style: None,
-            uses_base_unit: None,
-            size_columns: 0,
-        }
-    }
-
-    /// Computes the logical size of a file given its [Metadata].
-    pub fn logical(md: &Metadata, prefix_kind: PrefixKind, human_readable: bool) -> Self {
-        let bytes = md.len();
-        Self::new(bytes, DiskUsage::Logical, human_readable, prefix_kind)
-    }
-
-    /// Computes the physical size of a file given its [Path] and [Metadata].
-    pub fn physical(
-        path: &Path,
-        md: &Metadata,
-        prefix_kind: PrefixKind,
-        human_readable: bool,
-    ) -> Option<Self> {
-        path.size_on_disk_fast(md)
-            .ok()
-            .map(|bytes| Self::new(bytes, DiskUsage::Physical, human_readable, prefix_kind))
-    }
-
-    pub fn unpadded_display(&self) -> Option<&str> {
-        self.unpadded_display.as_deref()
-    }
-
-    /// Precompute the raw (unpadded) display and sets the number of columns the size (without
-    /// the prefix) will occupy. Also sets the [Style] to use in advance to style the size output.
-    pub fn precompute_unpadded_display(&mut self) {
-        let value = self.value as f64;
-
-        match self.prefix_kind {
-            PrefixKind::Si => {
-                let unit = SiPrefix::from(value);
-                let base_value = unit.base_value();
-
-                if !self.human_readable {
-                    self.unpadded_display = Some(format!("{} B", self.value));
-                    self.size_columns = utils::num_integral(self.value);
-                } else if matches!(unit, SiPrefix::Base) {
-                    self.unpadded_display = Some(format!("{} {unit}", self.value));
-                    self.size_columns = utils::num_integral(self.value);
-                    self.uses_base_unit = Some(());
-                } else {
-                    let size = value / (base_value as f64);
-                    self.unpadded_display = Some(format!("{size:.2} {unit}"));
-                    self.size_columns = utils::num_integral((size * 100.0).floor() as u64) + 1;
-                }
-
-                if let Ok(theme) = get_du_theme() {
-                    let style = theme.get(format!("{unit}").as_str());
-                    self.style = style;
-                }
-            }
-            PrefixKind::Bin => {
-                let unit = BinPrefix::from(value);
-                let base_value = unit.base_value();
-
-                if !self.human_readable {
-                    self.unpadded_display = Some(format!("{} B", self.value));
-                    self.size_columns = utils::num_integral(self.value);
-                } else if matches!(unit, BinPrefix::Base) {
-                    self.unpadded_display = Some(format!("{} {unit}", self.value));
-                    self.size_columns = utils::num_integral(self.value);
-                    self.uses_base_unit = Some(());
-                } else {
-                    let size = value / (base_value as f64);
-                    self.unpadded_display = Some(format!("{size:.2} {unit}"));
-                    self.size_columns = utils::num_integral((size * 100.0).floor() as u64) + 1;
-                }
-
-                if let Ok(theme) = get_du_theme() {
-                    let style = theme.get(format!("{unit}").as_str());
-                    self.style = style;
-                }
-            }
-        }
-    }
-
-    /// Formats [`FileSize`] for presentation.
-    pub fn format(&self, max_size_width: usize, max_size_unit_width: usize) -> String {
-        let out = if self.human_readable {
-            let mut precomputed = self.unpadded_display().unwrap().split(' ');
-            let size = precomputed.next().unwrap();
-            let unit = precomputed.next().unwrap();
-
-            if self.uses_base_unit.is_some() {
-                format!(
-                    "{:>max_size_width$} {unit:>max_size_unit_width$}",
-                    self.value
-                )
-            } else {
-                format!("{size:>max_size_width$} {unit:>max_size_unit_width$}")
-            }
-        } else {
-            format!("{:<max_size_width$} B", self.value)
-        };
-
-        if let Some(style) = self.style {
-            style.paint(out).to_string()
-        } else {
-            out
-        }
-    }
-
-    /// Returns a placeholder or empty string.
-    pub fn placeholder(ctx: &Context) -> String {
-        if ctx.suppress_size || ctx.max_size_width == 0 {
-            return String::new();
-        }
-
-        let placeholder = get_placeholder_style().map_or_else(
-            |_| Cow::from(styles::PLACEHOLDER),
-            |style| Cow::from(style.paint(styles::PLACEHOLDER).to_string()),
-        );
-
-        let placeholder_padding = placeholder.len()
-            + ctx.max_size_width
-            + match ctx.unit {
-                PrefixKind::Si if ctx.human => 2,
-                PrefixKind::Bin if ctx.human => 3,
-                PrefixKind::Si => 0,
-                PrefixKind::Bin => 1,
-            };
-
-        format!("{placeholder:>placeholder_padding$}")
-    }
-}
-
-impl AddAssign<&Self> for FileSize {
-    fn add_assign(&mut self, rhs: &Self) {
-        self.value += rhs.value;
-    }
-}
diff --git a/src/disk_usage/file_size/block.rs b/src/disk_usage/file_size/block.rs
new file mode 100644
index 00000000..f845daeb
--- /dev/null
+++ b/src/disk_usage/file_size/block.rs
@@ -0,0 +1,3 @@
+pub struct Metric {
+    value: u64,
+}
diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
new file mode 100644
index 00000000..bff25dd1
--- /dev/null
+++ b/src/disk_usage/file_size/byte.rs
@@ -0,0 +1,163 @@
+use super::super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
+use crate::context::Context;
+use filesize::PathExt;
+use std::{
+    convert::From,
+    fmt::{self, Display},
+    fs::Metadata,
+    path::Path,
+};
+
+pub struct Metric {
+    pub value: u64,
+    pub human_readable: bool,
+    #[allow(dead_code)]
+    kind: MetricKind,
+    prefix_kind: PrefixKind,
+}
+
+pub enum MetricKind {
+    Logical,
+    Physical,
+}
+
+impl Metric {
+    pub fn init_logical(
+        metadata: &Metadata,
+        prefix_kind: PrefixKind,
+        human_readable: bool,
+    ) -> Self {
+        let value = metadata.len();
+        let kind = MetricKind::Logical;
+
+        Self {
+            value,
+            human_readable,
+            kind,
+            prefix_kind,
+        }
+    }
+
+    pub fn init_physical(
+        path: &Path,
+        metadata: &Metadata,
+        prefix_kind: PrefixKind,
+        human_readable: bool,
+    ) -> Self {
+        let value = path.size_on_disk_fast(metadata).unwrap_or(metadata.len());
+        let kind = MetricKind::Physical;
+
+        Self {
+            value,
+            human_readable,
+            kind,
+            prefix_kind,
+        }
+    }
+}
+
+impl From<&Context> for Metric {
+    fn from(ctx: &Context) -> Self {
+        let metric_kind = match ctx.disk_usage {
+            super::DiskUsage::Logical => MetricKind::Logical,
+            super::DiskUsage::Physical => MetricKind::Physical,
+        };
+
+        Self {
+            value: 0,
+            prefix_kind: ctx.unit,
+            human_readable: ctx.human,
+            kind: metric_kind,
+        }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = self.value as f64;
+
+        match self.prefix_kind {
+            PrefixKind::Si => {
+                if !self.human_readable {
+                    return write!(f, "{} {}", self.value, SiPrefix::Base);
+                }
+
+                let unit = SiPrefix::from(self.value);
+
+                if matches!(unit, SiPrefix::Base) {
+                    write!(f, "{} {unit}", self.value)
+                } else {
+                    let base_value = unit.base_value();
+                    let size = value / (base_value as f64);
+                    write!(f, "{size:.2} {unit}")
+                }
+            }
+            PrefixKind::Bin => {
+                if !self.human_readable {
+                    return write!(f, "{} {}", self.value, BinPrefix::Base);
+                }
+
+                let unit = BinPrefix::from(self.value);
+
+                if matches!(unit, BinPrefix::Base) {
+                    write!(f, "{} {unit}", self.value)
+                } else {
+                    let base_value = unit.base_value();
+                    let size = value / (base_value as f64);
+                    write!(f, "{size:.2} {unit}")
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_metric() {
+    let metric = Metric {
+        value: 100,
+        kind: MetricKind::Logical,
+        human_readable: false,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "100 B");
+
+    let metric = Metric {
+        value: 1000,
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Si,
+    };
+    assert_eq!(format!("{}", metric), "1.00 KB");
+
+    let metric = Metric {
+        value: 1000,
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "1000 B");
+
+    let metric = Metric {
+        value: 1024,
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "1.00 KiB");
+
+    let metric = Metric {
+        value: 2_u64.pow(20),
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "1.00 MiB");
+
+    let metric = Metric {
+        value: 123454,
+        kind: MetricKind::Logical,
+        human_readable: false,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "123454 B");
+}
diff --git a/src/disk_usage/file_size/line_count.rs b/src/disk_usage/file_size/line_count.rs
new file mode 100644
index 00000000..f845daeb
--- /dev/null
+++ b/src/disk_usage/file_size/line_count.rs
@@ -0,0 +1,3 @@
+pub struct Metric {
+    value: u64,
+}
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
new file mode 100644
index 00000000..8b4aab3e
--- /dev/null
+++ b/src/disk_usage/file_size/mod.rs
@@ -0,0 +1,51 @@
+use crate::context::Context;
+use clap::ValueEnum;
+use std::{convert::From, ops::AddAssign};
+
+pub mod byte;
+//pub mod block;
+//pub mod word_count;
+//pub mod line_count;
+
+pub enum FileSize {
+    //Block(block::Metric),
+    //WordCount(word_count::Metric),
+    //LineCount(line_count::Metric),
+    Byte(byte::Metric),
+}
+
+/// Determines between logical or physical size for display
+#[derive(Copy, Clone, Debug, ValueEnum, Default)]
+pub enum DiskUsage {
+    /// How many bytes does a file contain
+    Logical,
+
+    /// How much actual space on disk in bytes, taking into account sparse files and compression.
+    #[default]
+    Physical,
+}
+
+impl FileSize {
+    #[inline]
+    pub const fn value(&self) -> u64 {
+        match self {
+            Self::Byte(metric) => metric.value,
+        }
+    }
+}
+
+impl AddAssign<&Self> for FileSize {
+    fn add_assign(&mut self, rhs: &Self) {
+        match self {
+            Self::Byte(metric) => metric.value += rhs.value(),
+        }
+    }
+}
+
+impl From<&Context> for FileSize {
+    fn from(ctx: &Context) -> Self {
+        match ctx.disk_usage {
+            DiskUsage::Logical | DiskUsage::Physical => Self::Byte(byte::Metric::from(ctx)),
+        }
+    }
+}
diff --git a/src/disk_usage/file_size/word_count.rs b/src/disk_usage/file_size/word_count.rs
new file mode 100644
index 00000000..f845daeb
--- /dev/null
+++ b/src/disk_usage/file_size/word_count.rs
@@ -0,0 +1,3 @@
+pub struct Metric {
+    value: u64,
+}
diff --git a/src/disk_usage/logical.rs b/src/disk_usage/logical.rs
deleted file mode 100644
index 6818cd49..00000000
--- a/src/disk_usage/logical.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use super::{
-    ByteDisplay,
-    DuMetric,
-    units::PrefixKind,
-};
-use std::{
-    fmt::{self, Display},
-    fs::Metadata,
-};
-
-pub struct Size {
-    pub value: u64,
-    pub prefix_kind: PrefixKind,
-    pub human_readable: bool,
-}
-
-impl DuMetric for Size {}
-
-impl Size {
-    pub fn new(metadata: &Metadata, prefix_kind: PrefixKind, human_readable: bool) -> Self {
-        let value = metadata.len();
-
-        Self {
-            value,
-            prefix_kind,
-            human_readable,
-        }
-    }
-}
-
-impl ByteDisplay for Size {
-    fn human_readable(&self) -> bool {
-        self.human_readable
-    }
-
-    fn prefix_kind(&self) -> PrefixKind {
-        self.prefix_kind
-    }
-
-    fn value(&self) -> u64 {
-        self.value
-    }
-}
-
-impl Display for Size {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        <Self as ByteDisplay>::fmt(self, f)
-    }
-}
-
-#[test]
-fn test_logical_size() -> std::io::Result<()> {
-    use std::fs;
-
-    let md = fs::metadata("./tests/data/nemesis.txt")?;
-
-    let logical_size = Size::new(&md, PrefixKind::Bin, false);
-
-    let display = format!("{logical_size}");
-
-    assert_eq!(logical_size.value, 161);
-    assert_eq!(display, "161 B");
-
-    assert_eq!(
-        format!(
-            "{}",
-            Size {
-                value: 1_024,
-                prefix_kind: PrefixKind::Bin,
-                human_readable: true
-            }
-        ),
-        "1.00 KiB"
-    );
-
-    Ok(())
-}
diff --git a/src/disk_usage/mod.rs b/src/disk_usage/mod.rs
index ba94ac2e..84582ca7 100644
--- a/src/disk_usage/mod.rs
+++ b/src/disk_usage/mod.rs
@@ -1,53 +1,4 @@
-use std::fmt;
-use units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
-
 /// Binary and SI prefixes
 pub mod units;
 
-/// Rules to display disk usage for individual files.
 pub mod file_size;
-
-pub mod block;
-
-pub mod logical;
-
-pub mod physical;
-
-pub trait DuMetric {}
-
-pub trait ByteDisplay {
-    fn prefix_kind(&self) -> PrefixKind;
-
-    fn value(&self) -> u64;
-
-    fn human_readable(&self) -> bool;
-
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let value = self.value() as f64;
-
-        match self.prefix_kind() {
-            PrefixKind::Si => {
-                let unit = SiPrefix::from(value);
-                let base_value = unit.base_value();
-
-                if !self.human_readable() || matches!(unit, SiPrefix::Base) {
-                    write!(f, "{} {unit}", self.value())
-                } else {
-                    let size = value / (base_value as f64);
-                    write!(f, "{size:.2} {unit}")
-                }
-            }
-            PrefixKind::Bin => {
-                let unit = BinPrefix::from(value);
-                let base_value = unit.base_value();
-
-                if !self.human_readable() || matches!(unit, BinPrefix::Base) {
-                    write!(f, "{} {unit}", self.value())
-                } else {
-                    let size = value / (base_value as f64);
-                    write!(f, "{size:.2} {unit}")
-                }
-            }
-        }
-    }
-}
diff --git a/src/disk_usage/physical.rs b/src/disk_usage/physical.rs
deleted file mode 100644
index d31174bf..00000000
--- a/src/disk_usage/physical.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use filesize::PathExt;
-use super::{
-    units::PrefixKind,
-    ByteDisplay,
-    DuMetric,
-};
-use std::{
-    path::Path,
-    fmt::{self, Display},
-    fs::Metadata,
-};
-
-pub struct Size {
-    pub value: u64,
-    pub prefix_kind: PrefixKind,
-    pub human_readable: bool,
-}
-
-impl DuMetric for Size {}
-
-impl Size {
-    pub fn new(path: &Path, metadata: &Metadata, prefix_kind: PrefixKind, human_readable: bool) -> Self {
-        let value = path.size_on_disk_fast(metadata).unwrap_or(0);
-
-        Self {
-            value,
-            prefix_kind,
-            human_readable,
-        }
-    }
-}
-
-impl ByteDisplay for Size {
-    fn human_readable(&self) -> bool {
-        self.human_readable
-    }
-
-    fn prefix_kind(&self) -> PrefixKind {
-        self.prefix_kind
-    }
-
-    fn value(&self) -> u64 {
-        self.value
-    }
-}
-
-impl Display for Size {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        <Self as ByteDisplay>::fmt(self, f)
-    }
-}
-
-#[test]
-fn test_physical_size() -> std::io::Result<()> {
-    assert_eq!(
-        format!(
-            "{}",
-            Size {
-                value: 1_024,
-                prefix_kind: PrefixKind::Bin,
-                human_readable: true
-            }
-        ),
-        "1.00 KiB"
-    );
-
-    Ok(())
-}
diff --git a/src/disk_usage/units.rs b/src/disk_usage/units.rs
index bf605c29..92e1da3f 100644
--- a/src/disk_usage/units.rs
+++ b/src/disk_usage/units.rs
@@ -64,9 +64,9 @@ impl UnitPrefix for BinPrefix {
 }
 
 /// Get the closest human-readable unit prefix for value.
-impl From<f64> for BinPrefix {
-    fn from(value: f64) -> Self {
-        let log = value.log2();
+impl From<u64> for BinPrefix {
+    fn from(value: u64) -> Self {
+        let log = (value as f64).log2();
 
         if log < 10. {
             Self::Base
@@ -83,9 +83,9 @@ impl From<f64> for BinPrefix {
 }
 
 /// Get the closest human-readable unit prefix for value.
-impl From<f64> for SiPrefix {
-    fn from(value: f64) -> Self {
-        let log = value.log10();
+impl From<u64> for SiPrefix {
+    fn from(value: u64) -> Self {
+        let log = (value as f64).log10();
 
         if log < 3. {
             Self::Base
diff --git a/src/icons/fs.rs b/src/icons/fs.rs
new file mode 100644
index 00000000..b19f08f8
--- /dev/null
+++ b/src/icons/fs.rs
@@ -0,0 +1,95 @@
+use ansi_term::{ANSIGenericString, Style};
+use ignore::DirEntry;
+use std::{borrow::Cow, path::Path};
+
+/// Computes a plain, colorless icon with given parameters.
+///
+/// The precedent from highest to lowest in terms of which parameters determine the icon used
+/// is as followed: file-type, file-extension, and then file-name. If an icon cannot be
+/// computed the fall-back default icon is used.
+///
+/// If a directory entry is a link and the link target is provided, the link target will be
+/// used to determine the icon.
+pub fn compute(entry: &DirEntry, link_target: Option<&Path>) -> Cow<'static, str> {
+    let icon = entry
+        .file_type()
+        .and_then(super::icon_from_file_type)
+        .map(Cow::from);
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let ext = match link_target {
+        Some(target) if entry.path_is_symlink() => target.extension(),
+        _ => entry.path().extension(),
+    };
+
+    let icon = ext
+        .and_then(super::icon_from_ext)
+        .map(|(_, i)| Cow::from(i));
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let icon = super::icon_from_file_name(entry.file_name()).map(Cow::from);
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    Cow::from(super::get_default_icon().1)
+}
+
+/// Computes a plain, colored icon with given parameters. See [compute] for more details.
+pub fn compute_with_color(
+    entry: &DirEntry,
+    link_target: Option<&Path>,
+    style: Option<Style>,
+) -> Cow<'static, str> {
+    let icon = entry
+        .file_type()
+        .and_then(super::icon_from_file_type)
+        .map(Cow::from);
+
+    let paint_icon = |icon| match style {
+        Some(Style {
+            foreground: Some(fg),
+            ..
+        }) => {
+            let ansi_string: ANSIGenericString<str> = fg.bold().paint(icon);
+            let styled_icon = ansi_string.to_string();
+            Cow::from(styled_icon)
+        }
+        _ => icon,
+    };
+
+    if let Some(icon) = icon {
+        return paint_icon(icon);
+    }
+
+    let ext = match link_target {
+        Some(target) if entry.path_is_symlink() => target.extension(),
+        _ => entry.path().extension(),
+    };
+
+    let icon = ext
+        .and_then(super::icon_from_ext)
+        .map(|attrs| Cow::from(super::col(attrs.0, attrs.1)));
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let icon = super::icon_from_file_name(entry.file_name())
+        .map(Cow::from)
+        .map(paint_icon);
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let (code, icon) = super::get_default_icon();
+    Cow::from(super::col(code, icon))
+}
diff --git a/src/icons.rs b/src/icons/mod.rs
similarity index 88%
rename from src/icons.rs
rename to src/icons/mod.rs
index f8648f3a..dbcb3018 100644
--- a/src/icons.rs
+++ b/src/icons/mod.rs
@@ -1,105 +1,14 @@
 use crate::hash;
-use ansi_term::Style;
-use ansi_term::{ANSIGenericString, Color};
-use ignore::DirEntry;
+use ansi_term::Color;
 use once_cell::sync::Lazy;
 use std::{
-    borrow::Cow,
     collections::HashMap,
     ffi::{OsStr, OsString},
     fs::FileType,
-    path::Path,
 };
 
-/// Computes a plain, colorless icon with given parameters.
-///
-/// The precedent from highest to lowest in terms of which parameters determine the icon used
-/// is as followed: file-type, file-extension, and then file-name. If an icon cannot be
-/// computed the fall-back default icon is used.
-///
-/// If a directory entry is a link and the link target is provided, the link target will be
-/// used to determine the icon.
-pub fn compute(entry: &DirEntry, link_target: Option<&Path>) -> Cow<'static, str> {
-    let icon = entry
-        .file_type()
-        .and_then(icon_from_file_type)
-        .map(Cow::from);
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let ext = match link_target {
-        Some(target) if entry.path_is_symlink() => target.extension(),
-        _ => entry.path().extension(),
-    };
-
-    let icon = ext.and_then(icon_from_ext).map(|(_, i)| Cow::from(i));
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let icon = icon_from_file_name(entry.file_name()).map(Cow::from);
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    Cow::from(get_default_icon().1)
-}
-
-/// Computes a plain, colored icon with given parameters. See [compute] for more details.
-pub fn compute_with_color(
-    entry: &DirEntry,
-    link_target: Option<&Path>,
-    style: Option<Style>,
-) -> Cow<'static, str> {
-    let icon = entry
-        .file_type()
-        .and_then(icon_from_file_type)
-        .map(Cow::from);
-
-    let paint_icon = |icon| match style {
-        Some(Style {
-            foreground: Some(fg),
-            ..
-        }) => {
-            let ansi_string: ANSIGenericString<str> = fg.bold().paint(icon);
-            let styled_icon = ansi_string.to_string();
-            Cow::from(styled_icon)
-        }
-        _ => icon,
-    };
-
-    if let Some(icon) = icon {
-        return paint_icon(icon);
-    }
-
-    let ext = match link_target {
-        Some(target) if entry.path_is_symlink() => target.extension(),
-        _ => entry.path().extension(),
-    };
-
-    let icon = ext
-        .and_then(icon_from_ext)
-        .map(|attrs| Cow::from(col(attrs.0, attrs.1)));
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let icon = icon_from_file_name(entry.file_name())
-        .map(Cow::from)
-        .map(paint_icon);
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let (code, icon) = get_default_icon();
-    Cow::from(col(code, icon))
-}
+/// Concerned with computing icons given filesystem parameters.
+pub mod fs;
 
 /// Attempts to return an icon given a file extension along with its default color code 8-bit
 /// value.
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 8a5474f0..36b3247e 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,11 +1,12 @@
 use crate::{
     context::Context,
-    disk_usage::file_size::FileSize,
+    disk_usage::{file_size::FileSize, units::PrefixKind},
     render::theme,
     styles::{self, PLACEHOLDER},
     tree::node::Node,
 };
 use std::{
+    borrow::Cow,
     ffi::OsStr,
     fmt::{self, Display},
     path::Path,
@@ -101,12 +102,30 @@ impl<'a> Cell<'a> {
         let node = self.node;
         let ctx = self.ctx;
 
-        let formatted_size = node.file_size().map_or_else(
-            || FileSize::placeholder(ctx),
-            |size| size.format(ctx.max_size_width, ctx.max_size_unit_width),
-        );
+        let Some(file_size) = node.file_size() else {
+            return Self::fmt_size_placeholder(f, ctx)
+        };
+
+        match file_size {
+            FileSize::Byte(metric) => {
+                let max_size_width = ctx.max_size_width;
+                let max_unit_width = ctx.max_size_unit_width;
+                let out = format!("{metric}");
+                let [size, unit]: [&str; 2] =
+                    out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
+
+                if ctx.no_color() {
+                    write!(f, "{size:>max_size_width$} {unit:>max_unit_width$}")
+                } else {
+                    let color = styles::get_du_theme().unwrap().get(unit).unwrap();
 
-        write!(f, "{formatted_size}")
+                    let out =
+                        color.paint(format!("{size:>max_size_width$} {unit:>max_unit_width$}"));
+
+                    write!(f, "{out}")
+                }
+            }
+        }
     }
 
     /// Rules on how to format block for rendering
@@ -223,6 +242,29 @@ impl<'a> Cell<'a> {
 
         write!(f, "{formatted_perms}")
     }
+
+    #[inline]
+    pub fn fmt_size_placeholder(f: &mut fmt::Formatter<'_>, ctx: &Context) -> fmt::Result {
+        if ctx.suppress_size || ctx.max_size_width == 0 {
+            return write!(f, "");
+        }
+
+        let placeholder = styles::get_placeholder_style().map_or_else(
+            |_| Cow::from(styles::PLACEHOLDER),
+            |style| Cow::from(style.paint(styles::PLACEHOLDER).to_string()),
+        );
+
+        let placeholder_padding = placeholder.len()
+            + ctx.max_size_width
+            + match ctx.unit {
+                PrefixKind::Si if ctx.human => 2,
+                PrefixKind::Bin if ctx.human => 3,
+                PrefixKind::Si => 0,
+                PrefixKind::Bin => 1,
+            };
+
+        write!(f, "{placeholder:>placeholder_padding$}")
+    }
 }
 
 impl Display for Cell<'_> {
diff --git a/src/render/theme.rs b/src/render/theme.rs
index ee305ac2..d2a97b92 100644
--- a/src/render/theme.rs
+++ b/src/render/theme.rs
@@ -1,5 +1,4 @@
 use crate::{
-    fs::permissions::FileModeXAttrs,
     styles::{self, ThemesMap},
     tree::node::Node,
 };
@@ -71,6 +70,8 @@ pub fn stylize_file_name(node: &Node) -> Cow<'_, str> {
 /// Styles the symbolic notation of file permissions.
 #[cfg(unix)]
 pub fn style_sym_permissions(node: &Node) -> String {
+    use crate::fs::permissions::FileModeXAttrs;
+
     let perms = node.mode().expect("Expected permissions to be initialized");
 
     let symb = if node.has_xattrs() {
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index 02a99ae5..340b9a73 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -1,6 +1,9 @@
 use crate::{
     context::{file, output::ColumnProperties, Context},
-    disk_usage::file_size::FileSize,
+    disk_usage::{
+        file_size::FileSize,
+        units::{BinPrefix, PrefixKind, SiPrefix},
+    },
     fs::inode::Inode,
     utils,
 };
@@ -186,7 +189,7 @@ impl Tree {
 
         let mut children = branches.remove(current_node.path()).unwrap();
 
-        let mut dir_size = FileSize::new(0, ctx.disk_usage, ctx.human, ctx.unit);
+        let mut dir_size = FileSize::from(ctx);
 
         for child_id in &children {
             let index = *child_id;
@@ -211,10 +214,10 @@ impl Tree {
             let node = tree[index].get();
 
             #[cfg(unix)]
-            Self::update_column_properties(column_properties, node, ctx.long);
+            Self::update_column_properties(column_properties, node, ctx);
 
             #[cfg(not(unix))]
-            Self::update_column_properties(column_properties, node);
+            Self::update_column_properties(column_properties, node, ctx);
 
             // If a hard-link is already accounted for then don't increment parent dir size.
             if let Some(inode) = node.inode() {
@@ -228,21 +231,19 @@ impl Tree {
             }
         }
 
-        if dir_size.value > 0 {
+        if dir_size.value() > 0 {
             let dir = tree[current_node_id].get_mut();
 
-            dir_size.precompute_unpadded_display();
-
             dir.set_file_size(dir_size);
         }
 
         let dir = tree[current_node_id].get();
 
         #[cfg(unix)]
-        Self::update_column_properties(column_properties, dir, ctx.long);
+        Self::update_column_properties(column_properties, dir, ctx);
 
         #[cfg(not(unix))]
-        Self::update_column_properties(column_properties, dir);
+        Self::update_column_properties(column_properties, dir, ctx);
 
         children.sort_by(|id_a, id_b| {
             let node_a = tree[*id_a].get();
@@ -306,16 +307,32 @@ impl Tree {
 
     /// Updates [`ColumnProperties`] with provided [Node].
     #[cfg(unix)]
-    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, long: bool) {
+    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
-            let file_size_cols = file_size.size_columns;
+            let file_size_cols = utils::num_integral(file_size.value());
 
             if file_size_cols > col_props.max_size_width {
                 col_props.max_size_width = file_size_cols;
             }
+
+            let unit_len = match ctx.unit {
+                PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
+                    BinPrefix::Base => 1,
+                    _ => 3,
+                },
+                PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
+                    SiPrefix::Base => 1,
+                    _ => 2,
+                },
+                _ => 1,
+            };
+
+            if unit_len > col_props.max_size_unit_width {
+                col_props.max_size_unit_width = unit_len;
+            }
         }
 
-        if long {
+        if ctx.long {
             if let Some(ino) = node.ino() {
                 let ino_num_integral = utils::num_integral(ino);
 
@@ -344,13 +361,29 @@ impl Tree {
 
     /// Updates [ColumnProperties] with provided [Node].
     #[cfg(not(unix))]
-    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node) {
+    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
-            let file_size_cols = file_size.size_columns;
+            let file_size_cols = utils::num_integral(file_size.value());
 
             if file_size_cols > col_props.max_size_width {
                 col_props.max_size_width = file_size_cols;
             }
+
+            let unit_len = match ctx.unit {
+                PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
+                    BinPrefix::Base => 1,
+                    _ => 3,
+                },
+                PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
+                    SiPrefix::Base => 1,
+                    _ => 2,
+                },
+                _ => 1,
+            };
+
+            if unit_len > col_props.max_size_unit_width {
+                col_props.max_size_unit_width = unit_len;
+            }
         }
     }
 }
diff --git a/src/tree/node/cmp.rs b/src/tree/node/cmp.rs
index 78613f73..c135b9a8 100644
--- a/src/tree/node/cmp.rs
+++ b/src/tree/node/cmp.rs
@@ -127,13 +127,14 @@ fn base_comparator(sort_type: sort::Type) -> Box<NodeComparator> {
 //}
 
 mod sizing {
+    use crate::disk_usage::file_size::FileSize;
     use crate::tree::node::Node;
     use core::cmp::Ordering;
 
     /// Comparator that sorts [Node]s by size, largest to smallest.
     pub fn comparator(a: &Node, b: &Node) -> Ordering {
-        let a_size = a.file_size().map_or(0, |fs| fs.value);
-        let b_size = b.file_size().map_or(0, |fs| fs.value);
+        let a_size = a.file_size().map_or(0, FileSize::value);
+        let b_size = b.file_size().map_or(0, FileSize::value);
         b_size.cmp(&a_size)
     }
     /// Comparator that sorts [Node]s by size, smallest to largest.
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 63561e49..444c6b06 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
     context::Context,
-    disk_usage::file_size::{DiskUsage, FileSize},
+    disk_usage::file_size::{byte, DiskUsage, FileSize},
     fs::inode::Inode,
     icons,
     styles::get_ls_colors,
@@ -204,9 +204,9 @@ impl Node {
     /// See [`icons::compute`].
     pub fn compute_icon(&self, no_color: bool) -> Cow<'static, str> {
         if no_color {
-            icons::compute(self.dir_entry(), self.symlink_target_path())
+            icons::fs::compute(self.dir_entry(), self.symlink_target_path())
         } else {
-            icons::compute_with_color(self.dir_entry(), self.symlink_target_path(), self.style)
+            icons::fs::compute_with_color(self.dir_entry(), self.symlink_target_path(), self.style)
         }
     }
 }
@@ -232,15 +232,18 @@ impl TryFrom<(DirEntry, &Context)> for Node {
 
         let file_type = dir_entry.file_type();
 
-        let mut file_size = match file_type {
+        let file_size = match file_type {
             Some(ref ft) if !ctx.suppress_size => {
                 if ft.is_file() || (ft.is_symlink() && !ctx.follow) {
                     match ctx.disk_usage {
                         DiskUsage::Logical => {
-                            Some(FileSize::logical(&metadata, ctx.unit, ctx.human))
+                            let metric = byte::Metric::init_logical(&metadata, ctx.unit, ctx.human);
+                            Some(FileSize::Byte(metric))
                         }
                         DiskUsage::Physical => {
-                            FileSize::physical(path, &metadata, ctx.unit, ctx.human)
+                            let metric =
+                                byte::Metric::init_physical(path, &metadata, ctx.unit, ctx.human);
+                            Some(FileSize::Byte(metric))
                         }
                     }
                 } else {
@@ -250,10 +253,6 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             _ => None,
         };
 
-        if let Some(ref mut fs) = file_size {
-            fs.precompute_unpadded_display();
-        }
-
         let inode = Inode::try_from(&metadata).ok();
 
         #[cfg(unix)]
diff --git a/tests/dirs_only.rs b/tests/dirs_only.rs
index c1804e2c..b7dea5f3 100644
--- a/tests/dirs_only.rs
+++ b/tests/dirs_only.rs
@@ -7,12 +7,12 @@ fn dirs_only() {
     assert_eq!(
         utils::run_cmd(&["--dirs-only", "--sort", "name", "tests/data"]),
         indoc!(
-            "143  B ┌─ the_yellow_king
-    446  B ├─ lipsum
-    308  B ├─ dream_cycle
-    1241 B data
+            "143 B ┌─ the_yellow_king
+ 446 B ├─ lipsum
+ 308 B ├─ dream_cycle
+1241 B data
 
-    3 directories"
+3 directories"
         )
     )
 }
diff --git a/tests/flat.rs b/tests/flat.rs
index 2b96b3da..23dcd485 100644
--- a/tests/flat.rs
+++ b/tests/flat.rs
@@ -7,18 +7,18 @@ fn flat() {
     assert_eq!(
         utils::run_cmd(&["--layout", "flat", "tests/data"]),
         indoc!(
-            "143  B   the_yellow_king/cassildas_song.md
-            143  B   the_yellow_king
-            100  B   nylarlathotep.txt
-            161  B   nemesis.txt
-            83   B   necronomicon.txt
-            446  B   lipsum/lipsum.txt
-            446  B   lipsum
-            308  B   dream_cycle/polaris.txt
-            308  B   dream_cycle
-            1241 B   data
+            "143 B   the_yellow_king/cassildas_song.md
+ 143 B   the_yellow_king
+ 100 B   nylarlathotep.txt
+ 161 B   nemesis.txt
+  83 B   necronomicon.txt
+ 446 B   lipsum/lipsum.txt
+ 446 B   lipsum
+ 308 B   dream_cycle/polaris.txt
+ 308 B   dream_cycle
+1241 B   data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     )
 }
@@ -29,17 +29,17 @@ fn flat_human() {
         utils::run_cmd(&["--layout", "flat", "--human", "tests/data"]),
         indoc!(
             "143   B   the_yellow_king/cassildas_song.md
-             143   B   the_yellow_king
-             100   B   nylarlathotep.txt
-             161   B   nemesis.txt
-              83   B   necronomicon.txt
-             446   B   lipsum/lipsum.txt
-             446   B   lipsum
-             308   B   dream_cycle/polaris.txt
-             308   B   dream_cycle
-            1.21 KiB   data
+ 143   B   the_yellow_king
+ 100   B   nylarlathotep.txt
+ 161   B   nemesis.txt
+  83   B   necronomicon.txt
+ 446   B   lipsum/lipsum.txt
+ 446   B   lipsum
+ 308   B   dream_cycle/polaris.txt
+ 308   B   dream_cycle
+1.21 KiB   data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     )
 }
@@ -49,15 +49,15 @@ fn flat_with_level() {
     assert_eq!(
         utils::run_cmd(&["--layout", "flat", "--level", "1", "tests/data"]),
         indoc!(
-            "143  B   the_yellow_king
-            100  B   nylarlathotep.txt
-            161  B   nemesis.txt
-            83   B   necronomicon.txt
-            446  B   lipsum
-            308  B   dream_cycle
-            1241 B   data
+            "143 B   the_yellow_king
+ 100 B   nylarlathotep.txt
+ 161 B   nemesis.txt
+  83 B   necronomicon.txt
+ 446 B   lipsum
+ 308 B   dream_cycle
+1241 B   data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     )
 }
diff --git a/tests/glob.rs b/tests/glob.rs
index ff370aa3..c5efd687 100644
--- a/tests/glob.rs
+++ b/tests/glob.rs
@@ -7,16 +7,16 @@ fn glob() {
     assert_eq!(
         utils::run_cmd(&["--glob", "--pattern", "*.txt", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     );
 }
@@ -27,10 +27,10 @@ fn glob_negative() {
         utils::run_cmd(&["--glob", "--pattern", "!*.txt", "tests/data"]),
         indoc!(
             "143 B    ┌─ cassildas_song.md
-            143 B ┌─ the_yellow_king
-            143 B data
-
-            1 directory, 1 file"
+ 143 B ┌─ the_yellow_king
+ 143 B data
+ 
+ 1 directory, 1 file"
         )
     )
 }
@@ -40,16 +40,16 @@ fn glob_case_insensitive() {
     assert_eq!(
         utils::run_cmd(&["--iglob", "--pattern", "*.TXT", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     )
 }
@@ -67,10 +67,10 @@ fn glob_with_filetype() {
         ]),
         indoc!(
             "308 B    ┌─ polaris.txt
-            308 B ┌─ dream_cycle
-            308 B data
-
-            1 directory, 1 file"
+ 308 B ┌─ dream_cycle
+ 308 B data
+ 
+ 1 directory, 1 file"
         )
     )
 }
@@ -88,15 +88,15 @@ fn negated_glob_with_filetype() {
         ]),
         indoc!(
             "143 B    ┌─ cassildas_song.md
-            143 B ┌─ the_yellow_king
-            100 B ├─ nylarlathotep.txt
-            161 B ├─ nemesis.txt
-            83  B ├─ necronomicon.txt
-            446 B │  ┌─ lipsum.txt
-            446 B ├─ lipsum
-            933 B data
-
-            2 directories, 5 files"
+ 143 B ┌─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 933 B data
+ 
+ 2 directories, 5 files"
         )
     )
 }
diff --git a/tests/hardlink.rs b/tests/hardlink.rs
index a4b5b9c0..c1e9e8a2 100644
--- a/tests/hardlink.rs
+++ b/tests/hardlink.rs
@@ -27,10 +27,10 @@ fn hardlink() -> Result<(), Box<dyn Error>> {
         out,
         indoc!(
             "157 B ┌─ kadath.txt
-            157 B ├─ curwin.hpl
-            157 B hardlinks
+ 157 B ├─ curwin.hpl
+ 157 B hardlinks
 
-            2 files"
+ 2 files"
         )
     );
 
diff --git a/tests/level.rs b/tests/level.rs
index f3d9cfd5..6d45cec8 100644
--- a/tests/level.rs
+++ b/tests/level.rs
@@ -7,15 +7,15 @@ fn level() {
     assert_eq!(
         utils::run_cmd(&["--level", "1", "tests/data"]),
         indoc!(
-            "143  B ┌─ the_yellow_king
-            100  B ├─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B ├─ lipsum
-            308  B ├─ dream_cycle
-            1241 B data
+            "143 B ┌─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B ├─ lipsum
+ 308 B ├─ dream_cycle
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to print at max level of 1."
     )
diff --git a/tests/prune.rs b/tests/prune.rs
index 139d87df..5a1e1148 100644
--- a/tests/prune.rs
+++ b/tests/prune.rs
@@ -7,16 +7,16 @@ fn prune() {
     assert_eq!(
         utils::run_cmd(&["--glob", "--pattern", "*.txt", "--prune", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     );
 }
diff --git a/tests/regex.rs b/tests/regex.rs
index 64a7ef3b..af40979e 100644
--- a/tests/regex.rs
+++ b/tests/regex.rs
@@ -7,16 +7,16 @@ fn regex() {
     assert_eq!(
         utils::run_cmd(&["--pattern", r"\.txt$", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     );
 
@@ -24,10 +24,10 @@ fn regex() {
         utils::run_cmd(&["--pattern", r"^cassildas.", "--prune", "tests/data"]),
         indoc!(
             "143 B    ┌─ cassildas_song.md
-            143 B ┌─ the_yellow_king
-            143 B data
-
-            1 directory, 1 file"
+ 143 B ┌─ the_yellow_king
+ 143 B data
+ 
+ 1 directory, 1 file"
         )
     );
 }
@@ -38,10 +38,10 @@ fn regex_file_type() {
         utils::run_cmd(&["--pattern", r"^dream.", "--file-type", "dir", "tests/data"]),
         indoc!(
             "308 B    ┌─ polaris.txt
-            308 B ┌─ dream_cycle
-            308 B data
-
-            1 directory, 1 file"
+ 308 B ┌─ dream_cycle
+ 308 B data
+ 
+ 1 directory, 1 file"
         )
     );
 }
diff --git a/tests/sort.rs b/tests/sort.rs
index 9942447e..4d38ef57 100644
--- a/tests/sort.rs
+++ b/tests/sort.rs
@@ -7,18 +7,18 @@ fn sort_name() {
     assert_eq!(
         utils::run_cmd(&["--sort", "name", "tests/data"]),
         indoc!(
-            "143  B    ┌─ cassildas_song.md
-            143  B ┌─ the_yellow_king
-            100  B ├─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1241 B data
+            "143 B    ┌─ cassildas_song.md
+ 143 B ┌─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to sort alphabetically by file name"
     )
@@ -29,36 +29,36 @@ fn sort_name_dir_order() {
     assert_eq!(
         utils::run_cmd(&["--sort", "name", "--dir-order", "first", "tests/data"]),
         indoc!(
-            "143  B    ┌─ cassildas_song.md
-            143  B ┌─ the_yellow_king
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            100  B ├─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            1241 B data
+            "143 B    ┌─ cassildas_song.md
+ 143 B ┌─ the_yellow_king
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     );
 
     assert_eq!(
         utils::run_cmd(&["--sort", "name", "--dir-order", "last", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            143  B │  ┌─ cassildas_song.md
-            143  B ├─ the_yellow_king
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1241 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 143 B │  ┌─ cassildas_song.md
+ 143 B ├─ the_yellow_king
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     );
 }
@@ -68,18 +68,18 @@ fn sort_size() {
     assert_eq!(
         utils::run_cmd(&["--sort", "size-rev", "tests/data"]),
         indoc!(
-            "446  B    ┌─ lipsum.txt
-            446  B ┌─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            161  B ├─ nemesis.txt
-            143  B │  ┌─ cassildas_song.md
-            143  B ├─ the_yellow_king
-            100  B ├─ nylarlathotep.txt
-            83   B ├─ necronomicon.txt
-            1241 B data
+            "446 B    ┌─ lipsum.txt
+ 446 B ┌─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+ 161 B ├─ nemesis.txt
+ 143 B │  ┌─ cassildas_song.md
+ 143 B ├─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+  83 B ├─ necronomicon.txt
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to sort by descending size"
     )
diff --git a/tests/suppress_size.rs b/tests/suppress_size.rs
index c771bf7d..00a2a76c 100644
--- a/tests/suppress_size.rs
+++ b/tests/suppress_size.rs
@@ -8,17 +8,17 @@ fn suppress_size() {
         utils::run_cmd(&["--suppress-size", "tests/data"]),
         indoc!(
             "┌─ cassildas_song.md
-             ┌─ the_yellow_king
-             ├─ nylarlathotep.txt
-             ├─ nemesis.txt
-             ├─ necronomicon.txt
-             │  ┌─ lipsum.txt
-             ├─ lipsum
-             │  ┌─ polaris.txt
-             ├─ dream_cycle
-             data
+ ┌─ the_yellow_king
+ ├─ nylarlathotep.txt
+ ├─ nemesis.txt
+ ├─ necronomicon.txt
+ │  ┌─ lipsum.txt
+ ├─ lipsum
+ │  ┌─ polaris.txt
+ ├─ dream_cycle
+ data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to suppress size."
     )

From 3a748469d6ce01bb233fe3166f55edded9572e47 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 22 May 2023 00:08:57 -0700
Subject: [PATCH 3/7] line count

---
 src/disk_usage/file_size/byte.rs       | 36 +++++++-------
 src/disk_usage/file_size/line_count.rs | 50 ++++++++++++++++++-
 src/disk_usage/file_size/mod.rs        | 15 ++++--
 src/render/grid/cell.rs                | 61 +++++++++++++++--------
 src/tree/mod.rs                        | 68 +++++++++++++++-----------
 src/tree/node/mod.rs                   |  6 ++-
 tests/line_count.rs                    | 24 +++++++++
 7 files changed, 188 insertions(+), 72 deletions(-)
 create mode 100644 tests/line_count.rs

diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index bff25dd1..ac0f4fd4 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -1,8 +1,6 @@
 use super::super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
-use crate::context::Context;
 use filesize::PathExt;
 use std::{
-    convert::From,
     fmt::{self, Display},
     fs::Metadata,
     path::Path,
@@ -38,6 +36,24 @@ impl Metric {
         }
     }
 
+    pub const fn init_empty_logical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
+        Self {
+            value: 0,
+            human_readable,
+            kind: MetricKind::Logical,
+            prefix_kind,
+        }
+    }
+
+    pub const fn init_empty_physical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
+        Self {
+            value: 0,
+            human_readable,
+            kind: MetricKind::Physical,
+            prefix_kind,
+        }
+    }
+
     pub fn init_physical(
         path: &Path,
         metadata: &Metadata,
@@ -56,22 +72,6 @@ impl Metric {
     }
 }
 
-impl From<&Context> for Metric {
-    fn from(ctx: &Context) -> Self {
-        let metric_kind = match ctx.disk_usage {
-            super::DiskUsage::Logical => MetricKind::Logical,
-            super::DiskUsage::Physical => MetricKind::Physical,
-        };
-
-        Self {
-            value: 0,
-            prefix_kind: ctx.unit,
-            human_readable: ctx.human,
-            kind: metric_kind,
-        }
-    }
-}
-
 impl Display for Metric {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let value = self.value as f64;
diff --git a/src/disk_usage/file_size/line_count.rs b/src/disk_usage/file_size/line_count.rs
index f845daeb..ac0bbc52 100644
--- a/src/disk_usage/file_size/line_count.rs
+++ b/src/disk_usage/file_size/line_count.rs
@@ -1,3 +1,51 @@
+use std::{
+    convert::{AsRef, From},
+    fmt::{self, Display},
+    fs,
+    path::Path,
+};
+
+#[derive(Default)]
 pub struct Metric {
-    value: u64,
+    pub value: u64,
+}
+
+impl Metric {
+    pub fn init_lc<P: AsRef<Path>>(path: P) -> Option<Self> {
+        let data = fs::read(path.as_ref()).ok();
+
+        let Some(text) = data else {
+            return None;
+        };
+
+        let lines = text.into_iter().fold(0, |acc, item| {
+            if u32::from(item) == u32::from('\n') {
+                acc + 1
+            } else {
+                acc
+            }
+        });
+
+        u64::try_from(lines).map(|value| Self { value }).ok()
+    }
+}
+
+impl From<u64> for Metric {
+    fn from(value: u64) -> Self {
+        Self { value }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <u64 as Display>::fmt(&self.value, f)
+    }
+}
+
+#[test]
+fn test_lc() {
+    let metric = Metric::init_lc("tests/data/nemesis.txt")
+        .expect("Expected 'tests/data/nemesis.txt' to exist");
+
+    assert_eq!(metric.value, 4);
 }
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index 8b4aab3e..8e57d5ae 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -5,12 +5,12 @@ use std::{convert::From, ops::AddAssign};
 pub mod byte;
 //pub mod block;
 //pub mod word_count;
-//pub mod line_count;
+pub mod line_count;
 
 pub enum FileSize {
     //Block(block::Metric),
     //WordCount(word_count::Metric),
-    //LineCount(line_count::Metric),
+    Line(line_count::Metric),
     Byte(byte::Metric),
 }
 
@@ -23,6 +23,9 @@ pub enum DiskUsage {
     /// How much actual space on disk in bytes, taking into account sparse files and compression.
     #[default]
     Physical,
+
+    /// How many total lines a file contains
+    Line,
 }
 
 impl FileSize {
@@ -30,6 +33,7 @@ impl FileSize {
     pub const fn value(&self) -> u64 {
         match self {
             Self::Byte(metric) => metric.value,
+            Self::Line(metric) => metric.value,
         }
     }
 }
@@ -38,6 +42,7 @@ impl AddAssign<&Self> for FileSize {
     fn add_assign(&mut self, rhs: &Self) {
         match self {
             Self::Byte(metric) => metric.value += rhs.value(),
+            Self::Line(metric) => metric.value += rhs.value(),
         }
     }
 }
@@ -45,7 +50,11 @@ impl AddAssign<&Self> for FileSize {
 impl From<&Context> for FileSize {
     fn from(ctx: &Context) -> Self {
         match ctx.disk_usage {
-            DiskUsage::Logical | DiskUsage::Physical => Self::Byte(byte::Metric::from(ctx)),
+            DiskUsage::Logical => Self::Byte(byte::Metric::init_empty_logical(ctx.human, ctx.unit)),
+            DiskUsage::Physical => {
+                Self::Byte(byte::Metric::init_empty_physical(ctx.human, ctx.unit))
+            }
+            DiskUsage::Line => Self::Line(line_count::Metric::default()),
         }
     }
 }
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 36b3247e..f3eecf27 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,6 +1,9 @@
 use crate::{
     context::Context,
-    disk_usage::{file_size::FileSize, units::PrefixKind},
+    disk_usage::{
+        file_size::{byte, line_count, FileSize},
+        units::PrefixKind,
+    },
     render::theme,
     styles::{self, PLACEHOLDER},
     tree::node::Node,
@@ -107,24 +110,8 @@ impl<'a> Cell<'a> {
         };
 
         match file_size {
-            FileSize::Byte(metric) => {
-                let max_size_width = ctx.max_size_width;
-                let max_unit_width = ctx.max_size_unit_width;
-                let out = format!("{metric}");
-                let [size, unit]: [&str; 2] =
-                    out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
-
-                if ctx.no_color() {
-                    write!(f, "{size:>max_size_width$} {unit:>max_unit_width$}")
-                } else {
-                    let color = styles::get_du_theme().unwrap().get(unit).unwrap();
-
-                    let out =
-                        color.paint(format!("{size:>max_size_width$} {unit:>max_unit_width$}"));
-
-                    write!(f, "{out}")
-                }
-            }
+            FileSize::Byte(metric) => Self::fmt_bytes(f, metric, ctx),
+            FileSize::Line(metric) => Self::fmt_line_count(f, metric, ctx),
         }
     }
 
@@ -244,7 +231,7 @@ impl<'a> Cell<'a> {
     }
 
     #[inline]
-    pub fn fmt_size_placeholder(f: &mut fmt::Formatter<'_>, ctx: &Context) -> fmt::Result {
+    fn fmt_size_placeholder(f: &mut fmt::Formatter<'_>, ctx: &Context) -> fmt::Result {
         if ctx.suppress_size || ctx.max_size_width == 0 {
             return write!(f, "");
         }
@@ -265,6 +252,40 @@ impl<'a> Cell<'a> {
 
         write!(f, "{placeholder:>placeholder_padding$}")
     }
+
+    #[inline]
+    fn fmt_bytes(f: &mut fmt::Formatter<'_>, metric: &byte::Metric, ctx: &Context) -> fmt::Result {
+        let max_size_width = ctx.max_size_width;
+        let max_unit_width = ctx.max_size_unit_width;
+        let out = format!("{metric}");
+        let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
+
+        if ctx.no_color() {
+            return write!(f, "{size:>max_size_width$} {unit:>max_unit_width$}");
+        }
+
+        let color = styles::get_du_theme().unwrap().get(unit).unwrap();
+
+        let out = color.paint(format!("{size:>max_size_width$} {unit:>max_unit_width$}"));
+
+        write!(f, "{out}")
+    }
+
+    #[inline]
+    fn fmt_line_count(
+        f: &mut fmt::Formatter<'_>,
+        metric: &line_count::Metric,
+        ctx: &Context,
+    ) -> fmt::Result {
+        let max_size_width = ctx.max_size_width;
+
+        if ctx.no_color() {
+            return write!(f, "{metric:>max_size_width$}");
+        }
+        let color = styles::get_du_theme().unwrap().get("B").unwrap();
+
+        write!(f, "{}", color.paint(format!("{metric:>max_size_width$}")))
+    }
 }
 
 impl Display for Cell<'_> {
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index 340b9a73..726d552e 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -1,7 +1,7 @@
 use crate::{
     context::{file, output::ColumnProperties, Context},
     disk_usage::{
-        file_size::FileSize,
+        file_size::{DiskUsage, FileSize},
         units::{BinPrefix, PrefixKind, SiPrefix},
     },
     fs::inode::Inode,
@@ -315,20 +315,25 @@ impl Tree {
                 col_props.max_size_width = file_size_cols;
             }
 
-            let unit_len = match ctx.unit {
-                PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
-                    BinPrefix::Base => 1,
-                    _ => 3,
-                },
-                PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
-                    SiPrefix::Base => 1,
-                    _ => 2,
-                },
-                _ => 1,
-            };
-
-            if unit_len > col_props.max_size_unit_width {
-                col_props.max_size_unit_width = unit_len;
+            match ctx.disk_usage {
+                DiskUsage::Logical | DiskUsage::Physical => {
+                    let unit_len = match ctx.unit {
+                        PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
+                            BinPrefix::Base => 1,
+                            _ => 3,
+                        },
+                        PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
+                            SiPrefix::Base => 1,
+                            _ => 2,
+                        },
+                        _ => 1,
+                    };
+
+                    if unit_len > col_props.max_size_unit_width {
+                        col_props.max_size_unit_width = unit_len;
+                    }
+                }
+                DiskUsage::Line => (),
             }
         }
 
@@ -369,20 +374,25 @@ impl Tree {
                 col_props.max_size_width = file_size_cols;
             }
 
-            let unit_len = match ctx.unit {
-                PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
-                    BinPrefix::Base => 1,
-                    _ => 3,
-                },
-                PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
-                    SiPrefix::Base => 1,
-                    _ => 2,
-                },
-                _ => 1,
-            };
-
-            if unit_len > col_props.max_size_unit_width {
-                col_props.max_size_unit_width = unit_len;
+            match ctx.disk_usage {
+                DiskUsage::Logical | DiskUsage::Physical => {
+                    let unit_len = match ctx.unit {
+                        PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
+                            BinPrefix::Base => 1,
+                            _ => 3,
+                        },
+                        PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
+                            SiPrefix::Base => 1,
+                            _ => 2,
+                        },
+                        _ => 1,
+                    };
+
+                    if unit_len > col_props.max_size_unit_width {
+                        col_props.max_size_unit_width = unit_len;
+                    }
+                }
+                _ => (),
             }
         }
     }
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 444c6b06..33ce7f5f 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
     context::Context,
-    disk_usage::file_size::{byte, DiskUsage, FileSize},
+    disk_usage::file_size::{byte, line_count, DiskUsage, FileSize},
     fs::inode::Inode,
     icons,
     styles::get_ls_colors,
@@ -245,6 +245,10 @@ impl TryFrom<(DirEntry, &Context)> for Node {
                                 byte::Metric::init_physical(path, &metadata, ctx.unit, ctx.human);
                             Some(FileSize::Byte(metric))
                         }
+                        DiskUsage::Line => {
+                            let metric = line_count::Metric::init_lc(path);
+                            metric.map(FileSize::Line)
+                        }
                     }
                 } else {
                     None
diff --git a/tests/line_count.rs b/tests/line_count.rs
new file mode 100644
index 00000000..dcd19472
--- /dev/null
+++ b/tests/line_count.rs
@@ -0,0 +1,24 @@
+use indoc::indoc;
+
+mod utils;
+
+#[test]
+fn line_count() {
+    assert_eq!(
+        utils::run_cmd(&["--disk-usage", "line", "tests/data"]),
+        indoc!(
+            "6    ┌─ cassildas_song.md
+ 6 ┌─ the_yellow_king
+ 1 ├─ nylarlathotep.txt
+ 4 ├─ nemesis.txt
+ 2 ├─ necronomicon.txt
+ 1 │  ┌─ lipsum.txt
+ 1 ├─ lipsum
+10 │  ┌─ polaris.txt
+10 ├─ dream_cycle
+24 data
+
+3 directories, 6 files"
+        )
+    )
+}

From 46c56951bb1378bfa9002be1beac706a65a09d51 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 22 May 2023 00:38:06 -0700
Subject: [PATCH 4/7] support block display

---
 src/disk_usage/file_size/block.rs | 21 ++++++++++++++++++++-
 src/disk_usage/file_size/mod.rs   | 30 +++++++++++++++++++++++-------
 src/render/grid/cell.rs           | 11 +++++++----
 src/tree/mod.rs                   |  2 +-
 src/tree/node/mod.rs              | 15 ++++++++++++---
 5 files changed, 63 insertions(+), 16 deletions(-)

diff --git a/src/disk_usage/file_size/block.rs b/src/disk_usage/file_size/block.rs
index f845daeb..bcb982ec 100644
--- a/src/disk_usage/file_size/block.rs
+++ b/src/disk_usage/file_size/block.rs
@@ -1,3 +1,22 @@
+use std::{
+    fmt::{self, Display},
+    fs::Metadata,
+    os::unix::fs::MetadataExt,
+};
+
+#[derive(Default)]
 pub struct Metric {
-    value: u64,
+    pub value: u64,
+}
+
+impl Metric {
+    pub fn init(md: &Metadata) -> Self {
+        Self { value: md.blocks() }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <u64 as Display>::fmt(&self.value, f)
+    }
 }
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index 8e57d5ae..9c667d14 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -2,16 +2,19 @@ use crate::context::Context;
 use clap::ValueEnum;
 use std::{convert::From, ops::AddAssign};
 
+#[cfg(unix)]
+pub mod block;
+
 pub mod byte;
-//pub mod block;
 //pub mod word_count;
 pub mod line_count;
 
+/// Represents all the different ways in which a filesize could be reported using various metrics.
 pub enum FileSize {
-    //Block(block::Metric),
     //WordCount(word_count::Metric),
     Line(line_count::Metric),
     Byte(byte::Metric),
+    Block(block::Metric),
 }
 
 /// Determines between logical or physical size for display
@@ -26,6 +29,10 @@ pub enum DiskUsage {
 
     /// How many total lines a file contains
     Line,
+
+    /// How many blocks are allocated to store the file
+    #[cfg(unix)]
+    Block,
 }
 
 impl FileSize {
@@ -34,6 +41,9 @@ impl FileSize {
         match self {
             Self::Byte(metric) => metric.value,
             Self::Line(metric) => metric.value,
+
+            #[cfg(unix)]
+            Self::Block(metric) => metric.value,
         }
     }
 }
@@ -43,18 +53,24 @@ impl AddAssign<&Self> for FileSize {
         match self {
             Self::Byte(metric) => metric.value += rhs.value(),
             Self::Line(metric) => metric.value += rhs.value(),
+
+            #[cfg(unix)]
+            Self::Block(metric) => metric.value += rhs.value(),
         }
     }
 }
 
 impl From<&Context> for FileSize {
     fn from(ctx: &Context) -> Self {
+        use DiskUsage::*;
+
         match ctx.disk_usage {
-            DiskUsage::Logical => Self::Byte(byte::Metric::init_empty_logical(ctx.human, ctx.unit)),
-            DiskUsage::Physical => {
-                Self::Byte(byte::Metric::init_empty_physical(ctx.human, ctx.unit))
-            }
-            DiskUsage::Line => Self::Line(line_count::Metric::default()),
+            Logical => Self::Byte(byte::Metric::init_empty_logical(ctx.human, ctx.unit)),
+            Physical => Self::Byte(byte::Metric::init_empty_physical(ctx.human, ctx.unit)),
+            Line => Self::Line(line_count::Metric::default()),
+
+            #[cfg(unix)]
+            Block => Self::Block(block::Metric::default()),
         }
     }
 }
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index f3eecf27..c2fee9ab 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,7 +1,7 @@
 use crate::{
     context::Context,
     disk_usage::{
-        file_size::{byte, line_count, FileSize},
+        file_size::{byte, FileSize},
         units::PrefixKind,
     },
     render::theme,
@@ -111,7 +111,10 @@ impl<'a> Cell<'a> {
 
         match file_size {
             FileSize::Byte(metric) => Self::fmt_bytes(f, metric, ctx),
-            FileSize::Line(metric) => Self::fmt_line_count(f, metric, ctx),
+            FileSize::Line(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
+
+            #[cfg(unix)]
+            FileSize::Block(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
         }
     }
 
@@ -272,9 +275,9 @@ impl<'a> Cell<'a> {
     }
 
     #[inline]
-    fn fmt_line_count(
+    fn fmt_unitless_disk_usage<M: Display>(
         f: &mut fmt::Formatter<'_>,
-        metric: &line_count::Metric,
+        metric: &M,
         ctx: &Context,
     ) -> fmt::Result {
         let max_size_width = ctx.max_size_width;
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index 726d552e..bc58f809 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -333,7 +333,7 @@ impl Tree {
                         col_props.max_size_unit_width = unit_len;
                     }
                 }
-                DiskUsage::Line => (),
+                DiskUsage::Line | DiskUsage::Block => (),
             }
         }
 
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 33ce7f5f..6c92b190 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -19,9 +19,12 @@ use std::{
 };
 
 #[cfg(unix)]
-use crate::fs::{
-    permissions::{FileMode, SymbolicNotation},
-    xattr::ExtendedAttr,
+use crate::{
+    disk_usage::file_size::block,
+    fs::{
+        permissions::{FileMode, SymbolicNotation},
+        xattr::ExtendedAttr,
+    },
 };
 
 /// Ordering and sorting rules for [Node].
@@ -249,6 +252,12 @@ impl TryFrom<(DirEntry, &Context)> for Node {
                             let metric = line_count::Metric::init_lc(path);
                             metric.map(FileSize::Line)
                         }
+
+                        #[cfg(unix)]
+                        DiskUsage::Block => {
+                            let metric = block::Metric::init(&metadata);
+                            Some(FileSize::Block(metric))
+                        }
                     }
                 } else {
                     None

From 6a664acea9e79b3c5f28548b85fcb2242e4d7aa3 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 22 May 2023 21:19:30 -0700
Subject: [PATCH 5/7] word count

---
 src/disk_usage/file_size/line_count.rs | 14 ++++-----
 src/disk_usage/file_size/mod.rs        | 10 +++++--
 src/disk_usage/file_size/word_count.rs | 40 +++++++++++++++++++++++++-
 src/render/grid/cell.rs                | 24 ++++++++++------
 src/tree/mod.rs                        |  2 +-
 src/tree/node/mod.rs                   |  8 ++++--
 6 files changed, 74 insertions(+), 24 deletions(-)

diff --git a/src/disk_usage/file_size/line_count.rs b/src/disk_usage/file_size/line_count.rs
index ac0bbc52..7f29f1e0 100644
--- a/src/disk_usage/file_size/line_count.rs
+++ b/src/disk_usage/file_size/line_count.rs
@@ -11,14 +11,10 @@ pub struct Metric {
 }
 
 impl Metric {
-    pub fn init_lc<P: AsRef<Path>>(path: P) -> Option<Self> {
-        let data = fs::read(path.as_ref()).ok();
+    pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
+        let data = fs::read(path.as_ref()).ok()?;
 
-        let Some(text) = data else {
-            return None;
-        };
-
-        let lines = text.into_iter().fold(0, |acc, item| {
+        let lines = data.into_iter().fold(0, |acc, item| {
             if u32::from(item) == u32::from('\n') {
                 acc + 1
             } else {
@@ -43,8 +39,8 @@ impl Display for Metric {
 }
 
 #[test]
-fn test_lc() {
-    let metric = Metric::init_lc("tests/data/nemesis.txt")
+fn test_line_count() {
+    let metric = Metric::init("tests/data/nemesis.txt")
         .expect("Expected 'tests/data/nemesis.txt' to exist");
 
     assert_eq!(metric.value, 4);
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index 9c667d14..333d7e2a 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -6,12 +6,12 @@ use std::{convert::From, ops::AddAssign};
 pub mod block;
 
 pub mod byte;
-//pub mod word_count;
+pub mod word_count;
 pub mod line_count;
 
 /// Represents all the different ways in which a filesize could be reported using various metrics.
 pub enum FileSize {
-    //WordCount(word_count::Metric),
+    Word(word_count::Metric),
     Line(line_count::Metric),
     Byte(byte::Metric),
     Block(block::Metric),
@@ -30,6 +30,9 @@ pub enum DiskUsage {
     /// How many total lines a file contains
     Line,
 
+    /// How many total words a file contains
+    Word,
+
     /// How many blocks are allocated to store the file
     #[cfg(unix)]
     Block,
@@ -41,6 +44,7 @@ impl FileSize {
         match self {
             Self::Byte(metric) => metric.value,
             Self::Line(metric) => metric.value,
+            Self::Word(metric) => metric.value,
 
             #[cfg(unix)]
             Self::Block(metric) => metric.value,
@@ -53,6 +57,7 @@ impl AddAssign<&Self> for FileSize {
         match self {
             Self::Byte(metric) => metric.value += rhs.value(),
             Self::Line(metric) => metric.value += rhs.value(),
+            Self::Word(metric) => metric.value += rhs.value(),
 
             #[cfg(unix)]
             Self::Block(metric) => metric.value += rhs.value(),
@@ -68,6 +73,7 @@ impl From<&Context> for FileSize {
             Logical => Self::Byte(byte::Metric::init_empty_logical(ctx.human, ctx.unit)),
             Physical => Self::Byte(byte::Metric::init_empty_physical(ctx.human, ctx.unit)),
             Line => Self::Line(line_count::Metric::default()),
+            Word => Self::Word(word_count::Metric::default()),
 
             #[cfg(unix)]
             Block => Self::Block(block::Metric::default()),
diff --git a/src/disk_usage/file_size/word_count.rs b/src/disk_usage/file_size/word_count.rs
index f845daeb..13056104 100644
--- a/src/disk_usage/file_size/word_count.rs
+++ b/src/disk_usage/file_size/word_count.rs
@@ -1,3 +1,41 @@
+use std::{
+    convert::{AsRef, From},
+    fmt::{self, Display},
+    fs,
+    path::Path,
+};
+
+#[derive(Default)]
 pub struct Metric {
-    value: u64,
+    pub value: u64,
+}
+
+impl Metric {
+    pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
+        let data = fs::read_to_string(path.as_ref()).ok()?;
+
+        let words = data.split_whitespace().count();
+
+        u64::try_from(words).map(|value| Self { value }).ok()
+    }
+}
+
+impl From<u64> for Metric {
+    fn from(value: u64) -> Self {
+        Self { value }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <u64 as Display>::fmt(&self.value, f)
+    }
+}
+
+#[test]
+fn test_line_count() {
+    let metric = Metric::init("tests/data/nemesis.txt")
+        .expect("Expected 'tests/data/nemesis.txt' to exist");
+
+    assert_eq!(metric.value, 27);
 }
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index c2fee9ab..be4a57fb 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,7 +1,7 @@
 use crate::{
     context::Context,
     disk_usage::{
-        file_size::{byte, FileSize},
+        file_size::{byte, DiskUsage, FileSize},
         units::PrefixKind,
     },
     render::theme,
@@ -112,6 +112,7 @@ impl<'a> Cell<'a> {
         match file_size {
             FileSize::Byte(metric) => Self::fmt_bytes(f, metric, ctx),
             FileSize::Line(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
+            FileSize::Word(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
 
             #[cfg(unix)]
             FileSize::Block(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
@@ -244,14 +245,19 @@ impl<'a> Cell<'a> {
             |style| Cow::from(style.paint(styles::PLACEHOLDER).to_string()),
         );
 
-        let placeholder_padding = placeholder.len()
-            + ctx.max_size_width
-            + match ctx.unit {
-                PrefixKind::Si if ctx.human => 2,
-                PrefixKind::Bin if ctx.human => 3,
-                PrefixKind::Si => 0,
-                PrefixKind::Bin => 1,
-            };
+        let mut placeholder_padding = placeholder.len() + ctx.max_size_width - 1;
+
+        placeholder_padding += match ctx.disk_usage {
+            DiskUsage::Logical | DiskUsage::Physical => {
+                match ctx.unit {
+                    PrefixKind::Si if ctx.human => 2,
+                    PrefixKind::Bin if ctx.human => 3,
+                    PrefixKind::Si => 0,
+                    PrefixKind::Bin => 1,
+                }
+            },
+            _ => 0
+        };
 
         write!(f, "{placeholder:>placeholder_padding$}")
     }
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index bc58f809..1792892f 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -333,7 +333,7 @@ impl Tree {
                         col_props.max_size_unit_width = unit_len;
                     }
                 }
-                DiskUsage::Line | DiskUsage::Block => (),
+                DiskUsage::Line | DiskUsage::Word | DiskUsage::Block => (),
             }
         }
 
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 6c92b190..db54703c 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
     context::Context,
-    disk_usage::file_size::{byte, line_count, DiskUsage, FileSize},
+    disk_usage::file_size::{byte, line_count, word_count, DiskUsage, FileSize},
     fs::inode::Inode,
     icons,
     styles::get_ls_colors,
@@ -249,9 +249,13 @@ impl TryFrom<(DirEntry, &Context)> for Node {
                             Some(FileSize::Byte(metric))
                         }
                         DiskUsage::Line => {
-                            let metric = line_count::Metric::init_lc(path);
+                            let metric = line_count::Metric::init(path);
                             metric.map(FileSize::Line)
                         }
+                        DiskUsage::Word => {
+                            let metric = word_count::Metric::init(path);
+                            metric.map(FileSize::Word)
+                        }
 
                         #[cfg(unix)]
                         DiskUsage::Block => {

From 6ed6b4c94d8d29cd5f5721b28ace1096ef79e913 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 22 May 2023 22:12:51 -0700
Subject: [PATCH 6/7] word count

---
 src/disk_usage/file_size/line_count.rs | 14 ++++----------
 src/disk_usage/file_size/mod.rs        |  6 +++---
 src/disk_usage/file_size/word_count.rs |  4 ++--
 src/render/grid/cell.rs                | 14 ++++++--------
 src/render/theme.rs                    |  4 ++--
 5 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/src/disk_usage/file_size/line_count.rs b/src/disk_usage/file_size/line_count.rs
index 7f29f1e0..e83b34de 100644
--- a/src/disk_usage/file_size/line_count.rs
+++ b/src/disk_usage/file_size/line_count.rs
@@ -12,15 +12,9 @@ pub struct Metric {
 
 impl Metric {
     pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
-        let data = fs::read(path.as_ref()).ok()?;
+        let data = fs::read_to_string(path.as_ref()).ok()?;
 
-        let lines = data.into_iter().fold(0, |acc, item| {
-            if u32::from(item) == u32::from('\n') {
-                acc + 1
-            } else {
-                acc
-            }
-        });
+        let lines = data.lines().count();
 
         u64::try_from(lines).map(|value| Self { value }).ok()
     }
@@ -40,8 +34,8 @@ impl Display for Metric {
 
 #[test]
 fn test_line_count() {
-    let metric = Metric::init("tests/data/nemesis.txt")
-        .expect("Expected 'tests/data/nemesis.txt' to exist");
+    let metric =
+        Metric::init("tests/data/nemesis.txt").expect("Expected 'tests/data/nemesis.txt' to exist");
 
     assert_eq!(metric.value, 4);
 }
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index 333d7e2a..3905111b 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -6,8 +6,8 @@ use std::{convert::From, ops::AddAssign};
 pub mod block;
 
 pub mod byte;
-pub mod word_count;
 pub mod line_count;
+pub mod word_count;
 
 /// Represents all the different ways in which a filesize could be reported using various metrics.
 pub enum FileSize {
@@ -67,7 +67,7 @@ impl AddAssign<&Self> for FileSize {
 
 impl From<&Context> for FileSize {
     fn from(ctx: &Context) -> Self {
-        use DiskUsage::*;
+        use DiskUsage::{Line, Logical, Physical, Word};
 
         match ctx.disk_usage {
             Logical => Self::Byte(byte::Metric::init_empty_logical(ctx.human, ctx.unit)),
@@ -76,7 +76,7 @@ impl From<&Context> for FileSize {
             Word => Self::Word(word_count::Metric::default()),
 
             #[cfg(unix)]
-            Block => Self::Block(block::Metric::default()),
+            DiskUsage::Block => Self::Block(block::Metric::default()),
         }
     }
 }
diff --git a/src/disk_usage/file_size/word_count.rs b/src/disk_usage/file_size/word_count.rs
index 13056104..ccb8c4fa 100644
--- a/src/disk_usage/file_size/word_count.rs
+++ b/src/disk_usage/file_size/word_count.rs
@@ -34,8 +34,8 @@ impl Display for Metric {
 
 #[test]
 fn test_line_count() {
-    let metric = Metric::init("tests/data/nemesis.txt")
-        .expect("Expected 'tests/data/nemesis.txt' to exist");
+    let metric =
+        Metric::init("tests/data/nemesis.txt").expect("Expected 'tests/data/nemesis.txt' to exist");
 
     assert_eq!(metric.value, 27);
 }
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index be4a57fb..8ffa53f3 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -248,15 +248,13 @@ impl<'a> Cell<'a> {
         let mut placeholder_padding = placeholder.len() + ctx.max_size_width - 1;
 
         placeholder_padding += match ctx.disk_usage {
-            DiskUsage::Logical | DiskUsage::Physical => {
-                match ctx.unit {
-                    PrefixKind::Si if ctx.human => 2,
-                    PrefixKind::Bin if ctx.human => 3,
-                    PrefixKind::Si => 0,
-                    PrefixKind::Bin => 1,
-                }
+            DiskUsage::Logical | DiskUsage::Physical => match ctx.unit {
+                PrefixKind::Si if ctx.human => 2,
+                PrefixKind::Bin if ctx.human => 3,
+                PrefixKind::Si => 0,
+                PrefixKind::Bin => 1,
             },
-            _ => 0
+            _ => 0,
         };
 
         write!(f, "{placeholder:>placeholder_padding$}")
diff --git a/src/render/theme.rs b/src/render/theme.rs
index d2a97b92..8b3e0410 100644
--- a/src/render/theme.rs
+++ b/src/render/theme.rs
@@ -55,8 +55,8 @@ pub fn stylize_file_name(node: &Node) -> Cow<'_, str> {
         return name.to_string_lossy();
     };
 
-    if style.is_some() {
-        let styled_name = stylize_file_name(node);
+    if let Some(color) = style {
+        let styled_name = color.paint(name.to_string_lossy());
         let target_name = Color::Red.paint(format!("\u{2192} {}", target_name.to_string_lossy()));
 
         return Cow::from(format!("{styled_name} {target_name}"));

From ce90529168079fbcfb43464f307ff0f5d259fee4 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 22 May 2023 22:49:15 -0700
Subject: [PATCH 7/7] doc comments

---
 src/disk_usage/file_size/byte.rs       | 9 +++++++++
 src/disk_usage/file_size/line_count.rs | 4 ++++
 src/disk_usage/file_size/mod.rs        | 7 +++++++
 src/disk_usage/file_size/word_count.rs | 6 ++++++
 src/disk_usage/mod.rs                  | 2 ++
 src/tree/node/mod.rs                   | 2 +-
 6 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index ac0f4fd4..4ecfef78 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -6,6 +6,8 @@ use std::{
     path::Path,
 };
 
+/// Concerned with measuring file size in bytes, whether logical or physical determined by `kind`.
+/// Binary or SI units used for reporting determined by `prefix_kind`.
 pub struct Metric {
     pub value: u64,
     pub human_readable: bool,
@@ -14,12 +16,16 @@ pub struct Metric {
     prefix_kind: PrefixKind,
 }
 
+/// Represents the appropriate method in which to compute bytes. `Logical` represent the total amount
+/// of bytes in a file; `Physical` represents how many bytes are actually used to store the file on
+/// disk.
 pub enum MetricKind {
     Logical,
     Physical,
 }
 
 impl Metric {
+    /// Initializes a [Metric] that stores the total amount of bytes in a file.
     pub fn init_logical(
         metadata: &Metadata,
         prefix_kind: PrefixKind,
@@ -36,6 +42,7 @@ impl Metric {
         }
     }
 
+    /// Initializes an empty [Metric] used to represent the total amount of bytes of a file.
     pub const fn init_empty_logical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
         Self {
             value: 0,
@@ -45,6 +52,7 @@ impl Metric {
         }
     }
 
+    /// Initializes an empty [Metric] used to represent the total disk space of a file in bytes.
     pub const fn init_empty_physical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
         Self {
             value: 0,
@@ -54,6 +62,7 @@ impl Metric {
         }
     }
 
+    /// Initializes a [Metric] that stores the total amount of bytes used to store a file on disk.
     pub fn init_physical(
         path: &Path,
         metadata: &Metadata,
diff --git a/src/disk_usage/file_size/line_count.rs b/src/disk_usage/file_size/line_count.rs
index e83b34de..1c145315 100644
--- a/src/disk_usage/file_size/line_count.rs
+++ b/src/disk_usage/file_size/line_count.rs
@@ -5,12 +5,16 @@ use std::{
     path::Path,
 };
 
+/// Concerned with measuring file size using line count as a metric.
 #[derive(Default)]
 pub struct Metric {
     pub value: u64,
 }
 
 impl Metric {
+    /// Reads in contents of a file given by `path` and attempts to compute the total number of
+    /// lines in that file. If a file is not UTF-8 encoded as in the case of a binary jpeg file
+    /// then `None` will be returned.
     pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
         let data = fs::read_to_string(path.as_ref()).ok()?;
 
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index 3905111b..fd210412 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -2,11 +2,17 @@ use crate::context::Context;
 use clap::ValueEnum;
 use std::{convert::From, ops::AddAssign};
 
+/// Concerned with measuring file size in blocks.
 #[cfg(unix)]
 pub mod block;
 
+/// Concerned with measuring file size in bytes, logical or physical.
 pub mod byte;
+
+/// Concerned with measuring file size by line count.
 pub mod line_count;
+
+/// Concerned with measuring file size by word count.
 pub mod word_count;
 
 /// Represents all the different ways in which a filesize could be reported using various metrics.
@@ -39,6 +45,7 @@ pub enum DiskUsage {
 }
 
 impl FileSize {
+    /// Extracts the inner value of [`FileSize`] which represents the file size for various metrics.
     #[inline]
     pub const fn value(&self) -> u64 {
         match self {
diff --git a/src/disk_usage/file_size/word_count.rs b/src/disk_usage/file_size/word_count.rs
index ccb8c4fa..92ebf8d1 100644
--- a/src/disk_usage/file_size/word_count.rs
+++ b/src/disk_usage/file_size/word_count.rs
@@ -5,12 +5,18 @@ use std::{
     path::Path,
 };
 
+/// Concerned with measuring file size using word count as a metric.
 #[derive(Default)]
 pub struct Metric {
     pub value: u64,
 }
 
 impl Metric {
+    /// Reads in contents of a file given by `path` and attempts to compute the total number of
+    /// words in that file. If a file is not UTF-8 encoded as in the case of a binary jpeg file
+    /// then `None` will be returned.
+    ///
+    /// Words are UTF-8 encoded byte sequences delimited by Unicode Derived Core Property `White_Space`.
     pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
         let data = fs::read_to_string(path.as_ref()).ok()?;
 
diff --git a/src/disk_usage/mod.rs b/src/disk_usage/mod.rs
index 84582ca7..c855943f 100644
--- a/src/disk_usage/mod.rs
+++ b/src/disk_usage/mod.rs
@@ -1,4 +1,6 @@
 /// Binary and SI prefixes
 pub mod units;
 
+/// Concerned with all of the different ways to measure file size: bytes, word-count, line-count,
+/// blocks (unix), etc..
 pub mod file_size;
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index db54703c..4281821d 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -204,7 +204,7 @@ impl Node {
         self.style
     }
 
-    /// See [`icons::compute`].
+    /// See [`crate::icons::fs::compute`].
     pub fn compute_icon(&self, no_color: bool) -> Cow<'static, str> {
         if no_color {
             icons::fs::compute(self.dir_entry(), self.symlink_target_path())