cargo clippy & fmt

5 files changed, 49 insertions, 28 deletions

diff --git a/src/interactive/app/eventloop.rs b/src/interactive/app/eventloop.rs
index ca878c7..2c00fd5 100644
--- a/src/interactive/app/eventloop.rs
+++ b/src/interactive/app/eventloop.rs
@@ -1,6 +1,5 @@
 use crate::interactive::{
     app::navigation::Navigation,
-    sorted_entries,
     state::FocussedPane,
     widgets::{glob_search, MainWindow, MainWindowProps},
     CursorDirection, CursorMode, DisplayOptions, MarkEntryMode,
@@ -72,11 +71,7 @@ impl AppState {
         Ok(())
     }
 
-    fn recompute_sizes_recursively(
-        &mut self,
-        traversal: &mut Traversal,
-        node_index: TreeIndex)
-    {
+    fn recompute_sizes_recursively(&mut self, traversal: &mut Traversal, node_index: TreeIndex) {
         let mut tree_view = self.tree_view(traversal);
         tree_view.recompute_sizes_recursively(node_index);
     }
@@ -165,7 +160,9 @@ impl AppState {
             }
         } else {
             let Ok(event) = events.recv() else {
-                return Ok(Some(WalkResult { num_errors: self.stats.io_errors }));
+                return Ok(Some(WalkResult {
+                    num_errors: self.stats.io_errors,
+                }));
             };
             let result =
                 self.process_terminal_event(window, traversal, display, terminal, event)?;
@@ -321,7 +318,12 @@ impl AppState {
         Ok(None)
     }
 
-    fn refresh(&mut self, tree: &mut TreeView<'_>, window: &mut MainWindow, what: Refresh) -> anyhow::Result<()> {
+    fn refresh(
+        &mut self,
+        tree: &mut TreeView<'_>,
+        window: &mut MainWindow,
+        what: Refresh,
+    ) -> anyhow::Result<()> {
         if let Some(glob_tree_root) = tree.glob_tree_root {
             if glob_tree_root == self.navigation().view_root {
                 self.quit_glob_mode(tree, window)
@@ -337,20 +339,25 @@ impl AppState {
                     .fs_parent_of(selected)
                     .expect("there is always a parent to a selection");
                 (true, false, selected, parent_index)
-            },
-            Refresh::AllInView => (false, true, self.navigation().view_root, self.navigation().view_root)
+            }
+            Refresh::AllInView => (
+                false,
+                true,
+                self.navigation().view_root,
+                self.navigation().view_root,
+            ),
         };
 
         let mut path = tree.path_of(index);
         if path.to_str() == Some("") {
             path = PathBuf::from(".");
         }
-        tree.remove_entries(index, remove_index);                
+        tree.remove_entries(index, remove_index);
         tree.recompute_sizes_recursively(parent_index);
-        
+
         self.entries = tree.sorted_entries(self.navigation().view_root, self.sorting);
         self.navigation_mut().selected = self.entries.first().map(|e| e.index);
-        
+
         self.active_traversal = Some(BackgroundTraversal::start(
             parent_index,
             &self.walk_options,
diff --git a/src/interactive/app/terminal.rs b/src/interactive/app/terminal.rs
index 8b62386..d2ae955 100644
--- a/src/interactive/app/terminal.rs
+++ b/src/interactive/app/terminal.rs
@@ -4,7 +4,7 @@ use anyhow::Result;
 use crossbeam::channel::Receiver;
 use crosstermion::input::Event;
 use dua::{
-    traverse::{EntryData, Traversal, Tree, TraversalStats},
+    traverse::{Traversal, TraversalStats},
     ByteFormat, WalkOptions, WalkResult,
 };
 use tui::prelude::Backend;
@@ -110,7 +110,9 @@ mod tests {
                     return Ok(res);
                 }
             }
-            Ok(WalkResult { num_errors: self.stats.io_errors })
+            Ok(WalkResult {
+                num_errors: self.stats.io_errors,
+            })
         }
     }
 }
diff --git a/src/interactive/app/tree_view.rs b/src/interactive/app/tree_view.rs
index 6dd3f38..612582b 100644
--- a/src/interactive/app/tree_view.rs
+++ b/src/interactive/app/tree_view.rs
@@ -90,12 +90,15 @@ impl TreeView<'_> {
                 .tree()
                 .neighbors_directed(index, Direction::Outgoing)
                 .filter_map(|idx| {
-                    self.tree().node_weight(idx).map(|w| (w.size, w.entry_count.unwrap_or(1)))
+                    self.tree()
+                        .node_weight(idx)
+                        .map(|w| (w.size, w.entry_count.unwrap_or(1)))
                 })
                 .reduce(|a, b| (a.0 + b.0, a.1 + b.1))
                 .unwrap_or_default();
 
-            let node = self.traversal
+            let node = self
+                .traversal
                 .tree
                 .node_weight_mut(index)
                 .expect("valid index");
diff --git a/src/interactive/widgets/footer.rs b/src/interactive/widgets/footer.rs
index dc54826..98251c7 100644
--- a/src/interactive/widgets/footer.rs
+++ b/src/interactive/widgets/footer.rs
@@ -46,7 +46,7 @@ impl Footer {
                     SortMode::CountAscending => "items ascending",
                     SortMode::CountDescending => "items descending",
                 },
-                format!("{}", format.display(*total_bytes)),
+                format.display(*total_bytes),
                 entries_traversed,
                 progress = match elapsed {
                     Some(elapsed) => format!("in {:.02}s", elapsed.as_secs_f32()),
diff --git a/src/traverse.rs b/src/traverse.rs
index fb05410..0bb16d7 100644
--- a/src/traverse.rs
+++ b/src/traverse.rs
@@ -58,17 +58,20 @@ pub struct Traversal {
     /// A tree representing the entire filestem traversal
     pub tree: Tree,
     /// The top-level node of the tree.
-    pub root_index: TreeIndex,    
+    pub root_index: TreeIndex,
+}
+
+impl Default for Traversal {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl Traversal {
     pub fn new() -> Self {
         let mut tree = Tree::new();
         let root_index = tree.add_node(EntryData::default());
-        Self {
-            tree,
-            root_index,
-        }
+        Self { tree, root_index }
     }
 
     pub fn recompute_node_size(&self, node_index: TreeIndex) -> u128 {
@@ -258,7 +261,7 @@ impl BackgroundTraversal {
                 match entry {
                     Ok(mut entry) => {
                         if self.skip_root {
-                            entry.depth = entry.depth - 1;
+                            entry.depth -= 1;
                             data.name = entry.file_name.into()
                         } else {
                             data.name = if entry.depth < 1 {
@@ -362,7 +365,9 @@ impl BackgroundTraversal {
                         data.size = file_size;
                         let entry_index = traversal.tree.add_node(data);
 
-                        traversal.tree.add_edge(self.parent_node_idx, entry_index, ());
+                        traversal
+                            .tree
+                            .add_edge(self.parent_node_idx, entry_index, ());
                         self.previous_node_idx = entry_index;
                         self.previous_depth = entry.depth;
                     }
@@ -370,7 +375,9 @@ impl BackgroundTraversal {
                         if self.previous_depth == 0 {
                             data.name = (*root_path).clone();
                             let entry_index = traversal.tree.add_node(data);
-                            traversal.tree.add_edge(self.parent_node_idx, entry_index, ());
+                            traversal
+                                .tree
+                                .add_edge(self.parent_node_idx, entry_index, ());
                         }
 
                         self.stats.io_errors += 1
@@ -398,7 +405,8 @@ impl BackgroundTraversal {
                         self.parent_node_idx,
                         self.current_directory_at_depth,
                     );
-                    self.parent_node_idx = parent_or_panic(&mut traversal.tree, self.parent_node_idx);
+                    self.parent_node_idx =
+                        parent_or_panic(&mut traversal.tree, self.parent_node_idx);
                 }
                 let root_size = traversal.recompute_node_size(self.root_idx);
                 set_entry_info_or_panic(
@@ -406,7 +414,8 @@ impl BackgroundTraversal {
                     self.root_idx,
                     EntryInfo {
                         size: root_size,
-                        entries_count: (self.stats.entries_traversed > 0).then_some(self.stats.entries_traversed),
+                        entries_count: (self.stats.entries_traversed > 0)
+                            .then_some(self.stats.entries_traversed),
                     },
                 );
                 self.stats.total_bytes = Some(root_size);