From c80d9330d8085290db1e380be2f4d3c393b728d2 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 11:24:23 -0700
Subject: [PATCH 1/8] support for user and group

---
 Cargo.lock                       | 18 +++++--
 Cargo.toml                       |  1 +
 src/disk_usage/file_size/byte.rs | 10 ++--
 src/fs/mod.rs                    |  5 +-
 src/fs/ug.rs                     | 89 ++++++++++++++++++++++++++++++++
 src/main.rs                      |  1 +
 src/render/grid/cell.rs          |  6 +--
 src/render/grid/mod.rs           | 18 ++++---
 src/tree/node/mod.rs             | 27 ++++++++--
 tests/flat.rs                    |  2 +-
 10 files changed, 152 insertions(+), 25 deletions(-)
 create mode 100644 src/fs/ug.rs

diff --git a/Cargo.lock b/Cargo.lock
index d3009ac5..bc25b3c5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -225,6 +225,7 @@ dependencies = [
  "clap",
  "clap_complete",
  "dirs",
+ "errno 0.3.1",
  "filesize",
  "ignore",
  "indextree",
@@ -253,13 +254,13 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d6a0976c999d473fe89ad888d5a284e55366d9dc9038b1ba2aa15128c4afa0"
+checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
 dependencies = [
  "errno-dragonfly",
  "libc",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -631,7 +632,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2aae838e49b3d63e9274e1c01833cc8139d3fec468c3b84688c628f44b1ae11d"
 dependencies = [
  "bitflags",
- "errno 0.3.0",
+ "errno 0.3.1",
  "io-lifetimes",
  "libc",
  "linux-raw-sys 0.3.1",
@@ -944,6 +945,15 @@ dependencies = [
  "windows-targets 0.42.2",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.0",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.42.2"
diff --git a/Cargo.toml b/Cargo.toml
index 68e4f6a1..e179b3fe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,6 +29,7 @@ chrono = "0.4.24"
 clap = { version = "4.1.1", features = ["derive"] }
 clap_complete = "4.1.1"
 dirs = "5.0"
+errno = "0.3.1"
 filesize = "0.2.0"
 ignore = "0.4.2"
 indextree = "4.6.0"
diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index 4ecfef78..b694cfc4 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -98,7 +98,7 @@ impl Display for Metric {
                 } else {
                     let base_value = unit.base_value();
                     let size = value / (base_value as f64);
-                    write!(f, "{size:.2} {unit}")
+                    write!(f, "{size:.1} {unit}")
                 }
             }
             PrefixKind::Bin => {
@@ -113,7 +113,7 @@ impl Display for Metric {
                 } else {
                     let base_value = unit.base_value();
                     let size = value / (base_value as f64);
-                    write!(f, "{size:.2} {unit}")
+                    write!(f, "{size:.1} {unit}")
                 }
             }
         }
@@ -136,7 +136,7 @@ fn test_metric() {
         human_readable: true,
         prefix_kind: PrefixKind::Si,
     };
-    assert_eq!(format!("{}", metric), "1.00 KB");
+    assert_eq!(format!("{}", metric), "1.0 KB");
 
     let metric = Metric {
         value: 1000,
@@ -152,7 +152,7 @@ fn test_metric() {
         human_readable: true,
         prefix_kind: PrefixKind::Bin,
     };
-    assert_eq!(format!("{}", metric), "1.00 KiB");
+    assert_eq!(format!("{}", metric), "1.0 KiB");
 
     let metric = Metric {
         value: 2_u64.pow(20),
@@ -160,7 +160,7 @@ fn test_metric() {
         human_readable: true,
         prefix_kind: PrefixKind::Bin,
     };
-    assert_eq!(format!("{}", metric), "1.00 MiB");
+    assert_eq!(format!("{}", metric), "1.0 MiB");
 
     let metric = Metric {
         value: 123454,
diff --git a/src/fs/mod.rs b/src/fs/mod.rs
index a266260f..9419eab8 100644
--- a/src/fs/mod.rs
+++ b/src/fs/mod.rs
@@ -8,10 +8,13 @@ pub mod inode;
 #[cfg(unix)]
 pub mod permissions;
 
-#[cfg(unix)]
 /// Determining whether or not a file has extended attributes.
+#[cfg(unix)]
 pub mod xattr;
 
+/// Concerned with determining group and owner of file.
+pub mod ug;
+
 /// 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/ug.rs b/src/fs/ug.rs
new file mode 100644
index 00000000..b067aacc
--- /dev/null
+++ b/src/fs/ug.rs
@@ -0,0 +1,89 @@
+use errno::{errno, set_errno, Errno};
+use ignore::DirEntry;
+use std::{convert::AsRef, ffi::CStr, mem, os::unix::ffi::OsStrExt, path::Path, ptr};
+
+impl UserGroupInfo for DirEntry {
+    fn path(&self) -> &Path {
+        self.path()
+    }
+}
+
+type Owner = String;
+type Group = String;
+
+/// Trait that allows for files to query their owner and group.
+pub trait UserGroupInfo {
+    fn path(&self) -> &Path;
+
+    /// Attemps to query the owner of the implementor.
+    fn try_get_owner(&self) -> Result<String, Errno> {
+        unsafe {
+            let libc::stat { st_uid, .. } = try_init_stat(self.path())?;
+            try_get_user(st_uid)
+        }
+    }
+
+    /// Attempts to query both the owner and group of the implementor.
+    fn try_get_owner_and_group(&self) -> Result<(Owner, Group), Errno> {
+        unsafe {
+            let libc::stat { st_uid, st_gid, .. } = try_init_stat(self.path())?;
+            let user = try_get_user(st_uid)?;
+            let group = try_get_group(st_gid)?;
+
+            Ok((user, group))
+        }
+    }
+}
+
+/// A wrapper around [`libc::stat`].
+unsafe fn try_init_stat<P: AsRef<Path>>(path: P) -> Result<libc::stat, Errno> {
+    let mut stat = mem::zeroed::<libc::stat>();
+
+    let stat_ptr = ptr::addr_of_mut!(stat);
+    let path_ptr = path
+        .as_ref()
+        .as_os_str()
+        .as_bytes()
+        .as_ptr()
+        .cast::<libc::c_char>();
+
+    if libc::stat(path_ptr, stat_ptr) == -1 {
+        return Err(errno());
+    }
+
+    Ok(stat)
+}
+
+/// Attempts to return the name of the group associated with `gid`.
+unsafe fn try_get_group(gid: libc::gid_t) -> Result<String, Errno> {
+    set_errno(Errno(0));
+
+    let group = libc::getgrgid(gid);
+
+    let errno = errno();
+
+    if errno.0 != 0 {
+        return Err(errno);
+    }
+
+    let libc::group { gr_name, .. } = *group;
+
+    Ok(CStr::from_ptr(gr_name).to_string_lossy().to_string())
+}
+
+/// Attempts to return the name of the user associated with `uid`.
+unsafe fn try_get_user(uid: libc::uid_t) -> Result<String, Errno> {
+    set_errno(Errno(0));
+
+    let pwd = libc::getpwuid(uid);
+
+    let errno = errno();
+
+    if errno.0 != 0 {
+        return Err(errno);
+    }
+
+    let libc::passwd { pw_name, .. } = *pwd;
+
+    Ok(CStr::from_ptr(pw_name).to_string_lossy().to_string())
+}
diff --git a/src/main.rs b/src/main.rs
index ea69ca84..e33ae735 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,6 +12,7 @@
 )]
 #![allow(
     clippy::struct_excessive_bools,
+    clippy::too_many_arguments,
     clippy::cast_precision_loss,
     clippy::cast_sign_loss,
     clippy::cast_possible_truncation
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 028479fa..9fd44e97 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,5 +1,5 @@
 use crate::{
-    context::{Context, time},
+    context::{time, Context},
     disk_usage::{
         file_size::{byte, DiskUsage, FileSize},
         units::PrefixKind,
@@ -216,7 +216,7 @@ impl<'a> Cell<'a> {
         write!(f, "{formatted_datetime}")
     }
 
-	/// Rules on how to format timestamp
+    /// Rules on how to format timestamp
     #[cfg(unix)]
     #[inline]
     fn fmt_timestamp(&self, dt: DateTime<Local>) -> String {
@@ -228,7 +228,7 @@ impl<'a> Cell<'a> {
             time::Format::Short => dt.format("%Y-%m-%d"),
         };
 
-        format!("{:>12}", delayed_format)
+        format!("{delayed_format:>12}")
     }
 
     /// Rules on how to format permissions for rendering
diff --git a/src/render/grid/mod.rs b/src/render/grid/mod.rs
index 2f46a883..34b3d738 100644
--- a/src/render/grid/mod.rs
+++ b/src/render/grid/mod.rs
@@ -48,13 +48,14 @@ impl Display for Row<'_, Tree> {
         );
 
         let row = if ctx.long {
-            let ino = Cell::new(node, ctx, cell::Kind::Ino);
+            //let ino = Cell::new(node, ctx, cell::Kind::Ino);
             let perms = Cell::new(node, ctx, cell::Kind::Permissions);
-            let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
-            let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
+            //let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
+            //let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
             let time = Cell::new(node, ctx, cell::Kind::Datetime);
 
-            format!("{ino} {perms} {nlink} {blocks} {time} {size} {name}")
+            //format!("{ino} {perms} {nlink} {blocks} {time} {size} {name}")
+            format!("{perms} {time} {size} {name}")
         } else {
             format!("{size} {name}")
         };
@@ -106,13 +107,14 @@ impl Display for Row<'_, Flat> {
         let path = Cell::new(node, ctx, cell::Kind::FilePath);
 
         let row = if ctx.long {
-            let ino = Cell::new(node, ctx, cell::Kind::Ino);
+            //let ino = Cell::new(node, ctx, cell::Kind::Ino);
             let perms = Cell::new(node, ctx, cell::Kind::Permissions);
-            let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
-            let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
+            //let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
+            //let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
             let time = Cell::new(node, ctx, cell::Kind::Datetime);
 
-            format!("{ino} {perms} {nlink} {blocks} {time} {size}   {path}")
+            //format!("{ino} {perms} {nlink} {blocks} {time} {size}   {path}")
+            format!("{perms} {time} {size}   {path}")
         } else {
             format!("{size}   {path}")
         };
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 4281821d..9466083a 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -23,6 +23,7 @@ use crate::{
     disk_usage::file_size::block,
     fs::{
         permissions::{FileMode, SymbolicNotation},
+        ug::UserGroupInfo,
         xattr::ExtendedAttr,
     },
 };
@@ -45,6 +46,10 @@ pub struct Node {
 
     #[cfg(unix)]
     has_xattrs: bool,
+    #[cfg(unix)]
+    owner: Option<String>,
+    #[cfg(unix)]
+    group: Option<String>,
 }
 
 impl Node {
@@ -58,6 +63,8 @@ impl Node {
         inode: Option<Inode>,
 
         #[cfg(unix)] has_xattrs: bool,
+        #[cfg(unix)] owner: Option<String>,
+        #[cfg(unix)] group: Option<String>,
     ) -> Self {
         Self {
             dir_entry,
@@ -68,6 +75,10 @@ impl Node {
             inode,
             #[cfg(unix)]
             has_xattrs,
+            #[cfg(unix)]
+            owner,
+            #[cfg(unix)]
+            group,
         }
     }
 
@@ -273,10 +284,16 @@ impl TryFrom<(DirEntry, &Context)> for Node {
         let inode = Inode::try_from(&metadata).ok();
 
         #[cfg(unix)]
-        let has_xattrs = if ctx.long {
-            dir_entry.has_xattrs()
+        let (has_xattrs, owner, group) = if ctx.long {
+            let has_xattrs = dir_entry.has_xattrs();
+
+            if let Ok((o, g)) = dir_entry.try_get_owner_and_group() {
+                (has_xattrs, Some(o), Some(g))
+            } else {
+                (has_xattrs, None, None)
+            }
         } else {
-            false
+            (false, None, None)
         };
 
         Ok(Self::new(
@@ -288,6 +305,10 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             inode,
             #[cfg(unix)]
             has_xattrs,
+            #[cfg(unix)]
+            owner,
+            #[cfg(unix)]
+            group,
         ))
     }
 }
diff --git a/tests/flat.rs b/tests/flat.rs
index 23dcd485..eede31a7 100644
--- a/tests/flat.rs
+++ b/tests/flat.rs
@@ -37,7 +37,7 @@ fn flat_human() {
  446   B   lipsum
  308   B   dream_cycle/polaris.txt
  308   B   dream_cycle
-1.21 KiB   data
+ 1.2 KiB   data
 
 3 directories, 6 files"
         )

From 407b612b47ad3bc9449ea431c247d171e92beda1 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 11:37:49 -0700
Subject: [PATCH 2/8] pull unix attrs into sep struct from node

---
 src/tree/node/mod.rs  | 40 +++++++++++-----------------------------
 src/tree/node/unix.rs | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 29 deletions(-)
 create mode 100644 src/tree/node/unix.rs

diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 9466083a..f1c7fe5c 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -31,6 +31,9 @@ use crate::{
 /// Ordering and sorting rules for [Node].
 pub mod cmp;
 
+/// File attributes specific to Unix systems.
+pub mod unix;
+
 /// 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`.
@@ -45,11 +48,7 @@ pub struct Node {
     inode: Option<Inode>,
 
     #[cfg(unix)]
-    has_xattrs: bool,
-    #[cfg(unix)]
-    owner: Option<String>,
-    #[cfg(unix)]
-    group: Option<String>,
+    unix_attrs: unix::Attrs,
 }
 
 impl Node {
@@ -61,10 +60,7 @@ impl Node {
         style: Option<Style>,
         symlink_target: Option<PathBuf>,
         inode: Option<Inode>,
-
-        #[cfg(unix)] has_xattrs: bool,
-        #[cfg(unix)] owner: Option<String>,
-        #[cfg(unix)] group: Option<String>,
+        #[cfg(unix)] unix_attrs: unix::Attrs,
     ) -> Self {
         Self {
             dir_entry,
@@ -74,11 +70,7 @@ impl Node {
             symlink_target,
             inode,
             #[cfg(unix)]
-            has_xattrs,
-            #[cfg(unix)]
-            owner,
-            #[cfg(unix)]
-            group,
+            unix_attrs,
         }
     }
 
@@ -207,7 +199,7 @@ impl Node {
     /// Whether or not [Node] has extended attributes.
     #[cfg(unix)]
     pub const fn has_xattrs(&self) -> bool {
-        self.has_xattrs
+        self.unix_attrs.has_xattrs
     }
 
     /// Getter for [Node]'s style field.
@@ -284,16 +276,10 @@ impl TryFrom<(DirEntry, &Context)> for Node {
         let inode = Inode::try_from(&metadata).ok();
 
         #[cfg(unix)]
-        let (has_xattrs, owner, group) = if ctx.long {
-            let has_xattrs = dir_entry.has_xattrs();
-
-            if let Ok((o, g)) = dir_entry.try_get_owner_and_group() {
-                (has_xattrs, Some(o), Some(g))
-            } else {
-                (has_xattrs, None, None)
-            }
+        let unix_attrs = if ctx.long {
+            unix::Attrs::from(&dir_entry)
         } else {
-            (false, None, None)
+            unix::Attrs::default()
         };
 
         Ok(Self::new(
@@ -304,11 +290,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             link_target,
             inode,
             #[cfg(unix)]
-            has_xattrs,
-            #[cfg(unix)]
-            owner,
-            #[cfg(unix)]
-            group,
+            unix_attrs,
         ))
     }
 }
diff --git a/src/tree/node/unix.rs b/src/tree/node/unix.rs
new file mode 100644
index 00000000..8a7da096
--- /dev/null
+++ b/src/tree/node/unix.rs
@@ -0,0 +1,35 @@
+use crate::fs::{ug::UserGroupInfo, xattr::ExtendedAttr};
+use ignore::DirEntry;
+use std::convert::From;
+
+/// File attributes that are optionally computed and specific to Unix-like systems.
+#[derive(Default)]
+pub struct Attrs {
+    pub has_xattrs: bool,
+    owner: Option<String>,
+    group: Option<String>,
+}
+
+impl Attrs {
+    /// Constructor for [`Attrs`].
+    pub fn new(has_xattrs: bool, owner: Option<String>, group: Option<String>) -> Self {
+        Self {
+            has_xattrs,
+            owner,
+            group,
+        }
+    }
+}
+
+/// Initializes a [`Attrs`] from a [`DirEntry`].
+impl From<&DirEntry> for Attrs {
+    fn from(entry: &DirEntry) -> Self {
+        let has_xattrs = entry.has_xattrs();
+
+        if let Ok((o, g)) = entry.try_get_owner_and_group() {
+            return Self::new(has_xattrs, Some(o), Some(g));
+        }
+
+        Self::new(has_xattrs, None, None)
+    }
+}

From 8995cb1ec9f900ae03cee29472d2a36de5501526 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 13:48:09 -0700
Subject: [PATCH 3/8] owner and group basic ui

---
 src/context/{output.rs => column.rs} | 14 ++++++--
 src/context/mod.rs                   | 17 +++++++--
 src/disk_usage/file_size/mod.rs      |  1 +
 src/fs/mod.rs                        |  1 +
 src/render/grid/cell.rs              | 54 +++++++++++++++++++++++++++-
 src/render/grid/mod.rs               |  4 ++-
 src/styles/mod.rs                    | 28 +++++++++++++++
 src/tree/mod.rs                      | 30 ++++++++++++----
 src/tree/node/mod.rs                 | 19 +++++++---
 src/tree/node/unix.rs                | 12 ++++++-
 10 files changed, 160 insertions(+), 20 deletions(-)
 rename src/context/{output.rs => column.rs} (76%)

diff --git a/src/context/output.rs b/src/context/column.rs
similarity index 76%
rename from src/context/output.rs
rename to src/context/column.rs
index 79f6c680..16bf5f82 100644
--- a/src/context/output.rs
+++ b/src/context/column.rs
@@ -3,7 +3,7 @@ use std::convert::From;
 
 /// Utility struct to help store maximum column widths for attributes of each node. Each width is
 /// measured as the number of columns of the tty's window.
-pub struct ColumnProperties {
+pub struct Properties {
     pub max_size_width: usize,
     pub max_size_unit_width: usize,
 
@@ -15,9 +15,15 @@ pub struct ColumnProperties {
 
     #[cfg(unix)]
     pub max_block_width: usize,
+
+    #[cfg(unix)]
+    pub max_owner_width: usize,
+
+    #[cfg(unix)]
+    pub max_group_width: usize,
 }
 
-impl From<&Context> for ColumnProperties {
+impl From<&Context> for Properties {
     fn from(ctx: &Context) -> Self {
         let unit_width = match ctx.unit {
             PrefixKind::Bin if ctx.human => 3,
@@ -34,6 +40,10 @@ impl From<&Context> for ColumnProperties {
             max_ino_width: 0,
             #[cfg(unix)]
             max_block_width: 0,
+            #[cfg(unix)]
+            max_owner_width: 0,
+            #[cfg(unix)]
+            max_group_width: 0,
         }
     }
 }
diff --git a/src/context/mod.rs b/src/context/mod.rs
index d7e9269e..d47e9688 100644
--- a/src/context/mod.rs
+++ b/src/context/mod.rs
@@ -7,7 +7,6 @@ use ignore::{
     overrides::{Override, OverrideBuilder},
     DirEntry,
 };
-use output::ColumnProperties;
 use regex::Regex;
 use std::{
     borrow::Borrow,
@@ -35,7 +34,7 @@ pub mod file;
 pub mod layout;
 
 /// Utilities to print output.
-pub mod output;
+pub mod column;
 
 /// Printing order kinds.
 pub mod sort;
@@ -208,6 +207,16 @@ pub struct Context {
     #[cfg(unix)]
     pub max_block_width: usize,
 
+    /// Restricts column width of file owner for long view
+    #[clap(skip = usize::default())]
+    #[cfg(unix)]
+    pub max_owner_width: usize,
+
+    /// Restricts column width of file group for long view
+    #[clap(skip = usize::default())]
+    #[cfg(unix)]
+    pub max_group_width: usize,
+
     /// Width of the terminal emulator's window
     #[clap(skip)]
     pub window_width: Option<usize>,
@@ -486,12 +495,14 @@ impl Context {
     }
 
     /// Update column width properties.
-    pub fn update_column_properties(&mut self, col_props: &ColumnProperties) {
+    pub fn update_column_properties(&mut self, col_props: &column::Properties) {
         self.max_size_width = col_props.max_size_width;
         self.max_size_unit_width = col_props.max_size_unit_width;
 
         #[cfg(unix)]
         {
+            self.max_owner_width = col_props.max_owner_width;
+            self.max_group_width = col_props.max_group_width;
             self.max_nlink_width = col_props.max_nlink_width;
             self.max_block_width = col_props.max_block_width;
             self.max_ino_width = col_props.max_ino_width;
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index fd210412..f280f5e4 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -20,6 +20,7 @@ pub enum FileSize {
     Word(word_count::Metric),
     Line(line_count::Metric),
     Byte(byte::Metric),
+    #[cfg(unix)]
     Block(block::Metric),
 }
 
diff --git a/src/fs/mod.rs b/src/fs/mod.rs
index 9419eab8..9c262071 100644
--- a/src/fs/mod.rs
+++ b/src/fs/mod.rs
@@ -13,6 +13,7 @@ pub mod permissions;
 pub mod xattr;
 
 /// Concerned with determining group and owner of file.
+#[cfg(unix)]
 pub mod ug;
 
 /// Returns the path to the target of the soft link. Returns `None` if provided `dir_entry` isn't a
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 9fd44e97..e4858dc2 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,5 +1,5 @@
 use crate::{
-    context::{time, Context},
+    context::Context,
     disk_usage::{
         file_size::{byte, DiskUsage, FileSize},
         units::PrefixKind,
@@ -16,6 +16,9 @@ use std::{
     path::Path,
 };
 
+#[cfg(unix)]
+use crate::context::time;
+
 /// Constitutes a single cell in a given row of the output. The `kind` field denotes what type of
 /// data actually goes into the cell once rendered. Each `kind` which is of type [Kind] has its own
 /// rules for rendering. Cell's do not have to be of a consistent width.
@@ -42,6 +45,10 @@ pub enum Kind<'a> {
     Blocks,
     #[cfg(unix)]
     Permissions,
+    #[cfg(unix)]
+    Owner,
+    #[cfg(unix)]
+    Group,
 }
 
 impl<'a> Cell<'a> {
@@ -189,6 +196,44 @@ impl<'a> Cell<'a> {
         write!(f, "{formatted_ino}")
     }
 
+    /// Rules on how to format owner.
+    #[cfg(unix)]
+    #[inline]
+    fn fmt_owner(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let max_owner_width = self.ctx.max_owner_width;
+
+        let owner = match self.node.owner() {
+            Some(o) => o,
+            None => styles::PLACEHOLDER,
+        };
+
+        if let Ok(style) = styles::get_owner_style() {
+            let formatted_owner = format!("{owner:>max_owner_width$}");
+            return write!(f, "{}", style.paint(formatted_owner));
+        }
+
+        write!(f, "{owner:>max_owner_width$}")
+    }
+
+    /// Rules on how to format group.
+    #[cfg(unix)]
+    #[inline]
+    fn fmt_group(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let max_group_width = self.ctx.max_group_width;
+
+        let group = match self.node.group() {
+            Some(o) => o,
+            None => styles::PLACEHOLDER,
+        };
+
+        if let Ok(style) = styles::get_group_style() {
+            let formatted_group = format!("{group:>max_group_width$}");
+            return write!(f, "{}", style.paint(formatted_group));
+        }
+
+        write!(f, "{group:>max_group_width$}")
+    }
+
     /// Rules on how to format datetime for rendering.
     #[cfg(unix)]
     #[inline]
@@ -247,6 +292,7 @@ impl<'a> Cell<'a> {
         write!(f, "{formatted_perms}")
     }
 
+    /// Formatter for the placeholder for file sizes.
     #[inline]
     fn fmt_size_placeholder(f: &mut fmt::Formatter<'_>, ctx: &Context) -> fmt::Result {
         if ctx.suppress_size || ctx.max_size_width == 0 {
@@ -329,6 +375,12 @@ impl Display for Cell<'_> {
 
             #[cfg(unix)]
             Kind::Permissions => self.fmt_permissions(f),
+
+            #[cfg(unix)]
+            Kind::Owner => self.fmt_owner(f),
+
+            #[cfg(unix)]
+            Kind::Group => self.fmt_group(f),
         }
     }
 }
diff --git a/src/render/grid/mod.rs b/src/render/grid/mod.rs
index 34b3d738..e7ab74e5 100644
--- a/src/render/grid/mod.rs
+++ b/src/render/grid/mod.rs
@@ -52,10 +52,12 @@ impl Display for Row<'_, Tree> {
             let perms = Cell::new(node, ctx, cell::Kind::Permissions);
             //let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
             //let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
+            let owner = Cell::new(node, ctx, cell::Kind::Owner);
+            let group = Cell::new(node, ctx, cell::Kind::Group);
             let time = Cell::new(node, ctx, cell::Kind::Datetime);
 
             //format!("{ino} {perms} {nlink} {blocks} {time} {size} {name}")
-            format!("{perms} {time} {size} {name}")
+            format!("{perms} {owner} {group} {time} {size} {name}")
         } else {
             format!("{size} {name}")
         };
diff --git a/src/styles/mod.rs b/src/styles/mod.rs
index a87c6e0f..38135c47 100644
--- a/src/styles/mod.rs
+++ b/src/styles/mod.rs
@@ -61,6 +61,14 @@ static PLACEHOLDER_STYLE: OnceCell<Style> = OnceCell::new();
 #[cfg(unix)]
 static INO_STYLE: OnceCell<Style> = OnceCell::new();
 
+/// Runtime evaluated static that contains style for the file owner string.
+#[cfg(unix)]
+static OWNER_STYLE: OnceCell<Style> = OnceCell::new();
+
+/// Runtime evaluated static that contains style for the file owner string.
+#[cfg(unix)]
+static GROUP_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();
@@ -148,6 +156,20 @@ pub fn get_ino_style() -> Result<&'static Style, Error<'static>> {
     INO_STYLE.get().ok_or(Error::Uninitialized("INO_STYLE"))
 }
 
+/// Getter for [`OWNER_STYLE`]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
+pub fn get_owner_style() -> Result<&'static Style, Error<'static>> {
+    OWNER_STYLE.get().ok_or(Error::Uninitialized("OWNER_STYLE"))
+}
+
+/// Getter for [`GROUP_STYLE`]. Returns an error if not initialized.
+#[cfg(unix)]
+#[inline]
+pub fn get_group_style() -> Result<&'static Style, Error<'static>> {
+    GROUP_STYLE.get().ok_or(Error::Uninitialized("GROUP_STYLE"))
+}
+
 /// Getter for [`NLINK_STYLE`]. Returns an error if not initialized.
 #[cfg(unix)]
 #[inline]
@@ -230,6 +252,12 @@ fn init_themes_for_long_view() {
 
     let datetime_style = Color::Purple.bold();
     DATETIME_STYLE.set(datetime_style).unwrap();
+
+    let owner_style = Color::Cyan.bold();
+    OWNER_STYLE.set(owner_style).unwrap();
+
+    let group_style = Color::Green.bold();
+    GROUP_STYLE.set(group_style).unwrap();
 }
 
 /// Initializes all color themes.
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index 1792892f..dbf08e00 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -1,5 +1,5 @@
 use crate::{
-    context::{file, output::ColumnProperties, Context},
+    context::{column, file, Context},
     disk_usage::{
         file_size::{DiskUsage, FileSize},
         units::{BinPrefix, PrefixKind, SiPrefix},
@@ -55,7 +55,7 @@ impl Tree {
     /// Initiates file-system traversal and [Tree] as well as updates the [Context] object with
     /// various properties necessary to render output.
     pub fn try_init_and_update_context(mut ctx: Context) -> Result<(Self, Context)> {
-        let mut column_properties = ColumnProperties::from(&ctx);
+        let mut column_properties = column::Properties::from(&ctx);
 
         let (arena, root_id) = Self::traverse(&ctx, &mut column_properties)?;
 
@@ -100,7 +100,7 @@ impl Tree {
     /// be completely CPU-bound.
     fn traverse(
         ctx: &Context,
-        column_properties: &mut ColumnProperties,
+        column_properties: &mut column::Properties,
     ) -> Result<(Arena<Node>, NodeId)> {
         let walker = WalkParallel::try_from(ctx)?;
         let (tx, rx) = mpsc::channel();
@@ -182,7 +182,7 @@ impl Tree {
         branches: &mut HashMap<PathBuf, Vec<NodeId>>,
         node_comparator: &NodeComparator,
         inode_set: &mut HashSet<Inode>,
-        column_properties: &mut ColumnProperties,
+        column_properties: &mut column::Properties,
         ctx: &Context,
     ) {
         let current_node = tree[current_node_id].get_mut();
@@ -307,7 +307,7 @@ impl Tree {
 
     /// Updates [`ColumnProperties`] with provided [Node].
     #[cfg(unix)]
-    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, ctx: &Context) {
+    fn update_column_properties(col_props: &mut column::Properties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
             let file_size_cols = utils::num_integral(file_size.value());
 
@@ -338,6 +338,22 @@ impl Tree {
         }
 
         if ctx.long {
+            if let Some(owner) = node.owner() {
+                let owner_len = owner.len();
+
+                if owner_len > col_props.max_owner_width {
+                    col_props.max_owner_width = owner_len;
+                }
+            }
+
+            if let Some(group) = node.group() {
+                let group_len = group.len();
+
+                if group_len > col_props.max_group_width {
+                    col_props.max_group_width = group_len;
+                }
+            }
+
             if let Some(ino) = node.ino() {
                 let ino_num_integral = utils::num_integral(ino);
 
@@ -364,9 +380,9 @@ impl Tree {
         }
     }
 
-    /// Updates [ColumnProperties] with provided [Node].
+    /// Updates [column::Properties] with provided [Node].
     #[cfg(not(unix))]
-    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, ctx: &Context) {
+    fn update_column_properties(col_props: &mut column::Properties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
             let file_size_cols = utils::num_integral(file_size.value());
 
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index f1c7fe5c..0a29a464 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -21,17 +21,14 @@ use std::{
 #[cfg(unix)]
 use crate::{
     disk_usage::file_size::block,
-    fs::{
-        permissions::{FileMode, SymbolicNotation},
-        ug::UserGroupInfo,
-        xattr::ExtendedAttr,
-    },
+    fs::permissions::{FileMode, SymbolicNotation},
 };
 
 /// Ordering and sorting rules for [Node].
 pub mod cmp;
 
 /// File attributes specific to Unix systems.
+#[cfg(unix)]
 pub mod unix;
 
 /// A node of [`Tree`] that can be created from a [`DirEntry`]. Any filesystem I/O and
@@ -202,6 +199,18 @@ impl Node {
         self.unix_attrs.has_xattrs
     }
 
+    /// Returns the owner of the [`Node`].
+    #[cfg(unix)]
+    pub fn owner(&self) -> Option<&str> {
+        self.unix_attrs.owner()
+    }
+
+    /// Returns the group of the [`Node`].
+    #[cfg(unix)]
+    pub fn group(&self) -> Option<&str> {
+        self.unix_attrs.group()
+    }
+
     /// Getter for [Node]'s style field.
     pub const fn style(&self) -> Option<Style> {
         self.style
diff --git a/src/tree/node/unix.rs b/src/tree/node/unix.rs
index 8a7da096..8c643320 100644
--- a/src/tree/node/unix.rs
+++ b/src/tree/node/unix.rs
@@ -12,13 +12,23 @@ pub struct Attrs {
 
 impl Attrs {
     /// Constructor for [`Attrs`].
-    pub fn new(has_xattrs: bool, owner: Option<String>, group: Option<String>) -> Self {
+    pub const fn new(has_xattrs: bool, owner: Option<String>, group: Option<String>) -> Self {
         Self {
             has_xattrs,
             owner,
             group,
         }
     }
+
+    /// Returns the file owner.
+    pub fn owner(&self) -> Option<&str> {
+        self.owner.as_ref().map(|s| s.as_str())
+    }
+
+    /// Returns the file's group.
+    pub fn group(&self) -> Option<&str> {
+        self.group.as_ref().map(|s| s.as_str())
+    }
 }
 
 /// Initializes a [`Attrs`] from a [`DirEntry`].

From 15e2f45157797ab242b99d1ccb5c580d9d7831a2 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 19:07:02 -0700
Subject: [PATCH 4/8] cache file size display

---
 src/disk_usage/file_size/byte.rs | 83 ++++++++++++++++++++++---------
 src/disk_usage/file_size/mod.rs  | 19 +++++++-
 src/render/grid/cell.rs          |  1 +
 src/tree/mod.rs                  | 84 ++++++++++++++------------------
 4 files changed, 115 insertions(+), 72 deletions(-)

diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index b694cfc4..dac9020e 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -1,6 +1,7 @@
 use super::super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
 use filesize::PathExt;
 use std::{
+    cell::{Ref, RefCell},
     fmt::{self, Display},
     fs::Metadata,
     path::Path,
@@ -14,6 +15,11 @@ pub struct Metric {
     #[allow(dead_code)]
     kind: MetricKind,
     prefix_kind: PrefixKind,
+
+    /// To prevent allocating the same string twice. We allocate the first time
+    /// in [`crate::tree::update_column_properties`] in order to compute the max column width for
+    /// human-readable size and the second time during the actual render.
+    cached_display: RefCell<String>,
 }
 
 /// Represents the appropriate method in which to compute bytes. `Logical` represent the total amount
@@ -39,26 +45,29 @@ impl Metric {
             human_readable,
             kind,
             prefix_kind,
+            cached_display: RefCell::default()
         }
     }
 
     /// Initializes an empty [Metric] used to represent the total amount of bytes of a file.
-    pub const fn init_empty_logical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
+    pub fn init_empty_logical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
         Self {
             value: 0,
             human_readable,
             kind: MetricKind::Logical,
             prefix_kind,
+            cached_display: RefCell::default()
         }
     }
 
     /// Initializes an empty [Metric] used to represent the total disk space of a file in bytes.
-    pub const fn init_empty_physical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
+    pub fn init_empty_physical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
         Self {
             value: 0,
             human_readable,
             kind: MetricKind::Physical,
             prefix_kind,
+            cached_display: RefCell::default()
         }
     }
 
@@ -77,46 +86,66 @@ impl Metric {
             human_readable,
             kind,
             prefix_kind,
+            cached_display: RefCell::default()
         }
     }
+
+    /// Returns an immutable borrow of the `cached_display`.
+    pub fn cached_display<'a>(&self) -> Ref<'_, String> {
+        self.cached_display.borrow()
+    }
 }
 
 impl Display for Metric {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        {
+            let cached_display = self.cached_display();
+
+            if cached_display.len() > 0 {
+                return write!(f, "{cached_display}");
+            }
+        }
+
         let value = self.value as f64;
 
-        match self.prefix_kind {
+        let display = match self.prefix_kind {
             PrefixKind::Si => {
                 if !self.human_readable {
-                    return write!(f, "{} {}", self.value, SiPrefix::Base);
-                }
-
-                let unit = SiPrefix::from(self.value);
-
-                if matches!(unit, SiPrefix::Base) {
-                    write!(f, "{} {unit}", self.value)
+                    format!("{} {}", self.value, SiPrefix::Base)
                 } else {
-                    let base_value = unit.base_value();
-                    let size = value / (base_value as f64);
-                    write!(f, "{size:.1} {unit}")
+                    let unit = SiPrefix::from(self.value);
+
+                    if matches!(unit, SiPrefix::Base) {
+                        format!("{} {unit}", self.value)
+                    } else {
+                        let base_value = unit.base_value();
+                        let size = value / (base_value as f64);
+                        format!("{size:.1} {unit}")
+                    }
                 }
             }
             PrefixKind::Bin => {
                 if !self.human_readable {
-                    return write!(f, "{} {}", self.value, BinPrefix::Base);
-                }
-
-                let unit = BinPrefix::from(self.value);
-
-                if matches!(unit, BinPrefix::Base) {
-                    write!(f, "{} {unit}", self.value)
+                    format!("{} {}", self.value, BinPrefix::Base)
                 } else {
-                    let base_value = unit.base_value();
-                    let size = value / (base_value as f64);
-                    write!(f, "{size:.1} {unit}")
+                    let unit = BinPrefix::from(self.value);
+
+                    if matches!(unit, BinPrefix::Base) {
+                        format!("{} {unit}", self.value)
+                    } else {
+                        let base_value = unit.base_value();
+                        let size = value / (base_value as f64);
+                        format!("{size:.1} {unit}")
+                    }
                 }
             }
-        }
+        };
+
+        write!(f, "{display}")?;
+
+        let _ = self.cached_display.replace(display);
+
+        Ok(())
     }
 }
 
@@ -127,6 +156,7 @@ fn test_metric() {
         kind: MetricKind::Logical,
         human_readable: false,
         prefix_kind: PrefixKind::Bin,
+        cached_display: RefCell::<String>::default(),
     };
     assert_eq!(format!("{}", metric), "100 B");
 
@@ -135,6 +165,7 @@ fn test_metric() {
         kind: MetricKind::Logical,
         human_readable: true,
         prefix_kind: PrefixKind::Si,
+        cached_display: RefCell::<String>::default(),
     };
     assert_eq!(format!("{}", metric), "1.0 KB");
 
@@ -143,6 +174,7 @@ fn test_metric() {
         kind: MetricKind::Logical,
         human_readable: true,
         prefix_kind: PrefixKind::Bin,
+        cached_display: RefCell::<String>::default(),
     };
     assert_eq!(format!("{}", metric), "1000 B");
 
@@ -151,6 +183,7 @@ fn test_metric() {
         kind: MetricKind::Logical,
         human_readable: true,
         prefix_kind: PrefixKind::Bin,
+        cached_display: RefCell::<String>::default(),
     };
     assert_eq!(format!("{}", metric), "1.0 KiB");
 
@@ -159,6 +192,7 @@ fn test_metric() {
         kind: MetricKind::Logical,
         human_readable: true,
         prefix_kind: PrefixKind::Bin,
+        cached_display: RefCell::<String>::default(),
     };
     assert_eq!(format!("{}", metric), "1.0 MiB");
 
@@ -167,6 +201,7 @@ fn test_metric() {
         kind: MetricKind::Logical,
         human_readable: false,
         prefix_kind: PrefixKind::Bin,
+        cached_display: RefCell::<String>::default(),
     };
     assert_eq!(format!("{}", metric), "123454 B");
 }
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index f280f5e4..59f01746 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -1,6 +1,10 @@
 use crate::context::Context;
 use clap::ValueEnum;
-use std::{convert::From, ops::AddAssign};
+use std::{
+    convert::From,
+    fmt::{self, Display},
+    ops::AddAssign,
+};
 
 /// Concerned with measuring file size in blocks.
 #[cfg(unix)]
@@ -88,3 +92,16 @@ impl From<&Context> for FileSize {
         }
     }
 }
+
+impl Display for FileSize {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Word(metric) => write!(f, "{metric}"),
+            Self::Line(metric) => write!(f, "{metric}"),
+            Self::Byte(metric) => write!(f, "{metric}"),
+
+            #[cfg(unix)]
+            Self::Block(metric) => write!(f, "{metric}"),
+        }
+    }
+}
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index e4858dc2..7948758a 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -324,6 +324,7 @@ impl<'a> Cell<'a> {
         let max_size_width = ctx.max_size_width;
         let max_unit_width = ctx.max_size_unit_width;
         let out = format!("{metric}");
+
         let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
 
         if ctx.no_color() {
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index dbf08e00..b562708e 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -305,36 +305,31 @@ impl Tree {
         count
     }
 
-    /// Updates [`ColumnProperties`] with provided [Node].
+    /// Updates [`column::Properties`] with provided [`Node`].
     #[cfg(unix)]
     fn update_column_properties(col_props: &mut column::Properties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
-            let file_size_cols = utils::num_integral(file_size.value());
+            if ctx.human {
+                let out = format!("{file_size}");
+                let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
 
-            if file_size_cols > col_props.max_size_width {
-                col_props.max_size_width = file_size_cols;
-            }
+                let file_size_cols = size.len();
+                let file_size_unit_cols = unit.len();
 
-            match ctx.disk_usage {
-                DiskUsage::Logical | DiskUsage::Physical => {
-                    let unit_len = match ctx.unit {
-                        PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
-                            BinPrefix::Base => 1,
-                            _ => 3,
-                        },
-                        PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
-                            SiPrefix::Base => 1,
-                            _ => 2,
-                        },
-                        _ => 1,
-                    };
-
-                    if unit_len > col_props.max_size_unit_width {
-                        col_props.max_size_unit_width = unit_len;
-                    }
+                if file_size_cols > col_props.max_size_width {
+                    col_props.max_size_width = file_size_cols;
                 }
-                DiskUsage::Line | DiskUsage::Word | DiskUsage::Block => (),
-            }
+
+                if file_size_unit_cols > col_props.max_size_unit_width {
+                    col_props.max_size_unit_width = file_size_unit_cols;
+                }
+            } else {
+                let file_size_cols = utils::num_integral(file_size.value());
+
+                if file_size_cols > col_props.max_size_width {
+                    col_props.max_size_width = file_size_cols;
+                }
+            };
         }
 
         if ctx.long {
@@ -384,32 +379,27 @@ impl Tree {
     #[cfg(not(unix))]
     fn update_column_properties(col_props: &mut column::Properties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
-            let file_size_cols = utils::num_integral(file_size.value());
+            if ctx.human {
+                let out = format!("{file_size}");
+                let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
 
-            if file_size_cols > col_props.max_size_width {
-                col_props.max_size_width = file_size_cols;
-            }
+                let file_size_cols = size.len();
+                let file_size_unit_cols = unit.len();
 
-            match ctx.disk_usage {
-                DiskUsage::Logical | DiskUsage::Physical => {
-                    let unit_len = match ctx.unit {
-                        PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
-                            BinPrefix::Base => 1,
-                            _ => 3,
-                        },
-                        PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
-                            SiPrefix::Base => 1,
-                            _ => 2,
-                        },
-                        _ => 1,
-                    };
-
-                    if unit_len > col_props.max_size_unit_width {
-                        col_props.max_size_unit_width = unit_len;
-                    }
+                if file_size_cols > col_props.max_size_width {
+                    col_props.max_size_width = file_size_cols;
                 }
-                _ => (),
-            }
+
+                if file_size_unit_cols > col_props.max_size_unit_width {
+                    col_props.max_size_unit_width = file_size_unit_cols;
+                }
+            } else {
+                let file_size_cols = utils::num_integral(file_size.value());
+
+                if file_size_cols > col_props.max_size_width {
+                    col_props.max_size_width = file_size_cols;
+                }
+            };
         }
     }
 }

From 03ef959566b7945bb9ffd0c7797ca05087bbef37 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 19:26:05 -0700
Subject: [PATCH 5/8] style non-human format

---
 src/disk_usage/file_size/byte.rs |  8 +++---
 src/disk_usage/units.rs          | 42 +++++++++++++++++++++-----------
 src/render/grid/cell.rs          | 19 +++++++++++++--
 src/tree/mod.rs                  |  6 +++--
 4 files changed, 53 insertions(+), 22 deletions(-)

diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index dac9020e..2ab7e1b0 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -45,7 +45,7 @@ impl Metric {
             human_readable,
             kind,
             prefix_kind,
-            cached_display: RefCell::default()
+            cached_display: RefCell::default(),
         }
     }
 
@@ -56,7 +56,7 @@ impl Metric {
             human_readable,
             kind: MetricKind::Logical,
             prefix_kind,
-            cached_display: RefCell::default()
+            cached_display: RefCell::default(),
         }
     }
 
@@ -67,7 +67,7 @@ impl Metric {
             human_readable,
             kind: MetricKind::Physical,
             prefix_kind,
-            cached_display: RefCell::default()
+            cached_display: RefCell::default(),
         }
     }
 
@@ -86,7 +86,7 @@ impl Metric {
             human_readable,
             kind,
             prefix_kind,
-            cached_display: RefCell::default()
+            cached_display: RefCell::default(),
         }
     }
 
diff --git a/src/disk_usage/units.rs b/src/disk_usage/units.rs
index 92e1da3f..d07385e7 100644
--- a/src/disk_usage/units.rs
+++ b/src/disk_usage/units.rs
@@ -35,6 +35,32 @@ pub enum SiPrefix {
     Tera,
 }
 
+impl SiPrefix {
+    /// Returns the human readable representation of the SI prefix.
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::Base => "B",
+            Self::Kilo => "KB",
+            Self::Mega => "MB",
+            Self::Giga => "GB",
+            Self::Tera => "TB",
+        }
+    }
+}
+
+impl BinPrefix {
+    /// Returns the human readable representation of the binary prefix.
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::Base => "B",
+            Self::Kibi => "KiB",
+            Self::Mebi => "MiB",
+            Self::Gibi => "GiB",
+            Self::Tebi => "TiB",
+        }
+    }
+}
+
 pub trait UnitPrefix {
     fn base_value(&self) -> u64;
 }
@@ -103,24 +129,12 @@ impl From<u64> for SiPrefix {
 
 impl Display for BinPrefix {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Base => f.pad("B"),
-            Self::Kibi => f.pad("KiB"),
-            Self::Mebi => f.pad("MiB"),
-            Self::Gibi => f.pad("GiB"),
-            Self::Tebi => f.pad("TiB"),
-        }
+        write!(f, "{}", self.as_str())
     }
 }
 
 impl Display for SiPrefix {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Base => f.pad("B"),
-            Self::Kilo => f.pad("KB"),
-            Self::Mega => f.pad("MB"),
-            Self::Giga => f.pad("GB"),
-            Self::Tera => f.pad("TB"),
-        }
+        write!(f, "{}", self.as_str())
     }
 }
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 7948758a..fdf642f4 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -2,7 +2,7 @@ use crate::{
     context::Context,
     disk_usage::{
         file_size::{byte, DiskUsage, FileSize},
-        units::PrefixKind,
+        units::{BinPrefix, PrefixKind, SiPrefix},
     },
     render::theme,
     styles::{self, PLACEHOLDER},
@@ -319,6 +319,7 @@ impl<'a> Cell<'a> {
         write!(f, "{placeholder:>placeholder_padding$}")
     }
 
+    /// Rules to format disk usage as bytes
     #[inline]
     fn fmt_bytes(f: &mut fmt::Formatter<'_>, metric: &byte::Metric, ctx: &Context) -> fmt::Result {
         let max_size_width = ctx.max_size_width;
@@ -331,13 +332,27 @@ impl<'a> Cell<'a> {
             return write!(f, "{size:>max_size_width$} {unit:>max_unit_width$}");
         }
 
-        let color = styles::get_du_theme().unwrap().get(unit).unwrap();
+        let color = if metric.human_readable {
+            styles::get_du_theme().unwrap().get(unit).unwrap()
+        } else {
+            match ctx.unit {
+                PrefixKind::Si => {
+                    let pre = SiPrefix::from(metric.value);
+                    styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
+                }
+                PrefixKind::Bin => {
+                    let pre = BinPrefix::from(metric.value);
+                    styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
+                }
+            }
+        };
 
         let out = color.paint(format!("{size:>max_size_width$} {unit:>max_unit_width$}"));
 
         write!(f, "{out}")
     }
 
+    /// Rules to format disk usage as unit-less values such as word count, lines, and blocks (unix).
     #[inline]
     fn fmt_unitless_disk_usage<M: Display>(
         f: &mut fmt::Formatter<'_>,
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index b562708e..4fdb6bab 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -311,7 +311,8 @@ impl Tree {
         if let Some(file_size) = node.file_size() {
             if ctx.human {
                 let out = format!("{file_size}");
-                let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
+                let [size, unit]: [&str; 2] =
+                    out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
 
                 let file_size_cols = size.len();
                 let file_size_unit_cols = unit.len();
@@ -381,7 +382,8 @@ impl Tree {
         if let Some(file_size) = node.file_size() {
             if ctx.human {
                 let out = format!("{file_size}");
-                let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
+                let [size, unit]: [&str; 2] =
+                    out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
 
                 let file_size_cols = size.len();
                 let file_size_unit_cols = unit.len();

From 0b1129724fbf4c49578749fb250406ed6e7b3e3d Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 21:23:46 -0700
Subject: [PATCH 6/8] blocks ui

---
 src/disk_usage/file_size/mod.rs |  3 +++
 src/render/grid/cell.rs         | 31 +++++++++++++++++++++++++++++--
 src/tree/mod.rs                 |  5 +----
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
index 59f01746..ff06745e 100644
--- a/src/disk_usage/file_size/mod.rs
+++ b/src/disk_usage/file_size/mod.rs
@@ -19,6 +19,9 @@ pub mod line_count;
 /// Concerned with measuring file size by word count.
 pub mod word_count;
 
+#[cfg(unix)]
+pub const BLOCK_SIZE_BYTES: u16 = 512;
+
 /// Represents all the different ways in which a filesize could be reported using various metrics.
 pub enum FileSize {
     Word(word_count::Metric),
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index fdf642f4..d6c62b18 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,7 +1,7 @@
 use crate::{
     context::Context,
     disk_usage::{
-        file_size::{byte, DiskUsage, FileSize},
+        file_size::{BLOCK_SIZE_BYTES, byte, block, DiskUsage, FileSize},
         units::{BinPrefix, PrefixKind, SiPrefix},
     },
     render::theme,
@@ -123,7 +123,7 @@ impl<'a> Cell<'a> {
             FileSize::Word(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
 
             #[cfg(unix)]
-            FileSize::Block(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
+            FileSize::Block(metric) => Self::fmt_block_usage(f, metric, ctx),
         }
     }
 
@@ -352,6 +352,33 @@ impl<'a> Cell<'a> {
         write!(f, "{out}")
     }
 
+    #[inline]
+    #[cfg(unix)]
+    fn fmt_block_usage(f: &mut fmt::Formatter<'_>, metric: &block::Metric, ctx: &Context) -> fmt::Result {
+        let max_size_width = ctx.max_size_width;
+
+        if ctx.no_color() {
+            return write!(f, "{metric:>max_size_width$}");
+        }
+
+        let bytes = metric.value * u64::from(BLOCK_SIZE_BYTES);
+
+        let color = match ctx.unit {
+            PrefixKind::Si => {
+                let pre = SiPrefix::from(bytes);
+                styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
+            }
+            PrefixKind::Bin => {
+                let pre = BinPrefix::from(bytes);
+                styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
+            }
+        };
+
+        let out = color.paint(format!("{metric:>max_size_width$}"));
+
+        write!(f, "{out}")
+    }
+
     /// Rules to format disk usage as unit-less values such as word count, lines, and blocks (unix).
     #[inline]
     fn fmt_unitless_disk_usage<M: Display>(
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index 4fdb6bab..113fcf3c 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -1,9 +1,6 @@
 use crate::{
     context::{column, file, Context},
-    disk_usage::{
-        file_size::{DiskUsage, FileSize},
-        units::{BinPrefix, PrefixKind, SiPrefix},
-    },
+    disk_usage::file_size::FileSize,
     fs::inode::Inode,
     utils,
 };

From c8d9f44ff3f5ad46b1c8e1b2c776036da5b4f526 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 22:08:27 -0700
Subject: [PATCH 7/8] use metadata traits rather than stat from libc

---
 src/fs/ug.rs          | 50 +++++++++++++------------------------------
 src/tree/node/mod.rs  |  2 +-
 src/tree/node/unix.rs |  8 +++----
 3 files changed, 20 insertions(+), 40 deletions(-)

diff --git a/src/fs/ug.rs b/src/fs/ug.rs
index b067aacc..071b8aa5 100644
--- a/src/fs/ug.rs
+++ b/src/fs/ug.rs
@@ -1,59 +1,39 @@
 use errno::{errno, set_errno, Errno};
-use ignore::DirEntry;
-use std::{convert::AsRef, ffi::CStr, mem, os::unix::ffi::OsStrExt, path::Path, ptr};
-
-impl UserGroupInfo for DirEntry {
-    fn path(&self) -> &Path {
-        self.path()
-    }
-}
+use std::{
+    ffi::CStr,
+    fs::Metadata,
+    os::unix::fs::MetadataExt,
+};
 
 type Owner = String;
 type Group = String;
 
-/// Trait that allows for files to query their owner and group.
-pub trait UserGroupInfo {
-    fn path(&self) -> &Path;
 
+impl UserGroupInfo for Metadata {}
+
+/// Trait that allows for files to query their owner and group.
+pub trait UserGroupInfo: MetadataExt {
     /// Attemps to query the owner of the implementor.
     fn try_get_owner(&self) -> Result<String, Errno> {
         unsafe {
-            let libc::stat { st_uid, .. } = try_init_stat(self.path())?;
-            try_get_user(st_uid)
+            let uid = self.uid();
+            try_get_user(uid)
         }
     }
 
     /// Attempts to query both the owner and group of the implementor.
     fn try_get_owner_and_group(&self) -> Result<(Owner, Group), Errno> {
         unsafe {
-            let libc::stat { st_uid, st_gid, .. } = try_init_stat(self.path())?;
-            let user = try_get_user(st_uid)?;
-            let group = try_get_group(st_gid)?;
+            let uid = self.uid();
+            let gid = self.gid();
+            let user = try_get_user(uid)?;
+            let group = try_get_group(gid)?;
 
             Ok((user, group))
         }
     }
 }
 
-/// A wrapper around [`libc::stat`].
-unsafe fn try_init_stat<P: AsRef<Path>>(path: P) -> Result<libc::stat, Errno> {
-    let mut stat = mem::zeroed::<libc::stat>();
-
-    let stat_ptr = ptr::addr_of_mut!(stat);
-    let path_ptr = path
-        .as_ref()
-        .as_os_str()
-        .as_bytes()
-        .as_ptr()
-        .cast::<libc::c_char>();
-
-    if libc::stat(path_ptr, stat_ptr) == -1 {
-        return Err(errno());
-    }
-
-    Ok(stat)
-}
-
 /// Attempts to return the name of the group associated with `gid`.
 unsafe fn try_get_group(gid: libc::gid_t) -> Result<String, Errno> {
     set_errno(Errno(0));
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 0a29a464..d2fc6459 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -286,7 +286,7 @@ impl TryFrom<(DirEntry, &Context)> for Node {
 
         #[cfg(unix)]
         let unix_attrs = if ctx.long {
-            unix::Attrs::from(&dir_entry)
+            unix::Attrs::from((&metadata, &dir_entry))
         } else {
             unix::Attrs::default()
         };
diff --git a/src/tree/node/unix.rs b/src/tree/node/unix.rs
index 8c643320..dd5768b7 100644
--- a/src/tree/node/unix.rs
+++ b/src/tree/node/unix.rs
@@ -1,6 +1,6 @@
 use crate::fs::{ug::UserGroupInfo, xattr::ExtendedAttr};
 use ignore::DirEntry;
-use std::convert::From;
+use std::{fs::Metadata, convert::From};
 
 /// File attributes that are optionally computed and specific to Unix-like systems.
 #[derive(Default)]
@@ -32,11 +32,11 @@ impl Attrs {
 }
 
 /// Initializes a [`Attrs`] from a [`DirEntry`].
-impl From<&DirEntry> for Attrs {
-    fn from(entry: &DirEntry) -> Self {
+impl From<(&Metadata, &DirEntry)> for Attrs {
+    fn from((md, entry): (&Metadata, &DirEntry)) -> Self {
         let has_xattrs = entry.has_xattrs();
 
-        if let Ok((o, g)) = entry.try_get_owner_and_group() {
+        if let Ok((o, g)) = md.try_get_owner_and_group() {
             return Self::new(has_xattrs, Some(o), Some(g));
         }
 

From 2d8931ebb179bc798df60f1bdf9b80f10825eb19 Mon Sep 17 00:00:00 2001
From: Benjamin Nguyen <benjamin.van.nguyen@gmail.com>
Date: Tue, 23 May 2023 23:14:45 -0700
Subject: [PATCH 8/8] clippy

---
 src/context/mod.rs               |  23 +++++-
 src/disk_usage/file_size/byte.rs |  16 ++--
 src/disk_usage/units.rs          |   4 +-
 src/fs/ug.rs                     |   7 +-
 src/render/grid/cell.rs          |  51 +++---------
 src/render/grid/mod.rs           |  63 +++++++-------
 src/render/long/mod.rs           | 138 +++++++++++++++++++++++++++++++
 src/render/mod.rs                |   4 +
 src/styles/mod.rs                |  15 ----
 src/tree/node/unix.rs            |   6 +-
 10 files changed, 215 insertions(+), 112 deletions(-)
 create mode 100644 src/render/long/mod.rs

diff --git a/src/context/mod.rs b/src/context/mod.rs
index d47e9688..abb3fe8a 100644
--- a/src/context/mod.rs
+++ b/src/context/mod.rs
@@ -86,6 +86,21 @@ pub struct Context {
     #[arg(short, long)]
     pub long: bool,
 
+    /// Show file's groups
+    #[cfg(unix)]
+    #[arg(long)]
+    pub group: bool,
+
+    /// Show each file's ino
+    #[cfg(unix)]
+    #[arg(long)]
+    pub ino: bool,
+
+    /// Show the total number of hardlinks to the underlying inode
+    #[cfg(unix)]
+    #[arg(long)]
+    pub nlink: bool,
+
     /// Show permissions in numeric octal format instead of symbolic
     #[cfg(unix)]
     #[arg(long, requires = "long")]
@@ -141,6 +156,10 @@ pub struct Context {
     #[arg(short, long, value_enum, default_value_t = PrefixKind::default())]
     pub unit: PrefixKind,
 
+    /// Which kind of layout to use when rendering the output
+    #[arg(short = 'y', long, value_enum, default_value_t = layout::Type::default())]
+    pub layout: layout::Type,
+
     /// Show hidden files
     #[arg(short = '.', long)]
     pub hidden: bool,
@@ -157,10 +176,6 @@ pub struct Context {
     #[arg(long)]
     pub dirs_only: bool,
 
-    /// Which kind of layout to use when rendering the output
-    #[arg(long, value_enum, default_value_t = layout::Type::default())]
-    pub layout: layout::Type,
-
     /// Don't read configuration file
     #[arg(long)]
     pub no_config: bool,
diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index 2ab7e1b0..b3baca34 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -91,7 +91,7 @@ impl Metric {
     }
 
     /// Returns an immutable borrow of the `cached_display`.
-    pub fn cached_display<'a>(&self) -> Ref<'_, String> {
+    pub fn cached_display(&self) -> Ref<'_, String> {
         self.cached_display.borrow()
     }
 }
@@ -110,9 +110,7 @@ impl Display for Metric {
 
         let display = match self.prefix_kind {
             PrefixKind::Si => {
-                if !self.human_readable {
-                    format!("{} {}", self.value, SiPrefix::Base)
-                } else {
+                if self.human_readable {
                     let unit = SiPrefix::from(self.value);
 
                     if matches!(unit, SiPrefix::Base) {
@@ -122,12 +120,12 @@ impl Display for Metric {
                         let size = value / (base_value as f64);
                         format!("{size:.1} {unit}")
                     }
+                } else {
+                    format!("{} {}", self.value, SiPrefix::Base)
                 }
             }
             PrefixKind::Bin => {
-                if !self.human_readable {
-                    format!("{} {}", self.value, BinPrefix::Base)
-                } else {
+                if self.human_readable {
                     let unit = BinPrefix::from(self.value);
 
                     if matches!(unit, BinPrefix::Base) {
@@ -137,13 +135,15 @@ impl Display for Metric {
                         let size = value / (base_value as f64);
                         format!("{size:.1} {unit}")
                     }
+                } else {
+                    format!("{} {}", self.value, BinPrefix::Base)
                 }
             }
         };
 
         write!(f, "{display}")?;
 
-        let _ = self.cached_display.replace(display);
+        self.cached_display.replace(display);
 
         Ok(())
     }
diff --git a/src/disk_usage/units.rs b/src/disk_usage/units.rs
index d07385e7..d2100c5e 100644
--- a/src/disk_usage/units.rs
+++ b/src/disk_usage/units.rs
@@ -37,7 +37,7 @@ pub enum SiPrefix {
 
 impl SiPrefix {
     /// Returns the human readable representation of the SI prefix.
-    pub fn as_str(&self) -> &str {
+    pub const fn as_str(&self) -> &str {
         match self {
             Self::Base => "B",
             Self::Kilo => "KB",
@@ -50,7 +50,7 @@ impl SiPrefix {
 
 impl BinPrefix {
     /// Returns the human readable representation of the binary prefix.
-    pub fn as_str(&self) -> &str {
+    pub const fn as_str(&self) -> &str {
         match self {
             Self::Base => "B",
             Self::Kibi => "KiB",
diff --git a/src/fs/ug.rs b/src/fs/ug.rs
index 071b8aa5..675c618a 100644
--- a/src/fs/ug.rs
+++ b/src/fs/ug.rs
@@ -1,14 +1,9 @@
 use errno::{errno, set_errno, Errno};
-use std::{
-    ffi::CStr,
-    fs::Metadata,
-    os::unix::fs::MetadataExt,
-};
+use std::{ffi::CStr, fs::Metadata, os::unix::fs::MetadataExt};
 
 type Owner = String;
 type Group = String;
 
-
 impl UserGroupInfo for Metadata {}
 
 /// Trait that allows for files to query their owner and group.
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index d6c62b18..1d59a581 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,7 +1,7 @@
 use crate::{
     context::Context,
     disk_usage::{
-        file_size::{BLOCK_SIZE_BYTES, byte, block, DiskUsage, FileSize},
+        file_size::{byte, DiskUsage, FileSize},
         units::{BinPrefix, PrefixKind, SiPrefix},
     },
     render::theme,
@@ -17,7 +17,10 @@ use std::{
 };
 
 #[cfg(unix)]
-use crate::context::time;
+use crate::{
+    context::time,
+    disk_usage::file_size::{block, BLOCK_SIZE_BYTES},
+};
 
 /// Constitutes a single cell in a given row of the output. The `kind` field denotes what type of
 /// data actually goes into the cell once rendered. Each `kind` which is of type [Kind] has its own
@@ -42,8 +45,6 @@ pub enum Kind<'a> {
     #[cfg(unix)]
     Nlink,
     #[cfg(unix)]
-    Blocks,
-    #[cfg(unix)]
     Permissions,
     #[cfg(unix)]
     Owner,
@@ -127,29 +128,6 @@ impl<'a> Cell<'a> {
         }
     }
 
-    /// Rules on how to format block for rendering
-    #[cfg(unix)]
-    #[inline]
-    fn fmt_blocks(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let node = self.node;
-        let ctx = self.ctx;
-
-        let max_width = ctx.max_block_width;
-
-        let out = node
-            .blocks()
-            .map(|num| format!("{num:>max_width$}"))
-            .unwrap_or(format!("{PLACEHOLDER:>max_width$}"));
-
-        let formatted_blocks = if let Ok(style) = styles::get_block_style() {
-            style.paint(out).to_string()
-        } else {
-            out
-        };
-
-        write!(f, "{formatted_blocks}")
-    }
-
     /// Rules on how to format nlink for rendering.
     #[cfg(unix)]
     #[inline]
@@ -202,10 +180,7 @@ impl<'a> Cell<'a> {
     fn fmt_owner(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let max_owner_width = self.ctx.max_owner_width;
 
-        let owner = match self.node.owner() {
-            Some(o) => o,
-            None => styles::PLACEHOLDER,
-        };
+        let owner = self.node.owner().map_or(styles::PLACEHOLDER, |o| o);
 
         if let Ok(style) = styles::get_owner_style() {
             let formatted_owner = format!("{owner:>max_owner_width$}");
@@ -221,10 +196,7 @@ impl<'a> Cell<'a> {
     fn fmt_group(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let max_group_width = self.ctx.max_group_width;
 
-        let group = match self.node.group() {
-            Some(o) => o,
-            None => styles::PLACEHOLDER,
-        };
+        let group = self.node.group().map_or(styles::PLACEHOLDER, |o| o);
 
         if let Ok(style) = styles::get_group_style() {
             let formatted_group = format!("{group:>max_group_width$}");
@@ -354,7 +326,11 @@ impl<'a> Cell<'a> {
 
     #[inline]
     #[cfg(unix)]
-    fn fmt_block_usage(f: &mut fmt::Formatter<'_>, metric: &block::Metric, ctx: &Context) -> fmt::Result {
+    fn fmt_block_usage(
+        f: &mut fmt::Formatter<'_>,
+        metric: &block::Metric,
+        ctx: &Context,
+    ) -> fmt::Result {
         let max_size_width = ctx.max_size_width;
 
         if ctx.no_color() {
@@ -410,9 +386,6 @@ impl Display for Cell<'_> {
             #[cfg(unix)]
             Kind::Nlink => self.fmt_nlink(f),
 
-            #[cfg(unix)]
-            Kind::Blocks => self.fmt_blocks(f),
-
             #[cfg(unix)]
             Kind::Datetime => self.fmt_datetime(f),
 
diff --git a/src/render/grid/mod.rs b/src/render/grid/mod.rs
index e7ab74e5..d847ff54 100644
--- a/src/render/grid/mod.rs
+++ b/src/render/grid/mod.rs
@@ -5,6 +5,9 @@ use std::{
     marker::PhantomData,
 };
 
+#[cfg(unix)]
+use super::long;
+
 /// Concerned with rules to construct and a single cell in a given row.
 pub mod cell;
 
@@ -48,16 +51,10 @@ impl Display for Row<'_, Tree> {
         );
 
         let row = if ctx.long {
-            //let ino = Cell::new(node, ctx, cell::Kind::Ino);
-            let perms = Cell::new(node, ctx, cell::Kind::Permissions);
-            //let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
-            //let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
-            let owner = Cell::new(node, ctx, cell::Kind::Owner);
-            let group = Cell::new(node, ctx, cell::Kind::Group);
-            let time = Cell::new(node, ctx, cell::Kind::Datetime);
-
-            //format!("{ino} {perms} {nlink} {blocks} {time} {size} {name}")
-            format!("{perms} {owner} {group} {time} {size} {name}")
+            let optionals = long::Optionals::from(ctx);
+            let long_display = long::Display::new(optionals, node, ctx);
+
+            format!("{long_display} {size} {name}")
         } else {
             format!("{size} {name}")
         };
@@ -72,22 +69,23 @@ impl Display for Row<'_, Tree> {
     }
 }
 
-#[cfg(not(unix))]
-impl Display for Row<'_, Tree> {
+#[cfg(unix)]
+impl Display for Row<'_, Flat> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let node = self.node;
         let ctx = self.ctx;
 
         let size = Cell::new(node, ctx, cell::Kind::FileSize);
-        let name = Cell::new(
-            node,
-            ctx,
-            cell::Kind::FileName {
-                prefix: self.prefix,
-            },
-        );
+        let path = Cell::new(node, ctx, cell::Kind::FilePath);
 
-        let row = format!("{size} {name}");
+        let row = if ctx.long {
+            let optionals = long::Optionals::from(ctx);
+            let long_display = long::Display::new(optionals, node, ctx);
+
+            format!("{long_display} {size} {path}")
+        } else {
+            format!("{size} {path}")
+        };
 
         if ctx.truncate && ctx.window_width.is_some() {
             let window_width = ctx.window_width.unwrap();
@@ -99,27 +97,22 @@ impl Display for Row<'_, Tree> {
     }
 }
 
-#[cfg(unix)]
-impl Display for Row<'_, Flat> {
+#[cfg(not(unix))]
+impl Display for Row<'_, Tree> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let node = self.node;
         let ctx = self.ctx;
 
         let size = Cell::new(node, ctx, cell::Kind::FileSize);
-        let path = Cell::new(node, ctx, cell::Kind::FilePath);
+        let name = Cell::new(
+            node,
+            ctx,
+            cell::Kind::FileName {
+                prefix: self.prefix,
+            },
+        );
 
-        let row = if ctx.long {
-            //let ino = Cell::new(node, ctx, cell::Kind::Ino);
-            let perms = Cell::new(node, ctx, cell::Kind::Permissions);
-            //let nlink = Cell::new(node, ctx, cell::Kind::Nlink);
-            //let blocks = Cell::new(node, ctx, cell::Kind::Blocks);
-            let time = Cell::new(node, ctx, cell::Kind::Datetime);
-
-            //format!("{ino} {perms} {nlink} {blocks} {time} {size}   {path}")
-            format!("{perms} {time} {size}   {path}")
-        } else {
-            format!("{size}   {path}")
-        };
+        let row = format!("{size} {name}");
 
         if ctx.truncate && ctx.window_width.is_some() {
             let window_width = ctx.window_width.unwrap();
diff --git a/src/render/long/mod.rs b/src/render/long/mod.rs
new file mode 100644
index 00000000..cd38cff2
--- /dev/null
+++ b/src/render/long/mod.rs
@@ -0,0 +1,138 @@
+use super::grid::cell::{self, Cell};
+use crate::{context::Context, tree::node::Node};
+use std::{convert::From, fmt};
+
+/// Concerned with displaying that actual attributes associated with the long view.
+pub struct Display<'a> {
+    node: &'a Node,
+    ctx: &'a Context,
+    optional: Optionals,
+}
+
+/// Optionals fields that are displayed when `--long` is specified. Each field is a boolean,
+/// specifying whether or not a particular field should be included in the output when the long
+/// view is enabled.
+pub struct Optionals {
+    #[allow(dead_code)]
+    perms: bool,
+    #[allow(dead_code)]
+    owner: bool,
+    group: bool,
+    ino: bool,
+    #[allow(dead_code)]
+    nlink: bool,
+    #[allow(dead_code)]
+    time: bool,
+}
+
+impl<'a> Display<'a> {
+    /// Constructor for [`Display`].
+    pub const fn new(optional: Optionals, node: &'a Node, ctx: &'a Context) -> Self {
+        Self {
+            node,
+            ctx,
+            optional,
+        }
+    }
+}
+
+/// Default implementation for [`Optionals`]. Fields that are `true` are the default fields that
+/// should display when the long view is enabled.
+impl Default for Optionals {
+    fn default() -> Self {
+        Self {
+            perms: true,
+            owner: true,
+            group: false,
+            ino: false,
+            nlink: false,
+            time: true,
+        }
+    }
+}
+
+impl fmt::Display for Display<'_> {
+    /// Formatting the attributes associated with the long view.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Optionals {
+            group, ino, nlink, ..
+        } = self.optional;
+        let node = self.node;
+        let ctx = self.ctx;
+
+        let perms = Cell::new(node, ctx, cell::Kind::Permissions);
+        let owner = Cell::new(node, ctx, cell::Kind::Owner);
+        let time = Cell::new(node, ctx, cell::Kind::Datetime);
+
+        match (group, ino, nlink) {
+            (false, false, false) => {
+                write!(f, "{perms} {owner} {time}")
+            }
+
+            (true, true, true) => {
+                let group_out = Cell::new(node, ctx, cell::Kind::Group);
+                let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
+                let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
+
+                write!(
+                    f,
+                    "{ino_out} {perms} {nlink_out} {owner} {group_out} {time}"
+                )
+            }
+
+            (true, false, false) => {
+                let group_out = Cell::new(node, ctx, cell::Kind::Group);
+
+                write!(f, "{perms} {owner} {group_out} {time}")
+            }
+
+            (true, true, false) => {
+                let group_out = Cell::new(node, ctx, cell::Kind::Group);
+                let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
+
+                write!(f, "{ino_out} {perms} {owner} {group_out} {time}")
+            }
+
+            (false, false, true) => {
+                let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
+
+                write!(f, "{perms} {nlink_out} {owner} {time}")
+            }
+
+            (true, false, true) => {
+                let group_out = Cell::new(node, ctx, cell::Kind::Group);
+                let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
+
+                write!(f, "{perms} {nlink_out} {owner} {group_out} {time}")
+            }
+
+            (false, true, false) => {
+                let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
+
+                write!(f, "{ino_out} {perms} {owner} {time}")
+            }
+
+            (false, true, true) => {
+                let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
+                let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
+
+                write!(f, "{ino_out} {perms} {nlink_out} {owner} {time}")
+            }
+        }
+    }
+}
+
+impl From<&Context> for Optionals {
+    fn from(ctx: &Context) -> Self {
+        let Context {
+            group, ino, nlink, ..
+        } = *ctx;
+
+        Self {
+            group,
+            ino,
+            nlink,
+            ..Self::default()
+        }
+    }
+}
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 70cd2b5a..d70a5ad5 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -11,6 +11,10 @@ pub mod grid;
 /// output tree.
 pub mod theme;
 
+/// Concerned with how to construct the long output.
+#[cfg(unix)]
+pub mod long;
+
 /// The struct that is generic over T, which is generally expected to be a unit-struct that
 /// ultimately determines which variant to use for the output.
 pub struct Engine<T> {
diff --git a/src/styles/mod.rs b/src/styles/mod.rs
index 38135c47..73a32d0e 100644
--- a/src/styles/mod.rs
+++ b/src/styles/mod.rs
@@ -77,11 +77,6 @@ static NLINK_STYLE: OnceCell<Style> = OnceCell::new();
 #[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)]
-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>;
 
@@ -177,13 +172,6 @@ pub fn get_nlink_style() -> Result<&'static Style, Error<'static>> {
     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"))
-}
-
 /// Getter for [`DATETIME_STYLE`]. Returns an error if not initialized.
 #[cfg(unix)]
 #[inline]
@@ -247,9 +235,6 @@ fn init_themes_for_long_view() {
     let nlink_style = Color::Red.bold();
     NLINK_STYLE.set(nlink_style).unwrap();
 
-    let block_style = Color::White.bold();
-    BLOCK_STYLE.set(block_style).unwrap();
-
     let datetime_style = Color::Purple.bold();
     DATETIME_STYLE.set(datetime_style).unwrap();
 
diff --git a/src/tree/node/unix.rs b/src/tree/node/unix.rs
index dd5768b7..9160ccd1 100644
--- a/src/tree/node/unix.rs
+++ b/src/tree/node/unix.rs
@@ -1,6 +1,6 @@
 use crate::fs::{ug::UserGroupInfo, xattr::ExtendedAttr};
 use ignore::DirEntry;
-use std::{fs::Metadata, convert::From};
+use std::{convert::From, fs::Metadata};
 
 /// File attributes that are optionally computed and specific to Unix-like systems.
 #[derive(Default)]
@@ -22,12 +22,12 @@ impl Attrs {
 
     /// Returns the file owner.
     pub fn owner(&self) -> Option<&str> {
-        self.owner.as_ref().map(|s| s.as_str())
+        self.owner.as_deref()
     }
 
     /// Returns the file's group.
     pub fn group(&self) -> Option<&str> {
-        self.group.as_ref().map(|s| s.as_str())
+        self.group.as_deref()
     }
 }