Refactor: deduplicate code

2 files changed, 40 insertions, 59 deletions

diff --git a/src/interactive/app/handlers.rs b/src/interactive/app/handlers.rs
index c15c764..6c072d9 100644
--- a/src/interactive/app/handlers.rs
+++ b/src/interactive/app/handlers.rs
@@ -268,29 +268,7 @@ impl AppState {
         if let Some(_entry) = traversal.tree.node_weight(index) {
             let path_to_delete = path_of(&traversal.tree, index);
             delete_directory_recursively(path_to_delete)?;
-            let parent_idx = traversal
-                .tree
-                .neighbors_directed(index, Direction::Incoming)
-                .next()
-                .expect("us being unable to delete the root index");
-            let mut bfs = Bfs::new(&traversal.tree, index);
-            while let Some(nx) = bfs.next(&traversal.tree) {
-                traversal.tree.remove_node(nx);
-                traversal.entries_traversed -= 1;
-                entries_deleted += 1;
-            }
-            self.entries = sorted_entries(&traversal.tree, self.root, self.sorting);
-            if traversal.tree.node_weight(self.root).is_none() {
-                self.set_root(traversal.root_index, traversal);
-            }
-            if self
-                .selected
-                .and_then(|selected| self.entries.iter().find(|e| e.index == selected))
-                .is_none()
-            {
-                self.selected = self.entries.get(0).map(|e| e.index);
-            }
-            self.recompute_sizes_recursively(parent_idx, traversal);
+            entries_deleted = self.delete_entries_in_traversal(index, traversal);
         }
         Ok(entries_deleted)
     }
@@ -300,37 +278,47 @@ impl AppState {
         index: TreeIndex,
         traversal: &mut Traversal,
     ) -> Result<usize, usize> {
-        let mut entries_trashed = 0;
+        let mut entries_deleted = 0;
         if let Some(_entry) = traversal.tree.node_weight(index) {
             let path_to_delete = path_of(&traversal.tree, index);
             if let Err(_) = trash::delete(path_to_delete) {
                 return Err(1);
             }
-            let parent_idx = traversal
-                .tree
-                .neighbors_directed(index, Direction::Incoming)
-                .next()
-                .expect("us being unable to delete the root index");
-            let mut bfs = Bfs::new(&traversal.tree, index);
-            while let Some(nx) = bfs.next(&traversal.tree) {
-                traversal.tree.remove_node(nx);
-                traversal.entries_traversed -= 1;
-                entries_trashed += 1;
-            }
-            self.entries = sorted_entries(&traversal.tree, self.root, self.sorting);
-            if traversal.tree.node_weight(self.root).is_none() {
-                self.set_root(traversal.root_index, traversal);
-            }
-            if self
-                .selected
-                .and_then(|selected| self.entries.iter().find(|e| e.index == selected))
-                .is_none()
-            {
-                self.selected = self.entries.get(0).map(|e| e.index);
-            }
-            self.recompute_sizes_recursively(parent_idx, traversal);
+            entries_deleted = self.delete_entries_in_traversal(index, traversal);
+        }
+        Ok(entries_deleted)
+    }
+
+    pub fn delete_entries_in_traversal(
+        &mut self,
+        index: TreeIndex,
+        traversal: &mut Traversal,
+    ) -> usize {
+        let mut entries_deleted = 0;
+        let parent_idx = traversal
+            .tree
+            .neighbors_directed(index, Direction::Incoming)
+            .next()
+            .expect("us being unable to delete the root index");
+        let mut bfs = Bfs::new(&traversal.tree, index);
+        while let Some(nx) = bfs.next(&traversal.tree) {
+            traversal.tree.remove_node(nx);
+            traversal.entries_traversed -= 1;
+            entries_deleted += 1;
+        }
+        self.entries = sorted_entries(&traversal.tree, self.root, self.sorting);
+        if traversal.tree.node_weight(self.root).is_none() {
+            self.set_root(traversal.root_index, traversal);
+        }
+        if self
+            .selected
+            .and_then(|selected| self.entries.iter().find(|e| e.index == selected))
+            .is_none()
+        {
+            self.selected = self.entries.get(0).map(|e| e.index);
         }
-        Ok(entries_trashed)
+        self.recompute_sizes_recursively(parent_idx, traversal);
+        return entries_deleted;
     }
 
     fn set_root(&mut self, root: TreeIndex, traversal: &Traversal) {
diff --git a/src/interactive/widgets/mark.rs b/src/interactive/widgets/mark.rs
index e01604b..a122f6c 100644
--- a/src/interactive/widgets/mark.rs
+++ b/src/interactive/widgets/mark.rs
@@ -109,8 +109,8 @@ impl MarkPane {
     pub fn process_events(mut self, key: Key) -> Option<(Self, Option<MarkMode>)> {
         let action = None;
         match key {
-            Ctrl('r') => return Some(self.prepare_deletion()),
-            Ctrl('t') => return Some(self.prepare_trashing()),
+            Ctrl('r') => return Some(self.prepare_deletion(MarkMode::Delete)),
+            Ctrl('t') => return Some(self.prepare_deletion(MarkMode::Trash)),
             Char('x') | Char('d') | Char(' ') => {
                 return self.remove_selected().map(|s| (s, action))
             }
@@ -179,19 +179,12 @@ impl MarkPane {
             d.num_errors_during_deletion = num_errors;
         }
     }
-    fn prepare_deletion(mut self) -> (Self, Option<MarkMode>) {
+    fn prepare_deletion(mut self, mark: MarkMode) -> (Self, Option<MarkMode>) {
         for entry in self.marked.values_mut() {
             entry.num_errors_during_deletion = 0;
         }
         self.selected = Some(0);
-        (self, Some(MarkMode::Delete))
-    }
-    fn prepare_trashing(mut self) -> (Self, Option<MarkMode>) {
-        for entry in self.marked.values_mut() {
-            entry.num_errors_during_deletion = 0;
-        }
-        self.selected = Some(0);
-        (self, Some(MarkMode::Trash))
+        (self, Some(mark))
     }
     fn remove_selected(mut self) -> Option<Self> {
         if let Some(mut selected) = self.selected {