1 files changed, 59 insertions, 0 deletions
diff --git a/src/interactive/app/handlers.rs b/src/interactive/app/handlers.rs
index 2360aae..c15c764 100644
--- a/src/interactive/app/handlers.rs
+++ b/src/interactive/app/handlers.rs
@@ -9,6 +9,7 @@ use dua::traverse::{Traversal, TreeIndex};
 use itertools::Itertools;
 use petgraph::{visit::Bfs, Direction};
 use std::{fs, io, path::PathBuf};
+use trash;
 use tui::backend::Backend;
 use tui_react::Terminal;
 
@@ -229,6 +230,26 @@ impl AppState {
                     self.message = None;
                     res
                 }
+                Some(MarkMode::Trash) => {
+                    self.message = Some("Trashing entries...".to_string());
+                    let mut entries_trashed = 0;
+                    let res = pane.iterate_deletable_items(|mut pane, entry_to_trash| {
+                        window.mark_pane = Some(pane);
+                        self.draw(window, traversal, display, terminal).ok();
+                        pane = window.mark_pane.take().expect("option to be filled");
+                        match self.trash_entry(entry_to_trash, traversal) {
+                            Ok(ed) => {
+                                entries_trashed += ed;
+                                self.message =
+                                    Some(format!("Trashed {} entries...", entries_trashed));
+                                Ok(pane)
+                            }
+                            Err(c) => Err((pane, c)),
+                        }
+                    });
+                    self.message = None;
+                    res
+                }
                 None => Some(pane),
             },
             None => None,
@@ -274,6 +295,44 @@ impl AppState {
         Ok(entries_deleted)
     }
 
+    pub fn trash_entry(
+        &mut self,
+        index: TreeIndex,
+        traversal: &mut Traversal,
+    ) -> Result<usize, usize> {
+        let mut entries_trashed = 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);
+        }
+        Ok(entries_trashed)
+    }
+
     fn set_root(&mut self, root: TreeIndex, traversal: &Traversal) {
         self.root = root;
         self.entries = sorted_entries(&traversal.tree, root, self.sorting);