Flag for the open command to show a single picker for multiple dirs.

 - The picker root is the common prefix path of all directories.
 - Shows an error if non-directories are supplied.
 - Flag naming seemed difficult, but I ended up with "single_picker" (-s). Happy to change that if someone has a better idea.

Future work:
 - multiplex between filename and directory completers based on flag presence

The main motivation for this are large mono-repos, where each developer cares about a certain subset of directories that they tend to work in, which are not under a common root.

This was previously discussed in #11589, but flags seem like an obvious and better alternative to the ideas presented in #11589 (comment).

Author: sdoerner

helix-term/src/commands/typed.rs

@@ -100,34 +100,56 @@ fn force_quit(cx: &mut compositor::Context, _args: Args, event: PromptEvent) ->
 }
 
 fn open(cx: &mut compositor::Context, args: Args, event: PromptEvent) -> anyhow::Result<()> {
+    fn parse(arg:Cow<str>) ->(Cow<Path>, Position) {
+        let (path, pos) = crate::args::parse_file(&arg);
+        let path = helix_stdx::path::expand_tilde(path);
+        (path, pos)
+    }
+
+    fn show_picker(cx: &mut compositor::Context, dirs: Vec<PathBuf>) {
+        let callback = async move {
+            let call: job::Callback = job::Callback::EditorCompositor(Box::new(
+                move |editor: &mut Editor, compositor: &mut Compositor| {
+                    let picker = ui::file_picker_multiple_roots(editor, dirs);
+                    compositor.push(Box::new(overlaid(picker)));
+                },
+            ));
+            Ok(call)
+        };
+        cx.jobs.callback(callback);
+    }
     if event != PromptEvent::Validate {
         return Ok(());
     }
 
-    for arg in args {
-        let (path, pos) = crate::args::parse_file(&arg);
-        let path = helix_stdx::path::expand_tilde(path);
-        // If the path is a directory, open a file picker on that directory and update the status
-        // message
-        if let Ok(true) = std::fs::canonicalize(&path).map(|p| p.is_dir()) {
-            let callback = async move {
-                let call: job::Callback = job::Callback::EditorCompositor(Box::new(
-                    move |editor: &mut Editor, compositor: &mut Compositor| {
-                        let picker = ui::file_picker(editor, path.into_owned());
-                        compositor.push(Box::new(overlaid(picker)));
-                    },
-                ));
-                Ok(call)
-            };
-            cx.jobs.callback(callback);
-        } else {
-            // Otherwise, just open the file
-            let _ = cx.editor.open(&path, Action::Replace)?;
-            let (view, doc) = current!(cx.editor);
-            let pos = Selection::point(pos_at_coords(doc.text().slice(..), pos, true));
-            doc.set_selection(view.id, pos);
-            // does not affect opening a buffer without pos
-            align_view(doc, view, Align::Center);
+    if args.has_flag("single_picker") {
+        let dirs: Vec<PathBuf> = args.into_iter().map(|a| {
+            let path = std::fs::canonicalize(&parse(a).0)?;
+            if !path.is_dir() {
+                bail!("argument {} is not a directory", path.to_string_lossy());
+            }
+            Ok(path)
+        }).collect::<anyhow::Result<Vec<_>>>()?;
+        if !dirs.is_empty() {
+            show_picker(cx, dirs);
+        }
+    } else {
+        for arg in args {
+            let (path, pos) = parse(arg);
+            // If the path is a directory, open a file picker on that directory and update the
+            // status message
+            if let Ok(true) = std::fs::canonicalize(&path).map(|p| p.is_dir()) {
+                let dirs = vec![path.into_owned()];
+                show_picker(cx, dirs);
+            } else {
+                // Otherwise, just open the file
+                let _ = cx.editor.open(&path, Action::Replace)?;
+                let (view, doc) = current!(cx.editor);
+                let pos = Selection::point(pos_at_coords(doc.text().slice(..), pos, true));
+                doc.set_selection(view.id, pos);
+                // does not affect opening a buffer without pos
+                align_view(doc, view, Align::Center);
+            }
         }
     }
     Ok(())
@@ -2600,9 +2622,18 @@ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[
         aliases: &["o", "edit", "e"],
         doc: "Open a file from disk into the current view.",
         fun: open,
+        // TODO: Use completers::directory if -s flag is supplied.
         completer: CommandCompleter::all(completers::filename),
         signature: Signature {
             positionals: (1, None),
+            flags: &[
+                Flag {
+                    name: "single_picker",
+                    alias: Some('s'),
+                    doc: "Show a single picker using multiple root directories.",
+                    ..Flag::DEFAULT
+                },
+            ],
             ..Signature::DEFAULT
         },
     },

helix-term/src/ui/mod.rs

@@ -193,21 +193,54 @@ pub struct FilePickerData {
 type FilePicker = Picker<PathBuf, FilePickerData>;
 
 pub fn file_picker(editor: &Editor, root: PathBuf) -> FilePicker {
+    let roots = vec![root];
+    file_picker_multiple_roots(editor, roots)
+}
+
+fn longest_common_prefix(paths: &Vec<PathBuf>) -> PathBuf {
+    if paths.is_empty() {
+        panic!("Got empty paths list")
+    }
+    // Optimize common case.
+    if paths.len() == 1 {
+        return paths[0].clone();
+    }
+    let mut num_common_components = 0;
+    let mut first_path_components = paths[0].components();
+    // Store path component references in a Vec so we can iterate it multiple times.
+    let mut all_paths_components: Vec<_> = paths[1..].into_iter().map(|p|p.components()).collect();
+    'components: while let Some(first_path_component) = first_path_components.next() {
+        for components in &mut all_paths_components {
+            let component = components.next();
+            if component.is_none() || component.is_some_and(|c| c!= first_path_component) {
+                break 'components;
+            }
+        }
+        // All paths matched in this component.
+        num_common_components += 1;
+    }
+
+    paths[0].components().take(num_common_components).collect()
+}
+
+pub fn file_picker_multiple_roots(editor: &Editor, roots: Vec<PathBuf>) -> FilePicker {
+    if roots.is_empty() {
+        panic!("Expected non-empty argument roots.")
+        
+    }
     use ignore::{types::TypesBuilder, WalkBuilder};
     use std::time::Instant;
 
     let config = editor.config();
-    let data = FilePickerData {
-        root: root.clone(),
-        directory_style: editor.theme.get("ui.text.directory"),
-    };
 
     let now = Instant::now();
 
+    let common_root: PathBuf = longest_common_prefix(&roots);
+
+    let mut walk_builder = WalkBuilder::new(&roots[0]);
     let dedup_symlinks = config.file_picker.deduplicate_links;
-    let absolute_root = root.canonicalize().unwrap_or_else(|_| root.clone());
+    let absolute_root = common_root.canonicalize().unwrap_or_else(|_| roots[0].clone());
 
-    let mut walk_builder = WalkBuilder::new(&root);
     walk_builder
         .hidden(config.file_picker.hidden)
         .parents(config.file_picker.parents)
@@ -220,6 +253,11 @@ pub fn file_picker(editor: &Editor, root: PathBuf) -> FilePicker {
         .max_depth(config.file_picker.max_depth)
         .filter_entry(move |entry| filter_picker_entry(entry, &absolute_root, dedup_symlinks));
 
+    for additional_root in &roots[1..] {
+        walk_builder.add(additional_root);
+    }
+
+
     walk_builder.add_custom_ignore_filename(helix_loader::config_dir().join("ignore"));
     walk_builder.add_custom_ignore_filename(".helix/ignore");
 
@@ -264,6 +302,11 @@ pub fn file_picker(editor: &Editor, root: PathBuf) -> FilePicker {
             Spans::from(spans).into()
         },
     )];
+
+    let data = FilePickerData {
+        root: common_root,
+        directory_style: editor.theme.get("ui.text.directory"),
+    };
     let picker = Picker::new(columns, 0, [], data, move |cx, path: &PathBuf, action| {
         if let Err(e) = cx.editor.open(path, action) {
             let err = if let Some(err) = e.source() {