Lots of code cleanup

- Try to use iterator adapters and collect in various places, where possible. This especially benefits draw_it.
- Try to use `.map` and other similar methods on Options and Results, where possible
- Replaced nearly all clones with reference-based equivalents
- Summarizing nodes by file extension is now much more efficient
- PartialOrd and PartialEq implementations now agree
- Replace #[cfg(...)] function definitions with simpler if cfg!(...) equivelents
- Simplify CLI Values handling by taking advantage of Values::default
- Various spelling corrections in comments
- Add `ColorState` enum to replace bool, for clarity
- Fix tests that break under some detected terminal widths when paths are long
- Use sort_by instead of (sort, reverse)
- Use new `ExtensionNode` struct internally to simplify extension aggregation code

src/filter.rs

@@ -3,6 +3,8 @@ use crate::node::Node;
 use std::collections::BinaryHeap;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::ffi::OsStr;
+use std::path::Path;
 use std::path::PathBuf;
 
 pub fn get_biggest(
@@ -21,14 +23,14 @@ pub fn get_biggest(
     let root = get_new_root(top_level_nodes);
     let mut allowed_nodes = HashSet::new();
 
-    allowed_nodes.insert(&root.name);
+    allowed_nodes.insert(root.name.as_path());
     heap = add_children(using_a_filter, &root, depth, heap);
 
     for _ in number_top_level_nodes..n {
         let line = heap.pop();
         match line {
             Some(line) => {
-                allowed_nodes.insert(&line.name);
+                allowed_nodes.insert(line.name.as_path());
                 heap = add_children(using_a_filter, line, depth, heap);
             }
             None => break,
@@ -37,33 +39,59 @@ pub fn get_biggest(
     recursive_rebuilder(&allowed_nodes, &root)
 }
 
-pub fn get_all_file_types(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
-    let mut map: HashMap<String, DisplayNode> = HashMap::new();
-    build_by_all_file_types(top_level_nodes, &mut map);
-    let mut by_types: Vec<DisplayNode> = map.into_iter().map(|(_k, v)| v).collect();
-    by_types.sort();
-    by_types.reverse();
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+struct ExtensionNode<'a> {
+    size: u64,
+    extension: Option<&'a OsStr>,
+}
 
-    let displayed = if by_types.len() <= n {
-        by_types
-    } else {
-        let (displayed, rest) = by_types.split_at(if n > 1 { n - 1 } else { 1 });
-        let remaining = DisplayNode {
-            name: PathBuf::from("(others)"),
-            size: rest.iter().map(|a| a.size).sum(),
-            children: vec![],
-        };
+pub fn get_all_file_types(top_level_nodes: &[Node], n: usize) -> Option<DisplayNode> {
+    let ext_nodes = {
+        let mut extension_cumulative_sizes = HashMap::new();
+        build_by_all_file_types(top_level_nodes, &mut extension_cumulative_sizes);
 
-        let mut displayed = displayed.to_vec();
-        displayed.push(remaining);
-        displayed
+        let mut extension_cumulative_sizes: Vec<ExtensionNode<'_>> = extension_cumulative_sizes
+            .iter()
+            .map(|(&extension, &size)| ExtensionNode { extension, size })
+            .collect();
+
+        extension_cumulative_sizes.sort_by(|lhs, rhs| lhs.cmp(rhs).reverse());
+
+        extension_cumulative_sizes
     };
 
+    let mut ext_nodes_iter = ext_nodes.iter();
+
+    // First, collect the first N - 1 nodes...
+    let mut displayed: Vec<DisplayNode> = ext_nodes_iter
+        .by_ref()
+        .take(if n > 1 { n - 1 } else { 1 })
+        .map(|node| DisplayNode {
+            name: PathBuf::from(
+                node.extension
+                    .map(|ext| format!(".{}", ext.to_string_lossy()))
+                    .unwrap_or_else(|| "(no extension)".to_owned()),
+            ),
+            size: node.size,
+            children: vec![],
+        })
+        .collect();
+
+    // ...then, aggregate the remaining nodes (if any) into a single  "(others)" node
+    if ext_nodes_iter.len() > 0 {
+        displayed.push(DisplayNode {
+            name: PathBuf::from("(others)"),
+            size: ext_nodes_iter.map(|node| node.size).sum(),
+            children: vec![],
+        });
+    }
+
     let result = DisplayNode {
         name: PathBuf::from("(total)"),
-        size: displayed.iter().map(|a| a.size).sum(),
+        size: displayed.iter().map(|node| node.size).sum(),
         children: displayed,
     };
+
     Some(result)
 }
 
@@ -74,44 +102,35 @@ fn add_children<'a>(
     mut heap: BinaryHeap<&'a Node>,
 ) -> BinaryHeap<&'a Node> {
     if depth > file_or_folder.depth {
-        if using_a_filter {
-            file_or_folder.children.iter().for_each(|c| {
-                if c.name.is_file() || c.size > 0 {
-                    heap.push(c)
-                }
-            });
-        } else {
-            file_or_folder.children.iter().for_each(|c| heap.push(c));
-        }
+        heap.extend(
+            file_or_folder
+                .children
+                .iter()
+                .filter(|c| !using_a_filter || c.name.is_file() || c.size > 0),
+        )
     }
     heap
 }
 
-fn build_by_all_file_types(top_level_nodes: Vec<Node>, counter: &mut HashMap<String, DisplayNode>) {
+fn build_by_all_file_types<'a>(
+    top_level_nodes: &'a [Node],
+    counter: &mut HashMap<Option<&'a OsStr>, u64>,
+) {
     for node in top_level_nodes {
         if node.name.is_file() {
             let ext = node.name.extension();
-            let key: String = match ext {
-                Some(e) => ".".to_string() + &e.to_string_lossy(),
-                None => "(no extension)".into(),
-            };
-            let mut display_node = counter.entry(key.clone()).or_insert(DisplayNode {
-                name: PathBuf::from(key),
-                size: 0,
-                children: vec![],
-            });
-            display_node.size += node.size;
+            let cumulative_size = counter.entry(ext).or_default();
+            *cumulative_size += node.size;
         }
-        build_by_all_file_types(node.children, counter)
+        build_by_all_file_types(&node.children, counter)
     }
 }
 
 fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
     if top_level_nodes.len() > 1 {
-        let total_size = top_level_nodes.iter().map(|node| node.size).sum();
         Node {
             name: PathBuf::from("(total)"),
-            size: total_size,
+            size: top_level_nodes.iter().map(|node| node.size).sum(),
             children: top_level_nodes,
             inode_device: None,
             depth: 0,
@@ -121,27 +140,19 @@ fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
     }
 }
 
-fn recursive_rebuilder<'a>(
-    allowed_nodes: &'a HashSet<&PathBuf>,
-    current: &Node,
-) -> Option<DisplayNode> {
+fn recursive_rebuilder(allowed_nodes: &HashSet<&Path>, current: &Node) -> Option<DisplayNode> {
     let mut new_children: Vec<_> = current
         .children
         .iter()
-        .filter_map(|c| {
-            if allowed_nodes.contains(&c.name) {
-                recursive_rebuilder(allowed_nodes, c)
-            } else {
-                None
-            }
-        })
+        .filter(|c| allowed_nodes.contains(c.name.as_path()))
+        .filter_map(|c| recursive_rebuilder(allowed_nodes, c))
         .collect();
-    new_children.sort();
-    new_children.reverse();
-    let newnode = DisplayNode {
+
+    new_children.sort_by(|lhs, rhs| lhs.cmp(rhs).reverse());
+
+    Some(DisplayNode {
         name: current.name.clone(),
         size: current.size,
         children: new_children,
-    };
-    Some(newnode)
+    })
 }