style: fix clippy

src/display.rs

@@ -125,9 +125,9 @@ impl DrawData<'_> {
 
 pub fn draw_it(
     idd: InitialDisplayData,
+    root_node: &DisplayNode,
     no_percent_bars: bool,
     terminal_width: usize,
-    root_node: &DisplayNode,
     skip_total: bool,
 ) {
     let num_chars_needed_on_left_most = if idd.by_filecount {

src/filter.rs

@@ -25,15 +25,14 @@ pub fn get_biggest(
     display_data: AggregateData,
     by_filetime: &Option<FileTime>,
     keep_collapsed: HashSet<PathBuf>,
-) -> Option<DisplayNode> {
+) -> DisplayNode {
-    if top_level_nodes.is_empty() {
-        // perhaps change this, bring back Error object?
-        return None;
-    }
     let mut heap = BinaryHeap::new();
     let number_top_level_nodes = top_level_nodes.len();
     let root;
 
+    if number_top_level_nodes == 0 {
+        root = total_node_builder(0, vec![])
+    } else {
         if number_top_level_nodes > 1 {
             let size = if by_filetime.is_some() {
                 top_level_nodes
@@ -46,28 +45,24 @@ pub fn get_biggest(
             };
 
             let nodes = handle_duplicate_top_level_names(top_level_nodes, display_data.short_paths);
-
+            root = total_node_builder(size, nodes);
-        root = Node {
-            name: PathBuf::from("(total)"),
-            size,
-            children: nodes,
-            inode_device: None,
-            depth: 0,
-        };
-
-        // Always include the base nodes if we add a 'parent' (total) node
-        heap = always_add_children(&display_data, &root, heap);
         } else {
             root = top_level_nodes.into_iter().next().unwrap();
+        }
         heap = add_children(&display_data, &root, heap);
     }
 
-    Some(fill_remaining_lines(
+    fill_remaining_lines(heap, &root, display_data, keep_collapsed)
-        heap,
+}
-        &root,
+
-        display_data,
+fn total_node_builder(size: u64, children: Vec<Node>) -> Node {
-        keep_collapsed,
+    Node {
-    ))
+        name: PathBuf::from("(total)"),
+        size,
+        children,
+        inode_device: None,
+        depth: 0,
+    }
 }
 
 pub fn fill_remaining_lines<'a>(

src/filter_type.rs

@@ -15,7 +15,7 @@ pub fn get_all_file_types(
     top_level_nodes: &[Node],
     n: usize,
     by_filetime: &Option<FileTime>,
-) -> Option<DisplayNode> {
+) -> DisplayNode {
     let ext_nodes = {
         let mut extension_cumulative_sizes = HashMap::new();
         build_by_all_file_types(top_level_nodes, &mut extension_cumulative_sizes);
@@ -67,13 +67,11 @@ pub fn get_all_file_types(
         displayed.iter().map(|node| node.size).sum()
     };
 
-    let result = DisplayNode {
+    DisplayNode {
         name: PathBuf::from("(total)"),
         size: actual_size,
         children: displayed,
-    };
+    }
-
-    Some(result)
 }
 
 fn build_by_all_file_types<'a>(

src/main.rs

@@ -11,6 +11,9 @@ mod progress;
 mod utils;
 
 use crate::cli::Cli;
+use crate::config::Config;
+use crate::display_node::DisplayNode;
+use crate::node::FileTime;
 use crate::progress::RuntimeErrors;
 use clap::Parser;
 use dir_walker::WalkData;
@@ -218,9 +221,12 @@ fn main() {
     let limit_filesystem = options.limit_filesystem;
     let follow_links = options.dereference_links;
 
-    let allowed_filesystems = limit_filesystem
+    let allowed_filesystems = if limit_filesystem {
-        .then(|| get_filesystem_devices(&target_dirs, follow_links))
+        get_filesystem_devices(&target_dirs, follow_links)
-        .unwrap_or_default();
+    } else {
+        Default::default()
+    };
+
     let simplified_dirs = simplify_dir_names(&target_dirs);
 
     let ignored_full_path: HashSet<PathBuf> = ignore_directories
@@ -295,47 +301,36 @@ fn main() {
     // Must have stopped indicator before we print to stderr
     indicator.stop();
 
-    let final_errors = walk_data.errors.lock().unwrap();
+    let print_errors = config.get_print_errors(&options);
-    if !final_errors.file_not_found.is_empty() {
+    print_any_errors(print_errors, walk_data.errors);
-        let err = final_errors
+
-            .file_not_found
+    print_output(
-            .iter()
+        config,
-            .map(|a| a.as_ref())
+        options,
-            .collect::<Vec<&str>>()
+        tree,
-            .join(", ");
+        walk_data.by_filecount,
-        eprintln!("No such file or directory: {}", err);
+        by_filetime,
-    }
+        is_colors,
-    if !final_errors.no_permissions.is_empty() {
+        terminal_width,
-        if config.get_print_errors(&options) {
+    )
-            let err = final_errors
-                .no_permissions
-                .iter()
-                .map(|a| a.as_ref())
-                .collect::<Vec<&str>>()
-                .join(", ");
-            eprintln!("Did not have permissions for directories: {}", err);
-        } else {
-            eprintln!(
-                "Did not have permissions for all directories (add --print-errors to see errors)"
-            );
-        }
-    }
-    if !final_errors.unknown_error.is_empty() {
-        let err = final_errors
-            .unknown_error
-            .iter()
-            .map(|a| a.as_ref())
-            .collect::<Vec<&str>>()
-            .join(", ");
-        eprintln!("Unknown Error: {}", err);
 }
 
-    if let Some(root_node) = tree {
+fn print_output(
+    config: Config,
+    options: Cli,
+    tree: DisplayNode,
+    by_filecount: bool,
+    by_filetime: Option<FileTime>,
+    is_colors: bool,
+    terminal_width: usize,
+) {
+    let output_format = config.get_output_format(&options);
+
     if config.get_output_json(&options) {
         OUTPUT_TYPE.with(|wrapped| {
             wrapped.replace(output_format);
         });
-            println!("{}", serde_json::to_string(&root_node).unwrap());
+        println!("{}", serde_json::to_string(&tree).unwrap());
     } else {
         let idd = InitialDisplayData {
             short_paths: !config.get_full_paths(&options),
@@ -350,13 +345,49 @@ fn main() {
 
         draw_it(
             idd,
+            &tree,
             config.get_no_bars(&options),
             terminal_width,
-                &root_node,
             config.get_skip_total(&options),
         )
     }
 }
+
+fn print_any_errors(print_errors: bool, errors: Arc<Mutex<RuntimeErrors>>) {
+    let final_errors = errors.lock().unwrap();
+    if !final_errors.file_not_found.is_empty() {
+        let err = final_errors
+            .file_not_found
+            .iter()
+            .map(|a| a.as_ref())
+            .collect::<Vec<&str>>()
+            .join(", ");
+        eprintln!("No such file or directory: {err}");
+    }
+    if !final_errors.no_permissions.is_empty() {
+        if print_errors {
+            let err = final_errors
+                .no_permissions
+                .iter()
+                .map(|a| a.as_ref())
+                .collect::<Vec<&str>>()
+                .join(", ");
+            eprintln!("Did not have permissions for directories: {err}");
+        } else {
+            eprintln!(
+                "Did not have permissions for all directories (add --print-errors to see errors)"
+            );
+        }
+    }
+    if !final_errors.unknown_error.is_empty() {
+        let err = final_errors
+            .unknown_error
+            .iter()
+            .map(|a| a.as_ref())
+            .collect::<Vec<&str>>()
+            .join(", ");
+        eprintln!("Unknown Error: {err}");
+    }
 }
 
 fn init_rayon(stack_size: &Option<usize>, threads: &Option<usize>) {