better separation of concerns when iterating marked items

also: fix consumption of mark-pane - it's now not always consuming it.

2 files changed, 30 insertions, 22 deletions

diff --git a/src/interactive/app/handlers.rs b/src/interactive/app/handlers.rs
index aed749f..a1a7358 100644
--- a/src/interactive/app/handlers.rs
+++ b/src/interactive/app/handlers.rs
@@ -182,26 +182,17 @@ impl TerminalApp {
     {
         let res = self.window.mark_pane.take().and_then(|p| p.key(key));
         self.window.mark_pane = match res {
-            Some((mut pane, mode)) => match mode {
-                Some(MarkMode::Delete) => {
-                    while let Some(entry_to_delete) = pane.next_entry_for_deletion() {
-                        self.draw(terminal).ok();
-                        match self.delete_entry(entry_to_delete) {
-                            Ok(_) => match pane.delete_entry() {
-                                Some(p) => pane = p,
-                                None => break,
-                            },
-                            Err(num_errors) => pane.set_error_on_marked_item(num_errors),
-                        }
-                    }
-                    None
-                }
+            Some((pane, mode)) => match mode {
+                Some(MarkMode::Delete) => pane.iterate_deletable_items(|entry_to_delete| {
+                    self.draw(terminal).ok();
+                    self.delete_entry(entry_to_delete)
+                }),
                 None => Some(pane),
             },
-            None => {
-                self.state.focussed = Main;
-                None
-            }
+            None => None,
         };
+        if self.window.mark_pane.is_none() {
+            self.state.focussed = Main;
+        }
     }
 }
diff --git a/src/interactive/widgets/mark.rs b/src/interactive/widgets/mark.rs
index 611dec0..e10930d 100644
--- a/src/interactive/widgets/mark.rs
+++ b/src/interactive/widgets/mark.rs
@@ -103,7 +103,25 @@ impl MarkPane {
         Some((self, action))
     }
 
-    pub fn next_entry_for_deletion(&mut self) -> Option<TreeIndex> {
+    pub fn iterate_deletable_items(
+        mut self,
+        mut delete_fn: impl FnMut(TreeIndex) -> Result<(), usize>,
+    ) -> Option<Self> {
+        loop {
+            match self.next_entry_for_deletion() {
+                Some(entry_to_delete) => match delete_fn(entry_to_delete) {
+                    Ok(_) => match self.delete_entry() {
+                        Some(p) => self = p,
+                        None => return None,
+                    },
+                    Err(num_errors) => self.set_error_on_marked_item(num_errors),
+                },
+                None => return Some(self),
+            }
+        }
+    }
+
+    fn next_entry_for_deletion(&mut self) -> Option<TreeIndex> {
         match self.selected.and_then(|selected| {
             self.tree_index_by_list_position(selected)
                 .and_then(|idx| self.marked.get(&idx).map(|d| (selected, idx, d)))
@@ -115,17 +133,16 @@ impl MarkPane {
                         p if p < self.marked.len() => Some(p),
                         _ => None,
                     };
-                    // we assume that each entry is either followed by `delete_entry()` or `set_error_on_marked_item`.
                     self.tree_index_by_list_position(position + 1)
                 }
             },
             None => None,
         }
     }
-    pub fn delete_entry(self) -> Option<Self> {
+    fn delete_entry(self) -> Option<Self> {
         self.remove_selected()
     }
-    pub fn set_error_on_marked_item(&mut self, num_errors: usize) {
+    fn set_error_on_marked_item(&mut self, num_errors: usize) {
         if let Some(d) = self
             .selected
             .and_then(|s| self.tree_index_by_list_position(s))