add ability to prune empty branches

README.md

@@ -65,6 +65,7 @@ Options:
   -l, --level <NUM>              Maximum depth to display
   -n, --scale <NUM>              Total number of digits after the decimal to display for disk usage [default: 2]
   -p, --prefix <PREFIX>          Display disk usage as binary or SI units [default: bin] [possible values: bin, si]
+  -P, --prune                    Disable printing of empty branches
   -s, --sort <SORT>              Sort-order to display directory content [possible values: name, size, size-rev]
       --dirs-first               Always sorts directories above files
   -S, --follow-links             Traverse symlink directories and consider their disk usage; disabled by default

src/render/context/mod.rs

@@ -73,6 +73,10 @@ pub struct Context {
     #[arg(short, long, value_enum, default_value_t = PrefixKind::Bin)]
     pub prefix: PrefixKind,
 
+    /// Disable printing of empty branches
+    #[arg(short = 'P', long)]
+    pub prune: bool,
+
     /// Sort-order to display directory content
     #[arg(short, long, value_enum)]
     sort: Option<SortType>,

src/render/order.rs

@@ -21,9 +21,12 @@ pub struct Order {
     dir_first: bool,
 }
 
+/// Comparator type used to sort [Node]s.
+pub type NodeComparator<'a> = dyn Fn(&Node, &Node) -> Ordering + 'a;
+
 impl Order {
     /// Yields function pointer to the appropriate `Node` comparator.
-    pub fn comparator(&self) -> Option<Box<dyn Fn(&Node, &Node) -> Ordering + '_>> {
+    pub fn comparator(&self) -> Option<Box<NodeComparator<'_>>> {
         if self.dir_first {
             return Some(Box::new(|a, b| {
                 Self::dir_comparator(a, b, self.sort.comparator())

src/render/tree/mod.rs

@@ -1,5 +1,4 @@
-use super::order::Order;
-use crate::render::{context::Context, disk_usage::FileSize};
+use crate::render::{context::Context, disk_usage::FileSize, order::Order};
 use crossbeam::channel::{self, Sender};
 use error::Error;
 use ignore::{WalkBuilder, WalkParallel, WalkState};
@@ -52,15 +51,19 @@ impl Tree {
     }
 
     /// Returns a reference to the root [Node].
-    pub fn root(&self) -> &Node {
+    fn root(&self) -> &Node {
         &self.root
     }
 
     /// Maximum depth to display
-    pub fn level(&self) -> usize {
+    fn level(&self) -> usize {
         self.ctx.level.unwrap_or(usize::MAX)
     }
 
+    fn context(&self) -> &Context {
+        &self.ctx
+    }
+
     /// Parallel traversal of the root directory and its contents taking `.gitignore` into
     /// consideration. Parallel traversal relies on `WalkParallel`. Any filesystem I/O or related
     /// system calls are expected to occur during parallel traversal; thus post-processing of all
@@ -134,41 +137,41 @@ impl Tree {
 
         Self::assemble_tree(&mut root, &mut branches, ctx);
 
+        if ctx.prune {
+            root.prune_directories()
+        }
+
         Ok(root)
     }
 
     /// Takes the results of the parallel traversal and uses it to construct the [Tree] data
     /// structure. Sorting occurs if specified.
-    fn assemble_tree(current_dir: &mut Node, branches: &mut Branches, ctx: &Context) {
-        let current_node = branches
-            .remove(current_dir.path())
-            .map(|children| {
-                current_dir.set_children(children);
-                current_dir
-            })
-            .unwrap();
+    fn assemble_tree(current_node: &mut Node, branches: &mut Branches, ctx: &Context) {
+        let children = branches.remove(current_node.path()).unwrap();
+
+        if children.len() > 0 {
+            current_node.set_children(children);
+        }
 
         let mut dir_size = FileSize::new(0, ctx.disk_usage, ctx.prefix, ctx.scale);
 
-        current_node.children_mut().map(|nodes| {
-            nodes.iter_mut().for_each(|node| {
-                if node.is_dir() {
-                    Self::assemble_tree(node, branches, ctx);
-                }
+        current_node.children_mut().for_each(|node| {
+            if node.is_dir() {
+                Self::assemble_tree(node, branches, ctx);
+            }
 
-                if let Some(fs) = node.file_size() {
-                    dir_size += fs
-                }
-            })
+            if let Some(fs) = node.file_size() {
+                dir_size += fs
+            }
         });
 
         if dir_size.bytes > 0 {
             current_node.set_file_size(dir_size)
         }
 
-        if let Some(ord) = ctx.sort().map(|s| Order::from((s, ctx.dirs_first()))) {
-            ord.comparator()
-                .map(|func| current_node.children_mut().map(|nodes| nodes.sort_by(func)));
+        if let Some(ordr) = ctx.sort().map(|s| Order::from((s, ctx.dirs_first()))) {
+            ordr.comparator()
+                .map(|func| current_node.sort_children(func));
         }
     }
 }
@@ -196,6 +199,7 @@ impl Display for Tree {
         let root = self.root();
         let level = self.level();
         let theme = ui::get_theme();
+        let prune = self.context().prune;
         let mut output = String::from("");
 
         #[inline]
@@ -210,6 +214,7 @@ impl Display for Tree {
             base_prefix: &str,
             level: usize,
             theme: &ui::ThemesMap,
+            prune: bool,
         ) {
             let mut peekable = children.peekable();
 
@@ -231,7 +236,9 @@ impl Display for Tree {
                         continue;
                     }
 
-                    if let Some(iter_children) = child.children() {
+                    if child.has_children() {
+                        let children = child.children();
+
                         let mut new_base = base_prefix.to_owned();
 
                         let new_theme = child
@@ -245,7 +252,7 @@ impl Display for Tree {
                             new_base.push_str(theme.get("vt").unwrap());
                         }
 
-                        traverse(output, iter_children, &new_base, level, new_theme);
+                        traverse(output, children, &new_base, level, new_theme, prune);
                     }
 
                     continue;
@@ -256,8 +263,8 @@ impl Display for Tree {
 
         extend_output(&mut output, root, "");
 
-        if let Some(iter_children) = root.children() {
-            traverse(&mut output, iter_children, "", level, theme)
+        if root.has_children() {
+            traverse(&mut output, root.children(), "", level, theme, prune)
         }
 
         write!(f, "{output}")

src/render/tree/node.rs

@@ -5,6 +5,7 @@ use crate::{
     render::{
         context::Context,
         disk_usage::{DiskUsage, FileSize},
+        order::NodeComparator,
     },
 };
 use ansi_term::Color;
@@ -18,7 +19,7 @@ use std::{
     fmt::{self, Display, Formatter},
     fs::{self, FileType},
     path::{Path, PathBuf},
-    slice::Iter,
+    slice::{Iter, IterMut},
 };
 
 /// A node of [`Tree`] that can be created from a [DirEntry]. Any filesystem I/O and
@@ -31,7 +32,7 @@ use std::{
 pub struct Node {
     pub depth: usize,
     pub file_size: Option<FileSize>,
-    children: Option<Vec<Node>>,
+    children: Vec<Node>,
     file_name: OsString,
     file_type: Option<FileType>,
     inode: Option<Inode>,
@@ -46,7 +47,7 @@ impl Node {
     pub fn new(
         depth: usize,
         file_size: Option<FileSize>,
-        children: Option<Vec<Node>>,
+        children: Vec<Node>,
         file_name: OsString,
         file_type: Option<FileType>,
         inode: Option<Inode>,
@@ -70,13 +71,43 @@ impl Node {
     }
 
     /// Returns a mutable reference to `children` if any.
-    pub fn children_mut(&mut self) -> Option<&mut Vec<Node>> {
-        self.children.as_mut()
+    pub fn children_mut(&mut self) -> IterMut<Node> {
+        self.children.iter_mut()
     }
 
     /// Returns an iter over a `children` slice if any.
-    pub fn children(&self) -> Option<Iter<Node>> {
-        self.children.as_ref().map(|children| children.iter())
+    pub fn children(&self) -> Iter<Node> {
+        self.children.iter()
+    }
+
+    /// Setter for `children`.
+    pub fn set_children(&mut self, children: Vec<Node>) {
+        self.children = children;
+    }
+
+    /// Sorts `children` given comparator.
+    pub fn sort_children(&mut self, comparator: Box<NodeComparator<'_>>) {
+        self.children.sort_by(comparator)
+    }
+
+    /// Whether or not a [Node] has children.
+    pub fn has_children(&self) -> bool {
+        self.children.len() > 0
+    }
+
+    /// Recursively traverse [Node]s, removing any [Node]s that have no children.
+    pub fn prune_directories(&mut self) {
+        self.children.retain_mut(|node| {
+            if node.is_dir() {
+                if node.has_children() {
+                    node.prune_directories();
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+            true
+        });
     }
 
     /// Returns a reference to `file_name`. If file is a symlink then `file_name` is the name of
@@ -137,11 +168,6 @@ impl Node {
         &self.path
     }
 
-    /// Sets `children`.
-    pub fn set_children(&mut self, children: Vec<Node>) {
-        self.children = Some(children);
-    }
-
     /// Gets 'file_size'.
     pub fn file_size(&self) -> Option<&FileSize> {
         self.file_size.as_ref()
@@ -229,7 +255,7 @@ impl From<(&DirEntry, &Context)> for Node {
         let prefix = prefix.clone();
         let icons = icons.clone();
 
-        let children = None;
+        let children = vec![];
 
         let depth = dir_entry.depth();
 

tests/prune.rs

@@ -0,0 +1,29 @@
+use indoc::indoc;
+
+mod utils;
+
+#[test]
+fn prune() {
+    assert_eq!(
+        utils::run_cmd(&[
+            "--sort",
+            "name",
+            "--glob",
+            "*.txt",
+            "--no-config",
+            "--prune",
+            "tests/data"
+        ]),
+        indoc!(
+            "
+            data (1.07 KiB)
+            ├─ dream_cycle (308 B)
+            │  └─ polaris.txt (308 B)
+            ├─ lipsum (446 B)
+            │  └─ lipsum.txt (446 B)
+            ├─ necronomicon.txt (83 B)
+            ├─ nemesis.txt (161 B)
+            └─ nylarlathotep.txt (100 B)"
+        )
+    )
+}