From 2813c7b33509dad08c483f61e623ecc6bbcea8f3 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Fri, 14 Apr 2023 00:30:18 -0700
Subject: [PATCH 01/33] preliminary support for unix symbolic notation
 permissions

---
 Cargo.lock                      | 46 ++++++++++++++++-
 Cargo.toml                      |  3 ++
 src/fs/mod.rs                   |  4 ++
 src/fs/permissions/error.rs     | 10 ++++
 src/fs/permissions/file_type.rs | 54 ++++++++++++++++++++
 src/fs/permissions/mod.rs       | 87 +++++++++++++++++++++++++++++++++
 src/fs/permissions/mode.rs      | 72 +++++++++++++++++++++++++++
 tests/utils/mod.rs              | 10 +++-
 8 files changed, 283 insertions(+), 3 deletions(-)
 create mode 100644 src/fs/permissions/error.rs
 create mode 100644 src/fs/permissions/file_type.rs
 create mode 100644 src/fs/permissions/mod.rs
 create mode 100644 src/fs/permissions/mode.rs

diff --git a/Cargo.lock b/Cargo.lock
index 05047386..2f9588f3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,6 +26,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -113,6 +119,7 @@ dependencies = [
  "indoc",
  "is-terminal",
  "lscolors",
+ "nix",
  "once_cell",
  "regex",
  "strip-ansi-escapes",
@@ -270,9 +277,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.140"
+version = "0.2.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
+checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5"
 
 [[package]]
 name = "linux-raw-sys"
@@ -311,6 +318,29 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
+[[package]]
+name = "memoffset"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "nix"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfdda3d196821d6af13126e40375cdf7da646a96114af134d5f417a9a1dc8e1a"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "memoffset",
+ "pin-utils",
+ "static_assertions",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -339,6 +369,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -450,6 +486,12 @@ version = "1.0.156"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
 
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "strip-ansi-escapes"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index cb5621b6..d5fbafd4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,6 +36,9 @@ once_cell = "1.17.0"
 regex = "1.7.3"
 thiserror = "1.0.40"
 
+[target.'cfg(unix)'.dependencies]
+nix = { version = "0.26.2", features = ["fs"] }
+
 [dev-dependencies]
 indoc = "2.0.0"
 strip-ansi-escapes = "0.1.1"
diff --git a/src/fs/mod.rs b/src/fs/mod.rs
index 73e5b5c1..f6295644 100644
--- a/src/fs/mod.rs
+++ b/src/fs/mod.rs
@@ -4,6 +4,10 @@ use std::{fs, path::PathBuf};
 /// Operations pertaining to underlying inodes of files.
 pub mod inode;
 
+/// Unix file permissions.
+#[cfg(unix)]
+pub mod permissions;
+
 /// Returns the path to the target of the soft link. Returns `None` if provided `dir_entry` isn't a
 /// symlink.
 pub fn symlink_target(dir_entry: &DirEntry) -> Option<PathBuf> {
diff --git a/src/fs/permissions/error.rs b/src/fs/permissions/error.rs
new file mode 100644
index 00000000..25a8165a
--- /dev/null
+++ b/src/fs/permissions/error.rs
@@ -0,0 +1,10 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Unknown file type.")]
+    UnknownFileType,
+
+    #[error("Failed to compute file mode.")]
+    UnknownMode,
+}
diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
new file mode 100644
index 00000000..e4e319cf
--- /dev/null
+++ b/src/fs/permissions/file_type.rs
@@ -0,0 +1,54 @@
+use super::error::Error;
+use nix::sys::stat::SFlag;
+
+/// Unix file types.
+pub enum FileType {
+    Directory,
+    File,
+    Symlink,
+    Fifo,
+    Socket,
+    CharDevice,
+    BlockDevice,
+}
+
+impl FileType {
+    /// Unix file identifiers that you'd find in the `ls -l` command.
+    pub const fn identifier(&self) -> char {
+        match self {
+            Self::Directory => 'd',
+            Self::File => '.',
+            Self::Symlink => 'l',
+            Self::Fifo => 'p',
+            Self::Socket => 's',
+            Self::CharDevice => 'c',
+            Self::BlockDevice => 'b',
+        }
+    }
+}
+
+impl TryFrom<u32> for FileType {
+    type Error = Error;
+
+    fn try_from(mode: u32) -> Result<Self, Self::Error> {
+        let file_mask = mode & u32::from(SFlag::S_IFMT.bits());
+
+        if file_mask == u32::from(SFlag::S_IFIFO.bits()) {
+            Ok(Self::Fifo)
+        } else if file_mask == u32::from(SFlag::S_IFCHR.bits()) {
+            Ok(Self::CharDevice)
+        } else if file_mask == u32::from(SFlag::S_IFDIR.bits()) {
+            Ok(Self::Directory)
+        } else if file_mask == u32::from(SFlag::S_IFBLK.bits()) {
+            Ok(Self::BlockDevice)
+        } else if file_mask == u32::from(SFlag::S_IFREG.bits()) {
+            Ok(Self::File)
+        } else if file_mask == u32::from(SFlag::S_IFLNK.bits()) {
+            Ok(Self::Symlink)
+        } else if file_mask == u32::from(SFlag::S_IFSOCK.bits()) {
+            Ok(Self::Socket)
+        } else {
+            Err(Error::UnknownFileType)
+        }
+    }
+}
diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
new file mode 100644
index 00000000..ada28bb3
--- /dev/null
+++ b/src/fs/permissions/mod.rs
@@ -0,0 +1,87 @@
+use error::Error;
+use file_type::FileType;
+use mode::Mode;
+use nix::sys::stat::SFlag;
+use std::{
+    convert::TryFrom,
+    fmt::{self, Display},
+    fs::Permissions,
+    os::unix::fs::PermissionsExt,
+};
+
+/// File permission related errors.
+pub mod error;
+
+pub mod file_type;
+
+pub mod mode;
+
+pub struct FileMode {
+    file_type: FileType,
+    user_mode: Mode,
+    group_mode: Mode,
+    other_mode: Mode,
+}
+
+impl FileMode {
+    pub const fn new(
+        file_type: FileType,
+        user_mode: Mode,
+        group_mode: Mode,
+        other_mode: Mode,
+    ) -> Self {
+        Self {
+            file_type,
+            user_mode,
+            group_mode,
+            other_mode,
+        }
+    }
+
+    const fn file_type(&self) -> &FileType {
+        &self.file_type
+    }
+
+    const fn user_mode(&self) -> &Mode {
+        &self.user_mode
+    }
+
+    const fn group_mode(&self) -> &Mode {
+        &self.group_mode
+    }
+
+    const fn other_mode(&self) -> &Mode {
+        &self.other_mode
+    }
+}
+
+impl Display for FileMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let file_iden = self.file_type().identifier();
+        let user_mode = self.user_mode();
+        let group_mode = self.group_mode();
+        let other_mode = self.other_mode();
+
+        write!(f, "{file_iden}{user_mode}{group_mode}{other_mode}")
+    }
+}
+
+impl TryFrom<Permissions> for FileMode {
+    type Error = Error;
+
+    fn try_from(permissions: Permissions) -> Result<Self, Self::Error> {
+        let mode = permissions.mode();
+        let file_type = FileType::try_from(mode)?;
+        let mode_mask = mode & !u32::from(SFlag::S_IFMT.bits());
+        let user_mode = Mode::try_user_mode_from(mode_mask)?;
+        let group_mode = Mode::try_group_mode_from(mode_mask)?;
+        let other_mode = Mode::try_other_mode_from(mode_mask)?;
+
+        Ok(Self {
+            file_type,
+            user_mode,
+            group_mode,
+            other_mode,
+        })
+    }
+}
diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
new file mode 100644
index 00000000..fd6b596e
--- /dev/null
+++ b/src/fs/permissions/mode.rs
@@ -0,0 +1,72 @@
+use super::error::Error;
+use nix::sys::stat::Mode as SMode;
+use std::fmt::{self, Display};
+
+pub enum Mode {
+    Read,
+    Write,
+    Execute,
+    ReadWrite,
+    ReadExecute,
+    WriteExecute,
+    ReadWriteExecute,
+}
+
+impl Mode {
+    pub fn try_user_mode_from(mode_mask: u32) -> Result<Self, Error> {
+        let owner = mode_mask & u32::from(SMode::S_IRWXU.bits());
+
+        let read = owner & u32::from(SMode::S_IRUSR.bits()) != 0;
+        let write = owner & u32::from(SMode::S_IWUSR.bits()) != 0;
+        let execute = owner & u32::from(SMode::S_IXUSR.bits()) != 0;
+
+        Self::try_mode_from_rwx(read, write, execute)
+    }
+
+    pub fn try_group_mode_from(mode_mask: u32) -> Result<Self, Error> {
+        let owner = mode_mask & u32::from(SMode::S_IRWXG.bits());
+
+        let read = owner & u32::from(SMode::S_IRGRP.bits()) != 0;
+        let write = owner & u32::from(SMode::S_IWGRP.bits()) != 0;
+        let execute = owner & u32::from(SMode::S_IXGRP.bits()) != 0;
+
+        Self::try_mode_from_rwx(read, write, execute)
+    }
+
+    pub fn try_other_mode_from(mode_mask: u32) -> Result<Self, Error> {
+        let owner = mode_mask & u32::from(SMode::S_IRWXO.bits());
+
+        let read = owner & u32::from(SMode::S_IROTH.bits()) != 0;
+        let write = owner & u32::from(SMode::S_IWOTH.bits()) != 0;
+        let execute = owner & u32::from(SMode::S_IXOTH.bits()) != 0;
+
+        Self::try_mode_from_rwx(read, write, execute)
+    }
+
+    const fn try_mode_from_rwx(r: bool, w: bool, x: bool) -> Result<Self, Error> {
+        match (r, w, x) {
+            (true, false, false) => Ok(Self::Read),
+            (false, true, false) => Ok(Self::Write),
+            (false, false, true) => Ok(Self::Execute),
+            (true, true, false) => Ok(Self::ReadWrite),
+            (true, false, true) => Ok(Self::ReadExecute),
+            (false, true, true) => Ok(Self::WriteExecute),
+            (true, true, true) => Ok(Self::ReadWriteExecute),
+            _ => Err(Error::UnknownMode),
+        }
+    }
+}
+
+impl Display for Mode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Read => write!(f, "r--"),
+            Self::Write => write!(f, "-w-"),
+            Self::Execute => write!(f, "--x"),
+            Self::ReadWrite => write!(f, "rw-"),
+            Self::ReadExecute => write!(f, "r-x"),
+            Self::WriteExecute => write!(f, "-wx"),
+            Self::ReadWriteExecute => write!(f, "rwx"),
+        }
+    }
+}
diff --git a/tests/utils/mod.rs b/tests/utils/mod.rs
index 3301cfd5..5e5f779a 100644
--- a/tests/utils/mod.rs
+++ b/tests/utils/mod.rs
@@ -4,7 +4,15 @@ use strip_ansi_escapes::strip as strip_ansi_escapes;
 
 pub fn run_cmd(args: &[&str]) -> String {
     let mut cmd = Command::new("cargo");
-    cmd.args(["run", "--", "--threads", "1", "--disk-usage", "logical", "--no-config"]);
+    cmd.args([
+        "run",
+        "--",
+        "--threads",
+        "1",
+        "--disk-usage",
+        "logical",
+        "--no-config",
+    ]);
 
     for arg in args {
         cmd.arg(arg);

From 0b7cf9a8348a4415b876ed3becf4406d8d7454bc Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Fri, 14 Apr 2023 00:39:16 -0700
Subject: [PATCH 02/33] fix bit comparison

---
 src/fs/permissions/mode.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
index fd6b596e..6acc95ac 100644
--- a/src/fs/permissions/mode.rs
+++ b/src/fs/permissions/mode.rs
@@ -16,9 +16,9 @@ impl Mode {
     pub fn try_user_mode_from(mode_mask: u32) -> Result<Self, Error> {
         let owner = mode_mask & u32::from(SMode::S_IRWXU.bits());
 
-        let read = owner & u32::from(SMode::S_IRUSR.bits()) != 0;
-        let write = owner & u32::from(SMode::S_IWUSR.bits()) != 0;
-        let execute = owner & u32::from(SMode::S_IXUSR.bits()) != 0;
+        let read = owner & u32::from(SMode::S_IRUSR.bits()) == u32::from(SMode::S_IRUSR.bits());
+        let write = owner & u32::from(SMode::S_IWUSR.bits()) == u32::from(SMode::S_IWUSR.bits());
+        let execute = owner & u32::from(SMode::S_IXUSR.bits()) == u32::from(SMode::S_IXUSR.bits());
 
         Self::try_mode_from_rwx(read, write, execute)
     }
@@ -26,9 +26,9 @@ impl Mode {
     pub fn try_group_mode_from(mode_mask: u32) -> Result<Self, Error> {
         let owner = mode_mask & u32::from(SMode::S_IRWXG.bits());
 
-        let read = owner & u32::from(SMode::S_IRGRP.bits()) != 0;
-        let write = owner & u32::from(SMode::S_IWGRP.bits()) != 0;
-        let execute = owner & u32::from(SMode::S_IXGRP.bits()) != 0;
+        let read = owner & u32::from(SMode::S_IRGRP.bits()) == u32::from(SMode::S_IRGRP.bits());
+        let write = owner & u32::from(SMode::S_IWGRP.bits()) == u32::from(SMode::S_IWGRP.bits());
+        let execute = owner & u32::from(SMode::S_IXGRP.bits()) == u32::from(SMode::S_IXGRP.bits());
 
         Self::try_mode_from_rwx(read, write, execute)
     }
@@ -36,9 +36,9 @@ impl Mode {
     pub fn try_other_mode_from(mode_mask: u32) -> Result<Self, Error> {
         let owner = mode_mask & u32::from(SMode::S_IRWXO.bits());
 
-        let read = owner & u32::from(SMode::S_IROTH.bits()) != 0;
-        let write = owner & u32::from(SMode::S_IWOTH.bits()) != 0;
-        let execute = owner & u32::from(SMode::S_IXOTH.bits()) != 0;
+        let read = owner & u32::from(SMode::S_IROTH.bits()) == u32::from(SMode::S_IROTH.bits());
+        let write = owner & u32::from(SMode::S_IWOTH.bits()) == u32::from(SMode::S_IWOTH.bits());
+        let execute = owner & u32::from(SMode::S_IXOTH.bits()) == u32::from(SMode::S_IXOTH.bits());
 
         Self::try_mode_from_rwx(read, write, execute)
     }

From 37a2c5ecdc7e5663694d24259e54db1ac2a25dc7 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Fri, 14 Apr 2023 00:49:55 -0700
Subject: [PATCH 03/33] dry up code

---
 src/fs/permissions/mode.rs | 37 ++++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
index 6acc95ac..814d5d00 100644
--- a/src/fs/permissions/mode.rs
+++ b/src/fs/permissions/mode.rs
@@ -13,36 +13,43 @@ pub enum Mode {
 }
 
 impl Mode {
-    pub fn try_user_mode_from(mode_mask: u32) -> Result<Self, Error> {
-        let owner = mode_mask & u32::from(SMode::S_IRWXU.bits());
+    pub fn try_user_mode_from(modes_mask: u32) -> Result<Self, Error> {
+        let user = modes_mask & u32::from(SMode::S_IRWXU.bits());
 
-        let read = owner & u32::from(SMode::S_IRUSR.bits()) == u32::from(SMode::S_IRUSR.bits());
-        let write = owner & u32::from(SMode::S_IWUSR.bits()) == u32::from(SMode::S_IWUSR.bits());
-        let execute = owner & u32::from(SMode::S_IXUSR.bits()) == u32::from(SMode::S_IXUSR.bits());
+        let read = Self::enabled(user, SMode::S_IRUSR.bits());
+        let write = Self::enabled(user, SMode::S_IWUSR.bits());
+        let execute = Self::enabled(user, SMode::S_IXUSR.bits());
 
         Self::try_mode_from_rwx(read, write, execute)
     }
 
-    pub fn try_group_mode_from(mode_mask: u32) -> Result<Self, Error> {
-        let owner = mode_mask & u32::from(SMode::S_IRWXG.bits());
+    pub fn try_group_mode_from(modes_mask: u32) -> Result<Self, Error> {
+        let group = modes_mask & u32::from(SMode::S_IRWXG.bits());
 
-        let read = owner & u32::from(SMode::S_IRGRP.bits()) == u32::from(SMode::S_IRGRP.bits());
-        let write = owner & u32::from(SMode::S_IWGRP.bits()) == u32::from(SMode::S_IWGRP.bits());
-        let execute = owner & u32::from(SMode::S_IXGRP.bits()) == u32::from(SMode::S_IXGRP.bits());
+        let read = Self::enabled(group, SMode::S_IRGRP.bits());
+        let write = Self::enabled(group, SMode::S_IWGRP.bits());
+        let execute = Self::enabled(group, SMode::S_IXGRP.bits());
 
         Self::try_mode_from_rwx(read, write, execute)
     }
 
-    pub fn try_other_mode_from(mode_mask: u32) -> Result<Self, Error> {
-        let owner = mode_mask & u32::from(SMode::S_IRWXO.bits());
+    pub fn try_other_mode_from(modes_mask: u32) -> Result<Self, Error> {
+        let other = modes_mask & u32::from(SMode::S_IRWXO.bits());
 
-        let read = owner & u32::from(SMode::S_IROTH.bits()) == u32::from(SMode::S_IROTH.bits());
-        let write = owner & u32::from(SMode::S_IWOTH.bits()) == u32::from(SMode::S_IWOTH.bits());
-        let execute = owner & u32::from(SMode::S_IXOTH.bits()) == u32::from(SMode::S_IXOTH.bits());
+        let read = Self::enabled(other, SMode::S_IROTH.bits());
+        let write = Self::enabled(other, SMode::S_IWOTH.bits());
+        let execute = Self::enabled(other, SMode::S_IXOTH.bits());
 
         Self::try_mode_from_rwx(read, write, execute)
     }
 
+    fn enabled<N>(class_mask: u32, mode_mask: N) -> bool
+    where
+        N: Copy + Into<u32>,
+    {
+        class_mask & mode_mask.into() == mode_mask.into()
+    }
+
     const fn try_mode_from_rwx(r: bool, w: bool, x: bool) -> Result<Self, Error> {
         match (r, w, x) {
             (true, false, false) => Ok(Self::Read),

From 3c572f220cf6c5783ef8353271206b77bc1bd72d Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Fri, 14 Apr 2023 01:23:35 -0700
Subject: [PATCH 04/33] doc comments

---
 src/fs/permissions/file_type.rs |  1 +
 src/fs/permissions/mod.rs       | 37 ++++++++++++++++++++++++++-------
 src/fs/permissions/mode.rs      |  8 +++++++
 3 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
index e4e319cf..345817b8 100644
--- a/src/fs/permissions/file_type.rs
+++ b/src/fs/permissions/file_type.rs
@@ -27,6 +27,7 @@ impl FileType {
     }
 }
 
+/// The argument `mode` is meant to come from the `mode` method of [std::fs::Permissions].
 impl TryFrom<u32> for FileType {
     type Error = Error;
 
diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index ada28bb3..3a96d376 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -5,17 +5,32 @@ use nix::sys::stat::SFlag;
 use std::{
     convert::TryFrom,
     fmt::{self, Display},
-    fs::Permissions,
     os::unix::fs::PermissionsExt,
 };
 
 /// File permission related errors.
 pub mod error;
 
+/// For working with Unix file identifiers.
 pub mod file_type;
 
+/// For working with permissions for a particular class i.e. user, group, or other.
 pub mod mode;
 
+/// Trait that is used to extend [std::fs::Permissions] behavior such that it allows for `mode` to
+/// be expressed in Unix's symbolic notation for file permissions.
+pub trait SymbolicNotation: PermissionsExt {
+    /// Attempts to return a [FileMode] which implements [Display] allowing it to be presented in
+    /// symbolic notation for file permissions.
+    fn try_mode_symbolic_notation(&self) -> Result<FileMode, Error> {
+        let mode = self.mode();
+        FileMode::try_from(mode)
+    }
+}
+
+/// A struct which holds information about the permissions of a particular file. [FileMode]
+/// implements [Display] which allows it to be conveniently represented in symbolic notation when
+/// expressing file permissions.
 pub struct FileMode {
     file_type: FileType,
     user_mode: Mode,
@@ -24,6 +39,7 @@ pub struct FileMode {
 }
 
 impl FileMode {
+    /// Constructor for [FileMode].
     pub const fn new(
         file_type: FileType,
         user_mode: Mode,
@@ -38,23 +54,28 @@ impl FileMode {
         }
     }
 
+    /// Returns a reference to `file_type`.
     const fn file_type(&self) -> &FileType {
         &self.file_type
     }
 
+    /// Returns a reference to a [Mode] which represents the permissions of the user class.
     const fn user_mode(&self) -> &Mode {
         &self.user_mode
     }
 
+    /// Returns a reference to a [Mode] which represents the permissions of the group class.
     const fn group_mode(&self) -> &Mode {
         &self.group_mode
     }
 
+    /// Returns a reference to a [Mode] which represents the permissions of the other class.
     const fn other_mode(&self) -> &Mode {
         &self.other_mode
     }
 }
 
+/// For representing [FileMode] in symbolic notation.
 impl Display for FileMode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let file_iden = self.file_type().identifier();
@@ -66,16 +87,16 @@ impl Display for FileMode {
     }
 }
 
-impl TryFrom<Permissions> for FileMode {
+/// The argument `mode` is meant to come from the `mode` method of [std::fs::Permissions].
+impl TryFrom<u32> for FileMode {
     type Error = Error;
 
-    fn try_from(permissions: Permissions) -> Result<Self, Self::Error> {
-        let mode = permissions.mode();
+    fn try_from(mode: u32) -> Result<Self, Self::Error> {
         let file_type = FileType::try_from(mode)?;
-        let mode_mask = mode & !u32::from(SFlag::S_IFMT.bits());
-        let user_mode = Mode::try_user_mode_from(mode_mask)?;
-        let group_mode = Mode::try_group_mode_from(mode_mask)?;
-        let other_mode = Mode::try_other_mode_from(mode_mask)?;
+        let modes_mask = mode & !u32::from(SFlag::S_IFMT.bits());
+        let user_mode = Mode::try_user_mode_from(modes_mask)?;
+        let group_mode = Mode::try_group_mode_from(modes_mask)?;
+        let other_mode = Mode::try_other_mode_from(modes_mask)?;
 
         Ok(Self {
             file_type,
diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
index 814d5d00..d7c3bdc9 100644
--- a/src/fs/permissions/mode.rs
+++ b/src/fs/permissions/mode.rs
@@ -2,6 +2,7 @@ use super::error::Error;
 use nix::sys::stat::Mode as SMode;
 use std::fmt::{self, Display};
 
+/// The set of permissions for a particular class i.e. user, group, or other.
 pub enum Mode {
     Read,
     Write,
@@ -12,7 +13,9 @@ pub enum Mode {
     ReadWriteExecute,
 }
 
+/// All `modes_mask` arguments represent the portions of `st_mode` which excludes the file-type.
 impl Mode {
+    /// Computes user permissions.
     pub fn try_user_mode_from(modes_mask: u32) -> Result<Self, Error> {
         let user = modes_mask & u32::from(SMode::S_IRWXU.bits());
 
@@ -23,6 +26,7 @@ impl Mode {
         Self::try_mode_from_rwx(read, write, execute)
     }
 
+    /// Computes group permissions.
     pub fn try_group_mode_from(modes_mask: u32) -> Result<Self, Error> {
         let group = modes_mask & u32::from(SMode::S_IRWXG.bits());
 
@@ -33,6 +37,7 @@ impl Mode {
         Self::try_mode_from_rwx(read, write, execute)
     }
 
+    /// Computes other permissions.
     pub fn try_other_mode_from(modes_mask: u32) -> Result<Self, Error> {
         let other = modes_mask & u32::from(SMode::S_IRWXO.bits());
 
@@ -43,6 +48,7 @@ impl Mode {
         Self::try_mode_from_rwx(read, write, execute)
     }
 
+    /// Checks if a particular mode (read, write, or execute) is enabled.
     fn enabled<N>(class_mask: u32, mode_mask: N) -> bool
     where
         N: Copy + Into<u32>,
@@ -50,6 +56,7 @@ impl Mode {
         class_mask & mode_mask.into() == mode_mask.into()
     }
 
+    /// Helper function to compute permissions.
     const fn try_mode_from_rwx(r: bool, w: bool, x: bool) -> Result<Self, Error> {
         match (r, w, x) {
             (true, false, false) => Ok(Self::Read),
@@ -64,6 +71,7 @@ impl Mode {
     }
 }
 
+/// The `rwx` representation of a [Mode].
 impl Display for Mode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

From cb00c09ffe8965aa8b196d7083392f0d3d77d163 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 00:48:39 -0700
Subject: [PATCH 05/33] symbolic notation test

---
 src/fs/permissions/file_type.rs |  1 +
 src/fs/permissions/mod.rs       | 14 +++++++++----
 src/fs/permissions/mode.rs      |  4 ++++
 src/fs/permissions/test.rs      | 36 +++++++++++++++++++++++++++++++++
 4 files changed, 51 insertions(+), 4 deletions(-)
 create mode 100644 src/fs/permissions/test.rs

diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
index 345817b8..3901e28a 100644
--- a/src/fs/permissions/file_type.rs
+++ b/src/fs/permissions/file_type.rs
@@ -2,6 +2,7 @@ use super::error::Error;
 use nix::sys::stat::SFlag;
 
 /// Unix file types.
+#[derive(Debug, PartialEq)]
 pub enum FileType {
     Directory,
     File,
diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index 3a96d376..b3be7af3 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -5,6 +5,7 @@ use nix::sys::stat::SFlag;
 use std::{
     convert::TryFrom,
     fmt::{self, Display},
+    fs::Permissions,
     os::unix::fs::PermissionsExt,
 };
 
@@ -17,6 +18,9 @@ pub mod file_type;
 /// For working with permissions for a particular class i.e. user, group, or other.
 pub mod mode;
 
+#[cfg(test)]
+mod test;
+
 /// Trait that is used to extend [std::fs::Permissions] behavior such that it allows for `mode` to
 /// be expressed in Unix's symbolic notation for file permissions.
 pub trait SymbolicNotation: PermissionsExt {
@@ -28,6 +32,8 @@ pub trait SymbolicNotation: PermissionsExt {
     }
 }
 
+impl SymbolicNotation for Permissions {}
+
 /// A struct which holds information about the permissions of a particular file. [FileMode]
 /// implements [Display] which allows it to be conveniently represented in symbolic notation when
 /// expressing file permissions.
@@ -55,22 +61,22 @@ impl FileMode {
     }
 
     /// Returns a reference to `file_type`.
-    const fn file_type(&self) -> &FileType {
+    pub const fn file_type(&self) -> &FileType {
         &self.file_type
     }
 
     /// Returns a reference to a [Mode] which represents the permissions of the user class.
-    const fn user_mode(&self) -> &Mode {
+    pub const fn user_mode(&self) -> &Mode {
         &self.user_mode
     }
 
     /// Returns a reference to a [Mode] which represents the permissions of the group class.
-    const fn group_mode(&self) -> &Mode {
+    pub const fn group_mode(&self) -> &Mode {
         &self.group_mode
     }
 
     /// Returns a reference to a [Mode] which represents the permissions of the other class.
-    const fn other_mode(&self) -> &Mode {
+    pub const fn other_mode(&self) -> &Mode {
         &self.other_mode
     }
 }
diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
index d7c3bdc9..03906e1d 100644
--- a/src/fs/permissions/mode.rs
+++ b/src/fs/permissions/mode.rs
@@ -3,6 +3,7 @@ use nix::sys::stat::Mode as SMode;
 use std::fmt::{self, Display};
 
 /// The set of permissions for a particular class i.e. user, group, or other.
+#[derive(Debug, PartialEq)]
 pub enum Mode {
     Read,
     Write,
@@ -11,6 +12,7 @@ pub enum Mode {
     ReadExecute,
     WriteExecute,
     ReadWriteExecute,
+    None
 }
 
 /// All `modes_mask` arguments represent the portions of `st_mode` which excludes the file-type.
@@ -66,6 +68,7 @@ impl Mode {
             (true, false, true) => Ok(Self::ReadExecute),
             (false, true, true) => Ok(Self::WriteExecute),
             (true, true, true) => Ok(Self::ReadWriteExecute),
+            (false, false, false) => Ok(Self::None),
             _ => Err(Error::UnknownMode),
         }
     }
@@ -82,6 +85,7 @@ impl Display for Mode {
             Self::ReadExecute => write!(f, "r-x"),
             Self::WriteExecute => write!(f, "-wx"),
             Self::ReadWriteExecute => write!(f, "rwx"),
+            Self::None => write!(f, "---"),
         }
     }
 }
diff --git a/src/fs/permissions/test.rs b/src/fs/permissions/test.rs
new file mode 100644
index 00000000..99f66ce3
--- /dev/null
+++ b/src/fs/permissions/test.rs
@@ -0,0 +1,36 @@
+use std::{
+    error::Error,
+    fs::File,
+};
+use super::{
+    file_type::FileType,
+    mode::Mode,
+    SymbolicNotation
+};
+
+#[test]
+fn test_symbolic_notation() -> Result<(), Box<dyn Error>> {
+    let temp = std::env::temp_dir().join("yogsothoth.hpl");
+    let file = File::create(temp)?;
+    let metadata = file.metadata()?;
+    let persmissions = metadata.permissions();
+
+    // Star of the show
+    let file_mode = persmissions.try_mode_symbolic_notation()?;
+
+    let file_type = file_mode.file_type();
+    let user = file_mode.user_mode();
+    let group = file_mode.group_mode();
+    let other = file_mode.other_mode();
+
+    assert_eq!(file_type, &FileType::File);
+    assert_eq!(user, &Mode::ReadWrite);
+    assert_eq!(group, &Mode::Read);
+    assert_eq!(other, &Mode::Read);
+
+    let rwx_string = format!("{file_mode}");
+
+    assert_eq!(rwx_string, ".rw-r--r--");
+    
+    Ok(())
+}

From 1b6cbebdcea6ababe121c16ae38f131c61681d3d Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 00:50:48 -0700
Subject: [PATCH 06/33] cargo fmt

---
 src/fs/permissions/error.rs     |  3 ---
 src/fs/permissions/file_type.rs |  2 +-
 src/fs/permissions/mod.rs       |  1 +
 src/fs/permissions/mode.rs      |  5 ++---
 src/fs/permissions/test.rs      | 13 +++----------
 5 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/src/fs/permissions/error.rs b/src/fs/permissions/error.rs
index 25a8165a..011e13f6 100644
--- a/src/fs/permissions/error.rs
+++ b/src/fs/permissions/error.rs
@@ -4,7 +4,4 @@ use thiserror::Error;
 pub enum Error {
     #[error("Unknown file type.")]
     UnknownFileType,
-
-    #[error("Failed to compute file mode.")]
-    UnknownMode,
 }
diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
index 3901e28a..ec5a191e 100644
--- a/src/fs/permissions/file_type.rs
+++ b/src/fs/permissions/file_type.rs
@@ -2,7 +2,7 @@ use super::error::Error;
 use nix::sys::stat::SFlag;
 
 /// Unix file types.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum FileType {
     Directory,
     File,
diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index b3be7af3..dbfaa41f 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -37,6 +37,7 @@ impl SymbolicNotation for Permissions {}
 /// A struct which holds information about the permissions of a particular file. [FileMode]
 /// implements [Display] which allows it to be conveniently represented in symbolic notation when
 /// expressing file permissions.
+#[derive(Debug)]
 pub struct FileMode {
     file_type: FileType,
     user_mode: Mode,
diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
index 03906e1d..1f7c5427 100644
--- a/src/fs/permissions/mode.rs
+++ b/src/fs/permissions/mode.rs
@@ -3,7 +3,7 @@ use nix::sys::stat::Mode as SMode;
 use std::fmt::{self, Display};
 
 /// The set of permissions for a particular class i.e. user, group, or other.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Mode {
     Read,
     Write,
@@ -12,7 +12,7 @@ pub enum Mode {
     ReadExecute,
     WriteExecute,
     ReadWriteExecute,
-    None
+    None,
 }
 
 /// All `modes_mask` arguments represent the portions of `st_mode` which excludes the file-type.
@@ -69,7 +69,6 @@ impl Mode {
             (false, true, true) => Ok(Self::WriteExecute),
             (true, true, true) => Ok(Self::ReadWriteExecute),
             (false, false, false) => Ok(Self::None),
-            _ => Err(Error::UnknownMode),
         }
     }
 }
diff --git a/src/fs/permissions/test.rs b/src/fs/permissions/test.rs
index 99f66ce3..f4d01843 100644
--- a/src/fs/permissions/test.rs
+++ b/src/fs/permissions/test.rs
@@ -1,12 +1,5 @@
-use std::{
-    error::Error,
-    fs::File,
-};
-use super::{
-    file_type::FileType,
-    mode::Mode,
-    SymbolicNotation
-};
+use super::{file_type::FileType, mode::Mode, SymbolicNotation};
+use std::{error::Error, fs::File};
 
 #[test]
 fn test_symbolic_notation() -> Result<(), Box<dyn Error>> {
@@ -31,6 +24,6 @@ fn test_symbolic_notation() -> Result<(), Box<dyn Error>> {
     let rwx_string = format!("{file_mode}");
 
     assert_eq!(rwx_string, ".rw-r--r--");
-    
+
     Ok(())
 }

From 027c04b8dfbce828f847c493b6020d22e934260a Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 01:23:47 -0700
Subject: [PATCH 07/33] libc instead of nix

---
 Cargo.lock                      | 43 +--------------------------------
 Cargo.toml                      |  2 +-
 src/fs/permissions/file_type.rs | 17 ++++++-------
 src/fs/permissions/mod.rs       |  3 +--
 src/fs/permissions/mode.rs      | 25 +++++++++----------
 5 files changed, 23 insertions(+), 67 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2f9588f3..69c91853 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,12 +26,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -118,8 +112,8 @@ dependencies = [
  "indextree",
  "indoc",
  "is-terminal",
+ "libc",
  "lscolors",
- "nix",
  "once_cell",
  "regex",
  "strip-ansi-escapes",
@@ -318,29 +312,6 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
-[[package]]
-name = "memoffset"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "nix"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfdda3d196821d6af13126e40375cdf7da646a96114af134d5f417a9a1dc8e1a"
-dependencies = [
- "bitflags",
- "cfg-if",
- "libc",
- "memoffset",
- "pin-utils",
- "static_assertions",
-]
-
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -369,12 +340,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -486,12 +451,6 @@ version = "1.0.156"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
 
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
 [[package]]
 name = "strip-ansi-escapes"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index d5fbafd4..85ecf5fd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ regex = "1.7.3"
 thiserror = "1.0.40"
 
 [target.'cfg(unix)'.dependencies]
-nix = { version = "0.26.2", features = ["fs"] }
+libc = "0.2.141"
 
 [dev-dependencies]
 indoc = "2.0.0"
diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
index ec5a191e..9c409973 100644
--- a/src/fs/permissions/file_type.rs
+++ b/src/fs/permissions/file_type.rs
@@ -1,5 +1,4 @@
 use super::error::Error;
-use nix::sys::stat::SFlag;
 
 /// Unix file types.
 #[derive(Debug, PartialEq, Eq)]
@@ -33,21 +32,21 @@ impl TryFrom<u32> for FileType {
     type Error = Error;
 
     fn try_from(mode: u32) -> Result<Self, Self::Error> {
-        let file_mask = mode & u32::from(SFlag::S_IFMT.bits());
+        let file_mask = mode & u32::from(libc::S_IFMT);
 
-        if file_mask == u32::from(SFlag::S_IFIFO.bits()) {
+        if file_mask == u32::from(libc::S_IFIFO) {
             Ok(Self::Fifo)
-        } else if file_mask == u32::from(SFlag::S_IFCHR.bits()) {
+        } else if file_mask == u32::from(libc::S_IFCHR) {
             Ok(Self::CharDevice)
-        } else if file_mask == u32::from(SFlag::S_IFDIR.bits()) {
+        } else if file_mask == u32::from(libc::S_IFDIR) {
             Ok(Self::Directory)
-        } else if file_mask == u32::from(SFlag::S_IFBLK.bits()) {
+        } else if file_mask == u32::from(libc::S_IFBLK) {
             Ok(Self::BlockDevice)
-        } else if file_mask == u32::from(SFlag::S_IFREG.bits()) {
+        } else if file_mask == u32::from(libc::S_IFREG) {
             Ok(Self::File)
-        } else if file_mask == u32::from(SFlag::S_IFLNK.bits()) {
+        } else if file_mask == u32::from(libc::S_IFLNK) {
             Ok(Self::Symlink)
-        } else if file_mask == u32::from(SFlag::S_IFSOCK.bits()) {
+        } else if file_mask == u32::from(libc::S_IFSOCK) {
             Ok(Self::Socket)
         } else {
             Err(Error::UnknownFileType)
diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index dbfaa41f..10ad6332 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -1,7 +1,6 @@
 use error::Error;
 use file_type::FileType;
 use mode::Mode;
-use nix::sys::stat::SFlag;
 use std::{
     convert::TryFrom,
     fmt::{self, Display},
@@ -100,7 +99,7 @@ impl TryFrom<u32> for FileMode {
 
     fn try_from(mode: u32) -> Result<Self, Self::Error> {
         let file_type = FileType::try_from(mode)?;
-        let modes_mask = mode & !u32::from(SFlag::S_IFMT.bits());
+        let modes_mask = mode & !u32::from(libc::S_IFMT);
         let user_mode = Mode::try_user_mode_from(modes_mask)?;
         let group_mode = Mode::try_group_mode_from(modes_mask)?;
         let other_mode = Mode::try_other_mode_from(modes_mask)?;
diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
index 1f7c5427..b9ffce52 100644
--- a/src/fs/permissions/mode.rs
+++ b/src/fs/permissions/mode.rs
@@ -1,5 +1,4 @@
 use super::error::Error;
-use nix::sys::stat::Mode as SMode;
 use std::fmt::{self, Display};
 
 /// The set of permissions for a particular class i.e. user, group, or other.
@@ -19,33 +18,33 @@ pub enum Mode {
 impl Mode {
     /// Computes user permissions.
     pub fn try_user_mode_from(modes_mask: u32) -> Result<Self, Error> {
-        let user = modes_mask & u32::from(SMode::S_IRWXU.bits());
+        let user = modes_mask & u32::from(libc::S_IRWXU);
 
-        let read = Self::enabled(user, SMode::S_IRUSR.bits());
-        let write = Self::enabled(user, SMode::S_IWUSR.bits());
-        let execute = Self::enabled(user, SMode::S_IXUSR.bits());
+        let read = Self::enabled(user, libc::S_IRUSR);
+        let write = Self::enabled(user, libc::S_IWUSR);
+        let execute = Self::enabled(user, libc::S_IXUSR);
 
         Self::try_mode_from_rwx(read, write, execute)
     }
 
     /// Computes group permissions.
     pub fn try_group_mode_from(modes_mask: u32) -> Result<Self, Error> {
-        let group = modes_mask & u32::from(SMode::S_IRWXG.bits());
+        let group = modes_mask & u32::from(libc::S_IRWXG);
 
-        let read = Self::enabled(group, SMode::S_IRGRP.bits());
-        let write = Self::enabled(group, SMode::S_IWGRP.bits());
-        let execute = Self::enabled(group, SMode::S_IXGRP.bits());
+        let read = Self::enabled(group, libc::S_IRGRP);
+        let write = Self::enabled(group, libc::S_IWGRP);
+        let execute = Self::enabled(group, libc::S_IXGRP);
 
         Self::try_mode_from_rwx(read, write, execute)
     }
 
     /// Computes other permissions.
     pub fn try_other_mode_from(modes_mask: u32) -> Result<Self, Error> {
-        let other = modes_mask & u32::from(SMode::S_IRWXO.bits());
+        let other = modes_mask & u32::from(libc::S_IRWXO);
 
-        let read = Self::enabled(other, SMode::S_IROTH.bits());
-        let write = Self::enabled(other, SMode::S_IWOTH.bits());
-        let execute = Self::enabled(other, SMode::S_IXOTH.bits());
+        let read = Self::enabled(other, libc::S_IROTH);
+        let write = Self::enabled(other, libc::S_IWOTH);
+        let execute = Self::enabled(other, libc::S_IXOTH);
 
         Self::try_mode_from_rwx(read, write, execute)
     }

From 3e323a70471afae3fd046ea47f5b08c0a669acd0 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 20:33:21 -0700
Subject: [PATCH 08/33] setuid setgid sticky

---
 Cargo.lock                      |  10 +++
 Cargo.toml                      |   1 +
 install.sh                      |   1 +
 src/fs/mod.rs                   |   4 +
 src/fs/permissions/class.rs     | 152 ++++++++++++++++++++++++++++++++
 src/fs/permissions/error.rs     |   2 +-
 src/fs/permissions/file_type.rs |   2 +-
 src/fs/permissions/mod.rs       |  93 ++++++++++---------
 src/fs/permissions/mode.rs      |  89 -------------------
 src/fs/permissions/test.rs      |  93 ++++++++++++++++---
 src/fs/xattr.rs                 |  25 ++++++
 src/render/tree/error.rs        |   2 +-
 12 files changed, 329 insertions(+), 145 deletions(-)
 create mode 100755 install.sh
 create mode 100644 src/fs/permissions/class.rs
 delete mode 100644 src/fs/permissions/mode.rs
 create mode 100644 src/fs/xattr.rs

diff --git a/Cargo.lock b/Cargo.lock
index 69c91853..b7989400 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -119,6 +119,7 @@ dependencies = [
  "strip-ansi-escapes",
  "tempfile",
  "thiserror",
+ "xattr",
 ]
 
 [[package]]
@@ -700,3 +701,12 @@ name = "windows_x86_64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "xattr"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea263437ca03c1522846a4ddafbca2542d0ad5ed9b784909d4b27b76f62bc34a"
+dependencies = [
+ "libc",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 85ecf5fd..dafb0b3b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,6 +38,7 @@ thiserror = "1.0.40"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.141"
+xattr = "1.0"
 
 [dev-dependencies]
 indoc = "2.0.0"
diff --git a/install.sh b/install.sh
new file mode 100755
index 00000000..7c0dffd8
--- /dev/null
+++ b/install.sh
@@ -0,0 +1 @@
+echo hello world
diff --git a/src/fs/mod.rs b/src/fs/mod.rs
index f6295644..a266260f 100644
--- a/src/fs/mod.rs
+++ b/src/fs/mod.rs
@@ -8,6 +8,10 @@ pub mod inode;
 #[cfg(unix)]
 pub mod permissions;
 
+#[cfg(unix)]
+/// Determining whether or not a file has extended attributes.
+pub mod xattr;
+
 /// Returns the path to the target of the soft link. Returns `None` if provided `dir_entry` isn't a
 /// symlink.
 pub fn symlink_target(dir_entry: &DirEntry) -> Option<PathBuf> {
diff --git a/src/fs/permissions/class.rs b/src/fs/permissions/class.rs
new file mode 100644
index 00000000..5b1d44d1
--- /dev/null
+++ b/src/fs/permissions/class.rs
@@ -0,0 +1,152 @@
+use std::fmt::{self, Display};
+
+/// The set of permissions for a particular class i.e. user, group, or other.
+#[derive(Debug)]
+#[allow(clippy::module_name_repetitions)]
+pub struct ClassPermissions {
+    class: Class,
+    attr: Option<Attribute>,
+    pub(super) triad: PermissionsTriad,
+}
+
+/// The class type that is associated with a permissions triad.
+#[derive(Debug)]
+pub enum Class {
+    User,
+    Group,
+    Other,
+}
+
+/// Represents the special attributes that exist on the overall file corresponding to the setuid,
+/// setgid, and the sticky bit.
+#[derive(Debug, PartialEq, Eq)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum Attribute {
+    SUID,
+    SGID,
+    Sticky,
+}
+
+/// Read, write, execute permissions.
+#[derive(Debug, PartialEq, Eq)]
+pub enum PermissionsTriad {
+    Read,
+    Write,
+    Execute,
+    ReadWrite,
+    ReadExecute,
+    WriteExecute,
+    ReadWriteExecute,
+    None,
+}
+
+/// All `permissions_mask` arguments represents the bits of `st_mode` which excludes the file-type
+/// and the setuid, setgid, and sticky bit.
+impl ClassPermissions {
+    /// Computes user permissions.
+    pub fn user_permissions_from(st_mode: u32) -> Self {
+        let read = Self::enabled(st_mode, libc::S_IRUSR);
+        let write = Self::enabled(st_mode, libc::S_IWUSR);
+        let execute = Self::enabled(st_mode, libc::S_IXUSR);
+        let suid = Self::enabled(st_mode, libc::S_ISUID).then_some(Attribute::SUID);
+
+        Self::permissions_from_rwx(Class::User, read, write, execute, suid)
+    }
+
+    /// Computes group permissions.
+    pub fn group_permissions_from(st_mode: u32) -> Self {
+        let read = Self::enabled(st_mode, libc::S_IRGRP);
+        let write = Self::enabled(st_mode, libc::S_IWGRP);
+        let execute = Self::enabled(st_mode, libc::S_IXGRP);
+        let sgid = Self::enabled(st_mode, libc::S_ISGID).then_some(Attribute::SGID);
+
+        Self::permissions_from_rwx(Class::Group, read, write, execute, sgid)
+    }
+
+    /// Computes other permissions.
+    pub fn other_permissions_from(st_mode: u32) -> Self {
+        let read = Self::enabled(st_mode, libc::S_IROTH);
+        let write = Self::enabled(st_mode, libc::S_IWOTH);
+        let execute = Self::enabled(st_mode, libc::S_IXOTH);
+        let sticky = Self::enabled(st_mode, libc::S_ISVTX).then_some(Attribute::Sticky);
+
+        Self::permissions_from_rwx(Class::Other, read, write, execute, sticky)
+    }
+
+    /// Checks if a particular mode (read, write, or execute) is enabled.
+    fn enabled<N>(st_mode: u32, mask: N) -> bool
+    where
+        N: Copy + Into<u32>,
+    {
+        st_mode & mask.into() == mask.into()
+    }
+
+    /// Returns `true` if sticky bit is enabled.
+    pub fn attr_is_sticky(&self) -> bool {
+        self.attr
+            .as_ref()
+            .map_or(false, |attr| attr == &Attribute::Sticky)
+    }
+
+    /// Helper function to compute permissions.
+    const fn permissions_from_rwx(
+        class: Class,
+        r: bool,
+        w: bool,
+        x: bool,
+        attr: Option<Attribute>,
+    ) -> Self {
+        let triad = match (r, w, x) {
+            (true, false, false) => PermissionsTriad::Read,
+            (false, true, false) => PermissionsTriad::Write,
+            (false, false, true) => PermissionsTriad::Execute,
+            (true, true, false) => PermissionsTriad::ReadWrite,
+            (true, false, true) => PermissionsTriad::ReadExecute,
+            (false, true, true) => PermissionsTriad::WriteExecute,
+            (true, true, true) => PermissionsTriad::ReadWriteExecute,
+            (false, false, false) => PermissionsTriad::None,
+        };
+
+        Self { class, attr, triad }
+    }
+}
+
+/// The symbolic representation of a [PermissionsTriad].
+impl Display for ClassPermissions {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.class {
+            Class::Other if self.attr_is_sticky() => match self.triad {
+                PermissionsTriad::Read => write!(f, "r-T"),
+                PermissionsTriad::Write => write!(f, "-wT"),
+                PermissionsTriad::Execute => write!(f, "--t"),
+                PermissionsTriad::ReadWrite => write!(f, "rwT"),
+                PermissionsTriad::ReadExecute => write!(f, "r-t"),
+                PermissionsTriad::WriteExecute => write!(f, "-wt"),
+                PermissionsTriad::ReadWriteExecute => write!(f, "rwt"),
+                PermissionsTriad::None => write!(f, "--T"),
+            },
+
+            _ if self.attr.is_some() => match self.triad {
+                PermissionsTriad::Read => write!(f, "r-S"),
+                PermissionsTriad::Write => write!(f, "-wS"),
+                PermissionsTriad::Execute => write!(f, "--s"),
+                PermissionsTriad::ReadWrite => write!(f, "rwS"),
+                PermissionsTriad::ReadExecute => write!(f, "r-s"),
+                PermissionsTriad::WriteExecute => write!(f, "-ws"),
+                PermissionsTriad::ReadWriteExecute => write!(f, "rws"),
+                PermissionsTriad::None => write!(f, "--S"),
+            },
+
+            _ => match self.triad {
+                PermissionsTriad::Read => write!(f, "r--"),
+                PermissionsTriad::Write => write!(f, "-w-"),
+                PermissionsTriad::Execute => write!(f, "--x"),
+                PermissionsTriad::ReadWrite => write!(f, "rw-"),
+                PermissionsTriad::ReadExecute => write!(f, "r-x"),
+                PermissionsTriad::WriteExecute => write!(f, "-wx"),
+                PermissionsTriad::ReadWriteExecute => write!(f, "rwx"),
+                PermissionsTriad::None => write!(f, "---"),
+            },
+        }
+    }
+}
diff --git a/src/fs/permissions/error.rs b/src/fs/permissions/error.rs
index 011e13f6..075f70f2 100644
--- a/src/fs/permissions/error.rs
+++ b/src/fs/permissions/error.rs
@@ -2,6 +2,6 @@ use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum Error {
-    #[error("Unknown file type.")]
+    #[error("Encountered an unknown file type.")]
     UnknownFileType,
 }
diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
index 9c409973..4bed7f22 100644
--- a/src/fs/permissions/file_type.rs
+++ b/src/fs/permissions/file_type.rs
@@ -17,7 +17,7 @@ impl FileType {
     pub const fn identifier(&self) -> char {
         match self {
             Self::Directory => 'd',
-            Self::File => '.',
+            Self::File => '-',
             Self::Symlink => 'l',
             Self::Fifo => 'p',
             Self::Socket => 's',
diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index 10ad6332..16ac16d8 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -1,25 +1,26 @@
+use class::ClassPermissions;
 use error::Error;
 use file_type::FileType;
-use mode::Mode;
 use std::{
     convert::TryFrom,
-    fmt::{self, Display},
-    fs::Permissions,
+    fmt::{self, Display, Octal},
     os::unix::fs::PermissionsExt,
 };
 
+/// For working with permissions for a particular class i.e. user, group, or other.
+pub mod class;
+
 /// File permission related errors.
 pub mod error;
 
 /// For working with Unix file identifiers.
 pub mod file_type;
 
-/// For working with permissions for a particular class i.e. user, group, or other.
-pub mod mode;
-
 #[cfg(test)]
 mod test;
 
+impl SymbolicNotation for std::fs::Permissions {}
+
 /// Trait that is used to extend [std::fs::Permissions] behavior such that it allows for `mode` to
 /// be expressed in Unix's symbolic notation for file permissions.
 pub trait SymbolicNotation: PermissionsExt {
@@ -31,32 +32,33 @@ pub trait SymbolicNotation: PermissionsExt {
     }
 }
 
-impl SymbolicNotation for Permissions {}
-
 /// A struct which holds information about the permissions of a particular file. [FileMode]
 /// implements [Display] which allows it to be conveniently represented in symbolic notation when
 /// expressing file permissions.
 #[derive(Debug)]
 pub struct FileMode {
+    pub st_mode: u32,
     file_type: FileType,
-    user_mode: Mode,
-    group_mode: Mode,
-    other_mode: Mode,
+    user_permissions: ClassPermissions,
+    group_permissions: ClassPermissions,
+    other_permissions: ClassPermissions,
 }
 
 impl FileMode {
     /// Constructor for [FileMode].
     pub const fn new(
+        st_mode: u32,
         file_type: FileType,
-        user_mode: Mode,
-        group_mode: Mode,
-        other_mode: Mode,
+        user_permissions: ClassPermissions,
+        group_permissions: ClassPermissions,
+        other_permissions: ClassPermissions,
     ) -> Self {
         Self {
+            st_mode,
             file_type,
-            user_mode,
-            group_mode,
-            other_mode,
+            user_permissions,
+            group_permissions,
+            other_permissions,
         }
     }
 
@@ -65,19 +67,19 @@ impl FileMode {
         &self.file_type
     }
 
-    /// Returns a reference to a [Mode] which represents the permissions of the user class.
-    pub const fn user_mode(&self) -> &Mode {
-        &self.user_mode
+    /// Returns a reference to a [ClassPermissions] which represents the permissions of the user class.
+    pub const fn user_permissions(&self) -> &ClassPermissions {
+        &self.user_permissions
     }
 
-    /// Returns a reference to a [Mode] which represents the permissions of the group class.
-    pub const fn group_mode(&self) -> &Mode {
-        &self.group_mode
+    /// Returns a reference to a [ClassPermissions] which represents the permissions of the group class.
+    pub const fn group_permissions(&self) -> &ClassPermissions {
+        &self.group_permissions
     }
 
-    /// Returns a reference to a [Mode] which represents the permissions of the other class.
-    pub const fn other_mode(&self) -> &Mode {
-        &self.other_mode
+    /// Returns a reference to a [ClassPermissions] which represents the permissions of the other class.
+    pub const fn other_permissions(&self) -> &ClassPermissions {
+        &self.other_permissions
     }
 }
 
@@ -85,30 +87,41 @@ impl FileMode {
 impl Display for FileMode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let file_iden = self.file_type().identifier();
-        let user_mode = self.user_mode();
-        let group_mode = self.group_mode();
-        let other_mode = self.other_mode();
+        let user_permissions = self.user_permissions();
+        let group_permissions = self.group_permissions();
+        let other_permissions = self.other_permissions();
+
+        write!(
+            f,
+            "{file_iden}{user_permissions}{group_permissions}{other_permissions}"
+        )
+    }
+}
 
-        write!(f, "{file_iden}{user_mode}{group_mode}{other_mode}")
+/// For the octal representation of the file type and class permisssions.
+impl Octal for FileMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let modes_mask = self.st_mode & !u32::from(libc::S_IFMT);
+        fmt::Octal::fmt(&modes_mask, f)
     }
 }
 
-/// The argument `mode` is meant to come from the `mode` method of [std::fs::Permissions].
+/// The argument `st_mode` is meant to come from the `mode` method of [std::fs::Permissions].
 impl TryFrom<u32> for FileMode {
     type Error = Error;
 
-    fn try_from(mode: u32) -> Result<Self, Self::Error> {
-        let file_type = FileType::try_from(mode)?;
-        let modes_mask = mode & !u32::from(libc::S_IFMT);
-        let user_mode = Mode::try_user_mode_from(modes_mask)?;
-        let group_mode = Mode::try_group_mode_from(modes_mask)?;
-        let other_mode = Mode::try_other_mode_from(modes_mask)?;
+    fn try_from(st_mode: u32) -> Result<Self, Self::Error> {
+        let file_type = FileType::try_from(st_mode)?;
+        let user_permissions = ClassPermissions::user_permissions_from(st_mode);
+        let group_permissions = ClassPermissions::group_permissions_from(st_mode);
+        let other_permissions = ClassPermissions::other_permissions_from(st_mode);
 
         Ok(Self {
+            st_mode,
             file_type,
-            user_mode,
-            group_mode,
-            other_mode,
+            user_permissions,
+            group_permissions,
+            other_permissions,
         })
     }
 }
diff --git a/src/fs/permissions/mode.rs b/src/fs/permissions/mode.rs
deleted file mode 100644
index b9ffce52..00000000
--- a/src/fs/permissions/mode.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use super::error::Error;
-use std::fmt::{self, Display};
-
-/// The set of permissions for a particular class i.e. user, group, or other.
-#[derive(Debug, PartialEq, Eq)]
-pub enum Mode {
-    Read,
-    Write,
-    Execute,
-    ReadWrite,
-    ReadExecute,
-    WriteExecute,
-    ReadWriteExecute,
-    None,
-}
-
-/// All `modes_mask` arguments represent the portions of `st_mode` which excludes the file-type.
-impl Mode {
-    /// Computes user permissions.
-    pub fn try_user_mode_from(modes_mask: u32) -> Result<Self, Error> {
-        let user = modes_mask & u32::from(libc::S_IRWXU);
-
-        let read = Self::enabled(user, libc::S_IRUSR);
-        let write = Self::enabled(user, libc::S_IWUSR);
-        let execute = Self::enabled(user, libc::S_IXUSR);
-
-        Self::try_mode_from_rwx(read, write, execute)
-    }
-
-    /// Computes group permissions.
-    pub fn try_group_mode_from(modes_mask: u32) -> Result<Self, Error> {
-        let group = modes_mask & u32::from(libc::S_IRWXG);
-
-        let read = Self::enabled(group, libc::S_IRGRP);
-        let write = Self::enabled(group, libc::S_IWGRP);
-        let execute = Self::enabled(group, libc::S_IXGRP);
-
-        Self::try_mode_from_rwx(read, write, execute)
-    }
-
-    /// Computes other permissions.
-    pub fn try_other_mode_from(modes_mask: u32) -> Result<Self, Error> {
-        let other = modes_mask & u32::from(libc::S_IRWXO);
-
-        let read = Self::enabled(other, libc::S_IROTH);
-        let write = Self::enabled(other, libc::S_IWOTH);
-        let execute = Self::enabled(other, libc::S_IXOTH);
-
-        Self::try_mode_from_rwx(read, write, execute)
-    }
-
-    /// Checks if a particular mode (read, write, or execute) is enabled.
-    fn enabled<N>(class_mask: u32, mode_mask: N) -> bool
-    where
-        N: Copy + Into<u32>,
-    {
-        class_mask & mode_mask.into() == mode_mask.into()
-    }
-
-    /// Helper function to compute permissions.
-    const fn try_mode_from_rwx(r: bool, w: bool, x: bool) -> Result<Self, Error> {
-        match (r, w, x) {
-            (true, false, false) => Ok(Self::Read),
-            (false, true, false) => Ok(Self::Write),
-            (false, false, true) => Ok(Self::Execute),
-            (true, true, false) => Ok(Self::ReadWrite),
-            (true, false, true) => Ok(Self::ReadExecute),
-            (false, true, true) => Ok(Self::WriteExecute),
-            (true, true, true) => Ok(Self::ReadWriteExecute),
-            (false, false, false) => Ok(Self::None),
-        }
-    }
-}
-
-/// The `rwx` representation of a [Mode].
-impl Display for Mode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Read => write!(f, "r--"),
-            Self::Write => write!(f, "-w-"),
-            Self::Execute => write!(f, "--x"),
-            Self::ReadWrite => write!(f, "rw-"),
-            Self::ReadExecute => write!(f, "r-x"),
-            Self::WriteExecute => write!(f, "-wx"),
-            Self::ReadWriteExecute => write!(f, "rwx"),
-            Self::None => write!(f, "---"),
-        }
-    }
-}
diff --git a/src/fs/permissions/test.rs b/src/fs/permissions/test.rs
index f4d01843..aa6dba70 100644
--- a/src/fs/permissions/test.rs
+++ b/src/fs/permissions/test.rs
@@ -1,29 +1,96 @@
-use super::{file_type::FileType, mode::Mode, SymbolicNotation};
-use std::{error::Error, fs::File};
+use super::{class::PermissionsTriad, file_type::FileType, SymbolicNotation};
+use std::{error::Error, fs::File, os::unix::fs::PermissionsExt};
 
 #[test]
 fn test_symbolic_notation() -> Result<(), Box<dyn Error>> {
     let temp = std::env::temp_dir().join("yogsothoth.hpl");
+
+    // File is created with read + write for user and read-only for all others.
     let file = File::create(temp)?;
     let metadata = file.metadata()?;
-    let persmissions = metadata.permissions();
 
-    // Star of the show
-    let file_mode = persmissions.try_mode_symbolic_notation()?;
+    let permissions = metadata.permissions();
+
+    let file_mode = permissions.try_mode_symbolic_notation()?;
 
     let file_type = file_mode.file_type();
-    let user = file_mode.user_mode();
-    let group = file_mode.group_mode();
-    let other = file_mode.other_mode();
+    let user = file_mode.user_permissions();
+    let group = file_mode.group_permissions();
+    let other = file_mode.other_permissions();
 
     assert_eq!(file_type, &FileType::File);
-    assert_eq!(user, &Mode::ReadWrite);
-    assert_eq!(group, &Mode::Read);
-    assert_eq!(other, &Mode::Read);
+    assert_eq!(&user.triad, &PermissionsTriad::ReadWrite);
+    assert_eq!(&group.triad, &PermissionsTriad::Read);
+    assert_eq!(&other.triad, &PermissionsTriad::Read);
+
+    let rwx = format!("{file_mode}");
+    assert_eq!(rwx, "-rw-r--r--");
+
+    let octal = format!("{:o}", file_mode);
+    assert_eq!(octal, "644");
+
+    Ok(())
+}
+
+#[test]
+fn test_symbolic_notation_special_attr() -> Result<(), Box<dyn Error>> {
+    let temp = std::env::temp_dir().join("sub-niggurath.hpl");
+
+    // File is created with read + write for user and read-only for all others.
+    let file = File::create(temp)?;
+
+    let metadata = file.metadata()?;
+    let mut permissions = metadata.permissions();
+
+    // Set the sticky bit
+    permissions.set_mode(0o101644);
+
+    let file_mode = permissions.try_mode_symbolic_notation()?;
+    let rwx = format!("{file_mode}");
+    assert_eq!(rwx, "-rw-r--r-T");
+
+    let octal = format!("{:o}", file_mode);
+    assert_eq!(octal, "1644");
+
+    // Set the getuid bit
+    permissions.set_mode(0o102644);
+
+    let file_mode = permissions.try_mode_symbolic_notation()?;
+    let rwx = format!("{file_mode}");
+    assert_eq!(rwx, "-rw-r-Sr--");
+
+    let octal = format!("{:o}", file_mode);
+    assert_eq!(octal, "2644");
+
+    // Set the setuid bit
+    permissions.set_mode(0o104644);
+
+    let file_mode = permissions.try_mode_symbolic_notation()?;
+    let rwx = format!("{file_mode}");
+    assert_eq!(rwx, "-rwSr--r--");
+
+    let octal = format!("{:o}", file_mode);
+    assert_eq!(octal, "4644");
+
+    // Set the all the attr bits
+    permissions.set_mode(0o107644);
+
+    let file_mode = permissions.try_mode_symbolic_notation()?;
+    let rwx = format!("{file_mode}");
+    assert_eq!(rwx, "-rwSr-Sr-T");
+
+    let octal = format!("{:o}", file_mode);
+    assert_eq!(octal, "7644");
+
+    // Set all the attr bits and give all classes execute permissions
+    permissions.set_mode(0o107777);
 
-    let rwx_string = format!("{file_mode}");
+    let file_mode = permissions.try_mode_symbolic_notation()?;
+    let rwx = format!("{file_mode}");
+    assert_eq!(rwx, "-rwsrwsrwt");
 
-    assert_eq!(rwx_string, ".rw-r--r--");
+    let octal = format!("{:o}", file_mode);
+    assert_eq!(octal, "7777");
 
     Ok(())
 }
diff --git a/src/fs/xattr.rs b/src/fs/xattr.rs
new file mode 100644
index 00000000..f2f97931
--- /dev/null
+++ b/src/fs/xattr.rs
@@ -0,0 +1,25 @@
+use ignore::DirEntry;
+use std::{io, path::Path};
+use xattr::XAttrs;
+
+/// Allow extended attributes to be queried directly from the directory entry.
+impl ExtendedAttr for DirEntry {
+    fn path(&self) -> &Path {
+        self.path()
+    }
+}
+
+/// Simple trait that allows files to query extended attributes if it exists.
+pub trait ExtendedAttr {
+    fn path(&self) -> &Path;
+
+    /// Query the extended attribute and return an error if something goes wrong.
+    fn try_xattr(&self) -> io::Result<XAttrs> {
+        xattr::list(self.path())
+    }
+
+    /// Query the extended attribute and return `None` if something goes.
+    fn xattr(&self) -> Option<XAttrs> {
+        xattr::list(self.path()).ok()
+    }
+}
diff --git a/src/render/tree/error.rs b/src/render/tree/error.rs
index 44fa18bc..28b23347 100644
--- a/src/render/tree/error.rs
+++ b/src/render/tree/error.rs
@@ -9,7 +9,7 @@ use std::io::Error as IoError;
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("{0}")]
-    ContextError(#[from] CtxError),
+    Context(#[from] CtxError),
 
     #[error("{0}")]
     DirNotFound(String),

From 75fc6a2432084c31a826f78df14a88c3568dd625 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 21:12:25 -0700
Subject: [PATCH 09/33] function renaming

---
 src/fs/permissions/mod.rs | 3 +--
 src/fs/xattr.rs           | 4 ++--
 src/main.rs               | 4 ++--
 src/render/tree/mod.rs    | 2 +-
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index 16ac16d8..bda03fb3 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -33,9 +33,8 @@ pub trait SymbolicNotation: PermissionsExt {
 }
 
 /// A struct which holds information about the permissions of a particular file. [FileMode]
-/// implements [Display] which allows it to be conveniently represented in symbolic notation when
+/// implements [Display] which allows it to be conveniently presented in symbolic notation when
 /// expressing file permissions.
-#[derive(Debug)]
 pub struct FileMode {
     pub st_mode: u32,
     file_type: FileType,
diff --git a/src/fs/xattr.rs b/src/fs/xattr.rs
index f2f97931..16838362 100644
--- a/src/fs/xattr.rs
+++ b/src/fs/xattr.rs
@@ -14,12 +14,12 @@ pub trait ExtendedAttr {
     fn path(&self) -> &Path;
 
     /// Query the extended attribute and return an error if something goes wrong.
-    fn try_xattr(&self) -> io::Result<XAttrs> {
+    fn try_get_xattrs(&self) -> io::Result<XAttrs> {
         xattr::list(self.path())
     }
 
     /// Query the extended attribute and return `None` if something goes.
-    fn xattr(&self) -> Option<XAttrs> {
+    fn get_xattrs(&self) -> Option<XAttrs> {
         xattr::list(self.path()).ok()
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 600ae721..e7607b16 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -62,11 +62,11 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     if ctx.report {
-        let tree = Tree::<Report>::init(ctx)?;
+        let tree = Tree::<Report>::try_init(ctx)?;
         println!("{tree}");
     } else {
         render::styles::init(ctx.no_color());
-        let tree = Tree::<Regular>::init(ctx)?;
+        let tree = Tree::<Regular>::try_init(ctx)?;
         println!("{tree}");
     }
 
diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index 3ad65b65..d3bccf3a 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -67,7 +67,7 @@ where
     }
 
     /// Initiates file-system traversal and [Tree construction].
-    pub fn init(ctx: Context) -> Result<Self> {
+    pub fn try_init(ctx: Context) -> Result<Self> {
         let (inner, root) = Self::traverse(&ctx)?;
 
         let tree = Self::new(inner, root, ctx);

From 2b07532b9592f39e3e51eded47ad581e8a7cb2cd Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 21:33:30 -0700
Subject: [PATCH 10/33] new cli arg; rename some args

---
 src/fs/inode.rs             |  2 +-
 src/render/context/mod.rs   | 14 +++++++++-----
 src/render/tree/error.rs    |  8 +++++++-
 src/render/tree/node/mod.rs | 20 ++++++++++++++++++--
 4 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/src/fs/inode.rs b/src/fs/inode.rs
index 4183906c..8f9ff6b9 100644
--- a/src/fs/inode.rs
+++ b/src/fs/inode.rs
@@ -1,7 +1,7 @@
 use std::{convert::TryFrom, fs::Metadata};
 
 /// Represents a file's underlying inode.
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Inode {
     pub ino: u64,
     pub dev: u64,
diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index 7214bb42..6a9e13f9 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -53,18 +53,22 @@ pub struct Context {
     #[arg(short = 'i', long)]
     pub no_ignore: bool,
 
+    /// Follow symlinks and consider their disk usage
+    #[arg(short = 'f', long = "follow")]
+    pub follow_links: bool,
+
     /// Display file icons
     #[arg(short = 'I', long)]
     pub icons: bool,
 
-    /// Follow symlinks and consider their disk usage
-    #[arg(short = 'L', long = "follow")]
-    pub follow_links: bool,
-
     /// Maximum depth to display
-    #[arg(short, long, value_name = "NUM")]
+    #[arg(short = 'L', long, value_name = "NUM")]
     level: Option<usize>,
 
+    /// Show extended metadata and attributes
+    #[arg(short, long)]
+    pub long: bool,
+
     /// Regular expression (or glob if '--glob' or '--iglob' is used) used to match files
     #[arg(short, long)]
     pub pattern: Option<String>,
diff --git a/src/render/tree/error.rs b/src/render/tree/error.rs
index 28b23347..58b7ac2b 100644
--- a/src/render/tree/error.rs
+++ b/src/render/tree/error.rs
@@ -1,5 +1,8 @@
 use super::styles::error::Error as StyleError;
-use crate::render::context::error::Error as CtxError;
+use crate::{
+    fs::permissions::error::Error as PermissionsError,
+    render::context::error::Error as CtxError,
+};
 use ignore::Error as IgnoreError;
 use std::io::Error as IoError;
 
@@ -29,6 +32,9 @@ pub enum Error {
     #[error("{0}")]
     PathCanonicalization(#[from] IoError),
 
+    #[error("{0}")]
+    Persmissions(#[from] PermissionsError),
+
     #[error("{0}")]
     UninitializedTheme(#[from] StyleError<'static>),
 }
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index c1edaf5d..edf2a6d9 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -1,5 +1,8 @@
 use crate::{
-    fs::inode::Inode,
+    fs::{
+        permissions::{FileMode, SymbolicNotation},
+        inode::Inode,
+    },
     icons::{self, get_default_icon, icon_from_ext, icon_from_file_name, icon_from_file_type},
     render::{
         context::Context,
@@ -37,6 +40,7 @@ pub struct Node {
     style: Option<Style>,
     icon: Option<Cow<'static, str>>,
     symlink_target: Option<PathBuf>,
+    inode: Option<Inode>,
 }
 
 impl Node {
@@ -48,6 +52,7 @@ impl Node {
         style: Option<Style>,
         icon: Option<Cow<'static, str>>,
         symlink_target: Option<PathBuf>,
+        inode: Option<Inode>,
     ) -> Self {
         Self {
             dir_entry,
@@ -56,6 +61,7 @@ impl Node {
             style,
             icon,
             symlink_target,
+            inode,
         }
     }
 
@@ -72,7 +78,7 @@ impl Node {
 
     /// Gets the underlying [Inode] of the entry.
     pub fn inode(&self) -> Option<Inode> {
-        Inode::try_from(&self.metadata).ok()
+        self.inode
     }
 
     /// Converts `OsStr` to `String`; if fails does a lossy conversion replacing non-Unicode
@@ -133,6 +139,13 @@ impl Node {
         self.icon.as_deref()
     }
 
+    /// Attempts to return an instance of [FileMode] for the display of symbolic permissions.
+    pub fn mode(&self) -> Result<FileMode, Error> {
+        let permissions = self.metadata.permissions();
+        let file_mode = permissions.try_mode_symbolic_notation()?;
+        Ok(file_mode)
+    }
+
     /// Stylizes input, `entity` based on `LS_COLORS`. If `style` is `None` then the entity is
     /// returned unmodified.
     fn stylize<'a>(&self, entity: Cow<'a, str>) -> Cow<'a, str> {
@@ -347,6 +360,8 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             None
         };
 
+        let inode = Inode::try_from(&metadata).ok();
+
         Ok(Self::new(
             dir_entry,
             metadata,
@@ -354,6 +369,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             style,
             icon,
             link_target,
+            inode,
         ))
     }
 }

From a06ac09177cf5ba3c12224e99e68fbba4e78525e Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 23:00:19 -0700
Subject: [PATCH 11/33] plain display for permissions

---
 src/render/tree/mod.rs      |  1 -
 src/render/tree/node/mod.rs | 37 +++++++++++++++++++++++++++++++++++--
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index d3bccf3a..74d64ce8 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -39,7 +39,6 @@ pub mod node;
 mod visitor;
 
 /// Virtual data structure that represents local file-system hierarchy.
-#[derive(Debug)]
 pub struct Tree<T>
 where
     T: display::TreeVariant,
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index edf2a6d9..55c00ddf 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -2,6 +2,7 @@ use crate::{
     fs::{
         permissions::{FileMode, SymbolicNotation},
         inode::Inode,
+        xattr::ExtendedAttr,
     },
     icons::{self, get_default_icon, icon_from_ext, icon_from_file_name, icon_from_file_type},
     render::{
@@ -23,6 +24,7 @@ use std::{
     fs::{FileType, Metadata},
     path::{Path, PathBuf},
 };
+use xattr::XAttrs;
 
 /// Ordering and sorting rules for [Node].
 pub mod cmp;
@@ -32,7 +34,6 @@ pub mod cmp;
 /// uses ANSI colors determined by the file-type and `LS_COLORS`.
 ///
 /// [`Tree`]: super::Tree
-#[derive(Debug)]
 pub struct Node {
     dir_entry: DirEntry,
     metadata: Metadata,
@@ -41,6 +42,9 @@ pub struct Node {
     icon: Option<Cow<'static, str>>,
     symlink_target: Option<PathBuf>,
     inode: Option<Inode>,
+
+    /// Will always be `None` on incompatible platforms.
+    xattrs: Option<XAttrs>,
 }
 
 impl Node {
@@ -53,6 +57,7 @@ impl Node {
         icon: Option<Cow<'static, str>>,
         symlink_target: Option<PathBuf>,
         inode: Option<Inode>,
+        xattrs: Option<XAttrs>,
     ) -> Self {
         Self {
             dir_entry,
@@ -62,6 +67,7 @@ impl Node {
             icon,
             symlink_target,
             inode,
+            xattrs,
         }
     }
 
@@ -160,6 +166,16 @@ impl Node {
         }
     }
 
+    /// Consumes `xattrs` and answers whether or not [Node] has extended attributes.
+    fn has_xattrs(&self) -> bool {
+        let count = self.xattrs
+            .as_ref()
+            .map(|xattrs| xattrs.clone().count())
+            .unwrap_or(0);
+
+        count > 0
+    }
+
     /// Stylizes symlink name for display.
     fn stylize_link_name(&self) -> Option<Cow<'_, str>> {
         self.symlink_target_file_name().map(|name| {
@@ -204,7 +220,17 @@ impl Node {
             })
         };
 
-        write!(f, "{size} {prefix}{icon:<icon_padding$}{file_name}")
+        if ctx.long {
+            let mode = if self.has_xattrs() {
+                format!("{}@", self.mode().unwrap())
+            } else {
+                format!("{}", self.mode().unwrap())
+            };
+
+            write!(f, "{mode:12}{size} {prefix}{icon:<icon_padding$}{file_name}")
+        } else {
+            write!(f, "{size} {prefix}{icon:<icon_padding$}{file_name}")
+        }
     }
 
     /// Unix file identifiers that you'd find in the `ls -l` command.
@@ -362,6 +388,12 @@ impl TryFrom<(DirEntry, &Context)> for Node {
 
         let inode = Inode::try_from(&metadata).ok();
 
+        let xattrs = if ctx.long {
+            dir_entry.get_xattrs()
+        } else {
+            None
+        };
+
         Ok(Self::new(
             dir_entry,
             metadata,
@@ -370,6 +402,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             icon,
             link_target,
             inode,
+            xattrs
         ))
     }
 }

From c81af41b303674975abd75cb2bb3a6c8b5b31b76 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sat, 15 Apr 2023 23:02:44 -0700
Subject: [PATCH 12/33] fix doc comment

---
 src/render/tree/node/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index 55c00ddf..aef2a34f 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -166,7 +166,7 @@ impl Node {
         }
     }
 
-    /// Consumes `xattrs` and answers whether or not [Node] has extended attributes.
+    /// Whether or not [Node] has extended attributes.
     fn has_xattrs(&self) -> bool {
         let count = self.xattrs
             .as_ref()

From 6bad3301f53ed2c483ed1f76b7cdc6c193f7cc47 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sun, 16 Apr 2023 01:22:49 -0700
Subject: [PATCH 13/33] style adjustments for disk usage and permissions

---
 install.sh                  |  1 -
 src/render/styles/mod.rs    | 36 ++++++++++++++++++++++++++++--------
 src/render/tree/node/mod.rs | 35 +++++++++++++++++++++++++++++++----
 3 files changed, 59 insertions(+), 13 deletions(-)
 delete mode 100755 install.sh

diff --git a/install.sh b/install.sh
deleted file mode 100755
index 7c0dffd8..00000000
--- a/install.sh
+++ /dev/null
@@ -1 +0,0 @@
-echo hello world
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index 65001ecc..923c83db 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -1,5 +1,5 @@
 use crate::hash;
-use ansi_term::Color;
+use ansi_term::{Color, Style};
 use error::Error;
 use lscolors::LsColors;
 use once_cell::sync::OnceCell;
@@ -38,7 +38,10 @@ static TREE_THEME: OnceCell<ThemesMap> = OnceCell::new();
 static LINK_THEME: OnceCell<ThemesMap> = OnceCell::new();
 
 /// Runtime evaluated static that contains styles for disk usage output.
-static DU_THEME: OnceCell<HashMap<&'static str, Color>> = OnceCell::new();
+static DU_THEME: OnceCell<HashMap<&'static str, Style>> = OnceCell::new();
+
+/// Runtime evaluated static that contains styles for permissions.
+static PERMISSIONS_THEME: OnceCell<HashMap<char, Style>> = OnceCell::new();
 
 /// Map of the names box-drawing elements to their styled strings.
 pub type ThemesMap = HashMap<&'static str, String>;
@@ -63,7 +66,7 @@ pub fn get_ls_colors() -> Result<&'static LsColors, Error<'static>> {
 }
 
 /// Getter for [DU_THEME]. Returns an error if not initialized.
-pub fn get_du_theme() -> Result<&'static HashMap<&'static str, Color>, Error<'static>> {
+pub fn get_du_theme() -> Result<&'static HashMap<&'static str, Style>, Error<'static>> {
     DU_THEME.get().ok_or(Error::Uninitialized("DU_THEME"))
 }
 
@@ -77,6 +80,11 @@ pub fn get_link_theme() -> Result<&'static ThemesMap, Error<'static>> {
     LINK_THEME.get().ok_or(Error::Uninitialized("LINK_THEME"))
 }
 
+/// Getter for [PERMISSIONS_THEME]. Returns an error if not initialized.
+pub fn get_permissions_theme() -> Result<&'static HashMap<char, Style>, Error<'static>> {
+    PERMISSIONS_THEME.get().ok_or(Error::Uninitialized("PERMISSIONS_THEME"))
+}
+
 /// Initializes [LS_COLORS] by reading in the `LS_COLORS` environment variable. If it isn't set, a
 /// default determined by `lscolors` crate will be used.
 fn init_ls_colors() {
@@ -123,12 +131,24 @@ fn init_themes() {
     LINK_THEME.set(link_theme).unwrap();
 
     let du_theme = hash! {
-        "B" => Color::Cyan,
-        "KB" | "KiB" => Color::Yellow,
-        "MB" | "MiB" => Color::Green,
-        "GB" | "GiB" => Color::Red,
-        "TB" | "TiB" => Color::Blue
+        "B" => Color::Cyan.bold(),
+        "KB" | "KiB" => Color::Yellow.bold(),
+        "MB" | "MiB" => Color::Green.bold(),
+        "GB" | "GiB" => Color::Red.bold(),
+        "TB" | "TiB" => Color::Blue.bold()
     };
 
     DU_THEME.set(du_theme).unwrap();
+
+    let permissions_theme = hash! {
+        '-' => Color::Purple.normal(),
+        'd' => Color::Blue.bold(),
+        'r' => Color::Green.bold(),
+        'w' => Color::Yellow.bold(),
+        'x' | 's' | 'S' | 't' | 'T' => Color::Red.bold(),
+        '@' => Color::Cyan.bold(),
+        ' ' => Color::White.normal()
+    };
+
+    PERMISSIONS_THEME.set(permissions_theme).unwrap();
 }
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index aef2a34f..dcfbf12a 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -8,7 +8,7 @@ use crate::{
     render::{
         context::Context,
         disk_usage::file_size::{DiskUsage, FileSize},
-        styles::get_ls_colors,
+        styles::{get_ls_colors, get_permissions_theme},
         tree::error::Error,
     },
     tty,
@@ -167,6 +167,10 @@ impl Node {
     }
 
     /// Whether or not [Node] has extended attributes.
+    ///
+    /// TODO: Cloning can potentially be expensive here, but practically speaking we won't run into
+    /// this scenario a lot, but we will want to optimize this bad boy by removing the `xattr`
+    /// crate and just query for the existence of xattrs ourselves.
     fn has_xattrs(&self) -> bool {
         let count = self.xattrs
             .as_ref()
@@ -221,13 +225,21 @@ impl Node {
         };
 
         if ctx.long {
-            let mode = if self.has_xattrs() {
+            let mut mode = if self.has_xattrs() {
                 format!("{}@", self.mode().unwrap())
             } else {
-                format!("{}", self.mode().unwrap())
+                format!("{} ", self.mode().unwrap())
             };
 
-            write!(f, "{mode:12}{size} {prefix}{icon:<icon_padding$}{file_name}")
+            if !ctx.no_color() {
+                mode = Self::style_permissions(&mode)
+            }
+
+            write!(
+                f,
+                "{mode:mode_len$}{size} {prefix}{icon:<icon_padding$}{file_name}",
+                mode_len = mode.len() + 2,
+            )
         } else {
             write!(f, "{size} {prefix}{icon:<icon_padding$}{file_name}")
         }
@@ -279,6 +291,21 @@ impl Node {
         Some(iden)
     }
 
+    /// Styles the symbolic notation file permissions.
+    fn style_permissions(perm_str: &str) -> String {
+        let theme = get_permissions_theme().unwrap();
+
+        perm_str
+            .chars()
+            .flat_map(|ch| {
+                theme.get(&ch).map(|color| {
+                    let chstr = ch.to_string();
+                    color.paint(chstr).to_string()
+                })
+            })
+            .collect::<String>()
+    }
+
     /// Attempts to compute icon with given parameters. Icon will be colorless if stdout isn't a
     /// tty or if `no_color` is true.
     ///

From 1f6c0a8972618103ca794bf835d72342913c270d Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sun, 16 Apr 2023 15:55:15 -0700
Subject: [PATCH 14/33] octal permissions

---
 src/fs/permissions/mod.rs          |   6 +-
 src/icons.rs                       | 106 +++++++++++++++-
 src/render/context/mod.rs          |  19 ++-
 src/render/disk_usage/file_size.rs |  33 ++---
 src/render/styles/mod.rs           |  21 +++-
 src/render/tree/display.rs         |   5 +-
 src/render/tree/error.rs           |   3 +-
 src/render/tree/mod.rs             |   7 +-
 src/render/tree/node/mod.rs        | 190 ++++-------------------------
 src/render/tree/node/output.rs     |  93 ++++++++++++++
 src/render/tree/node/style.rs      |  65 ++++++++++
 src/utils.rs                       |   7 ++
 12 files changed, 358 insertions(+), 197 deletions(-)
 create mode 100644 src/render/tree/node/output.rs
 create mode 100644 src/render/tree/node/style.rs

diff --git a/src/fs/permissions/mod.rs b/src/fs/permissions/mod.rs
index bda03fb3..82814607 100644
--- a/src/fs/permissions/mod.rs
+++ b/src/fs/permissions/mod.rs
@@ -97,7 +97,7 @@ impl Display for FileMode {
     }
 }
 
-/// For the octal representation of the file type and class permisssions.
+/// For the octal representation of permissions
 impl Octal for FileMode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let modes_mask = self.st_mode & !u32::from(libc::S_IFMT);
@@ -115,12 +115,12 @@ impl TryFrom<u32> for FileMode {
         let group_permissions = ClassPermissions::group_permissions_from(st_mode);
         let other_permissions = ClassPermissions::other_permissions_from(st_mode);
 
-        Ok(Self {
+        Ok(Self::new(
             st_mode,
             file_type,
             user_permissions,
             group_permissions,
             other_permissions,
-        })
+        ))
     }
 }
diff --git a/src/icons.rs b/src/icons.rs
index b5980f8e..f8648f3a 100644
--- a/src/icons.rs
+++ b/src/icons.rs
@@ -1,20 +1,114 @@
 use crate::hash;
-use ansi_term::Color;
+use ansi_term::Style;
+use ansi_term::{ANSIGenericString, Color};
+use ignore::DirEntry;
 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))
+}
+
 /// Attempts to return an icon given a file extension along with its default color code 8-bit
 /// value.
-pub fn icon_from_ext(ext: &OsStr) -> Option<(u8, &'static str)> {
+fn icon_from_ext(ext: &OsStr) -> Option<(u8, &'static str)> {
     EXT_ICON_MAP.get(ext).map(|(code, icon)| (*code, *icon))
 }
 
 /// Attempts to return an icon based on file type.
-pub fn icon_from_file_type(ft: FileType) -> Option<&'static str> {
+fn icon_from_file_type(ft: FileType) -> Option<&'static str> {
     if ft.is_dir() {
         return FILE_TYPE_ICON_MAP.get("dir").copied();
     } else if ft.is_symlink() {
@@ -25,17 +119,17 @@ pub fn icon_from_file_type(ft: FileType) -> Option<&'static str> {
 }
 
 /// Attempts to get the icon associated with the special file kind.
-pub fn icon_from_file_name(name: &OsStr) -> Option<&'static str> {
+fn icon_from_file_name(name: &OsStr) -> Option<&'static str> {
     FILE_NAME_ICON_MAP.get(name).copied()
 }
 
 /// Returns the default fallback icon.
-pub fn get_default_icon<'a>() -> (u8, &'a str) {
+fn get_default_icon<'a>() -> (u8, &'a str) {
     *DEFAULT_ICON
 }
 
 /// Convenience method to paint fixed colors.
-pub fn col(num: u8, code: &str) -> String {
+fn col(num: u8, code: &str) -> String {
     Color::Fixed(num).paint(code).to_string()
 }
 
diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index 6a9e13f9..129048cb 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -54,8 +54,8 @@ pub struct Context {
     pub no_ignore: bool,
 
     /// Follow symlinks and consider their disk usage
-    #[arg(short = 'f', long = "follow")]
-    pub follow_links: bool,
+    #[arg(short = 'f', long)]
+    pub follow: bool,
 
     /// Display file icons
     #[arg(short = 'I', long)]
@@ -69,6 +69,10 @@ pub struct Context {
     #[arg(short, long)]
     pub long: bool,
 
+    /// Display numeric permissions
+    #[arg(long, requires = "long")]
+    pub octal: bool,
+
     /// Regular expression (or glob if '--glob' or '--iglob' is used) used to match files
     #[arg(short, long)]
     pub pattern: Option<String>,
@@ -142,6 +146,9 @@ pub struct Context {
 
     #[clap(skip = tty::stdout_is_tty())]
     pub stdout_is_tty: bool,
+
+    #[clap(skip = usize::default())]
+    pub max_du_width: usize,
 }
 
 impl Context {
@@ -298,4 +305,12 @@ impl Context {
             re.is_match(&file_name)
         }))
     }
+
+    /// Setter for `total_du`.
+    pub fn set_total_du(&mut self, size: u64) {
+        if size == 0 {
+            return;
+        }
+        self.max_du_width = crate::utils::num_integral(size);
+    }
 }
diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index 8336b07d..ed62f9fc 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -77,30 +77,35 @@ impl FileSize {
     /// `123.45 KiB`
     /// `  1.23 MiB`
     /// `    12   B`
-    pub fn format(&self, align: bool) -> String {
+    pub fn format(&self, max_size_width: usize) -> String {
         let du_themes = get_du_theme().ok();
 
         let HumanReadableComponents { size, unit } = Self::human_readable_components(self);
         let color = du_themes.and_then(|th| th.get(unit.as_str()));
 
+        let max_padded = max_size_width + 4;
+        let current_padded = self.scale + 4;
+
+        let padded_total_width = if current_padded > max_padded {
+            max_padded
+        } else {
+            current_padded
+        };
+
         match color {
-            Some(col) if align => match self.prefix_kind {
+            Some(col) => match self.prefix_kind {
                 PrefixKind::Bin => col
-                    .paint(format!("{size:>len$} {unit:>3}", len = self.scale + 4))
+                    .paint(format!("{size:>padded_total_width$} {unit:>3}"))
                     .to_string(),
                 PrefixKind::Si => col
-                    .paint(format!("{size:>len$} {unit:>2}", len = self.scale + 4))
+                    .paint(format!("{size:>padded_total_width$} {unit:>2}"))
                     .to_string(),
             },
 
-            Some(col) => col.paint(format!("{size} {unit}")).to_string(),
-
-            None if align => match self.prefix_kind {
-                PrefixKind::Bin => format!("{size:>len$} {unit:>3}", len = self.scale + 4),
-                PrefixKind::Si => format!("{size:>len$} {unit:>2}", len = self.scale + 4),
+            None => match self.prefix_kind {
+                PrefixKind::Bin => format!("{size:>padded_total_width$} {unit:>3}"),
+                PrefixKind::Si => format!("{size:>padded_total_width$} {unit:>2}"),
             },
-
-            _ => format!("{size} {unit}"),
         }
     }
 
@@ -133,7 +138,7 @@ impl FileSize {
     pub fn human_readable_components(&self) -> HumanReadableComponents {
         let fbytes = self.bytes as f64;
         let scale = self.scale;
-        let power = u32::try_from(scale).unwrap();
+        let power = u32::try_from(scale).expect("Provided scale caused an overflow");
 
         let (size, unit) = match self.prefix_kind {
             PrefixKind::Bin => {
@@ -144,7 +149,7 @@ impl FileSize {
                     (format!("{}", self.bytes), format!("{unit}"))
                 } else {
                     // Checks if the `scale` provided results in a value that implies fractional bytes.
-                    if self.bytes <= 10_u64.pow(power) {
+                    if self.bytes <= 10_u64.checked_pow(power).unwrap_or(u64::MAX) {
                         (format!("{}", self.bytes), format!("{}", BinPrefix::Base))
                     } else {
                         (
@@ -163,7 +168,7 @@ impl FileSize {
                     (format!("{}", self.bytes), format!("{unit}"))
                 } else {
                     // Checks if the `scale` provided results in a value that implies fractional bytes.
-                    if 10_u64.pow(power) >= base_value {
+                    if 10_u64.checked_pow(power).unwrap_or(u64::MAX) >= base_value {
                         (format!("{}", self.bytes), format!("{}", SiPrefix::Base))
                     } else {
                         (
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index 923c83db..066673a8 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -43,6 +43,9 @@ static DU_THEME: OnceCell<HashMap<&'static str, Style>> = OnceCell::new();
 /// Runtime evaluated static that contains styles for permissions.
 static PERMISSIONS_THEME: OnceCell<HashMap<char, Style>> = OnceCell::new();
 
+/// Runtime evaluated static that contains style for octal permissions.
+static OCTAL_PERMISSIONS_STYLE: OnceCell<Style> = OnceCell::new();
+
 /// Map of the names box-drawing elements to their styled strings.
 pub type ThemesMap = HashMap<&'static str, String>;
 
@@ -82,7 +85,16 @@ pub fn get_link_theme() -> Result<&'static ThemesMap, Error<'static>> {
 
 /// Getter for [PERMISSIONS_THEME]. Returns an error if not initialized.
 pub fn get_permissions_theme() -> Result<&'static HashMap<char, Style>, Error<'static>> {
-    PERMISSIONS_THEME.get().ok_or(Error::Uninitialized("PERMISSIONS_THEME"))
+    PERMISSIONS_THEME
+        .get()
+        .ok_or(Error::Uninitialized("PERMISSIONS_THEME"))
+}
+
+/// Getter for [PERMISSIONS_THEME]. Returns an error if not initialized.
+pub fn get_octal_permissions_style() -> Result<&'static Style, Error<'static>> {
+    OCTAL_PERMISSIONS_STYLE
+        .get()
+        .ok_or(Error::Uninitialized("OCTAL_PERMISSIONS_STYLE"))
 }
 
 /// Initializes [LS_COLORS] by reading in the `LS_COLORS` environment variable. If it isn't set, a
@@ -143,6 +155,7 @@ fn init_themes() {
     let permissions_theme = hash! {
         '-' => Color::Purple.normal(),
         'd' => Color::Blue.bold(),
+        'l' => Color::Red.bold(),
         'r' => Color::Green.bold(),
         'w' => Color::Yellow.bold(),
         'x' | 's' | 'S' | 't' | 'T' => Color::Red.bold(),
@@ -151,4 +164,10 @@ fn init_themes() {
     };
 
     PERMISSIONS_THEME.set(permissions_theme).unwrap();
+
+    let octal_permissions_style = Color::Purple.bold();
+
+    OCTAL_PERMISSIONS_STYLE
+        .set(octal_permissions_style)
+        .unwrap();
 }
diff --git a/src/render/tree/display.rs b/src/render/tree/display.rs
index d581edb1..ac4cedf2 100644
--- a/src/render/tree/display.rs
+++ b/src/render/tree/display.rs
@@ -141,10 +141,7 @@ impl Display for Tree<Report> {
 
         file_count_data.push(Self::compute_file_count(root, tree));
 
-        let total_du_width = root_node
-            .file_size()
-            .map_or_else(|| String::from("0"), |fs| format!("{}", fs.bytes))
-            .len();
+        let total_du_width = ctx.max_du_width;
 
         let (total_du, root_unit) = du_info(root_node);
 
diff --git a/src/render/tree/error.rs b/src/render/tree/error.rs
index 58b7ac2b..d00deff2 100644
--- a/src/render/tree/error.rs
+++ b/src/render/tree/error.rs
@@ -1,7 +1,6 @@
 use super::styles::error::Error as StyleError;
 use crate::{
-    fs::permissions::error::Error as PermissionsError,
-    render::context::error::Error as CtxError,
+    fs::permissions::error::Error as PermissionsError, render::context::error::Error as CtxError,
 };
 use ignore::Error as IgnoreError;
 use std::io::Error as IoError;
diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index 74d64ce8..1ef99be4 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -66,9 +66,12 @@ where
     }
 
     /// Initiates file-system traversal and [Tree construction].
-    pub fn try_init(ctx: Context) -> Result<Self> {
+    pub fn try_init(mut ctx: Context) -> Result<Self> {
         let (inner, root) = Self::traverse(&ctx)?;
 
+        let total_du = inner[root].get().file_size().map_or(0, |size| size.bytes);
+        ctx.set_total_du(total_du);
+
         let tree = Self::new(inner, root, ctx);
 
         if tree.is_stump() {
@@ -292,7 +295,7 @@ impl TryFrom<&Context> for WalkParallel {
         let mut builder = WalkBuilder::new(root);
 
         builder
-            .follow_links(ctx.follow_links)
+            .follow_links(ctx.follow)
             .git_ignore(!ctx.no_ignore)
             .hidden(!ctx.hidden)
             .threads(ctx.threads)
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index dcfbf12a..8724d080 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -1,19 +1,18 @@
 use crate::{
     fs::{
-        permissions::{FileMode, SymbolicNotation},
         inode::Inode,
+        permissions::{FileMode, SymbolicNotation},
         xattr::ExtendedAttr,
     },
-    icons::{self, get_default_icon, icon_from_ext, icon_from_file_name, icon_from_file_type},
+    icons,
     render::{
         context::Context,
         disk_usage::file_size::{DiskUsage, FileSize},
-        styles::{get_ls_colors, get_permissions_theme},
+        styles::get_ls_colors,
         tree::error::Error,
     },
-    tty,
 };
-use ansi_term::{ANSIGenericString, Color, Style};
+use ansi_term::Style;
 use ignore::DirEntry;
 use lscolors::Style as LS_Style;
 use std::{
@@ -29,6 +28,12 @@ use xattr::XAttrs;
 /// Ordering and sorting rules for [Node].
 pub mod cmp;
 
+/// For building the actual output.
+pub mod output;
+
+/// All methods of [Node] that pertain to styling the output.
+pub mod style;
+
 /// A node of [`Tree`] that can be created from a [DirEntry]. Any filesystem I/O and
 /// relevant system calls are expected to complete after initialization. A `Node` when `Display`ed
 /// uses ANSI colors determined by the file-type and `LS_COLORS`.
@@ -39,7 +44,6 @@ pub struct Node {
     metadata: Metadata,
     file_size: Option<FileSize>,
     style: Option<Style>,
-    icon: Option<Cow<'static, str>>,
     symlink_target: Option<PathBuf>,
     inode: Option<Inode>,
 
@@ -54,7 +58,6 @@ impl Node {
         metadata: Metadata,
         file_size: Option<FileSize>,
         style: Option<Style>,
-        icon: Option<Cow<'static, str>>,
         symlink_target: Option<PathBuf>,
         inode: Option<Inode>,
         xattrs: Option<XAttrs>,
@@ -64,7 +67,6 @@ impl Node {
             metadata,
             file_size,
             style,
-            icon,
             symlink_target,
             inode,
             xattrs,
@@ -77,13 +79,17 @@ impl Node {
         self.dir_entry.file_name()
     }
 
+    pub const fn dir_entry(&self) -> &DirEntry {
+        &self.dir_entry
+    }
+
     /// Get depth level of [Node].
     pub fn depth(&self) -> usize {
         self.dir_entry.depth()
     }
 
     /// Gets the underlying [Inode] of the entry.
-    pub fn inode(&self) -> Option<Inode> {
+    pub const fn inode(&self) -> Option<Inode> {
         self.inode
     }
 
@@ -140,11 +146,6 @@ impl Node {
         self.file_size = Some(size);
     }
 
-    /// Grabs a reference to `icon`.
-    pub fn icon(&self) -> Option<&str> {
-        self.icon.as_deref()
-    }
-
     /// Attempts to return an instance of [FileMode] for the display of symbolic permissions.
     pub fn mode(&self) -> Result<FileMode, Error> {
         let permissions = self.metadata.permissions();
@@ -152,44 +153,20 @@ impl Node {
         Ok(file_mode)
     }
 
-    /// Stylizes input, `entity` based on `LS_COLORS`. If `style` is `None` then the entity is
-    /// returned unmodified.
-    fn stylize<'a>(&self, entity: Cow<'a, str>) -> Cow<'a, str> {
-        if let Some(Style {
-            foreground: Some(ref fg),
-            ..
-        }) = self.style
-        {
-            Cow::from(fg.bold().paint(entity).to_string())
-        } else {
-            entity
-        }
-    }
-
     /// Whether or not [Node] has extended attributes.
     ///
     /// TODO: Cloning can potentially be expensive here, but practically speaking we won't run into
     /// this scenario a lot, but we will want to optimize this bad boy by removing the `xattr`
     /// crate and just query for the existence of xattrs ourselves.
     fn has_xattrs(&self) -> bool {
-        let count = self.xattrs
+        let count = self
+            .xattrs
             .as_ref()
-            .map(|xattrs| xattrs.clone().count())
-            .unwrap_or(0);
+            .map_or(0, |xattrs| xattrs.clone().count());
 
         count > 0
     }
 
-    /// Stylizes symlink name for display.
-    fn stylize_link_name(&self) -> Option<Cow<'_, str>> {
-        self.symlink_target_file_name().map(|name| {
-            let file_name = self.file_name_lossy();
-            let styled_name = self.stylize(file_name);
-            let target_name = Color::Red.paint(format!("\u{2192} {}", name.to_string_lossy()));
-            Cow::from(format!("{styled_name} {target_name}"))
-        })
-    }
-
     /// General method for printing a `Node`. The `Display` (and `ToString`) traits are not used,
     /// to give more control over the output.
     ///
@@ -207,42 +184,13 @@ impl Node {
     /// Note the two spaces to the left of the first character of the number -- even if never used,
     /// numbers are padded to 3 digits to the left of the decimal (and ctx.scale digits after)
     pub fn display(&self, f: &mut Formatter, prefix: &str, ctx: &Context) -> fmt::Result {
-        let size = self
-            .file_size()
-            .map_or_else(|| FileSize::empty_string(ctx), |size| size.format(true));
-
-        let icon = self.icon().unwrap_or("");
-
-        let icon_padding = if icon.len() > 1 { icon.len() - 1 } else { 0 };
-
-        let file_name = if ctx.no_color() {
-            self.file_name().to_string_lossy()
+        let out = if ctx.no_color() {
+            output::compute(self, prefix, ctx)
         } else {
-            self.stylize_link_name().unwrap_or_else(|| {
-                let file_name = self.file_name_lossy();
-                self.stylize(file_name)
-            })
+            output::compute_with_color(self, prefix, ctx)
         };
 
-        if ctx.long {
-            let mut mode = if self.has_xattrs() {
-                format!("{}@", self.mode().unwrap())
-            } else {
-                format!("{} ", self.mode().unwrap())
-            };
-
-            if !ctx.no_color() {
-                mode = Self::style_permissions(&mode)
-            }
-
-            write!(
-                f,
-                "{mode:mode_len$}{size} {prefix}{icon:<icon_padding$}{file_name}",
-                mode_len = mode.len() + 2,
-            )
-        } else {
-            write!(f, "{size} {prefix}{icon:<icon_padding$}{file_name}")
-        }
+        write!(f, "{out}")
     }
 
     /// Unix file identifiers that you'd find in the `ls -l` command.
@@ -291,88 +239,12 @@ impl Node {
         Some(iden)
     }
 
-    /// Styles the symbolic notation file permissions.
-    fn style_permissions(perm_str: &str) -> String {
-        let theme = get_permissions_theme().unwrap();
-
-        perm_str
-            .chars()
-            .flat_map(|ch| {
-                theme.get(&ch).map(|color| {
-                    let chstr = ch.to_string();
-                    color.paint(chstr).to_string()
-                })
-            })
-            .collect::<String>()
-    }
-
-    /// Attempts to compute icon with given parameters. Icon will be colorless if stdout isn't a
-    /// tty or if `no_color` is true.
-    ///
-    /// 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.
-    fn compute_icon(
-        entry: &DirEntry,
-        link_target: Option<&PathBuf>,
-        style: Option<Style>,
-        no_color: bool,
-    ) -> Option<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),
-                ..
-            }) if tty::stdout_is_tty() && !no_color => {
-                let ansi_string: ANSIGenericString<str> = fg.bold().paint(icon);
-                let styled_icon = ansi_string.to_string();
-                Some(Cow::from(styled_icon))
-            }
-
-            _ => Some(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| {
-            if no_color || !tty::stdout_is_tty() {
-                Cow::from(attrs.1)
-            } else {
-                Cow::from(icons::col(attrs.0, attrs.1))
-            }
-        });
-
-        if icon.is_some() {
-            return icon;
-        }
-
-        let icon = icon_from_file_name(entry.file_name())
-            .map(Cow::from)
-            .and_then(paint_icon);
-
-        if icon.is_some() {
-            return icon;
-        }
-
+    /// See [icons::compute].
+    fn compute_icon(&self, no_color: bool) -> Cow<'static, str> {
         if no_color {
-            Some(Cow::from(get_default_icon().1))
+            icons::compute(self.dir_entry(), self.symlink_target_path())
         } else {
-            let (code, icon) = get_default_icon();
-            Some(Cow::from(icons::col(code, icon)))
+            icons::compute_with_color(self.dir_entry(), self.symlink_target_path(), self.style)
         }
     }
 }
@@ -406,13 +278,6 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             _ => None,
         };
 
-        let icon = if ctx.icons {
-            let no_color = ctx.no_color();
-            Self::compute_icon(&dir_entry, link_target.as_ref(), style, no_color)
-        } else {
-            None
-        };
-
         let inode = Inode::try_from(&metadata).ok();
 
         let xattrs = if ctx.long {
@@ -426,10 +291,9 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             metadata,
             file_size,
             style,
-            icon,
             link_target,
             inode,
-            xattrs
+            xattrs,
         ))
     }
 }
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
new file mode 100644
index 00000000..fb4ca4bd
--- /dev/null
+++ b/src/render/tree/node/output.rs
@@ -0,0 +1,93 @@
+use crate::render::{context::Context, tree::node::Node};
+
+pub fn compute_with_color(node: &Node, prefix: &str, ctx: &Context) -> String {
+    let size = presenters::size(node, ctx);
+    let padded_icon = presenters::padded_icon(node, ctx);
+
+    let file_name = node.symlink_target_file_name().map_or_else(
+        || Node::stylize(node.file_name(), node.style),
+        |target_name| {
+            let link_name = node.file_name();
+            Node::stylize_link_name(link_name, target_name, node.style)
+        },
+    );
+
+    if ctx.long {
+        let mode = node.mode().unwrap();
+
+        let sym_permissions = if node.has_xattrs() {
+            Node::style_sym_permissions(&format!("{}@", &mode))
+        } else {
+            Node::style_sym_permissions(&format!("{} ", &mode))
+        };
+
+        let oct_permissions = if ctx.octal {
+            Node::style_octal_permissions(&mode)
+        } else {
+            String::new()
+        };
+
+        format!(
+            "{oct_permissions} {sym_permissions:mode_len$}{size} {prefix}{padded_icon}{file_name}",
+            mode_len = sym_permissions.len() + 1,
+        )
+    } else {
+        format!("{size} {prefix}{padded_icon}{file_name}")
+    }
+}
+
+pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
+    let size = presenters::size(node, ctx);
+    let padded_icon = presenters::padded_icon(node, ctx);
+
+    let file_name = node.symlink_target_file_name().map_or_else(
+        || node.file_name_lossy(),
+        |target_name| {
+            let link_name = node.file_name();
+            Node::stylize_link_name(link_name, target_name, None)
+        },
+    );
+
+    if ctx.long {
+        let mode = node.mode().unwrap();
+
+        let sym_permissions = if node.has_xattrs() {
+            format!("{mode}@")
+        } else {
+            format!("{mode} ")
+        };
+
+        format!(
+            "{sym_permissions:mode_len$}{size} {prefix}{padded_icon}{file_name}",
+            mode_len = sym_permissions.len() + 1,
+        )
+    } else {
+        format!("{size} {prefix}{padded_icon}{file_name}")
+    }
+}
+
+/// Helper functions to build each component of the output.
+mod presenters {
+    use crate::render::{context::Context, disk_usage::file_size::FileSize, tree::Node};
+
+    #[inline]
+    /// Builds the disk usage portion of the output.
+    pub(super) fn size(node: &Node, ctx: &Context) -> String {
+        node.file_size().map_or_else(
+            || FileSize::empty_string(ctx),
+            |size| size.format(ctx.max_du_width),
+        )
+    }
+
+    #[inline]
+    /// Builds the icon portion of the output.
+    pub(super) fn padded_icon(node: &Node, ctx: &Context) -> String {
+        if ctx.icons {
+            let icon = node.compute_icon(ctx.no_color());
+            let padding = icon.len() - 1;
+            format!("{icon:<padding$}")
+        } else {
+            String::new()
+        }
+    }
+}
diff --git a/src/render/tree/node/style.rs b/src/render/tree/node/style.rs
new file mode 100644
index 00000000..d6de2735
--- /dev/null
+++ b/src/render/tree/node/style.rs
@@ -0,0 +1,65 @@
+use super::Node;
+use crate::{
+    fs::permissions::FileMode,
+    render::styles::{get_octal_permissions_style, get_permissions_theme},
+};
+use ansi_term::{Color, Style};
+use std::{borrow::Cow, ffi::OsStr};
+
+impl Node {
+    /// Stylizes input, `entity` based on `LS_COLORS`. If `style` is `None` then the entity is
+    /// returned unmodified.
+    pub(super) fn stylize(file_name: &OsStr, style: Option<Style>) -> Cow<'_, str> {
+        let name = file_name.to_string_lossy();
+
+        if let Some(Style {
+            foreground: Some(ref fg),
+            ..
+        }) = style
+        {
+            Cow::from(fg.bold().paint(name).to_string())
+        } else {
+            name
+        }
+    }
+
+    /// Stylizes symlink name for display.
+    pub(super) fn stylize_link_name<'a>(
+        link_name: &'a OsStr,
+        target_name: &'a OsStr,
+        style: Option<Style>,
+    ) -> Cow<'a, str> {
+        if style.is_some() {
+            let styled_name = Self::stylize(link_name, style);
+            let target_name =
+                Color::Red.paint(format!("\u{2192} {}", target_name.to_string_lossy()));
+            Cow::from(format!("{styled_name} {target_name}"))
+        } else {
+            let link = link_name.to_string_lossy();
+            let target = target_name.to_string_lossy();
+            Cow::from(format!("{link} \u{2192} {target}"))
+        }
+    }
+
+    /// Styles the symbolic notation file permissions.
+    pub(super) fn style_sym_permissions(perm_str: &str) -> String {
+        let theme = get_permissions_theme().unwrap();
+
+        perm_str
+            .chars()
+            .filter_map(|ch| {
+                theme.get(&ch).map(|color| {
+                    let chstr = ch.to_string();
+                    color.paint(chstr).to_string()
+                })
+            })
+            .collect::<String>()
+    }
+
+    pub(super) fn style_octal_permissions(mode: &FileMode) -> String {
+        get_octal_permissions_style()
+            .unwrap()
+            .paint(format!("{mode:04o}"))
+            .to_string()
+    }
+}
diff --git a/src/utils.rs b/src/utils.rs
index b4f4db00..7189af33 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -22,6 +22,7 @@ macro_rules! hash {
 }
 
 /// Ensure every item in a `Vec` is unique.
+#[inline]
 pub fn uniq<T>(items: Vec<T>) -> Vec<T>
 where
     T: Eq + Hash + ToOwned,
@@ -34,3 +35,9 @@ where
         .filter(|item| set.insert(item.to_owned()))
         .collect::<Vec<T>>()
 }
+
+/// How many integral digits are there?
+#[inline]
+pub const fn num_integral(value: u64) -> usize {
+    value.ilog10() as usize + 1
+}

From 0685f3e6476f3971ced639ae6a739e8d00e3cfda Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sun, 16 Apr 2023 17:21:57 -0700
Subject: [PATCH 15/33] placeholder character

---
 src/render/context/mod.rs          |  4 ----
 src/render/disk_usage/file_size.rs | 22 +++++++++++++++++++---
 src/render/styles/mod.rs           | 19 ++++++++++++++++++-
 src/render/tree/node/output.rs     | 20 +++++++++-----------
 src/render/tree/node/style.rs      |  1 +
 tests/glob.rs                      | 10 +++++-----
 tests/regex.rs                     |  2 +-
 7 files changed, 53 insertions(+), 25 deletions(-)

diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index 129048cb..1f955abf 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -69,10 +69,6 @@ pub struct Context {
     #[arg(short, long)]
     pub long: bool,
 
-    /// Display numeric permissions
-    #[arg(long, requires = "long")]
-    pub octal: bool,
-
     /// Regular expression (or glob if '--glob' or '--iglob' is used) used to match files
     #[arg(short, long)]
     pub pattern: Option<String>,
diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index ed62f9fc..e9f65ed1 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -1,8 +1,11 @@
 use super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
-use crate::{render::styles::get_du_theme, Context};
+use crate::{
+    render::styles::{self, get_du_theme, get_placeholder_style},
+    Context,
+};
 use clap::ValueEnum;
 use filesize::PathExt;
-use std::{fs::Metadata, ops::AddAssign, path::Path};
+use std::{borrow::Cow, fs::Metadata, ops::AddAssign, path::Path};
 
 /// Represents either logical or physical size and handles presentation.
 #[derive(Clone, Debug)]
@@ -115,7 +118,20 @@ impl FileSize {
         if ctx.suppress_size {
             String::new()
         } else {
-            format!("{:len$}", "", len = Self::empty_string_len(ctx))
+            let (placeholder, extra_padding) = get_placeholder_style().map_or_else(
+                |_| (Cow::from(styles::PLACEHOLDER), 0),
+                |style| {
+                    let placeholder = Cow::from(style.paint(styles::PLACEHOLDER).to_string());
+                    let padding = placeholder.len() - 1;
+                    (placeholder, padding)
+                },
+            );
+
+            format!(
+                "{:>len$}",
+                placeholder,
+                len = Self::empty_string_len(ctx) + extra_padding
+            )
         }
     }
 
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index 066673a8..f2eebad6 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -8,6 +8,9 @@ use std::collections::HashMap;
 /// Errors for this module.
 pub mod error;
 
+/// Used as general placeholder for an empty field.
+pub const PLACEHOLDER: &str = "-";
+
 /// Used for padding between tree branches.
 pub const SEP: &str = "   ";
 
@@ -46,6 +49,9 @@ static PERMISSIONS_THEME: OnceCell<HashMap<char, Style>> = OnceCell::new();
 /// Runtime evaluated static that contains style for octal permissions.
 static OCTAL_PERMISSIONS_STYLE: OnceCell<Style> = OnceCell::new();
 
+/// Runtime evaluated static that contains style for the general use placeholder "-".
+static PLACEHOLDER_STYLE: OnceCell<Style> = OnceCell::new();
+
 /// Map of the names box-drawing elements to their styled strings.
 pub type ThemesMap = HashMap<&'static str, String>;
 
@@ -90,13 +96,20 @@ pub fn get_permissions_theme() -> Result<&'static HashMap<char, Style>, Error<'s
         .ok_or(Error::Uninitialized("PERMISSIONS_THEME"))
 }
 
-/// Getter for [PERMISSIONS_THEME]. Returns an error if not initialized.
+/// Getter for [OCTAL_PERMISSIONS_STYLE]. Returns an error if not initialized.
 pub fn get_octal_permissions_style() -> Result<&'static Style, Error<'static>> {
     OCTAL_PERMISSIONS_STYLE
         .get()
         .ok_or(Error::Uninitialized("OCTAL_PERMISSIONS_STYLE"))
 }
 
+/// Getter for [PLACEHOLDER_STYLE]. Returns an error if not initialized.
+pub fn get_placeholder_style() -> Result<&'static Style, Error<'static>> {
+    PLACEHOLDER_STYLE
+        .get()
+        .ok_or(Error::Uninitialized("PLACEHOLDER_STYLE"))
+}
+
 /// Initializes [LS_COLORS] by reading in the `LS_COLORS` environment variable. If it isn't set, a
 /// default determined by `lscolors` crate will be used.
 fn init_ls_colors() {
@@ -170,4 +183,8 @@ fn init_themes() {
     OCTAL_PERMISSIONS_STYLE
         .set(octal_permissions_style)
         .unwrap();
+
+    let placeholder_style = Color::Purple.normal();
+
+    PLACEHOLDER_STYLE.set(placeholder_style).unwrap();
 }
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index fb4ca4bd..a3d31afa 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -15,21 +15,17 @@ pub fn compute_with_color(node: &Node, prefix: &str, ctx: &Context) -> String {
     if ctx.long {
         let mode = node.mode().unwrap();
 
-        let sym_permissions = if node.has_xattrs() {
+        let sym = if node.has_xattrs() {
             Node::style_sym_permissions(&format!("{}@", &mode))
         } else {
             Node::style_sym_permissions(&format!("{} ", &mode))
         };
 
-        let oct_permissions = if ctx.octal {
-            Node::style_octal_permissions(&mode)
-        } else {
-            String::new()
-        };
+        let oct = Node::style_octal_permissions(&mode);
 
         format!(
-            "{oct_permissions} {sym_permissions:mode_len$}{size} {prefix}{padded_icon}{file_name}",
-            mode_len = sym_permissions.len() + 1,
+            "{oct} {sym:mode_len$}{size} {prefix}{padded_icon}{file_name}",
+            mode_len = sym.len() + 1,
         )
     } else {
         format!("{size} {prefix}{padded_icon}{file_name}")
@@ -51,15 +47,17 @@ pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
     if ctx.long {
         let mode = node.mode().unwrap();
 
-        let sym_permissions = if node.has_xattrs() {
+        let sym = if node.has_xattrs() {
             format!("{mode}@")
         } else {
             format!("{mode} ")
         };
 
+        let oct = format!("{mode:04o}");
+
         format!(
-            "{sym_permissions:mode_len$}{size} {prefix}{padded_icon}{file_name}",
-            mode_len = sym_permissions.len() + 1,
+            "{oct} {sym:mode_len$}{size} {prefix}{padded_icon}{file_name}",
+            mode_len = sym.len() + 1,
         )
     } else {
         format!("{size} {prefix}{padded_icon}{file_name}")
diff --git a/src/render/tree/node/style.rs b/src/render/tree/node/style.rs
index d6de2735..c5aff129 100644
--- a/src/render/tree/node/style.rs
+++ b/src/render/tree/node/style.rs
@@ -33,6 +33,7 @@ impl Node {
             let styled_name = Self::stylize(link_name, style);
             let target_name =
                 Color::Red.paint(format!("\u{2192} {}", target_name.to_string_lossy()));
+
             Cow::from(format!("{styled_name} {target_name}"))
         } else {
             let link = link_name.to_string_lossy();
diff --git a/tests/glob.rs b/tests/glob.rs
index 90f04961..db5071bf 100644
--- a/tests/glob.rs
+++ b/tests/glob.rs
@@ -22,7 +22,7 @@ fn glob() {
                83   B ├─ necronomicon.txt
               161   B ├─ nemesis.txt
               100   B ├─ nylarlathotep.txt
-                      └─ the_yellow_king
+                    - └─ the_yellow_king
 
            3 directories, 5 files"
         )
@@ -42,8 +42,8 @@ fn glob_negative() {
         ]),
         indoc!(
             "143   B data
-                   ├─ dream_cycle
-                   ├─ lipsum
+                 - ├─ dream_cycle
+                 - ├─ lipsum
            143   B └─ the_yellow_king
            143   B    └─ cassildas_song.md
 
@@ -72,7 +72,7 @@ fn glob_case_insensitive() {
                 83   B ├─ necronomicon.txt
                161   B ├─ nemesis.txt
                100   B ├─ nylarlathotep.txt
-                       └─ the_yellow_king
+                     - └─ the_yellow_king
 
             3 directories, 5 files"
         )
@@ -99,7 +99,7 @@ fn iglob() {
                 83   B ├─ necronomicon.txt
                161   B ├─ nemesis.txt
                100   B ├─ nylarlathotep.txt
-                       └─ the_yellow_king
+                     - └─ the_yellow_king
 
             3 directories, 5 files"
         )
diff --git a/tests/regex.rs b/tests/regex.rs
index 29185297..21a709cc 100644
--- a/tests/regex.rs
+++ b/tests/regex.rs
@@ -15,7 +15,7 @@ fn regex() {
                 83   B ├─ necronomicon.txt
                161   B ├─ nemesis.txt
                100   B ├─ nylarlathotep.txt
-                       └─ the_yellow_king
+                     - └─ the_yellow_king
 
             3 directories, 5 files"
         )

From 99c85e7198dd7a52b7e26b286b7ccd5698a2d2dd Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Sun, 16 Apr 2023 21:58:02 -0700
Subject: [PATCH 16/33] support nlinks

---
 src/render/context/mod.rs      | 15 ++++++++++--
 src/render/styles/mod.rs       | 32 ++++++++++++++++++++-----
 src/render/tree/mod.rs         | 35 +++++++++++++++++++++++++--
 src/render/tree/node/mod.rs    | 10 ++++++++
 src/render/tree/node/output.rs | 44 +++++++++++++++++++++++++++++++---
 5 files changed, 123 insertions(+), 13 deletions(-)

diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index 1f955abf..d88cad75 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -145,6 +145,9 @@ pub struct Context {
 
     #[clap(skip = usize::default())]
     pub max_du_width: usize,
+
+    #[clap(skip = usize::default())]
+    pub max_nlink_width: usize,
 }
 
 impl Context {
@@ -302,11 +305,19 @@ impl Context {
         }))
     }
 
-    /// Setter for `total_du`.
-    pub fn set_total_du(&mut self, size: u64) {
+    /// Setter for `max_du_width` to inform formatters what the width of the disk usage column
+    /// should be.
+    pub fn set_max_du_width(&mut self, size: u64) {
         if size == 0 {
             return;
         }
         self.max_du_width = crate::utils::num_integral(size);
     }
+
+    /// Setter for `max_nlink_width` which is used to inform formatters what the width of the
+    /// `nlink` column should be.
+    pub fn set_max_nlink_width(&mut self, nlink: u64) {
+        // `nlink` shouldn't be big so we shouldn't worry about truncation.
+        self.max_nlink_width = crate::utils::num_integral(nlink);
+    }
 }
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index f2eebad6..e265b15e 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -52,6 +52,12 @@ static OCTAL_PERMISSIONS_STYLE: OnceCell<Style> = OnceCell::new();
 /// Runtime evaluated static that contains style for the general use placeholder "-".
 static PLACEHOLDER_STYLE: OnceCell<Style> = OnceCell::new();
 
+/// Runtime evaluated static that contains style for inode number i.e. `ino`.
+static INO_STYLE: OnceCell<Style> = OnceCell::new();
+
+/// Runtime evaluated static that contains style for number of hardlinks i.e. `nlink`.
+static NLINK_STYLE: OnceCell<Style> = OnceCell::new();
+
 /// Map of the names box-drawing elements to their styled strings.
 pub type ThemesMap = HashMap<&'static str, String>;
 
@@ -110,6 +116,20 @@ pub fn get_placeholder_style() -> Result<&'static Style, Error<'static>> {
         .ok_or(Error::Uninitialized("PLACEHOLDER_STYLE"))
 }
 
+/// Getter for [INO_STYLE]. Returns an error if not initialized.
+pub fn get_ino_style() -> Result<&'static Style, Error<'static>> {
+    INO_STYLE
+        .get()
+        .ok_or(Error::Uninitialized("INO_STYLE"))
+}
+
+/// Getter for [NLINK_STYLE]. Returns an error if not initialized.
+pub fn get_nlink_style() -> Result<&'static Style, Error<'static>> {
+    NLINK_STYLE
+        .get()
+        .ok_or(Error::Uninitialized("NLINK_STYLE"))
+}
+
 /// Initializes [LS_COLORS] by reading in the `LS_COLORS` environment variable. If it isn't set, a
 /// default determined by `lscolors` crate will be used.
 fn init_ls_colors() {
@@ -144,7 +164,6 @@ fn init_themes() {
         "uprt" => format!("{}", Color::Purple.paint(UPRT)),
         "vtrt" => format!("{}", Color::Purple.paint(VTRT))
     };
-
     TREE_THEME.set(theme).unwrap();
 
     let link_theme = hash! {
@@ -152,7 +171,6 @@ fn init_themes() {
         "uprt" => format!("{}", Color::Red.paint(UPRT)),
         "vtrt" => format!("{}", Color::Red.paint(VTRT))
     };
-
     LINK_THEME.set(link_theme).unwrap();
 
     let du_theme = hash! {
@@ -162,7 +180,6 @@ fn init_themes() {
         "GB" | "GiB" => Color::Red.bold(),
         "TB" | "TiB" => Color::Blue.bold()
     };
-
     DU_THEME.set(du_theme).unwrap();
 
     let permissions_theme = hash! {
@@ -175,16 +192,19 @@ fn init_themes() {
         '@' => Color::Cyan.bold(),
         ' ' => Color::White.normal()
     };
-
     PERMISSIONS_THEME.set(permissions_theme).unwrap();
 
     let octal_permissions_style = Color::Purple.bold();
-
     OCTAL_PERMISSIONS_STYLE
         .set(octal_permissions_style)
         .unwrap();
 
     let placeholder_style = Color::Purple.normal();
-
     PLACEHOLDER_STYLE.set(placeholder_style).unwrap();
+
+    let ino_style = Color::Cyan.bold();
+    INO_STYLE.set(ino_style).unwrap();
+
+    let nlink_style = Color::Red.bold();
+    NLINK_STYLE.set(nlink_style).unwrap();
 }
diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index 1ef99be4..7209e7cf 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -69,8 +69,13 @@ where
     pub fn try_init(mut ctx: Context) -> Result<Self> {
         let (inner, root) = Self::traverse(&ctx)?;
 
-        let total_du = inner[root].get().file_size().map_or(0, |size| size.bytes);
-        ctx.set_total_du(total_du);
+        let max_du_width = inner[root].get().file_size().map_or(0, |size| size.bytes);
+        ctx.set_max_du_width(max_du_width);
+
+        if ctx.long {
+            let max_nlink = Self::compute_max_nlink(root, &inner, &ctx);
+            ctx.set_max_nlink_width(max_nlink);
+        }
 
         let tree = Self::new(inner, root, ctx);
 
@@ -273,6 +278,9 @@ where
         }
     }
 
+    /// Compute total number of files for a single directory without recurring into child
+    /// directories. Files are grouped into three categories: directories, regular files, and
+    /// symlinks.
     fn compute_file_count(node_id: NodeId, tree: &Arena<Node>) -> FileCount {
         let mut count = FileCount::default();
 
@@ -282,6 +290,29 @@ where
 
         count
     }
+
+    /// Among the files to be printed, this will seek out the [Node] whose underling inode contains
+    /// the highest `nlink` which is used for determining the width of the nlink column for the
+    /// `--long` output.
+    fn compute_max_nlink(root: NodeId, tree: &Arena<Node>, ctx: &Context) -> u64 {
+        let max_depth = ctx.level();
+
+        root.descendants(tree).fold(0, |max, i| {
+            let node = tree[i].get();
+
+            if node.depth() > max_depth {
+                return max;
+            }
+
+            let nlink = node.nlink().unwrap_or(0);
+
+            if nlink > max {
+                nlink
+            } else {
+                max 
+            }
+        })
+    }
 }
 
 impl TryFrom<&Context> for WalkParallel {
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index 8724d080..56a83f4a 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -93,6 +93,16 @@ impl Node {
         self.inode
     }
 
+    /// Returns the underlying `ino` of the [DirEntry].
+    pub fn ino(&self) -> Option<u64> {
+        self.inode.map(|inode| inode.ino)
+    }
+
+    /// Returns the underlying `nlink` of the [DirEntry].
+    pub fn nlink(&self) -> Option<u64> {
+        self.inode.map(|inode| inode.nlink)
+    }
+
     /// Converts `OsStr` to `String`; if fails does a lossy conversion replacing non-Unicode
     /// sequences with Unicode replacement scalar values.
     pub fn file_name_lossy(&self) -> Cow<'_, str> {
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index a3d31afa..64297db0 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -22,10 +22,14 @@ pub fn compute_with_color(node: &Node, prefix: &str, ctx: &Context) -> String {
         };
 
         let oct = Node::style_octal_permissions(&mode);
+        let ino = presenters::ino(node.ino());
+        let nlink = presenters::nlink(node.nlink(), ctx);
 
         format!(
-            "{oct} {sym:mode_len$}{size} {prefix}{padded_icon}{file_name}",
-            mode_len = sym.len() + 1,
+            "{ino:<ino_padding$}{oct:<oct_padding$}{sym:<mode_padding$}{nlink} {size} {prefix}{padded_icon}{file_name}",
+            ino_padding = ino.len() + 1,
+            oct_padding = oct.len() + 1,
+            mode_padding = sym.len() + 1,
         )
     } else {
         format!("{size} {prefix}{padded_icon}{file_name}")
@@ -66,7 +70,13 @@ pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
 
 /// Helper functions to build each component of the output.
 mod presenters {
-    use crate::render::{context::Context, disk_usage::file_size::FileSize, tree::Node};
+    use crate::render::{
+        context::Context,
+        disk_usage::file_size::FileSize,
+        styles,
+        tree::Node
+    };
+    use std::borrow::Cow;
 
     #[inline]
     /// Builds the disk usage portion of the output.
@@ -88,4 +98,32 @@ mod presenters {
             String::new()
         }
     }
+
+    #[inline]
+    /// Builds the `ino` portion of the output
+    pub(super) fn ino(ino: Option<u64>) -> Cow<'static, str> {
+        let out = ino
+            .map(|num| Cow::from(format!("{num}")))
+            .unwrap_or(Cow::from(styles::PLACEHOLDER));
+
+        if let Some(style) = styles::get_ino_style().ok() {
+            Cow::from(style.paint(out).to_string())
+        } else {
+            out
+        }
+    }
+
+    #[inline]
+    /// Builds the `nlink` portion of the output
+    pub(super) fn nlink(nlink: Option<u64>, ctx: &Context) -> Cow<'static, str> {
+        let out = nlink
+            .map(|num| Cow::from(format!("{num:>width$}", width = ctx.max_nlink_width)))
+            .unwrap_or(Cow::from(format!("{:>width$}", styles::PLACEHOLDER, width = ctx.max_nlink_width)));
+
+        if let Some(style) = styles::get_nlink_style().ok() {
+            Cow::from(style.paint(out).to_string())
+        } else {
+            out
+        }
+    }
 }

From ced3e49a4814477b49742607007b00b739b834f5 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 17 Apr 2023 22:59:48 -0700
Subject: [PATCH 17/33] support blocks in long output

---
 src/render/context/mod.rs          | 51 +++++++++++++---
 src/render/disk_usage/file_size.rs |  1 +
 src/render/mod.rs                  |  2 +-
 src/render/styles/mod.rs           | 94 ++++++++++++++++++++----------
 src/render/tree/error.rs           |  8 ++-
 src/render/tree/mod.rs             | 67 ++++++++++++++++-----
 src/render/tree/node/mod.rs        | 58 ++++++++++--------
 src/render/tree/node/output.rs     | 92 +++++++++++------------------
 src/render/tree/node/style.rs      | 12 ++--
 9 files changed, 242 insertions(+), 143 deletions(-)

diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index d88cad75..e758dded 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -66,9 +66,15 @@ pub struct Context {
     level: Option<usize>,
 
     /// Show extended metadata and attributes
+    #[cfg(unix)]
     #[arg(short, long)]
     pub long: bool,
 
+    /// Show permissions in numeric octal format instead of symbolic
+    #[cfg(unix)]
+    #[arg(long, requires = "long")]
+    pub octal: bool,
+
     /// Regular expression (or glob if '--glob' or '--iglob' is used) used to match files
     #[arg(short, long)]
     pub pattern: Option<String>,
@@ -137,17 +143,35 @@ pub struct Context {
     #[arg(long)]
     pub suppress_size: bool,
 
+    //////////////////////////
+    /* INTERNAL USAGE BELOW */
+    //////////////////////////
+    /// Is stdin in a tty?
     #[clap(skip = tty::stdin_is_tty())]
     pub stdin_is_tty: bool,
 
+    /// Is stdin in a tty?
     #[clap(skip = tty::stdout_is_tty())]
     pub stdout_is_tty: bool,
 
+    /// Restricts column width of disk usage
     #[clap(skip = usize::default())]
     pub max_du_width: usize,
 
+    /// Restricts column width of nlink for long view.
     #[clap(skip = usize::default())]
+    #[cfg(unix)]
     pub max_nlink_width: usize,
+
+    /// Restricts column width of ino for long view.
+    #[clap(skip = usize::default())]
+    #[cfg(unix)]
+    pub max_ino_width: usize,
+
+    /// Restricts column width of block for long view.
+    #[clap(skip = usize::default())]
+    #[cfg(unix)]
+    pub max_block_width: usize,
 }
 
 impl Context {
@@ -307,17 +331,28 @@ impl Context {
 
     /// Setter for `max_du_width` to inform formatters what the width of the disk usage column
     /// should be.
-    pub fn set_max_du_width(&mut self, size: u64) {
-        if size == 0 {
-            return;
-        }
-        self.max_du_width = crate::utils::num_integral(size);
+    pub fn set_max_du_width(&mut self, width: usize) {
+        self.max_du_width = width;
     }
 
     /// Setter for `max_nlink_width` which is used to inform formatters what the width of the
     /// `nlink` column should be.
-    pub fn set_max_nlink_width(&mut self, nlink: u64) {
-        // `nlink` shouldn't be big so we shouldn't worry about truncation.
-        self.max_nlink_width = crate::utils::num_integral(nlink);
+    #[cfg(unix)]
+    pub fn set_max_nlink_width(&mut self, width: usize) {
+        self.max_nlink_width = width;
+    }
+
+    /// Setter for `max_ino_width` which is used to inform formatters what the width of the
+    /// `ino` column should be.
+    #[cfg(unix)]
+    pub fn set_max_ino_width(&mut self, width: usize) {
+        self.max_ino_width = width;
+    }
+
+    /// Setter for `max_block_width` which is used to inform formatters what the width of the
+    /// `block` column should be.
+    #[cfg(unix)]
+    pub fn set_max_block_width(&mut self, width: usize) {
+        self.max_block_width = width;
     }
 }
diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index e9f65ed1..fdcf3ad3 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -95,6 +95,7 @@ impl FileSize {
             current_padded
         };
 
+        #[allow(clippy::option_if_let_else)]
         match color {
             Some(col) => match self.prefix_kind {
                 PrefixKind::Bin => col
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 1d6e3562..88dbe780 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -10,5 +10,5 @@ pub mod disk_usage;
 /// contents.
 pub mod tree;
 
-/// Controls color output.
+/// Global styles.
 pub mod styles;
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index e265b15e..0d6ff765 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -44,20 +44,29 @@ static LINK_THEME: OnceCell<ThemesMap> = OnceCell::new();
 static DU_THEME: OnceCell<HashMap<&'static str, Style>> = OnceCell::new();
 
 /// Runtime evaluated static that contains styles for permissions.
+#[cfg(unix)]
 static PERMISSIONS_THEME: OnceCell<HashMap<char, Style>> = OnceCell::new();
 
 /// Runtime evaluated static that contains style for octal permissions.
+#[cfg(unix)]
 static OCTAL_PERMISSIONS_STYLE: OnceCell<Style> = OnceCell::new();
 
 /// Runtime evaluated static that contains style for the general use placeholder "-".
 static PLACEHOLDER_STYLE: OnceCell<Style> = OnceCell::new();
 
 /// Runtime evaluated static that contains style for inode number i.e. `ino`.
+#[cfg(unix)]
 static INO_STYLE: OnceCell<Style> = OnceCell::new();
 
 /// Runtime evaluated static that contains style for number of hardlinks i.e. `nlink`.
+#[cfg(unix)]
 static NLINK_STYLE: OnceCell<Style> = OnceCell::new();
 
+/// Runtime evaluated static that contains style for number of blocks of a directory entry i.e.
+/// `blocks`.
+#[cfg(unix)]
+static BLOCK_STYLE: OnceCell<Style> = OnceCell::new();
+
 /// Map of the names box-drawing elements to their styled strings.
 pub type ThemesMap = HashMap<&'static str, String>;
 
@@ -76,26 +85,32 @@ pub fn init(plain: bool) {
 }
 
 /// Getter for [LS_COLORS]. Returns an error if not initialized.
+#[inline]
 pub fn get_ls_colors() -> Result<&'static LsColors, Error<'static>> {
     LS_COLORS.get().ok_or(Error::Uninitialized("LS_COLORS"))
 }
 
 /// Getter for [DU_THEME]. Returns an error if not initialized.
+#[inline]
 pub fn get_du_theme() -> Result<&'static HashMap<&'static str, Style>, Error<'static>> {
     DU_THEME.get().ok_or(Error::Uninitialized("DU_THEME"))
 }
 
 /// Getter for [TREE_THEME]. Returns an error if not initialized.
+#[inline]
 pub fn get_tree_theme() -> Result<&'static ThemesMap, Error<'static>> {
     TREE_THEME.get().ok_or(Error::Uninitialized("TREE_THEME"))
 }
 
 /// Getter for [LINK_THEME]. Returns an error if not initialized.
+#[inline]
 pub fn get_link_theme() -> Result<&'static ThemesMap, Error<'static>> {
     LINK_THEME.get().ok_or(Error::Uninitialized("LINK_THEME"))
 }
 
 /// Getter for [PERMISSIONS_THEME]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
 pub fn get_permissions_theme() -> Result<&'static HashMap<char, Style>, Error<'static>> {
     PERMISSIONS_THEME
         .get()
@@ -103,6 +118,8 @@ pub fn get_permissions_theme() -> Result<&'static HashMap<char, Style>, Error<'s
 }
 
 /// Getter for [OCTAL_PERMISSIONS_STYLE]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
 pub fn get_octal_permissions_style() -> Result<&'static Style, Error<'static>> {
     OCTAL_PERMISSIONS_STYLE
         .get()
@@ -110,6 +127,7 @@ pub fn get_octal_permissions_style() -> Result<&'static Style, Error<'static>> {
 }
 
 /// Getter for [PLACEHOLDER_STYLE]. Returns an error if not initialized.
+#[inline]
 pub fn get_placeholder_style() -> Result<&'static Style, Error<'static>> {
     PLACEHOLDER_STYLE
         .get()
@@ -117,17 +135,24 @@ pub fn get_placeholder_style() -> Result<&'static Style, Error<'static>> {
 }
 
 /// Getter for [INO_STYLE]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
 pub fn get_ino_style() -> Result<&'static Style, Error<'static>> {
-    INO_STYLE
-        .get()
-        .ok_or(Error::Uninitialized("INO_STYLE"))
+    INO_STYLE.get().ok_or(Error::Uninitialized("INO_STYLE"))
 }
 
 /// Getter for [NLINK_STYLE]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
 pub fn get_nlink_style() -> Result<&'static Style, Error<'static>> {
-    NLINK_STYLE
-        .get()
-        .ok_or(Error::Uninitialized("NLINK_STYLE"))
+    NLINK_STYLE.get().ok_or(Error::Uninitialized("NLINK_STYLE"))
+}
+
+/// Getter for [BLOCK_STYLE]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
+pub fn get_block_style() -> Result<&'static Style, Error<'static>> {
+    BLOCK_STYLE.get().ok_or(Error::Uninitialized("BLOCK_STYLE"))
 }
 
 /// Initializes [LS_COLORS] by reading in the `LS_COLORS` environment variable. If it isn't set, a
@@ -145,7 +170,6 @@ fn init_plain() {
         "uprt" => UPRT.to_owned(),
         "vtrt" => VTRT.to_owned()
     };
-
     TREE_THEME.set(theme).unwrap();
 
     let link_theme = hash! {
@@ -153,10 +177,40 @@ fn init_plain() {
         "uprt" => UPRT.to_owned(),
         "vtrt" => VTRT.to_owned()
     };
-
     LINK_THEME.set(link_theme).unwrap();
 }
 
+/// Initialize themes for the `--long` view.
+#[cfg(unix)]
+#[inline]
+fn init_themes_for_long_view() {
+    let permissions_theme = hash! {
+        '-' => Color::Purple.normal(),
+        'd' => Color::Blue.bold(),
+        'l' => Color::Red.bold(),
+        'r' => Color::Green.bold(),
+        'w' => Color::Yellow.bold(),
+        'x' | 's' | 'S' | 't' | 'T' => Color::Red.bold(),
+        '@' => Color::Cyan.bold(),
+        ' ' => Color::White.normal()
+    };
+    PERMISSIONS_THEME.set(permissions_theme).unwrap();
+
+    let octal_permissions_style = Color::Purple.bold();
+    OCTAL_PERMISSIONS_STYLE
+        .set(octal_permissions_style)
+        .unwrap();
+
+    let ino_style = Color::Cyan.bold();
+    INO_STYLE.set(ino_style).unwrap();
+
+    let nlink_style = Color::Red.bold();
+    NLINK_STYLE.set(nlink_style).unwrap();
+
+    let block_style = Color::White.bold();
+    BLOCK_STYLE.set(block_style).unwrap();
+}
+
 /// Initializes all color themes.
 fn init_themes() {
     let theme = hash! {
@@ -182,29 +236,9 @@ fn init_themes() {
     };
     DU_THEME.set(du_theme).unwrap();
 
-    let permissions_theme = hash! {
-        '-' => Color::Purple.normal(),
-        'd' => Color::Blue.bold(),
-        'l' => Color::Red.bold(),
-        'r' => Color::Green.bold(),
-        'w' => Color::Yellow.bold(),
-        'x' | 's' | 'S' | 't' | 'T' => Color::Red.bold(),
-        '@' => Color::Cyan.bold(),
-        ' ' => Color::White.normal()
-    };
-    PERMISSIONS_THEME.set(permissions_theme).unwrap();
-
-    let octal_permissions_style = Color::Purple.bold();
-    OCTAL_PERMISSIONS_STYLE
-        .set(octal_permissions_style)
-        .unwrap();
-
     let placeholder_style = Color::Purple.normal();
     PLACEHOLDER_STYLE.set(placeholder_style).unwrap();
 
-    let ino_style = Color::Cyan.bold();
-    INO_STYLE.set(ino_style).unwrap();
-
-    let nlink_style = Color::Red.bold();
-    NLINK_STYLE.set(nlink_style).unwrap();
+    #[cfg(unix)]
+    init_themes_for_long_view();
 }
diff --git a/src/render/tree/error.rs b/src/render/tree/error.rs
index d00deff2..ba01fdc5 100644
--- a/src/render/tree/error.rs
+++ b/src/render/tree/error.rs
@@ -1,10 +1,11 @@
 use super::styles::error::Error as StyleError;
-use crate::{
-    fs::permissions::error::Error as PermissionsError, render::context::error::Error as CtxError,
-};
+use crate::render::context::error::Error as CtxError;
 use ignore::Error as IgnoreError;
 use std::io::Error as IoError;
 
+#[cfg(unix)]
+use crate::fs::permissions::error::Error as PermissionsError;
+
 /// Errors that may occur while traversing or construction of [`Tree`].
 ///
 /// [`Tree`]: super::Tree
@@ -31,6 +32,7 @@ pub enum Error {
     #[error("{0}")]
     PathCanonicalization(#[from] IoError),
 
+    #[cfg(unix)]
     #[error("{0}")]
     Persmissions(#[from] PermissionsError),
 
diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index 7209e7cf..2c3a7116 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -69,12 +69,17 @@ where
     pub fn try_init(mut ctx: Context) -> Result<Self> {
         let (inner, root) = Self::traverse(&ctx)?;
 
-        let max_du_width = inner[root].get().file_size().map_or(0, |size| size.bytes);
+        let max_du_width = Self::compute_max_du_column_width(root, &inner);
         ctx.set_max_du_width(max_du_width);
 
+        #[cfg(unix)]
         if ctx.long {
-            let max_nlink = Self::compute_max_nlink(root, &inner, &ctx);
-            ctx.set_max_nlink_width(max_nlink);
+            let (max_nlink_width, max_ino_width, max_block_width) =
+                Self::compute_max_column_widths(root, &inner, &ctx);
+
+            ctx.set_max_nlink_width(max_nlink_width);
+            ctx.set_max_ino_width(max_ino_width);
+            ctx.set_max_block_width(max_block_width);
         }
 
         let tree = Self::new(inner, root, ctx);
@@ -291,27 +296,57 @@ where
         count
     }
 
-    /// Among the files to be printed, this will seek out the [Node] whose underling inode contains
-    /// the highest `nlink` which is used for determining the width of the nlink column for the
-    /// `--long` output.
-    fn compute_max_nlink(root: NodeId, tree: &Arena<Node>, ctx: &Context) -> u64 {
+    fn compute_max_du_column_width(root: NodeId, tree: &Arena<Node>) -> usize {
+        tree[root]
+            .get()
+            .file_size()
+            .map(|size| size.bytes)
+            .map_or(0, crate::utils::num_integral)
+    }
+
+    #[cfg(unix)]
+    fn compute_max_column_widths(
+        root: NodeId,
+        tree: &Arena<Node>,
+        ctx: &Context,
+    ) -> (usize, usize, usize) {
+        let mut max_nlink = 0;
+        let mut max_ino = 0;
+        let mut max_blocks = 0;
+
         let max_depth = ctx.level();
 
-        root.descendants(tree).fold(0, |max, i| {
-            let node = tree[i].get();
+        for id in root.descendants(tree) {
+            let node = tree[id].get();
 
             if node.depth() > max_depth {
-                return max;
+                continue;
+            }
+
+            if let Some(ino) = node.ino() {
+                if ino > max_ino {
+                    max_ino = ino;
+                }
             }
 
-            let nlink = node.nlink().unwrap_or(0);
+            if let Some(nlink) = node.nlink() {
+                if nlink > max_nlink {
+                    max_nlink = nlink;
+                }
+            }
 
-            if nlink > max {
-                nlink
-            } else {
-                max 
+            if let Some(blocks) = node.blocks() {
+                if blocks > max_blocks {
+                    max_blocks = blocks;
+                }
             }
-        })
+        }
+
+        let max_nlink_width = crate::utils::num_integral(max_nlink);
+        let max_ino_width = crate::utils::num_integral(max_ino);
+        let max_block_width = crate::utils::num_integral(max_blocks);
+
+        (max_nlink_width, max_ino_width, max_block_width)
     }
 }
 
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index 56a83f4a..ca124983 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -1,9 +1,5 @@
 use crate::{
-    fs::{
-        inode::Inode,
-        permissions::{FileMode, SymbolicNotation},
-        xattr::ExtendedAttr,
-    },
+    fs::inode::Inode,
     icons,
     render::{
         context::Context,
@@ -23,6 +19,14 @@ use std::{
     fs::{FileType, Metadata},
     path::{Path, PathBuf},
 };
+
+#[cfg(unix)]
+use crate::fs::{
+    permissions::{FileMode, SymbolicNotation},
+    xattr::ExtendedAttr,
+};
+
+#[cfg(unix)]
 use xattr::XAttrs;
 
 /// Ordering and sorting rules for [Node].
@@ -31,7 +35,7 @@ pub mod cmp;
 /// For building the actual output.
 pub mod output;
 
-/// All methods of [Node] that pertain to styling the output.
+/// Styling utilities for a [Node].
 pub mod style;
 
 /// A node of [`Tree`] that can be created from a [DirEntry]. Any filesystem I/O and
@@ -47,7 +51,7 @@ pub struct Node {
     symlink_target: Option<PathBuf>,
     inode: Option<Inode>,
 
-    /// Will always be `None` on incompatible platforms.
+    #[cfg(unix)]
     xattrs: Option<XAttrs>,
 }
 
@@ -60,7 +64,8 @@ impl Node {
         style: Option<Style>,
         symlink_target: Option<PathBuf>,
         inode: Option<Inode>,
-        xattrs: Option<XAttrs>,
+
+        #[cfg(unix)] xattrs: Option<XAttrs>,
     ) -> Self {
         Self {
             dir_entry,
@@ -69,6 +74,8 @@ impl Node {
             style,
             symlink_target,
             inode,
+
+            #[cfg(unix)]
             xattrs,
         }
     }
@@ -88,6 +95,21 @@ impl Node {
         self.dir_entry.depth()
     }
 
+    /// Gets the number of blocks used by the underlying [DirEntry]. Returns `None` in the case of
+    /// no blocks allocated like in the case of directories.
+    #[cfg(unix)]
+    pub fn blocks(&self) -> Option<u64> {
+        use std::os::unix::fs::MetadataExt;
+
+        let blocks = self.metadata.blocks();
+
+        if blocks == 0 {
+            None
+        } else {
+            Some(blocks)
+        }
+    }
+
     /// Gets the underlying [Inode] of the entry.
     pub const fn inode(&self) -> Option<Inode> {
         self.inode
@@ -103,14 +125,6 @@ impl Node {
         self.inode.map(|inode| inode.nlink)
     }
 
-    /// Converts `OsStr` to `String`; if fails does a lossy conversion replacing non-Unicode
-    /// sequences with Unicode replacement scalar values.
-    pub fn file_name_lossy(&self) -> Cow<'_, str> {
-        self.file_name()
-            .to_str()
-            .map_or_else(|| self.file_name().to_string_lossy(), Cow::from)
-    }
-
     /// Returns `true` if node is a directory.
     pub fn is_dir(&self) -> bool {
         self.file_type().map_or(false, |ft| ft.is_dir())
@@ -157,6 +171,7 @@ impl Node {
     }
 
     /// Attempts to return an instance of [FileMode] for the display of symbolic permissions.
+    #[cfg(unix)]
     pub fn mode(&self) -> Result<FileMode, Error> {
         let permissions = self.metadata.permissions();
         let file_mode = permissions.try_mode_symbolic_notation()?;
@@ -168,6 +183,7 @@ impl Node {
     /// TODO: Cloning can potentially be expensive here, but practically speaking we won't run into
     /// this scenario a lot, but we will want to optimize this bad boy by removing the `xattr`
     /// crate and just query for the existence of xattrs ourselves.
+    #[cfg(unix)]
     fn has_xattrs(&self) -> bool {
         let count = self
             .xattrs
@@ -194,13 +210,7 @@ impl Node {
     /// Note the two spaces to the left of the first character of the number -- even if never used,
     /// numbers are padded to 3 digits to the left of the decimal (and ctx.scale digits after)
     pub fn display(&self, f: &mut Formatter, prefix: &str, ctx: &Context) -> fmt::Result {
-        let out = if ctx.no_color() {
-            output::compute(self, prefix, ctx)
-        } else {
-            output::compute_with_color(self, prefix, ctx)
-        };
-
-        write!(f, "{out}")
+        write!(f, "{}", output::compute(self, prefix, ctx))
     }
 
     /// Unix file identifiers that you'd find in the `ls -l` command.
@@ -290,6 +300,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
 
         let inode = Inode::try_from(&metadata).ok();
 
+        #[cfg(unix)]
         let xattrs = if ctx.long {
             dir_entry.get_xattrs()
         } else {
@@ -303,6 +314,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             style,
             link_target,
             inode,
+            #[cfg(unix)]
             xattrs,
         ))
     }
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index 64297db0..44907c3e 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -1,6 +1,10 @@
 use crate::render::{context::Context, tree::node::Node};
 
-pub fn compute_with_color(node: &Node, prefix: &str, ctx: &Context) -> String {
+#[cfg(unix)]
+use crate::render::styles;
+
+#[cfg(unix)]
+pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
     let size = presenters::size(node, ctx);
     let padded_icon = presenters::padded_icon(node, ctx);
 
@@ -15,71 +19,56 @@ pub fn compute_with_color(node: &Node, prefix: &str, ctx: &Context) -> String {
     if ctx.long {
         let mode = node.mode().unwrap();
 
-        let sym = if node.has_xattrs() {
+        let perms = if ctx.octal {
+            Node::style_octal_permissions(&mode)
+        } else if node.has_xattrs() {
             Node::style_sym_permissions(&format!("{}@", &mode))
         } else {
             Node::style_sym_permissions(&format!("{} ", &mode))
         };
 
-        let oct = Node::style_octal_permissions(&mode);
-        let ino = presenters::ino(node.ino());
-        let nlink = presenters::nlink(node.nlink(), ctx);
+        let ino = presenters::num(node.ino(), ctx.max_ino_width, styles::get_ino_style);
+        let nlink = presenters::num(node.nlink(), ctx.max_nlink_width, styles::get_nlink_style);
+        let blocks = presenters::num(node.blocks(), ctx.max_block_width, styles::get_block_style);
 
         format!(
-            "{ino:<ino_padding$}{oct:<oct_padding$}{sym:<mode_padding$}{nlink} {size} {prefix}{padded_icon}{file_name}",
+            "{ino:<ino_padding$}{perms:<perms_padding$}{nlink} {blocks} {size} {prefix}{padded_icon}{file_name}",
             ino_padding = ino.len() + 1,
-            oct_padding = oct.len() + 1,
-            mode_padding = sym.len() + 1,
+            perms_padding = perms.len() + 1,
         )
     } else {
         format!("{size} {prefix}{padded_icon}{file_name}")
     }
 }
 
+#[cfg(not(unix))]
 pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
     let size = presenters::size(node, ctx);
     let padded_icon = presenters::padded_icon(node, ctx);
 
     let file_name = node.symlink_target_file_name().map_or_else(
-        || node.file_name_lossy(),
+        || Node::stylize(node.file_name(), node.style),
         |target_name| {
             let link_name = node.file_name();
-            Node::stylize_link_name(link_name, target_name, None)
+            Node::stylize_link_name(link_name, target_name, node.style)
         },
     );
 
-    if ctx.long {
-        let mode = node.mode().unwrap();
-
-        let sym = if node.has_xattrs() {
-            format!("{mode}@")
-        } else {
-            format!("{mode} ")
-        };
-
-        let oct = format!("{mode:04o}");
-
-        format!(
-            "{oct} {sym:mode_len$}{size} {prefix}{padded_icon}{file_name}",
-            mode_len = sym.len() + 1,
-        )
-    } else {
-        format!("{size} {prefix}{padded_icon}{file_name}")
-    }
+    format!("{size} {prefix}{padded_icon}{file_name}")
 }
 
 /// Helper functions to build each component of the output.
 mod presenters {
-    use crate::render::{
-        context::Context,
-        disk_usage::file_size::FileSize,
-        styles,
-        tree::Node
-    };
-    use std::borrow::Cow;
+    use crate::render::{context::Context, disk_usage::file_size::FileSize, tree::Node};
+
+    #[cfg(unix)]
+    use crate::render::styles::{error::Error, PLACEHOLDER};
+
+    #[cfg(unix)]
+    type StyleGetter = fn() -> Result<&'static ansi_term::Style, Error<'static>>;
 
-    #[inline]
     /// Builds the disk usage portion of the output.
+    #[inline]
     pub(super) fn size(node: &Node, ctx: &Context) -> String {
         node.file_size().map_or_else(
             || FileSize::empty_string(ctx),
@@ -87,8 +76,8 @@ mod presenters {
         )
     }
 
-    #[inline]
     /// Builds the icon portion of the output.
+    #[inline]
     pub(super) fn padded_icon(node: &Node, ctx: &Context) -> String {
         if ctx.icons {
             let icon = node.compute_icon(ctx.no_color());
@@ -99,29 +88,16 @@ mod presenters {
         }
     }
 
+    /// Builds a numeric portion of the output.
+    #[cfg(unix)]
     #[inline]
-    /// Builds the `ino` portion of the output
-    pub(super) fn ino(ino: Option<u64>) -> Cow<'static, str> {
-        let out = ino
-            .map(|num| Cow::from(format!("{num}")))
-            .unwrap_or(Cow::from(styles::PLACEHOLDER));
-
-        if let Some(style) = styles::get_ino_style().ok() {
-            Cow::from(style.paint(out).to_string())
-        } else {
-            out
-        }
-    }
+    pub(super) fn num(num: Option<u64>, max_width: usize, style_getter: StyleGetter) -> String {
+        let out = num
+            .map(|num| format!("{num:>max_width$}"))
+            .unwrap_or(format!("{PLACEHOLDER:>max_width$}"));
 
-    #[inline]
-    /// Builds the `nlink` portion of the output
-    pub(super) fn nlink(nlink: Option<u64>, ctx: &Context) -> Cow<'static, str> {
-        let out = nlink
-            .map(|num| Cow::from(format!("{num:>width$}", width = ctx.max_nlink_width)))
-            .unwrap_or(Cow::from(format!("{:>width$}", styles::PLACEHOLDER, width = ctx.max_nlink_width)));
-
-        if let Some(style) = styles::get_nlink_style().ok() {
-            Cow::from(style.paint(out).to_string())
+        if let Ok(style) = style_getter() {
+            style.paint(out).to_string()
         } else {
             out
         }
diff --git a/src/render/tree/node/style.rs b/src/render/tree/node/style.rs
index c5aff129..1c21abff 100644
--- a/src/render/tree/node/style.rs
+++ b/src/render/tree/node/style.rs
@@ -1,11 +1,13 @@
 use super::Node;
-use crate::{
-    fs::permissions::FileMode,
-    render::styles::{get_octal_permissions_style, get_permissions_theme},
-};
 use ansi_term::{Color, Style};
 use std::{borrow::Cow, ffi::OsStr};
 
+#[cfg(unix)]
+use crate::fs::permissions::FileMode;
+
+#[cfg(unix)]
+use crate::render::styles::{get_octal_permissions_style, get_permissions_theme};
+
 impl Node {
     /// Stylizes input, `entity` based on `LS_COLORS`. If `style` is `None` then the entity is
     /// returned unmodified.
@@ -43,6 +45,7 @@ impl Node {
     }
 
     /// Styles the symbolic notation file permissions.
+    #[cfg(unix)]
     pub(super) fn style_sym_permissions(perm_str: &str) -> String {
         let theme = get_permissions_theme().unwrap();
 
@@ -57,6 +60,7 @@ impl Node {
             .collect::<String>()
     }
 
+    #[cfg(unix)]
     pub(super) fn style_octal_permissions(mode: &FileMode) -> String {
         get_octal_permissions_style()
             .unwrap()

From 3daece636f7c9e7c8107aaece2653fd2f98a5e57 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 17 Apr 2023 23:16:38 -0700
Subject: [PATCH 18/33] fix nocolor

---
 src/render/tree/node/output.rs |  4 +--
 src/render/tree/node/style.rs  | 46 +++++++++++++++++++++-------------
 2 files changed, 30 insertions(+), 20 deletions(-)

diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index 44907c3e..298c714e 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -22,9 +22,9 @@ pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
         let perms = if ctx.octal {
             Node::style_octal_permissions(&mode)
         } else if node.has_xattrs() {
-            Node::style_sym_permissions(&format!("{}@", &mode))
+            Node::style_sym_permissions(&mode, true)
         } else {
-            Node::style_sym_permissions(&format!("{} ", &mode))
+            Node::style_sym_permissions(&mode, false)
         };
 
         let ino = presenters::num(node.ino(), ctx.max_ino_width, styles::get_ino_style);
diff --git a/src/render/tree/node/style.rs b/src/render/tree/node/style.rs
index 1c21abff..9bfeb693 100644
--- a/src/render/tree/node/style.rs
+++ b/src/render/tree/node/style.rs
@@ -3,10 +3,10 @@ use ansi_term::{Color, Style};
 use std::{borrow::Cow, ffi::OsStr};
 
 #[cfg(unix)]
-use crate::fs::permissions::FileMode;
-
-#[cfg(unix)]
-use crate::render::styles::{get_octal_permissions_style, get_permissions_theme};
+use crate::{
+    fs::permissions::FileMode,
+    render::styles::{get_octal_permissions_style, get_permissions_theme},
+};
 
 impl Node {
     /// Stylizes input, `entity` based on `LS_COLORS`. If `style` is `None` then the entity is
@@ -46,25 +46,35 @@ impl Node {
 
     /// Styles the symbolic notation file permissions.
     #[cfg(unix)]
-    pub(super) fn style_sym_permissions(perm_str: &str) -> String {
-        let theme = get_permissions_theme().unwrap();
+    pub(super) fn style_sym_permissions(mode: &FileMode, has_xattrs: bool) -> String {
+        let sym = if has_xattrs {
+            format!("{mode}@")
+        } else {
+            format!("{mode} ")
+        };
 
-        perm_str
-            .chars()
-            .filter_map(|ch| {
-                theme.get(&ch).map(|color| {
-                    let chstr = ch.to_string();
-                    color.paint(chstr).to_string()
+        if let Ok(theme) = get_permissions_theme() {
+            sym.chars()
+                .filter_map(|ch| {
+                    theme.get(&ch).map(|color| {
+                        let chstr = ch.to_string();
+                        color.paint(chstr).to_string()
+                    })
                 })
-            })
-            .collect::<String>()
+                .collect::<String>()
+        } else {
+            sym
+        }
     }
 
+    /// Styles the numeric octal format of permissions.
     #[cfg(unix)]
     pub(super) fn style_octal_permissions(mode: &FileMode) -> String {
-        get_octal_permissions_style()
-            .unwrap()
-            .paint(format!("{mode:04o}"))
-            .to_string()
+        let oct = format!("{mode:04o}");
+        if let Ok(style) = get_octal_permissions_style() {
+            style.paint(oct).to_string()
+        } else {
+            oct
+        }
     }
 }

From 445726bf0b45c425d42141691c17fdcca90440f9 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 17 Apr 2023 23:17:20 -0700
Subject: [PATCH 19/33] move import

---
 foo                            | 1 +
 src/render/tree/node/output.rs | 5 ++---
 2 files changed, 3 insertions(+), 3 deletions(-)
 create mode 120000 foo

diff --git a/foo b/foo
new file mode 120000
index 00000000..3598c300
--- /dev/null
+++ b/foo
@@ -0,0 +1 @@
+tests
\ No newline at end of file
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index 298c714e..cb22ffb8 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -1,10 +1,9 @@
 use crate::render::{context::Context, tree::node::Node};
 
-#[cfg(unix)]
-use crate::render::styles;
-
 #[cfg(unix)]
 pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
+    use crate::render::styles;
+
     let size = presenters::size(node, ctx);
     let padded_icon = presenters::padded_icon(node, ctx);
 

From c3d253ece0a81d678e724308bb6a7a9afcd0e854 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Mon, 17 Apr 2023 23:17:33 -0700
Subject: [PATCH 20/33] old file

---
 foo | 1 -
 1 file changed, 1 deletion(-)
 delete mode 120000 foo

diff --git a/foo b/foo
deleted file mode 120000
index 3598c300..00000000
--- a/foo
+++ /dev/null
@@ -1 +0,0 @@
-tests
\ No newline at end of file

From 7c1c8ea5b53e138cafcd79596b16c581059389d0 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 18 Apr 2023 01:48:13 -0700
Subject: [PATCH 21/33] support timestamps

---
 Cargo.lock                     | 337 +++++++++++++++++++++++++++++++--
 Cargo.toml                     |   1 +
 src/render/context/mod.rs      |   9 +
 src/render/context/time.rs     |  15 ++
 src/render/styles/mod.rs       |  16 ++
 src/render/tree/node/mod.rs    |  16 ++
 src/render/tree/node/output.rs |  33 +++-
 7 files changed, 409 insertions(+), 18 deletions(-)
 create mode 100644 src/render/context/time.rs

diff --git a/Cargo.lock b/Cargo.lock
index b7989400..f39c9547 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,6 +11,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -26,6 +35,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -42,6 +57,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bumpalo"
+version = "3.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+
 [[package]]
 name = "cc"
 version = "1.0.79"
@@ -54,6 +75,21 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chrono"
+version = "0.4.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e3c5919066adf22df73762e50cffcde3a758f2a848b113b586d1f86728b673b"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-integer",
+ "num-traits",
+ "time",
+ "wasm-bindgen",
+ "winapi",
+]
+
 [[package]]
 name = "clap"
 version = "4.1.9"
@@ -100,11 +136,72 @@ dependencies = [
  "os_str_bytes",
 ]
 
+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
+
+[[package]]
+name = "cxx"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f61f1b6389c3fe1c316bf8a4dccc90a38208354b330925bce1f74a6c4756eb93"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12cee708e8962df2aeb38f594aae5d827c022b6460ac71a7a3e2c3c2aae5a07b"
+dependencies = [
+ "cc",
+ "codespan-reporting",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn 2.0.10",
+]
+
+[[package]]
+name = "cxxbridge-flags"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7944172ae7e4068c533afbb984114a56c46e9ccddda550499caa222902c7f7bb"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2345488264226bf682893e25de0769f3360aac9957980ec49361b083ddaa5bc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.10",
+]
+
 [[package]]
 name = "erdtree"
 version = "1.8.1"
 dependencies = [
  "ansi_term",
+ "chrono",
  "clap",
  "clap_complete",
  "filesize",
@@ -203,6 +300,30 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0722cd7114b7de04316e7ea5456a0bbb20e4adb46fd27a3697adb812cff0f37c"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+dependencies = [
+ "cxx",
+ "cxx-build",
+]
+
 [[package]]
 name = "ignore"
 version = "0.4.20"
@@ -264,6 +385,15 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "js-sys"
+version = "0.3.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
+dependencies = [
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -276,6 +406,15 @@ version = "0.2.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5"
 
+[[package]]
+name = "link-cplusplus"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.1.4"
@@ -323,6 +462,25 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.17.1"
@@ -446,6 +604,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "scratch"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
+
 [[package]]
 name = "serde"
 version = "1.0.156"
@@ -541,12 +705,29 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi",
+ "winapi",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
 
+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.1"
@@ -590,6 +771,66 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.84"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -621,19 +862,28 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
+dependencies = [
+ "windows-targets 0.48.0",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
 ]
 
 [[package]]
@@ -642,7 +892,7 @@ version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.42.2",
 ]
 
 [[package]]
@@ -651,13 +901,28 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.0",
+ "windows_aarch64_msvc 0.48.0",
+ "windows_i686_gnu 0.48.0",
+ "windows_i686_msvc 0.48.0",
+ "windows_x86_64_gnu 0.48.0",
+ "windows_x86_64_gnullvm 0.48.0",
+ "windows_x86_64_msvc 0.48.0",
 ]
 
 [[package]]
@@ -666,42 +931,84 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
 [[package]]
 name = "xattr"
 version = "1.0.0"
diff --git a/Cargo.toml b/Cargo.toml
index dafb0b3b..df3874d1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ path = "src/main.rs"
 
 [dependencies]
 ansi_term = "0.12.1"
+chrono = "0.4.24"
 clap = { version = "4.1.1", features = ["derive"] }
 clap_complete = "4.1.1"
 filesize = "0.2.0"
diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index e758dded..394f93f6 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -23,6 +23,10 @@ pub mod error;
 /// Printing order kinds.
 pub mod sort;
 
+/// Different types of timestamps available in long view.
+#[cfg(unix)]
+pub mod time;
+
 /// Unit tests for [Context]
 #[cfg(test)]
 mod test;
@@ -75,6 +79,11 @@ pub struct Context {
     #[arg(long, requires = "long")]
     pub octal: bool,
 
+    /// Which kind of timestamp to use
+    #[cfg(unix)]
+    #[arg(long, requires = "long", value_enum, default_value_t = time::Stamp::default())]
+    pub time: time::Stamp,
+
     /// Regular expression (or glob if '--glob' or '--iglob' is used) used to match files
     #[arg(short, long)]
     pub pattern: Option<String>,
diff --git a/src/render/context/time.rs b/src/render/context/time.rs
new file mode 100644
index 00000000..fdf2b754
--- /dev/null
+++ b/src/render/context/time.rs
@@ -0,0 +1,15 @@
+use clap::ValueEnum;
+
+/// Different types of timestamps available in long-view.
+#[derive(Copy, Clone, Debug, ValueEnum, PartialEq, Eq, PartialOrd, Ord, Default)]
+pub enum Stamp {
+    /// Timestamp showing when the file was created.
+    Created,
+
+    /// Timestamp showing when the file was last accessed.
+    Accessed,
+
+    /// Timestamp showing when the file was last modified.
+    #[default]
+    Modified,
+}
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index 0d6ff765..18ae96d9 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -62,6 +62,10 @@ static INO_STYLE: OnceCell<Style> = OnceCell::new();
 #[cfg(unix)]
 static NLINK_STYLE: OnceCell<Style> = OnceCell::new();
 
+/// Runtime evaluated static that contains style for datetime column.
+#[cfg(unix)]
+static DATETIME_STYLE: OnceCell<Style> = OnceCell::new();
+
 /// Runtime evaluated static that contains style for number of blocks of a directory entry i.e.
 /// `blocks`.
 #[cfg(unix)]
@@ -155,6 +159,15 @@ pub fn get_block_style() -> Result<&'static Style, Error<'static>> {
     BLOCK_STYLE.get().ok_or(Error::Uninitialized("BLOCK_STYLE"))
 }
 
+/// Getter for [DATETIME_STYLE]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
+pub fn get_datetime_style() -> Result<&'static Style, Error<'static>> {
+    DATETIME_STYLE
+        .get()
+        .ok_or(Error::Uninitialized("DATETIME_STYLE"))
+}
+
 /// Initializes [LS_COLORS] by reading in the `LS_COLORS` environment variable. If it isn't set, a
 /// default determined by `lscolors` crate will be used.
 fn init_ls_colors() {
@@ -209,6 +222,9 @@ fn init_themes_for_long_view() {
 
     let block_style = Color::White.bold();
     BLOCK_STYLE.set(block_style).unwrap();
+
+    let datetime_style = Color::Purple.bold();
+    DATETIME_STYLE.set(datetime_style).unwrap();
 }
 
 /// Initializes all color themes.
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index ca124983..a3037717 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -18,6 +18,7 @@ use std::{
     fmt::{self, Formatter},
     fs::{FileType, Metadata},
     path::{Path, PathBuf},
+    time::SystemTime,
 };
 
 #[cfg(unix)]
@@ -110,6 +111,21 @@ impl Node {
         }
     }
 
+    /// Timestamp of when file was last modified.
+    pub fn modified(&self) -> Option<SystemTime> {
+        self.metadata.modified().ok()
+    }
+
+    /// Timestamp of when file was created.
+    pub fn created(&self) -> Option<SystemTime> {
+        self.metadata.created().ok()
+    }
+
+    /// Timestamp of when file was last accessed.
+    pub fn accessed(&self) -> Option<SystemTime> {
+        self.metadata.accessed().ok()
+    }
+
     /// Gets the underlying [Inode] of the entry.
     pub const fn inode(&self) -> Option<Inode> {
         self.inode
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index cb22ffb8..7d6f5e5c 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -2,7 +2,7 @@ use crate::render::{context::Context, tree::node::Node};
 
 #[cfg(unix)]
 pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
-    use crate::render::styles;
+    use crate::render::{context::time::Stamp, styles};
 
     let size = presenters::size(node, ctx);
     let padded_icon = presenters::padded_icon(node, ctx);
@@ -26,12 +26,19 @@ pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
             Node::style_sym_permissions(&mode, false)
         };
 
+        let datetime = match ctx.time {
+            Stamp::Created => node.created(),
+            Stamp::Accessed => node.accessed(),
+            Stamp::Modified => node.modified(),
+        };
+
         let ino = presenters::num(node.ino(), ctx.max_ino_width, styles::get_ino_style);
         let nlink = presenters::num(node.nlink(), ctx.max_nlink_width, styles::get_nlink_style);
         let blocks = presenters::num(node.blocks(), ctx.max_block_width, styles::get_block_style);
+        let timestamp = presenters::datetime(datetime);
 
         format!(
-            "{ino:<ino_padding$}{perms:<perms_padding$}{nlink} {blocks} {size} {prefix}{padded_icon}{file_name}",
+            "{ino:<ino_padding$}{perms:<perms_padding$}{nlink} {blocks} {timestamp} {size} {prefix}{padded_icon}{file_name}",
             ino_padding = ino.len() + 1,
             perms_padding = perms.len() + 1,
         )
@@ -61,7 +68,10 @@ mod presenters {
     use crate::render::{context::Context, disk_usage::file_size::FileSize, tree::Node};
 
     #[cfg(unix)]
-    use crate::render::styles::{error::Error, PLACEHOLDER};
+    use crate::render::styles::{self, error::Error, PLACEHOLDER};
+
+    #[cfg(unix)]
+    use std::time::SystemTime;
 
     #[cfg(unix)]
     type StyleGetter = fn() -> Result<&'static ansi_term::Style, Error<'static>>;
@@ -101,4 +111,21 @@ mod presenters {
             out
         }
     }
+
+    #[cfg(unix)]
+    #[inline]
+    pub(super) fn datetime(datetime: Option<SystemTime>) -> String {
+        use chrono::{offset::Local, DateTime};
+
+        let out = datetime.map(DateTime::<Local>::from).map_or_else(
+            || format!("{PLACEHOLDER:>12}"),
+            |dt| format!("{:>12}", dt.format("%d %h %H:%M %g")),
+        );
+
+        if let Ok(style) = styles::get_datetime_style() {
+            style.paint(out).to_string()
+        } else {
+            out
+        }
+    }
 }

From 7ab7d256dc9007c7ac24f7f3b07de38037082a14 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 18 Apr 2023 02:36:46 -0700
Subject: [PATCH 22/33] fix some visual bugs

---
 src/render/context/mod.rs          | 4 +++-
 src/render/disk_usage/file_size.rs | 6 +++---
 src/utils.rs                       | 3 +++
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index 394f93f6..f9f44ebf 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -79,9 +79,11 @@ pub struct Context {
     #[arg(long, requires = "long")]
     pub octal: bool,
 
+    // WARNING: `time` should require `--long` but unfortunately a default value still gets set
+    // which causes `init` to fail so for now it will just do nothing if set by the user.
     /// Which kind of timestamp to use
     #[cfg(unix)]
-    #[arg(long, requires = "long", value_enum, default_value_t = time::Stamp::default())]
+    #[arg(long, value_enum, default_value_t = time::Stamp::default())]
     pub time: time::Stamp,
 
     /// Regular expression (or glob if '--glob' or '--iglob' is used) used to match files
diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index fdcf3ad3..e3a06caa 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -86,8 +86,8 @@ impl FileSize {
         let HumanReadableComponents { size, unit } = Self::human_readable_components(self);
         let color = du_themes.and_then(|th| th.get(unit.as_str()));
 
-        let max_padded = max_size_width + 4;
-        let current_padded = self.scale + 4;
+        let max_padded = max_size_width + 5;
+        let current_padded = self.scale + 5;
 
         let padded_total_width = if current_padded > max_padded {
             max_padded
@@ -123,7 +123,7 @@ impl FileSize {
                 |_| (Cow::from(styles::PLACEHOLDER), 0),
                 |style| {
                     let placeholder = Cow::from(style.paint(styles::PLACEHOLDER).to_string());
-                    let padding = placeholder.len() - 1;
+                    let padding = placeholder.len();
                     (placeholder, padding)
                 },
             );
diff --git a/src/utils.rs b/src/utils.rs
index 7189af33..b7356d5e 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -39,5 +39,8 @@ where
 /// How many integral digits are there?
 #[inline]
 pub const fn num_integral(value: u64) -> usize {
+    if value == 0 {
+        return 0;
+    }
     value.ilog10() as usize + 1
 }

From 0537493b10a11a695c0d788837158f82574adbc1 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 18 Apr 2023 02:40:16 -0700
Subject: [PATCH 23/33] visual bug

---
 src/render/disk_usage/file_size.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index e3a06caa..bb970490 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -120,7 +120,7 @@ impl FileSize {
             String::new()
         } else {
             let (placeholder, extra_padding) = get_placeholder_style().map_or_else(
-                |_| (Cow::from(styles::PLACEHOLDER), 0),
+                |_| (Cow::from(styles::PLACEHOLDER), 1),
                 |style| {
                     let placeholder = Cow::from(style.paint(styles::PLACEHOLDER).to_string());
                     let padding = placeholder.len();

From acab8e04d4e6fd5f6930ea4d6d18491246b15e72 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 18 Apr 2023 02:42:29 -0700
Subject: [PATCH 24/33] another visual bug

---
 src/render/disk_usage/file_size.rs | 5 ++---
 src/render/tree/node/output.rs     | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index bb970490..b40ce088 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -113,9 +113,8 @@ impl FileSize {
         }
     }
 
-    /// Returns spaces times the length of a file size, formatted with the given options
-    /// " " * len(123.45 KiB)
-    pub fn empty_string(ctx: &Context) -> String {
+    /// Returns a placeholder or empty string. 
+    pub fn placeholder(ctx: &Context) -> String {
         if ctx.suppress_size {
             String::new()
         } else {
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
index 7d6f5e5c..770a7371 100644
--- a/src/render/tree/node/output.rs
+++ b/src/render/tree/node/output.rs
@@ -80,7 +80,7 @@ mod presenters {
     #[inline]
     pub(super) fn size(node: &Node, ctx: &Context) -> String {
         node.file_size().map_or_else(
-            || FileSize::empty_string(ctx),
+            || FileSize::placeholder(ctx),
             |size| size.format(ctx.max_du_width),
         )
     }

From 765e49e29771faa38d160e61b14cc46c2d657778 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 18 Apr 2023 11:16:09 -0700
Subject: [PATCH 25/33] fix tests

---
 src/render/disk_usage/file_size.rs |  2 +-
 tests/dirs_only.rs                 |  6 +--
 tests/glob.rs                      | 56 +++++++++++------------
 tests/level.rs                     | 12 ++---
 tests/prune.rs                     | 14 +++---
 tests/regex.rs                     | 20 ++++-----
 tests/sort.rs                      | 72 +++++++++++++++---------------
 tests/symlink.rs                   |  2 +-
 8 files changed, 92 insertions(+), 92 deletions(-)

diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index b40ce088..b9270d79 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -113,7 +113,7 @@ impl FileSize {
         }
     }
 
-    /// Returns a placeholder or empty string. 
+    /// Returns a placeholder or empty string.
     pub fn placeholder(ctx: &Context) -> String {
         if ctx.suppress_size {
             String::new()
diff --git a/tests/dirs_only.rs b/tests/dirs_only.rs
index 9be04e02..66918085 100644
--- a/tests/dirs_only.rs
+++ b/tests/dirs_only.rs
@@ -8,9 +8,9 @@ fn dirs_only() {
         utils::run_cmd(&["--dirs-only", "--sort", "name", "tests/data"]),
         indoc!(
             "1.21 KiB data
-              308   B ├─ dream_cycle
-              446   B ├─ lipsum
-              143   B └─ the_yellow_king
+               308   B ├─ dream_cycle
+               446   B ├─ lipsum
+               143   B └─ the_yellow_king
 
            3 directories"
         )
diff --git a/tests/glob.rs b/tests/glob.rs
index db5071bf..d7da895c 100644
--- a/tests/glob.rs
+++ b/tests/glob.rs
@@ -15,14 +15,14 @@ fn glob() {
         ]),
         indoc!(
             "1.07 KiB data
-              308   B ├─ dream_cycle
-              308   B │  └─ polaris.txt
-              446   B ├─ lipsum
-              446   B │  └─ lipsum.txt
-               83   B ├─ necronomicon.txt
-              161   B ├─ nemesis.txt
-              100   B ├─ nylarlathotep.txt
-                    - └─ the_yellow_king
+               308   B ├─ dream_cycle
+               308   B │  └─ polaris.txt
+               446   B ├─ lipsum
+               446   B │  └─ lipsum.txt
+                83   B ├─ necronomicon.txt
+               161   B ├─ nemesis.txt
+               100   B ├─ nylarlathotep.txt
+                     - └─ the_yellow_king
 
            3 directories, 5 files"
         )
@@ -42,10 +42,10 @@ fn glob_negative() {
         ]),
         indoc!(
             "143   B data
-                 - ├─ dream_cycle
-                 - ├─ lipsum
-           143   B └─ the_yellow_king
-           143   B    └─ cassildas_song.md
+                  - ├─ dream_cycle
+                  - ├─ lipsum
+            143   B └─ the_yellow_king
+            143   B    └─ cassildas_song.md
 
         3 directories, 1 file"
         )
@@ -65,14 +65,14 @@ fn glob_case_insensitive() {
         ]),
         indoc!(
             "1.07 KiB data
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B ├─ nylarlathotep.txt
-                     - └─ the_yellow_king
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B ├─ nylarlathotep.txt
+                      - └─ the_yellow_king
 
             3 directories, 5 files"
         )
@@ -92,14 +92,14 @@ fn iglob() {
         ]),
         indoc!(
             "1.07 KiB data
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B ├─ nylarlathotep.txt
-                     - └─ the_yellow_king
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B ├─ nylarlathotep.txt
+                      - └─ the_yellow_king
 
             3 directories, 5 files"
         )
diff --git a/tests/level.rs b/tests/level.rs
index e06b90ce..d7295183 100644
--- a/tests/level.rs
+++ b/tests/level.rs
@@ -8,12 +8,12 @@ fn level() {
         utils::run_cmd(&["--sort", "name", "--level", "1", "tests/data"]),
         indoc!(
             "1.21 KiB data
-               308   B ├─ dream_cycle
-               446   B ├─ lipsum
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B ├─ nylarlathotep.txt
-               143   B └─ the_yellow_king
+                308   B ├─ dream_cycle
+                446   B ├─ lipsum
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B ├─ nylarlathotep.txt
+                143   B └─ the_yellow_king
 
             3 directories, 6 files"
         ),
diff --git a/tests/prune.rs b/tests/prune.rs
index c3341eea..25a71e86 100644
--- a/tests/prune.rs
+++ b/tests/prune.rs
@@ -16,13 +16,13 @@ fn prune() {
         ]),
         indoc!(
             "1.07 KiB data
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B └─ nylarlathotep.txt
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B └─ nylarlathotep.txt
 
             2 directories, 5 files"
         )
diff --git a/tests/regex.rs b/tests/regex.rs
index 21a709cc..02724c57 100644
--- a/tests/regex.rs
+++ b/tests/regex.rs
@@ -8,14 +8,14 @@ fn regex() {
         utils::run_cmd(&["--sort", "name", "--pattern", r"\.txt$", "tests/data"]),
         indoc!(
             "1.07 KiB data
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B ├─ nylarlathotep.txt
-                     - └─ the_yellow_king
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B ├─ nylarlathotep.txt
+                      - └─ the_yellow_king
 
             3 directories, 5 files"
         )
@@ -32,8 +32,8 @@ fn regex() {
         ]),
         indoc!(
             "143   B data
-               143   B └─ the_yellow_king
-               143   B    └─ cassildas_song.md
+                143   B └─ the_yellow_king
+                143   B    └─ cassildas_song.md
 
             1 directory, 1 file"
         )
diff --git a/tests/sort.rs b/tests/sort.rs
index 0d7f883f..b6bd0fb6 100644
--- a/tests/sort.rs
+++ b/tests/sort.rs
@@ -8,15 +8,15 @@ fn sort_name() {
         utils::run_cmd(&["--sort", "name", "tests/data"]),
         indoc!(
             "1.21 KiB data
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B ├─ nylarlathotep.txt
-               143   B └─ the_yellow_king
-               143   B    └─ cassildas_song.md
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B ├─ nylarlathotep.txt
+                143   B └─ the_yellow_king
+                143   B    └─ cassildas_song.md
 
             3 directories, 6 files"
         ),
@@ -30,15 +30,15 @@ fn sort_name_dir_first() {
         utils::run_cmd(&["--sort", "name", "--dirs-first", "tests/data"]),
         indoc!(
             "1.21 KiB data
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-               143   B ├─ the_yellow_king
-               143   B │  └─ cassildas_song.md
-                83   B ├─ necronomicon.txt
-               161   B ├─ nemesis.txt
-               100   B └─ nylarlathotep.txt
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                143   B ├─ the_yellow_king
+                143   B │  └─ cassildas_song.md
+                 83   B ├─ necronomicon.txt
+                161   B ├─ nemesis.txt
+                100   B └─ nylarlathotep.txt
 
             3 directories, 6 files"
         ),
@@ -52,15 +52,15 @@ fn sort_size() {
         utils::run_cmd(&["--sort", "size", "tests/data"]),
         indoc!(
             "1.21 KiB data
-                83   B ├─ necronomicon.txt
-               100   B ├─ nylarlathotep.txt
-               143   B ├─ the_yellow_king
-               143   B │  └─ cassildas_song.md
-               161   B ├─ nemesis.txt
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B └─ lipsum
-               446   B    └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                100   B ├─ nylarlathotep.txt
+                143   B ├─ the_yellow_king
+                143   B │  └─ cassildas_song.md
+                161   B ├─ nemesis.txt
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B └─ lipsum
+                446   B    └─ lipsum.txt
 
             3 directories, 6 files"
         ),
@@ -74,15 +74,15 @@ fn sort_size_dir_first() {
         utils::run_cmd(&["--sort", "size", "--dirs-first", "tests/data"]),
         indoc!(
             "1.21 KiB data
-               143   B ├─ the_yellow_king
-               143   B │  └─ cassildas_song.md
-               308   B ├─ dream_cycle
-               308   B │  └─ polaris.txt
-               446   B ├─ lipsum
-               446   B │  └─ lipsum.txt
-                83   B ├─ necronomicon.txt
-               100   B ├─ nylarlathotep.txt
-               161   B └─ nemesis.txt
+                143   B ├─ the_yellow_king
+                143   B │  └─ cassildas_song.md
+                308   B ├─ dream_cycle
+                308   B │  └─ polaris.txt
+                446   B ├─ lipsum
+                446   B │  └─ lipsum.txt
+                 83   B ├─ necronomicon.txt
+                100   B ├─ nylarlathotep.txt
+                161   B └─ nemesis.txt
 
             3 directories, 6 files"
         ),
diff --git a/tests/symlink.rs b/tests/symlink.rs
index 127ce2b3..ac7b258f 100644
--- a/tests/symlink.rs
+++ b/tests/symlink.rs
@@ -25,7 +25,7 @@ mod test {
             out,
             indoc!(
                 "143   B the_yellow_king
-                   143   B └─ cassildas_song.md
+                    143   B └─ cassildas_song.md
 
                 1 file"
             ),

From 6d02a550d0d287283a209440454a84f20e7ee61f Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 01:33:34 -0700
Subject: [PATCH 26/33] long view for report

---
 src/main.rs                        |   3 +-
 src/render/context/mod.rs          |  11 +-
 src/render/context/sort.rs         |   5 +-
 src/render/disk_usage/file_size.rs |  20 +--
 src/render/tree/display.rs         |  91 +---------
 src/render/tree/mod.rs             |  13 +-
 src/render/tree/node/cmp.rs        |  19 +--
 src/render/tree/node/display.rs    | 257 +++++++++++++++++++++++++++++
 src/render/tree/node/mod.rs        |  75 ++-------
 src/render/tree/node/output.rs     | 131 ---------------
 tests/report.rs                    |  60 +++----
 11 files changed, 335 insertions(+), 350 deletions(-)
 create mode 100644 src/render/tree/node/display.rs
 delete mode 100644 src/render/tree/node/output.rs

diff --git a/src/main.rs b/src/main.rs
index e7607b16..3ff709dc 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -61,11 +61,12 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
+    render::styles::init(ctx.no_color());
+
     if ctx.report {
         let tree = Tree::<Report>::try_init(ctx)?;
         println!("{tree}");
     } else {
-        render::styles::init(ctx.no_color());
         let tree = Tree::<Regular>::try_init(ctx)?;
         println!("{tree}");
     }
diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index f9f44ebf..e7d88ad5 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -114,10 +114,6 @@ pub struct Context {
     #[arg(long, requires = "report")]
     pub human: bool,
 
-    /// Print file-name in report as opposed to full path
-    #[arg(long, requires = "report")]
-    pub file_name: bool,
-
     /// Sort-order to display directory content
     #[arg(short, long, value_enum, default_value_t = SortType::default())]
     pub sort: SortType,
@@ -258,13 +254,18 @@ impl Context {
         self.no_color || !self.stdout_is_tty
     }
 
-    /// Returns reference to the path of the root directory to be traversed.
+    /// Returns [Path] of the root directory to be traversed.
     pub fn dir(&self) -> &Path {
         self.dir
             .as_ref()
             .map_or_else(|| Path::new("."), |pb| pb.as_path())
     }
 
+    /// Returns canonical [Path] of the root directory to be traversed.
+    pub fn dir_canonical(&self) -> PathBuf {
+        std::fs::canonicalize(self.dir()).unwrap_or_else(|_| self.dir().to_path_buf())
+    }
+
     /// The max depth to print. Note that all directories are fully traversed to compute file
     /// sizes; this just determines how much to print.
     pub fn level(&self) -> usize {
diff --git a/src/render/context/sort.rs b/src/render/context/sort.rs
index 8fab6a73..59a9ec16 100644
--- a/src/render/context/sort.rs
+++ b/src/render/context/sort.rs
@@ -8,12 +8,9 @@ pub enum SortType {
     Name,
 
     /// Sort entries by size smallest to largest, top to bottom
+    #[default]
     Size,
 
     /// Sort entries by size largest to smallest, bottom to top
     SizeRev,
-
-    /// Do not sort entries
-    #[default]
-    None,
 }
diff --git a/src/render/disk_usage/file_size.rs b/src/render/disk_usage/file_size.rs
index b9270d79..233ad6ac 100644
--- a/src/render/disk_usage/file_size.rs
+++ b/src/render/disk_usage/file_size.rs
@@ -68,19 +68,8 @@ impl FileSize {
             .map(|bytes| Self::new(bytes, DiskUsage::Physical, prefix_kind, scale))
     }
 
-    /// Transforms the `FileSize` into a string.
-    /// `Display` / `ToString` traits not used in order to have control over alignment.
-    ///
-    /// `align` false makes strings such as
-    /// `123.45 KiB`
-    /// `1.23 MiB`
-    /// `12 B`
-    ///
-    /// `align` true makes strings such as
-    /// `123.45 KiB`
-    /// `  1.23 MiB`
-    /// `    12   B`
-    pub fn format(&self, max_size_width: usize) -> String {
+    /// Formats the [FileSize] in a human readable format.
+    pub fn format_human_readable(&self, max_size_width: usize) -> String {
         let du_themes = get_du_theme().ok();
 
         let HumanReadableComponents { size, unit } = Self::human_readable_components(self);
@@ -113,6 +102,11 @@ impl FileSize {
         }
     }
 
+    /// Formats [FileSize] for presentation.
+    pub fn format(&self, max_size_width: usize) -> String {
+        format!("{:<width$}B", self.bytes, width = max_size_width + 1)
+    }
+
     /// Returns a placeholder or empty string.
     pub fn placeholder(ctx: &Context) -> String {
         if ctx.suppress_size {
diff --git a/src/render/tree/display.rs b/src/render/tree/display.rs
index ac4cedf2..e43bb7ed 100644
--- a/src/render/tree/display.rs
+++ b/src/render/tree/display.rs
@@ -1,17 +1,9 @@
 use crate::render::{
-    disk_usage::{
-        file_size::{FileSize, HumanReadableComponents},
-        units::PrefixKind,
-    },
     styles,
-    tree::{count::FileCount, node::Node, Tree},
+    tree::{count::FileCount, Tree},
 };
 use indextree::NodeId;
-use std::{
-    ffi::OsStr,
-    fmt::{self, Display, Formatter},
-    path::Path,
-};
+use std::fmt::{self, Display, Formatter};
 
 /// Empty trait used to constrain generic parameter `display_variant` of [Tree].
 pub trait TreeVariant {}
@@ -39,7 +31,7 @@ impl Display for Tree<Regular> {
         let mut display_node = |node_id: NodeId, prefix: &str| -> fmt::Result {
             let node = inner[node_id].get();
 
-            node.display(f, prefix, ctx)?;
+            node.tree_display(f, prefix, ctx)?;
             file_count_data.push(Self::compute_file_count(node_id, inner));
 
             writeln!(f)
@@ -114,86 +106,19 @@ impl Display for Tree<Report> {
         let root = self.root();
         let ctx = self.context();
         let max_depth = ctx.level();
-        let dir = ctx.dir();
-        let prefix_kind = ctx.unit;
         let mut file_count_data = vec![];
 
-        let du_info = |node: &Node| {
-            if ctx.human {
-                let HumanReadableComponents { size, unit } = node.file_size().map_or_else(
-                    HumanReadableComponents::default,
-                    FileSize::human_readable_components,
-                );
-
-                (size, unit)
-            } else {
-                let size = node
-                    .file_size()
-                    .map_or_else(|| String::from("0"), |fs| format!("{}", fs.bytes));
-
-                let unit = String::from("B");
-
-                (size, unit)
-            }
-        };
-
-        let root_node = tree[root].get();
-
-        file_count_data.push(Self::compute_file_count(root, tree));
-
-        let total_du_width = ctx.max_du_width;
-
-        let (total_du, root_unit) = du_info(root_node);
-
-        let width_du_col = if ctx.human {
-            total_du_width
-                + root_unit.len()
-                + if matches!(prefix_kind, PrefixKind::Bin) {
-                    3
-                } else {
-                    1
-                }
-        } else {
-            total_du_width + 2
-        };
-
-        let root_du_info = format!("{total_du} {root_unit}");
-        let root_iden = root_node.file_type_identifier().unwrap_or("-");
-
-        let root_name = <OsStr as AsRef<Path>>::as_ref(root_node.file_name()).display();
-
-        writeln!(
-            f,
-            "{root_iden}   {root_du_info:>width_du_col$}   {root_name}"
-        )?;
+        let descendants = root.descendants(tree);
 
-        let base_path = dir.canonicalize().unwrap_or_else(|_| dir.to_path_buf());
-
-        for node_id in root.descendants(tree).skip(1) {
+        for node_id in descendants {
             let node = tree[node_id].get();
 
-            file_count_data.push(Self::compute_file_count(node_id, tree));
-
             if node.depth() > max_depth {
-                continue;
+                continue
             }
 
-            let (du, unit) = du_info(node);
-            let du_info = format!("{du} {unit}");
-            let ft_iden = node.file_type_identifier().unwrap_or("-");
-
-            let file = if ctx.file_name {
-                <OsStr as AsRef<Path>>::as_ref(node.file_name()).display()
-            } else {
-                let full_path = node.path();
-
-                full_path
-                    .strip_prefix(&base_path)
-                    .unwrap_or(full_path)
-                    .display()
-            };
-
-            writeln!(f, "{ft_iden}   {du_info:>width_du_col$}   {file}")?;
+            node.report_display(f, ctx)?;
+            file_count_data.push(Self::compute_file_count(node_id, tree));
         }
 
         if !file_count_data.is_empty() {
diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index 2c3a7116..0a38e28d 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -226,14 +226,11 @@ where
             tree[current_node_id].get_mut().set_file_size(dir_size);
         }
 
-        // Sort if sorting specified
-        if let Some(func) = node::cmp::comparator(ctx) {
-            children.sort_by(|id_a, id_b| {
-                let node_a = tree[*id_a].get();
-                let node_b = tree[*id_b].get();
-                func(node_a, node_b)
-            });
-        }
+        children.sort_by(|id_a, id_b| {
+            let node_a = tree[*id_a].get();
+            let node_b = tree[*id_b].get();
+            node::cmp::comparator(ctx)(node_a, node_b)
+        });
 
         // Append children to current node.
         for child_id in children {
diff --git a/src/render/tree/node/cmp.rs b/src/render/tree/node/cmp.rs
index d883fe9d..77f8ada6 100644
--- a/src/render/tree/node/cmp.rs
+++ b/src/render/tree/node/cmp.rs
@@ -6,25 +6,24 @@ use std::cmp::Ordering;
 pub type NodeComparator = dyn Fn(&Node, &Node) -> Ordering;
 
 /// Yields function pointer to the appropriate `Node` comparator.
-pub fn comparator(ctx: &Context) -> Option<Box<NodeComparator>> {
+pub fn comparator(ctx: &Context) -> Box<NodeComparator> {
     let sort_type = ctx.sort;
 
     if ctx.dirs_first {
-        return Some(Box::new(move |a, b| {
+        return Box::new(move |a, b| {
             dir_comparator(a, b, base_comparator(sort_type))
-        }));
+        });
     }
 
     base_comparator(sort_type)
 }
 
 /// Grabs the comparator for two non-dir type [Node]s.
-fn base_comparator(sort_type: SortType) -> Option<Box<NodeComparator>> {
+fn base_comparator(sort_type: SortType) -> Box<NodeComparator> {
     match sort_type {
-        SortType::Name => Some(Box::new(name_comparator)),
-        SortType::Size => Some(Box::new(size_comparator)),
-        SortType::SizeRev => Some(Box::new(size_rev_comparator)),
-        SortType::None => None,
+        SortType::Name => Box::new(name_comparator),
+        SortType::Size => Box::new(size_comparator),
+        SortType::SizeRev => Box::new(size_rev_comparator),
     }
 }
 
@@ -32,12 +31,12 @@ fn base_comparator(sort_type: SortType) -> Option<Box<NodeComparator>> {
 fn dir_comparator(
     a: &Node,
     b: &Node,
-    fallback: Option<impl Fn(&Node, &Node) -> Ordering>,
+    fallback: impl Fn(&Node, &Node) -> Ordering,
 ) -> Ordering {
     match (a.is_dir(), b.is_dir()) {
         (true, false) => Ordering::Less,
         (false, true) => Ordering::Greater,
-        _ => fallback.map_or_else(|| Ordering::Equal, |sort| sort(a, b)),
+        _ => fallback(a, b),
     }
 }
 
diff --git a/src/render/tree/node/display.rs b/src/render/tree/node/display.rs
new file mode 100644
index 00000000..69213abd
--- /dev/null
+++ b/src/render/tree/node/display.rs
@@ -0,0 +1,257 @@
+use crate::render::{context::Context, tree::node::Node};
+use std::{
+    borrow::Cow,
+    fmt::{self, Formatter},
+};
+
+impl Node {
+    /// Formats the [Node] for the tree view.
+    #[cfg(unix)]
+    pub(super) fn tree(&self, f: &mut Formatter, prefix: Option<&str>, ctx: &Context) -> fmt::Result {
+        let size = presenters::format_size(self, ctx);
+        let padded_icon = presenters::format_padded_icon(self, ctx);
+
+
+        let file_name = self.symlink_target_file_name().map_or_else(
+            || Self::stylize(self.file_name(), self.style),
+            |target_name| {
+                let link_name = self.file_name();
+                Self::stylize_link_name(link_name, target_name, self.style)
+            },
+        );
+
+        let pre = prefix.unwrap_or("");
+
+        if ctx.long {
+            let presenters::LongAttrs { ino, perms, nlink, blocks, timestamp } = presenters::format_long(self, ctx);
+
+            write!(
+                f,
+                "{ino:<ino_padding$} {perms:<perms_padding$} {nlink} {blocks} {timestamp} {size} {pre}{padded_icon}{file_name}",
+                ino_padding = ino.len(),
+                perms_padding = perms.len(),
+            )
+        } else {
+            write!(f, "{size} {pre}{padded_icon}{file_name}")
+        }
+    }
+
+    /// Formats the [Node] for a plain report view.
+    #[cfg(unix)]
+    pub(super) fn report(&self, f: &mut Formatter, ctx: &Context) -> fmt::Result {
+        use std::{path::Path, ffi::OsStr};
+
+        let size = if ctx.human {
+            presenters::format_size(self, ctx)
+        } else {
+            presenters::format_nonhuman_size(self, ctx)
+        };
+
+        let file = {
+            let node_path = self.path();
+
+            if self.depth() == 0 {
+                node_path.file_name().map_or_else(
+                    || Cow::from(node_path.display().to_string()),
+                    OsStr::to_string_lossy,
+                )
+            } else {
+                node_path
+                    .strip_prefix(ctx.dir_canonical())
+                    .map_or_else(
+                        |_| self.path().to_string_lossy(),
+                        Path::to_string_lossy,
+                    )
+            }
+        };
+
+        if !ctx.long {
+            return writeln!(f, "{size}   {file}");
+        }
+
+        let presenters::LongAttrs {
+            ino,
+            perms,
+            nlink,
+            blocks,
+            timestamp
+        } = presenters::format_long(self, ctx);
+
+        writeln!(
+            f,
+            "{ino:<ino_padding$} {perms:<perms_padding$} {nlink} {blocks} {timestamp} {size}   {file}",
+            ino_padding = ino.len(),
+            perms_padding = perms.len(),
+        )
+    }
+
+    /// Formats the [Node] for a plain report view.
+    #[cfg(not(unix))]
+    pub(super) fn report(&self, f: &mut Formatter, ctx: &Context) -> fmt::Result {
+        let size = if ctx.human {
+            presenters::format_size(self, ctx)
+        } else {
+            presenters::format_nonhuman_size(self, ctx)
+        };
+
+        let file = {
+            let path = self.path()
+                .strip_prefix(ctx.dir_canonical())
+                .unwrap_or_else(|_| self.path());
+
+            Cow::from(path.display().to_string())
+        };
+
+        writeln!(f, "{size}   {file}")
+    }
+
+    /// Formats the [Node] for the tree view.
+    #[cfg(not(unix))]
+    pub(super) fn tree(&self, f: &mut Formatter, prefix: Option<&str>, ctx: &Context) -> fmt::Result {
+        let size = presenters::format_size(self, ctx);
+        let padded_icon = presenters::format_padded_icon(self, ctx);
+        let pre = prefix.unwrap_or("");
+
+        let file_name = self.symlink_target_file_name().map_or_else(
+            || Node::stylize(self.file_name(), self.style),
+            |target_name| {
+                let link_name = self.file_name();
+                Node::stylize_link_name(link_name, target_name, self.style)
+            },
+        );
+
+        write!(f, "{size} {pre}{padded_icon}{file_name}")
+    }
+}
+
+/// Helper functions to build each component of the output.
+mod presenters {
+    use crate::render::{
+        context::Context,
+        disk_usage::file_size::FileSize,
+        styles::get_du_theme,
+        tree::Node
+    };
+
+    #[cfg(unix)]
+    use crate::render::{
+        context::time::Stamp,
+        styles::{self, error::Error, PLACEHOLDER},
+    };
+
+    #[cfg(unix)]
+    use std::time::SystemTime;
+
+    #[cfg(unix)]
+    type StyleGetter = fn() -> Result<&'static ansi_term::Style, Error<'static>>;
+
+    /// Attributes for the long view to be displayed.
+    #[cfg(unix)]
+    pub(super) struct LongAttrs {
+        pub ino: String,
+        pub perms: String,
+        pub nlink: String,
+        pub blocks: String,
+        pub timestamp: String,
+    }
+
+    /// Formats the parameters for the long view.
+    #[cfg(unix)]
+    #[inline]
+    pub(super) fn format_long(node: &Node, ctx: &Context) -> LongAttrs {
+
+        let mode = node.mode().unwrap();
+
+        let perms = if ctx.octal {
+            Node::style_octal_permissions(&mode)
+        } else if node.has_xattrs() {
+            Node::style_sym_permissions(&mode, true)
+        } else {
+            Node::style_sym_permissions(&mode, false)
+        };
+
+        let datetime = match ctx.time {
+            Stamp::Created => node.created(),
+            Stamp::Accessed => node.accessed(),
+            Stamp::Modified => node.modified(),
+        };
+
+        let ino = format_num(node.ino(), ctx.max_ino_width, styles::get_ino_style);
+        let nlink = format_num(node.nlink(), ctx.max_nlink_width, styles::get_nlink_style);
+        let blocks = format_num(node.blocks(), ctx.max_block_width, styles::get_block_style);
+        let timestamp = format_datetime(datetime);
+
+        LongAttrs { ino, perms, nlink, blocks, timestamp }
+    }
+
+    /// Builds the disk usage portion of the output.
+    #[inline]
+    pub(super) fn format_size(node: &Node, ctx: &Context) -> String {
+        node.file_size().map_or_else(
+            || FileSize::placeholder(ctx),
+            |size| size.format_human_readable(ctx.max_du_width),
+        )
+    }
+
+    /// Builds the disk usage portion of the output in unprefixed bytes.
+    #[inline]
+    pub(super) fn format_nonhuman_size(node: &Node, ctx: &Context) -> String {
+        node.file_size().map_or_else(
+            || FileSize::placeholder(ctx),
+            |size| {
+                let Ok(th) = get_du_theme() else {
+                    return size.format(ctx.max_du_width)
+                };
+
+                th.get("B").map_or_else(
+                    || size.format(ctx.max_du_width),
+                    |style| style.paint(size.format(ctx.max_du_width)).to_string(),
+                )
+            }
+        )
+    }
+
+    /// Builds the icon portion of the output.
+    #[inline]
+    pub(super) fn format_padded_icon(node: &Node, ctx: &Context) -> String {
+        if ctx.icons {
+            let icon = node.compute_icon(ctx.no_color());
+            let padding = icon.len() - 1;
+            format!("{icon:<padding$}")
+        } else {
+            String::new()
+        }
+    }
+
+    /// Builds a numeric portion of the output.
+    #[cfg(unix)]
+    #[inline]
+    pub(super) fn format_num(num: Option<u64>, max_width: usize, style_getter: StyleGetter) -> String {
+        let out = num
+            .map(|num| format!("{num:>max_width$}"))
+            .unwrap_or(format!("{PLACEHOLDER:>max_width$}"));
+
+        if let Ok(style) = style_getter() {
+            style.paint(out).to_string()
+        } else {
+            out
+        }
+    }
+
+    #[cfg(unix)]
+    #[inline]
+    pub(super) fn format_datetime(datetime: Option<SystemTime>) -> String {
+        use chrono::{offset::Local, DateTime};
+
+        let out = datetime.map(DateTime::<Local>::from).map_or_else(
+            || format!("{PLACEHOLDER:>12}"),
+            |dt| format!("{:>12}", dt.format("%d %h %H:%M %g")),
+        );
+
+        if let Ok(style) = styles::get_datetime_style() {
+            style.paint(out).to_string()
+        } else {
+            out
+        }
+    }
+}
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index a3037717..cd4a832c 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -33,8 +33,8 @@ use xattr::XAttrs;
 /// Ordering and sorting rules for [Node].
 pub mod cmp;
 
-/// For building the actual output.
-pub mod output;
+/// Methods format the [Node] for display variants.
+pub mod display;
 
 /// Styling utilities for a [Node].
 pub mod style;
@@ -171,7 +171,8 @@ impl Node {
         self.path().parent()
     }
 
-    /// Returns a reference to `path`.
+    /// Returns a reference to `path`. If the underlying [DirEntry] is a symlink then the path of
+    /// the symlink shall be returned.
     pub fn path(&self) -> &Path {
         self.dir_entry.path()
     }
@@ -209,70 +210,14 @@ impl Node {
         count > 0
     }
 
-    /// General method for printing a `Node`. The `Display` (and `ToString`) traits are not used,
-    /// to give more control over the output.
-    ///
-    /// Format a node for display with size on the right.
-    ///
-    /// Example:
-    /// `| Some Directory (12.3 KiB)`
-    ///
-    ///
-    /// Format a node for display with size on the left.
-    ///
-    /// Example:
-    /// `  1.23 MiB | Some File`
-    ///
-    /// Note the two spaces to the left of the first character of the number -- even if never used,
-    /// numbers are padded to 3 digits to the left of the decimal (and ctx.scale digits after)
-    pub fn display(&self, f: &mut Formatter, prefix: &str, ctx: &Context) -> fmt::Result {
-        write!(f, "{}", output::compute(self, prefix, ctx))
+    /// Formats the [Node] for the tree presentation.
+    pub fn tree_display(&self, f: &mut Formatter, prefix: &str, ctx: &Context) -> fmt::Result {
+        self.tree(f, Some(prefix), ctx)
     }
 
-    /// Unix file identifiers that you'd find in the `ls -l` command.
-    #[cfg(unix)]
-    pub fn file_type_identifier(&self) -> Option<&str> {
-        use std::os::unix::fs::FileTypeExt;
-
-        let file_type = self.file_type()?;
-
-        let iden = if file_type.is_dir() {
-            "d"
-        } else if file_type.is_file() {
-            "-"
-        } else if file_type.is_symlink() {
-            "l"
-        } else if file_type.is_fifo() {
-            "p"
-        } else if file_type.is_socket() {
-            "s"
-        } else if file_type.is_char_device() {
-            "c"
-        } else if file_type.is_block_device() {
-            "b"
-        } else {
-            return None;
-        };
-
-        Some(iden)
-    }
-
-    /// File identifiers.
-    #[cfg(not(unix))]
-    pub fn file_type_identifier(&self) -> Option<&str> {
-        let file_type = self.file_type()?;
-
-        let iden = if file_type.is_dir() {
-            "d"
-        } else if file_type.is_file() {
-            "-"
-        } else if file_type.is_symlink() {
-            "l"
-        } else {
-            return None;
-        };
-
-        Some(iden)
+    /// Formats the [Node] for the report presentation.
+    pub fn report_display(&self, f: &mut Formatter, ctx: &Context) -> fmt::Result {
+        self.report(f, ctx)
     }
 
     /// See [icons::compute].
diff --git a/src/render/tree/node/output.rs b/src/render/tree/node/output.rs
deleted file mode 100644
index 770a7371..00000000
--- a/src/render/tree/node/output.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-use crate::render::{context::Context, tree::node::Node};
-
-#[cfg(unix)]
-pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
-    use crate::render::{context::time::Stamp, styles};
-
-    let size = presenters::size(node, ctx);
-    let padded_icon = presenters::padded_icon(node, ctx);
-
-    let file_name = node.symlink_target_file_name().map_or_else(
-        || Node::stylize(node.file_name(), node.style),
-        |target_name| {
-            let link_name = node.file_name();
-            Node::stylize_link_name(link_name, target_name, node.style)
-        },
-    );
-
-    if ctx.long {
-        let mode = node.mode().unwrap();
-
-        let perms = if ctx.octal {
-            Node::style_octal_permissions(&mode)
-        } else if node.has_xattrs() {
-            Node::style_sym_permissions(&mode, true)
-        } else {
-            Node::style_sym_permissions(&mode, false)
-        };
-
-        let datetime = match ctx.time {
-            Stamp::Created => node.created(),
-            Stamp::Accessed => node.accessed(),
-            Stamp::Modified => node.modified(),
-        };
-
-        let ino = presenters::num(node.ino(), ctx.max_ino_width, styles::get_ino_style);
-        let nlink = presenters::num(node.nlink(), ctx.max_nlink_width, styles::get_nlink_style);
-        let blocks = presenters::num(node.blocks(), ctx.max_block_width, styles::get_block_style);
-        let timestamp = presenters::datetime(datetime);
-
-        format!(
-            "{ino:<ino_padding$}{perms:<perms_padding$}{nlink} {blocks} {timestamp} {size} {prefix}{padded_icon}{file_name}",
-            ino_padding = ino.len() + 1,
-            perms_padding = perms.len() + 1,
-        )
-    } else {
-        format!("{size} {prefix}{padded_icon}{file_name}")
-    }
-}
-
-#[cfg(not(unix))]
-pub fn compute(node: &Node, prefix: &str, ctx: &Context) -> String {
-    let size = presenters::size(node, ctx);
-    let padded_icon = presenters::padded_icon(node, ctx);
-
-    let file_name = node.symlink_target_file_name().map_or_else(
-        || Node::stylize(node.file_name(), node.style),
-        |target_name| {
-            let link_name = node.file_name();
-            Node::stylize_link_name(link_name, target_name, node.style)
-        },
-    );
-
-    format!("{size} {prefix}{padded_icon}{file_name}")
-}
-
-/// Helper functions to build each component of the output.
-mod presenters {
-    use crate::render::{context::Context, disk_usage::file_size::FileSize, tree::Node};
-
-    #[cfg(unix)]
-    use crate::render::styles::{self, error::Error, PLACEHOLDER};
-
-    #[cfg(unix)]
-    use std::time::SystemTime;
-
-    #[cfg(unix)]
-    type StyleGetter = fn() -> Result<&'static ansi_term::Style, Error<'static>>;
-
-    /// Builds the disk usage portion of the output.
-    #[inline]
-    pub(super) fn size(node: &Node, ctx: &Context) -> String {
-        node.file_size().map_or_else(
-            || FileSize::placeholder(ctx),
-            |size| size.format(ctx.max_du_width),
-        )
-    }
-
-    /// Builds the icon portion of the output.
-    #[inline]
-    pub(super) fn padded_icon(node: &Node, ctx: &Context) -> String {
-        if ctx.icons {
-            let icon = node.compute_icon(ctx.no_color());
-            let padding = icon.len() - 1;
-            format!("{icon:<padding$}")
-        } else {
-            String::new()
-        }
-    }
-
-    /// Builds a numeric portion of the output.
-    #[cfg(unix)]
-    #[inline]
-    pub(super) fn num(num: Option<u64>, max_width: usize, style_getter: StyleGetter) -> String {
-        let out = num
-            .map(|num| format!("{num:>max_width$}"))
-            .unwrap_or(format!("{PLACEHOLDER:>max_width$}"));
-
-        if let Ok(style) = style_getter() {
-            style.paint(out).to_string()
-        } else {
-            out
-        }
-    }
-
-    #[cfg(unix)]
-    #[inline]
-    pub(super) fn datetime(datetime: Option<SystemTime>) -> String {
-        use chrono::{offset::Local, DateTime};
-
-        let out = datetime.map(DateTime::<Local>::from).map_or_else(
-            || format!("{PLACEHOLDER:>12}"),
-            |dt| format!("{:>12}", dt.format("%d %h %H:%M %g")),
-        );
-
-        if let Ok(style) = styles::get_datetime_style() {
-            style.paint(out).to_string()
-        } else {
-            out
-        }
-    }
-}
diff --git a/tests/report.rs b/tests/report.rs
index 6a8b458e..48180af7 100644
--- a/tests/report.rs
+++ b/tests/report.rs
@@ -7,18 +7,18 @@ fn report() {
     assert_eq!(
         utils::run_cmd(&["--report", "--sort", "name", "tests/data"]),
         indoc!(
-            "d   1241 B   data
-             d    308 B   dream_cycle
-             -    308 B   dream_cycle/polaris.txt
-             d    446 B   lipsum
-             -    446 B   lipsum/lipsum.txt
-             -     83 B   necronomicon.txt
-             -    161 B   nemesis.txt
-             -    100 B   nylarlathotep.txt
-             d    143 B   the_yellow_king
-             -    143 B   the_yellow_king/cassildas_song.md
- 
-             3 directories, 6 files"
+           "1241 B   data
+            308  B   dream_cycle
+            308  B   dream_cycle/polaris.txt
+            446  B   lipsum
+            446  B   lipsum/lipsum.txt
+            83   B   necronomicon.txt
+            161  B   nemesis.txt
+            100  B   nylarlathotep.txt
+            143  B   the_yellow_king
+            143  B   the_yellow_king/cassildas_song.md
+
+            3 directories, 6 files"
         )
     )
 }
@@ -28,18 +28,18 @@ fn report_human() {
     assert_eq!(
         utils::run_cmd(&["--report", "--human", "--sort", "name", "tests/data"]),
         indoc!(
-            "d     1.21 KiB   data
-            d        308 B   dream_cycle
-            -        308 B   dream_cycle/polaris.txt
-            d        446 B   lipsum
-            -        446 B   lipsum/lipsum.txt
-            -         83 B   necronomicon.txt
-            -        161 B   nemesis.txt
-            -        100 B   nylarlathotep.txt
-            d        143 B   the_yellow_king
-            -        143 B   the_yellow_king/cassildas_song.md
+            "1.21 KiB   data
+              308   B   dream_cycle
+              308   B   dream_cycle/polaris.txt
+              446   B   lipsum
+              446   B   lipsum/lipsum.txt
+               83   B   necronomicon.txt
+              161   B   nemesis.txt
+              100   B   nylarlathotep.txt
+              143   B   the_yellow_king
+              143   B   the_yellow_king/cassildas_song.md
 
-            3 directories, 6 files"
+          3 directories, 6 files"
         )
     )
 }
@@ -49,13 +49,13 @@ fn report_with_level() {
     assert_eq!(
         utils::run_cmd(&["--report", "--level", "1", "--sort", "name", "tests/data"]),
         indoc!(
-            "d   1241 B   data
-            d    308 B   dream_cycle
-            d    446 B   lipsum
-            -     83 B   necronomicon.txt
-            -    161 B   nemesis.txt
-            -    100 B   nylarlathotep.txt
-            d    143 B   the_yellow_king
+           "1241 B   data
+            308  B   dream_cycle
+            446  B   lipsum
+            83   B   necronomicon.txt
+            161  B   nemesis.txt
+            100  B   nylarlathotep.txt
+            143  B   the_yellow_king
 
             3 directories, 6 files"
         )

From 8da33880780b57d9b7d144ed4786b9149c4af1ad Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 01:36:04 -0700
Subject: [PATCH 27/33] cargo fmt

---
 src/render/tree/display.rs      |  2 +-
 src/render/tree/node/cmp.rs     | 10 ++----
 src/render/tree/node/display.rs | 57 ++++++++++++++++++++++-----------
 tests/report.rs                 |  4 +--
 4 files changed, 43 insertions(+), 30 deletions(-)

diff --git a/src/render/tree/display.rs b/src/render/tree/display.rs
index e43bb7ed..3c17fc64 100644
--- a/src/render/tree/display.rs
+++ b/src/render/tree/display.rs
@@ -114,7 +114,7 @@ impl Display for Tree<Report> {
             let node = tree[node_id].get();
 
             if node.depth() > max_depth {
-                continue
+                continue;
             }
 
             node.report_display(f, ctx)?;
diff --git a/src/render/tree/node/cmp.rs b/src/render/tree/node/cmp.rs
index 77f8ada6..23bf791a 100644
--- a/src/render/tree/node/cmp.rs
+++ b/src/render/tree/node/cmp.rs
@@ -10,9 +10,7 @@ pub fn comparator(ctx: &Context) -> Box<NodeComparator> {
     let sort_type = ctx.sort;
 
     if ctx.dirs_first {
-        return Box::new(move |a, b| {
-            dir_comparator(a, b, base_comparator(sort_type))
-        });
+        return Box::new(move |a, b| dir_comparator(a, b, base_comparator(sort_type)));
     }
 
     base_comparator(sort_type)
@@ -28,11 +26,7 @@ fn base_comparator(sort_type: SortType) -> Box<NodeComparator> {
 }
 
 /// Orders directories first. Provides a fallback if inputs are not directories.
-fn dir_comparator(
-    a: &Node,
-    b: &Node,
-    fallback: impl Fn(&Node, &Node) -> Ordering,
-) -> Ordering {
+fn dir_comparator(a: &Node, b: &Node, fallback: impl Fn(&Node, &Node) -> Ordering) -> Ordering {
     match (a.is_dir(), b.is_dir()) {
         (true, false) => Ordering::Less,
         (false, true) => Ordering::Greater,
diff --git a/src/render/tree/node/display.rs b/src/render/tree/node/display.rs
index 69213abd..28dbdc0a 100644
--- a/src/render/tree/node/display.rs
+++ b/src/render/tree/node/display.rs
@@ -7,11 +7,15 @@ use std::{
 impl Node {
     /// Formats the [Node] for the tree view.
     #[cfg(unix)]
-    pub(super) fn tree(&self, f: &mut Formatter, prefix: Option<&str>, ctx: &Context) -> fmt::Result {
+    pub(super) fn tree(
+        &self,
+        f: &mut Formatter,
+        prefix: Option<&str>,
+        ctx: &Context,
+    ) -> fmt::Result {
         let size = presenters::format_size(self, ctx);
         let padded_icon = presenters::format_padded_icon(self, ctx);
 
-
         let file_name = self.symlink_target_file_name().map_or_else(
             || Self::stylize(self.file_name(), self.style),
             |target_name| {
@@ -23,7 +27,13 @@ impl Node {
         let pre = prefix.unwrap_or("");
 
         if ctx.long {
-            let presenters::LongAttrs { ino, perms, nlink, blocks, timestamp } = presenters::format_long(self, ctx);
+            let presenters::LongAttrs {
+                ino,
+                perms,
+                nlink,
+                blocks,
+                timestamp,
+            } = presenters::format_long(self, ctx);
 
             write!(
                 f,
@@ -39,7 +49,7 @@ impl Node {
     /// Formats the [Node] for a plain report view.
     #[cfg(unix)]
     pub(super) fn report(&self, f: &mut Formatter, ctx: &Context) -> fmt::Result {
-        use std::{path::Path, ffi::OsStr};
+        use std::{ffi::OsStr, path::Path};
 
         let size = if ctx.human {
             presenters::format_size(self, ctx)
@@ -58,10 +68,7 @@ impl Node {
             } else {
                 node_path
                     .strip_prefix(ctx.dir_canonical())
-                    .map_or_else(
-                        |_| self.path().to_string_lossy(),
-                        Path::to_string_lossy,
-                    )
+                    .map_or_else(|_| self.path().to_string_lossy(), Path::to_string_lossy)
             }
         };
 
@@ -74,7 +81,7 @@ impl Node {
             perms,
             nlink,
             blocks,
-            timestamp
+            timestamp,
         } = presenters::format_long(self, ctx);
 
         writeln!(
@@ -95,7 +102,8 @@ impl Node {
         };
 
         let file = {
-            let path = self.path()
+            let path = self
+                .path()
                 .strip_prefix(ctx.dir_canonical())
                 .unwrap_or_else(|_| self.path());
 
@@ -107,7 +115,12 @@ impl Node {
 
     /// Formats the [Node] for the tree view.
     #[cfg(not(unix))]
-    pub(super) fn tree(&self, f: &mut Formatter, prefix: Option<&str>, ctx: &Context) -> fmt::Result {
+    pub(super) fn tree(
+        &self,
+        f: &mut Formatter,
+        prefix: Option<&str>,
+        ctx: &Context,
+    ) -> fmt::Result {
         let size = presenters::format_size(self, ctx);
         let padded_icon = presenters::format_padded_icon(self, ctx);
         let pre = prefix.unwrap_or("");
@@ -127,10 +140,7 @@ impl Node {
 /// Helper functions to build each component of the output.
 mod presenters {
     use crate::render::{
-        context::Context,
-        disk_usage::file_size::FileSize,
-        styles::get_du_theme,
-        tree::Node
+        context::Context, disk_usage::file_size::FileSize, styles::get_du_theme, tree::Node,
     };
 
     #[cfg(unix)]
@@ -159,7 +169,6 @@ mod presenters {
     #[cfg(unix)]
     #[inline]
     pub(super) fn format_long(node: &Node, ctx: &Context) -> LongAttrs {
-
         let mode = node.mode().unwrap();
 
         let perms = if ctx.octal {
@@ -181,7 +190,13 @@ mod presenters {
         let blocks = format_num(node.blocks(), ctx.max_block_width, styles::get_block_style);
         let timestamp = format_datetime(datetime);
 
-        LongAttrs { ino, perms, nlink, blocks, timestamp }
+        LongAttrs {
+            ino,
+            perms,
+            nlink,
+            blocks,
+            timestamp,
+        }
     }
 
     /// Builds the disk usage portion of the output.
@@ -207,7 +222,7 @@ mod presenters {
                     || size.format(ctx.max_du_width),
                     |style| style.paint(size.format(ctx.max_du_width)).to_string(),
                 )
-            }
+            },
         )
     }
 
@@ -226,7 +241,11 @@ mod presenters {
     /// Builds a numeric portion of the output.
     #[cfg(unix)]
     #[inline]
-    pub(super) fn format_num(num: Option<u64>, max_width: usize, style_getter: StyleGetter) -> String {
+    pub(super) fn format_num(
+        num: Option<u64>,
+        max_width: usize,
+        style_getter: StyleGetter,
+    ) -> String {
         let out = num
             .map(|num| format!("{num:>max_width$}"))
             .unwrap_or(format!("{PLACEHOLDER:>max_width$}"));
diff --git a/tests/report.rs b/tests/report.rs
index 48180af7..efedf657 100644
--- a/tests/report.rs
+++ b/tests/report.rs
@@ -7,7 +7,7 @@ fn report() {
     assert_eq!(
         utils::run_cmd(&["--report", "--sort", "name", "tests/data"]),
         indoc!(
-           "1241 B   data
+            "1241 B   data
             308  B   dream_cycle
             308  B   dream_cycle/polaris.txt
             446  B   lipsum
@@ -49,7 +49,7 @@ fn report_with_level() {
     assert_eq!(
         utils::run_cmd(&["--report", "--level", "1", "--sort", "name", "tests/data"]),
         indoc!(
-           "1241 B   data
+            "1241 B   data
             308  B   dream_cycle
             446  B   lipsum
             83   B   necronomicon.txt

From 9f186e3df4338e8675dc5084e741b0c1fe6b1203 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 14:01:04 -0700
Subject: [PATCH 28/33] reuse the same comparator rather than re-allocating

---
 src/render/tree/mod.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index 0a38e28d..e17cbf95 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -7,7 +7,7 @@ use count::FileCount;
 use error::Error;
 use ignore::{WalkBuilder, WalkParallel};
 use indextree::{Arena, NodeId};
-use node::Node;
+use node::{cmp::NodeComparator, Node};
 use std::{
     collections::{HashMap, HashSet},
     convert::TryFrom,
@@ -167,8 +167,9 @@ where
                 }
 
                 let root = root_id.ok_or(Error::MissingRoot)?;
+                let node_comparator = node::cmp::comparator(ctx);
 
-                Self::assemble_tree(&mut tree, root, &mut branches, ctx);
+                Self::assemble_tree(&mut tree, root, &mut branches, &node_comparator, ctx);
 
                 if ctx.prune {
                     Self::prune_directories(root, &mut tree);
@@ -197,6 +198,7 @@ where
         tree: &mut Arena<Node>,
         current_node_id: NodeId,
         branches: &mut HashMap<PathBuf, Vec<NodeId>>,
+        node_comparator: &Box<NodeComparator>,
         ctx: &Context,
     ) {
         let current_node = tree[current_node_id].get_mut();
@@ -214,7 +216,7 @@ where
             };
 
             if is_dir {
-                Self::assemble_tree(tree, index, branches, ctx);
+                Self::assemble_tree(tree, index, branches, node_comparator, ctx);
             }
 
             if let Some(file_size) = tree[index].get().file_size() {
@@ -229,7 +231,7 @@ where
         children.sort_by(|id_a, id_b| {
             let node_a = tree[*id_a].get();
             let node_b = tree[*id_b].get();
-            node::cmp::comparator(ctx)(node_a, node_b)
+            node_comparator(node_a, node_b)
         });
 
         // Append children to current node.

From 922bdd74a097bc5c6339b67d3ff92cf2275dfeb7 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 15:10:45 -0700
Subject: [PATCH 29/33] ditch xattrs package; talk to c

---
 Cargo.lock                  | 10 ----------
 Cargo.toml                  |  1 -
 src/fs/xattr.rs             | 40 ++++++++++++++++++++++++++++---------
 src/render/tree/mod.rs      |  2 +-
 src/render/tree/node/mod.rs | 31 +++++++++-------------------
 5 files changed, 41 insertions(+), 43 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f39c9547..b22f88e2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -216,7 +216,6 @@ dependencies = [
  "strip-ansi-escapes",
  "tempfile",
  "thiserror",
- "xattr",
 ]
 
 [[package]]
@@ -1008,12 +1007,3 @@ name = "windows_x86_64_msvc"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
-
-[[package]]
-name = "xattr"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea263437ca03c1522846a4ddafbca2542d0ad5ed9b784909d4b27b76f62bc34a"
-dependencies = [
- "libc",
-]
diff --git a/Cargo.toml b/Cargo.toml
index df3874d1..fdab8a06 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,6 @@ thiserror = "1.0.40"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.141"
-xattr = "1.0"
 
 [dev-dependencies]
 indoc = "2.0.0"
diff --git a/src/fs/xattr.rs b/src/fs/xattr.rs
index 16838362..841ec2ac 100644
--- a/src/fs/xattr.rs
+++ b/src/fs/xattr.rs
@@ -1,6 +1,5 @@
 use ignore::DirEntry;
-use std::{io, path::Path};
-use xattr::XAttrs;
+use std::{os::unix::ffi::OsStrExt, path::Path, ptr};
 
 /// Allow extended attributes to be queried directly from the directory entry.
 impl ExtendedAttr for DirEntry {
@@ -13,13 +12,36 @@ impl ExtendedAttr for DirEntry {
 pub trait ExtendedAttr {
     fn path(&self) -> &Path;
 
-    /// Query the extended attribute and return an error if something goes wrong.
-    fn try_get_xattrs(&self) -> io::Result<XAttrs> {
-        xattr::list(self.path())
+    /// Queries the filesystem to check if there exists extended attributes for the implementor's
+    /// path.
+    fn has_xattrs(&self) -> bool {
+        unsafe { has_xattrs(self.path()) }
     }
+}
 
-    /// Query the extended attribute and return `None` if something goes.
-    fn get_xattrs(&self) -> Option<XAttrs> {
-        xattr::list(self.path()).ok()
-    }
+/// Checks to see if a directory entry referred to by `path` has extended attributes.
+#[cfg(target_os = "macos")]
+unsafe fn has_xattrs(path: &Path) -> bool {
+    use libc::{c_char, listxattr};
+
+    let path_ptr = {
+        let slice = path.as_os_str().as_bytes();
+        let slice_ptr = slice.as_ptr();
+        slice_ptr.cast::<c_char>()
+    };
+
+    0 < listxattr(path_ptr, ptr::null_mut::<c_char>(), 0, 0)
+}
+
+#[cfg(target_os = "linux")]
+unsafe fn has_xattrs(path: &Path) -> bool {
+    use libc::{c_char, listxattr};
+
+    let path_ptr = {
+        let slice = path.as_os_str().as_bytes();
+        let slice_ptr = slice.as_ptr();
+        slice_ptr.cast::<*const c_char>()
+    };
+
+    0 < listxattr(path_ptr, ptr::null_mut::<c_char>(), 0)
 }
diff --git a/src/render/tree/mod.rs b/src/render/tree/mod.rs
index e17cbf95..994ce8e1 100644
--- a/src/render/tree/mod.rs
+++ b/src/render/tree/mod.rs
@@ -198,7 +198,7 @@ where
         tree: &mut Arena<Node>,
         current_node_id: NodeId,
         branches: &mut HashMap<PathBuf, Vec<NodeId>>,
-        node_comparator: &Box<NodeComparator>,
+        node_comparator: &NodeComparator,
         ctx: &Context,
     ) {
         let current_node = tree[current_node_id].get_mut();
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index cd4a832c..58ccdb87 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -27,9 +27,6 @@ use crate::fs::{
     xattr::ExtendedAttr,
 };
 
-#[cfg(unix)]
-use xattr::XAttrs;
-
 /// Ordering and sorting rules for [Node].
 pub mod cmp;
 
@@ -53,7 +50,7 @@ pub struct Node {
     inode: Option<Inode>,
 
     #[cfg(unix)]
-    xattrs: Option<XAttrs>,
+    has_xattrs: bool,
 }
 
 impl Node {
@@ -66,7 +63,7 @@ impl Node {
         symlink_target: Option<PathBuf>,
         inode: Option<Inode>,
 
-        #[cfg(unix)] xattrs: Option<XAttrs>,
+        #[cfg(unix)] has_xattrs: bool,
     ) -> Self {
         Self {
             dir_entry,
@@ -75,9 +72,8 @@ impl Node {
             style,
             symlink_target,
             inode,
-
             #[cfg(unix)]
-            xattrs,
+            has_xattrs,
         }
     }
 
@@ -196,18 +192,9 @@ impl Node {
     }
 
     /// Whether or not [Node] has extended attributes.
-    ///
-    /// TODO: Cloning can potentially be expensive here, but practically speaking we won't run into
-    /// this scenario a lot, but we will want to optimize this bad boy by removing the `xattr`
-    /// crate and just query for the existence of xattrs ourselves.
     #[cfg(unix)]
-    fn has_xattrs(&self) -> bool {
-        let count = self
-            .xattrs
-            .as_ref()
-            .map_or(0, |xattrs| xattrs.clone().count());
-
-        count > 0
+    const fn has_xattrs(&self) -> bool {
+        self.has_xattrs
     }
 
     /// Formats the [Node] for the tree presentation.
@@ -262,10 +249,10 @@ impl TryFrom<(DirEntry, &Context)> for Node {
         let inode = Inode::try_from(&metadata).ok();
 
         #[cfg(unix)]
-        let xattrs = if ctx.long {
-            dir_entry.get_xattrs()
+        let has_xattrs = if ctx.long {
+            dir_entry.has_xattrs()
         } else {
-            None
+            false
         };
 
         Ok(Self::new(
@@ -276,7 +263,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             link_target,
             inode,
             #[cfg(unix)]
-            xattrs,
+            has_xattrs,
         ))
     }
 }

From 5315a3eb338ba355cb95a3abe7e0ecf57a40a8a6 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 15:12:59 -0700
Subject: [PATCH 30/33] use '.' for regular file identifier

---
 src/fs/permissions/file_type.rs | 2 +-
 src/render/styles/mod.rs        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/fs/permissions/file_type.rs b/src/fs/permissions/file_type.rs
index 4bed7f22..9c409973 100644
--- a/src/fs/permissions/file_type.rs
+++ b/src/fs/permissions/file_type.rs
@@ -17,7 +17,7 @@ impl FileType {
     pub const fn identifier(&self) -> char {
         match self {
             Self::Directory => 'd',
-            Self::File => '-',
+            Self::File => '.',
             Self::Symlink => 'l',
             Self::Fifo => 'p',
             Self::Socket => 's',
diff --git a/src/render/styles/mod.rs b/src/render/styles/mod.rs
index 18ae96d9..f30781f1 100644
--- a/src/render/styles/mod.rs
+++ b/src/render/styles/mod.rs
@@ -198,7 +198,7 @@ fn init_plain() {
 #[inline]
 fn init_themes_for_long_view() {
     let permissions_theme = hash! {
-        '-' => Color::Purple.normal(),
+        '-' | '.' => Color::Purple.normal(),
         'd' => Color::Blue.bold(),
         'l' => Color::Red.bold(),
         'r' => Color::Green.bold(),

From 422bb8b630883872ef52ec87c520589af7fec408 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 15:15:04 -0700
Subject: [PATCH 31/33] reduce redundant code

---
 src/fs/xattr.rs | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/src/fs/xattr.rs b/src/fs/xattr.rs
index 841ec2ac..43ff2ee7 100644
--- a/src/fs/xattr.rs
+++ b/src/fs/xattr.rs
@@ -20,7 +20,6 @@ pub trait ExtendedAttr {
 }
 
 /// Checks to see if a directory entry referred to by `path` has extended attributes.
-#[cfg(target_os = "macos")]
 unsafe fn has_xattrs(path: &Path) -> bool {
     use libc::{c_char, listxattr};
 
@@ -30,18 +29,9 @@ unsafe fn has_xattrs(path: &Path) -> bool {
         slice_ptr.cast::<c_char>()
     };
 
-    0 < listxattr(path_ptr, ptr::null_mut::<c_char>(), 0, 0)
-}
-
-#[cfg(target_os = "linux")]
-unsafe fn has_xattrs(path: &Path) -> bool {
-    use libc::{c_char, listxattr};
-
-    let path_ptr = {
-        let slice = path.as_os_str().as_bytes();
-        let slice_ptr = slice.as_ptr();
-        slice_ptr.cast::<*const c_char>()
-    };
+    #[cfg(target_os = "linux")]
+    return 0 < listxattr(path_ptr, ptr::null_mut::<c_char>(), 0);
 
-    0 < listxattr(path_ptr, ptr::null_mut::<c_char>(), 0)
+    #[cfg(target_os = "macos")]
+    return 0 < listxattr(path_ptr, ptr::null_mut::<c_char>(), 0, 0);
 }

From c64b22f1bcc2382c8199bb11c4abfce68594c478 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 15:16:04 -0700
Subject: [PATCH 32/33] fix test

---
 src/fs/permissions/test.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/fs/permissions/test.rs b/src/fs/permissions/test.rs
index aa6dba70..5e2b4b9a 100644
--- a/src/fs/permissions/test.rs
+++ b/src/fs/permissions/test.rs
@@ -24,7 +24,7 @@ fn test_symbolic_notation() -> Result<(), Box<dyn Error>> {
     assert_eq!(&other.triad, &PermissionsTriad::Read);
 
     let rwx = format!("{file_mode}");
-    assert_eq!(rwx, "-rw-r--r--");
+    assert_eq!(rwx, ".rw-r--r--");
 
     let octal = format!("{:o}", file_mode);
     assert_eq!(octal, "644");
@@ -47,7 +47,7 @@ fn test_symbolic_notation_special_attr() -> Result<(), Box<dyn Error>> {
 
     let file_mode = permissions.try_mode_symbolic_notation()?;
     let rwx = format!("{file_mode}");
-    assert_eq!(rwx, "-rw-r--r-T");
+    assert_eq!(rwx, ".rw-r--r-T");
 
     let octal = format!("{:o}", file_mode);
     assert_eq!(octal, "1644");
@@ -57,7 +57,7 @@ fn test_symbolic_notation_special_attr() -> Result<(), Box<dyn Error>> {
 
     let file_mode = permissions.try_mode_symbolic_notation()?;
     let rwx = format!("{file_mode}");
-    assert_eq!(rwx, "-rw-r-Sr--");
+    assert_eq!(rwx, ".rw-r-Sr--");
 
     let octal = format!("{:o}", file_mode);
     assert_eq!(octal, "2644");
@@ -67,7 +67,7 @@ fn test_symbolic_notation_special_attr() -> Result<(), Box<dyn Error>> {
 
     let file_mode = permissions.try_mode_symbolic_notation()?;
     let rwx = format!("{file_mode}");
-    assert_eq!(rwx, "-rwSr--r--");
+    assert_eq!(rwx, ".rwSr--r--");
 
     let octal = format!("{:o}", file_mode);
     assert_eq!(octal, "4644");
@@ -77,7 +77,7 @@ fn test_symbolic_notation_special_attr() -> Result<(), Box<dyn Error>> {
 
     let file_mode = permissions.try_mode_symbolic_notation()?;
     let rwx = format!("{file_mode}");
-    assert_eq!(rwx, "-rwSr-Sr-T");
+    assert_eq!(rwx, ".rwSr-Sr-T");
 
     let octal = format!("{:o}", file_mode);
     assert_eq!(octal, "7644");
@@ -87,7 +87,7 @@ fn test_symbolic_notation_special_attr() -> Result<(), Box<dyn Error>> {
 
     let file_mode = permissions.try_mode_symbolic_notation()?;
     let rwx = format!("{file_mode}");
-    assert_eq!(rwx, "-rwsrwsrwt");
+    assert_eq!(rwx, ".rwsrwsrwt");
 
     let octal = format!("{:o}", file_mode);
     assert_eq!(octal, "7777");

From c6f1b0187a6f25cbdb5b7069f06d6996d31fa4f4 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Wed, 19 Apr 2023 15:31:54 -0700
Subject: [PATCH 33/33] arg renaming

---
 src/main.rs                  |  6 +++---
 src/render/context/mod.rs    | 18 +++++++++---------
 src/render/tree/display.rs   |  8 ++++----
 src/render/tree/node/mod.rs  |  2 +-
 tests/{report.rs => flat.rs} | 16 ++++++++--------
 5 files changed, 25 insertions(+), 25 deletions(-)
 rename tests/{report.rs => flat.rs} (80%)

diff --git a/src/main.rs b/src/main.rs
index 3ff709dc..ba4774d2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -23,7 +23,7 @@ use clap::CommandFactory;
 use render::{
     context::Context,
     tree::{
-        display::{Regular, Report},
+        display::{Flat, Regular},
         Tree,
     },
 };
@@ -63,8 +63,8 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 
     render::styles::init(ctx.no_color());
 
-    if ctx.report {
-        let tree = Tree::<Report>::try_init(ctx)?;
+    if ctx.flat {
+        let tree = Tree::<Flat>::try_init(ctx)?;
         println!("{tree}");
     } else {
         let tree = Tree::<Regular>::try_init(ctx)?;
diff --git a/src/render/context/mod.rs b/src/render/context/mod.rs
index e7d88ad5..15f6ed42 100644
--- a/src/render/context/mod.rs
+++ b/src/render/context/mod.rs
@@ -57,6 +57,14 @@ pub struct Context {
     #[arg(short = 'i', long)]
     pub no_ignore: bool,
 
+    /// Print disk usage information in plain format without the ASCII tree
+    #[arg(short = 'F', long)]
+    pub flat: bool,
+
+    /// Print human-readable disk usage in report
+    #[arg(long, requires = "flat")]
+    pub human: bool,
+
     /// Follow symlinks and consider their disk usage
     #[arg(short = 'f', long)]
     pub follow: bool,
@@ -106,14 +114,6 @@ pub struct Context {
     #[arg(short = 'n', long, default_value_t = 2, value_name = "NUM")]
     pub scale: usize,
 
-    /// Print disk usage information in plain format without ASCII tree
-    #[arg(short, long)]
-    pub report: bool,
-
-    /// Print human-readable disk usage in report
-    #[arg(long, requires = "report")]
-    pub human: bool,
-
     /// Sort-order to display directory content
     #[arg(short, long, value_enum, default_value_t = SortType::default())]
     pub sort: SortType,
@@ -123,7 +123,7 @@ pub struct Context {
     pub dirs_first: bool,
 
     /// Number of threads to use
-    #[arg(short, long, default_value_t = 3)]
+    #[arg(short = 'T', long, default_value_t = 3)]
     pub threads: usize,
 
     /// Report disk usage in binary or SI units
diff --git a/src/render/tree/display.rs b/src/render/tree/display.rs
index 3c17fc64..1d9fb3f9 100644
--- a/src/render/tree/display.rs
+++ b/src/render/tree/display.rs
@@ -12,10 +12,10 @@ pub trait TreeVariant {}
 pub struct Regular {}
 
 /// For generating plain-text report of disk usage without ASCII tree.
-pub struct Report {}
+pub struct Flat {}
 
 impl TreeVariant for Regular {}
-impl TreeVariant for Report {}
+impl TreeVariant for Flat {}
 
 impl Display for Tree<Regular> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
@@ -100,7 +100,7 @@ impl Display for Tree<Regular> {
     }
 }
 
-impl Display for Tree<Report> {
+impl Display for Tree<Flat> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let tree = self.inner();
         let root = self.root();
@@ -117,7 +117,7 @@ impl Display for Tree<Report> {
                 continue;
             }
 
-            node.report_display(f, ctx)?;
+            node.flat_display(f, ctx)?;
             file_count_data.push(Self::compute_file_count(node_id, tree));
         }
 
diff --git a/src/render/tree/node/mod.rs b/src/render/tree/node/mod.rs
index 58ccdb87..322fe450 100644
--- a/src/render/tree/node/mod.rs
+++ b/src/render/tree/node/mod.rs
@@ -203,7 +203,7 @@ impl Node {
     }
 
     /// Formats the [Node] for the report presentation.
-    pub fn report_display(&self, f: &mut Formatter, ctx: &Context) -> fmt::Result {
+    pub fn flat_display(&self, f: &mut Formatter, ctx: &Context) -> fmt::Result {
         self.report(f, ctx)
     }
 
diff --git a/tests/report.rs b/tests/flat.rs
similarity index 80%
rename from tests/report.rs
rename to tests/flat.rs
index efedf657..a39995cf 100644
--- a/tests/report.rs
+++ b/tests/flat.rs
@@ -3,9 +3,9 @@ use indoc::indoc;
 mod utils;
 
 #[test]
-fn report() {
+fn flat() {
     assert_eq!(
-        utils::run_cmd(&["--report", "--sort", "name", "tests/data"]),
+        utils::run_cmd(&["--flat", "--sort", "name", "tests/data"]),
         indoc!(
             "1241 B   data
             308  B   dream_cycle
@@ -24,9 +24,9 @@ fn report() {
 }
 
 #[test]
-fn report_human() {
+fn flat_human() {
     assert_eq!(
-        utils::run_cmd(&["--report", "--human", "--sort", "name", "tests/data"]),
+        utils::run_cmd(&["--flat", "--human", "--sort", "name", "tests/data"]),
         indoc!(
             "1.21 KiB   data
               308   B   dream_cycle
@@ -45,9 +45,9 @@ fn report_human() {
 }
 
 #[test]
-fn report_with_level() {
+fn flat_with_level() {
     assert_eq!(
-        utils::run_cmd(&["--report", "--level", "1", "--sort", "name", "tests/data"]),
+        utils::run_cmd(&["--flat", "--level", "1", "--sort", "name", "tests/data"]),
         indoc!(
             "1241 B   data
             308  B   dream_cycle
@@ -64,12 +64,12 @@ fn report_with_level() {
 
 #[test]
 #[should_panic]
-fn report_requires_human() {
+fn flat_requires_human() {
     utils::run_cmd(&["--human"]);
 }
 
 #[test]
 #[should_panic]
-fn report_requires_file_name() {
+fn flat_requires_file_name() {
     utils::run_cmd(&["--file-name"]);
 }