Fix refresh with multiple input paths

src/interactive/app/eventloop.rs

@@ -64,11 +64,11 @@ impl AppState {
         result
     }
 
-    pub fn traverse(&mut self, traversal: &Traversal, input: Vec<PathBuf>) -> Result<()> {
+    pub fn traverse(&mut self, traversal: &Traversal) -> Result<()> {
         let traverasal = BackgroundTraversal::start(
             traversal.root_index,
             &self.walk_options,
-            input,
+            self.input.clone(),
             false,
             true,
         )?;
@@ -380,28 +380,63 @@ impl AppState {
             }
         }
 
-        let (remove_root_node, skip_root, index, parent_index) = match what {
+        let (paths, remove_root_node, skip_root, use_root_path, index, parent_index) = match what {
             Refresh::Selected => {
                 let Some(selected) = self.navigation().selected else {
                     return Ok(());
                 };
                 let parent_index = tree
                     .fs_parent_of(selected)
                     .expect("there is always a parent to a selection");
-                (true, false, selected, parent_index)
+
+                let mut path = tree.path_of(selected);
+                if path.to_str() == Some("") {
+                    path = PathBuf::from(".");
+                }
+
+                let (paths, use_root_path, skip_root) = if self.navigation().view_root
+                    == tree.traversal.root_index
+                    && self.input.len() > 1
+                {
+                    (vec![path], true, false)
+                } else {
+                    (vec![path], false, false)
+                };
+
+                (
+                    paths,
+                    true,
+                    skip_root,
+                    use_root_path,
+                    selected,
+                    parent_index,
+                )
+            }
+            Refresh::AllInView => {
+                let (paths, use_root_path, skip_root) = if self.navigation().view_root
+                    == tree.traversal.root_index
+                    && self.input.len() > 1
+                {
+                    (self.input.clone(), true, false)
+                } else {
+                    let mut path = tree.path_of(self.navigation().view_root);
+                    if path.to_str() == Some("") {
+                        path = PathBuf::from(".");
+                    }
+                    (vec![path], false, true)
+                };
+
+                (
+                    paths,
+                    false,
+                    skip_root,
+                    use_root_path,
+                    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_root_node);
         tree.recompute_sizes_recursively(parent_index);
 
@@ -412,9 +447,9 @@ impl AppState {
             active_traversal: BackgroundTraversal::start(
                 parent_index,
                 &self.walk_options,
-                vec![path],
+                paths,
                 skip_root,
-                false,
+                use_root_path,
             )?,
             previous_selection,
         });

src/interactive/app/state.rs

@@ -42,10 +42,11 @@ pub struct AppState {
     pub scan: Option<FilesystemScan>,
     pub stats: TraversalStats,
     pub walk_options: WalkOptions,
+    pub input: Vec<PathBuf>,
 }
 
 impl AppState {
-    pub fn new(walk_options: WalkOptions) -> Self {
+    pub fn new(walk_options: WalkOptions, input: Vec<PathBuf>) -> Self {
         AppState {
             navigation: Default::default(),
             glob_navigation: None,
@@ -58,6 +59,7 @@ impl AppState {
             scan: None,
             stats: TraversalStats::default(),
             walk_options,
+            input,
         }
     }
 }

src/interactive/app/terminal.rs

@@ -28,6 +28,7 @@ impl TerminalApp {
         terminal: &mut Terminal<B>,
         walk_options: WalkOptions,
         byte_format: ByteFormat,
+        input: Vec<PathBuf>,
     ) -> Result<TerminalApp>
     where
         B: Backend,
@@ -38,7 +39,7 @@ impl TerminalApp {
         let display = DisplayOptions::new(byte_format);
         let window = MainWindow::default();
 
-        let mut state = AppState::new(walk_options);
+        let mut state = AppState::new(walk_options, input);
         let traversal = Traversal::new();
         let stats = TraversalStats::default();
 
@@ -61,8 +62,8 @@ impl TerminalApp {
         Ok(app)
     }
 
-    pub fn traverse(&mut self, input: Vec<PathBuf>) -> Result<()> {
-        self.state.traverse(&self.traversal, input)?;
+    pub fn traverse(&mut self) -> Result<()> {
+        self.state.traverse(&self.traversal)?;
         Ok(())
     }
 

src/interactive/app/tests/utils.rs

@@ -196,10 +196,11 @@ pub fn initialized_app_and_terminal_with_closure(
     };
 
     let (_key_send, key_receive) = crossbeam::channel::bounded(0);
-    let mut app = TerminalApp::initialize(&mut terminal, walk_options, ByteFormat::Metric)?;
-
     let input_paths = fixture_paths.iter().map(|c| convert(c.as_ref())).collect();
-    app.traverse(input_paths)?;
+
+    let mut app =
+        TerminalApp::initialize(&mut terminal, walk_options, ByteFormat::Metric, input_paths)?;
+    app.traverse()?;
     app.run_until_traversed(&mut terminal, key_receive)?;
 
     Ok((terminal, app))

src/main.rs

@@ -77,8 +77,13 @@ fn main() -> Result<()> {
             .with_context(|| "Could not instantiate terminal")?;
 
             let keys_rx = input_channel();
-            let mut app = TerminalApp::initialize(&mut terminal, walk_options, byte_format)?;
-            app.traverse(extract_paths_maybe_set_cwd(input, !opt.stay_on_filesystem)?)?;
+            let mut app = TerminalApp::initialize(
+                &mut terminal,
+                walk_options,
+                byte_format,
+                extract_paths_maybe_set_cwd(input, !opt.stay_on_filesystem)?,
+            )?;
+            app.traverse()?;
 
             let res = app.process_events(&mut terminal, keys_rx);