From 3326f7b727b512e5fdd2e75cc52bb771897ba9a0 Mon Sep 17 00:00:00 2001 From: Sebastian Doerner Date: Thu, 24 Oct 2024 14:01:07 +0200 Subject: [PATCH] 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 https://github.com/helix-editor/helix/discussions/11589#discussioncomment-10922295. --- helix-term/src/commands/typed.rs | 82 ++++++++++++++++++++++---------- helix-term/src/ui/mod.rs | 57 +++++++++++++++++++--- 2 files changed, 108 insertions(+), 31 deletions(-) diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs index 4e912127c..6cd7f9a64 100644 --- a/helix-term/src/commands/typed.rs +++ b/helix-term/src/commands/typed.rs @@ -100,34 +100,59 @@ 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) -> (Cow, 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) { + 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 = 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::>>()?; + 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 +2625,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 }, }, diff --git a/helix-term/src/ui/mod.rs b/helix-term/src/ui/mod.rs index a76adbe21..aa2f2fedf 100644 --- a/helix-term/src/ui/mod.rs +++ b/helix-term/src/ui/mod.rs @@ -193,21 +193,55 @@ pub struct FilePickerData { type FilePicker = Picker; pub fn file_picker(editor: &Editor, root: PathBuf) -> FilePicker { + let roots = vec![root]; + file_picker_multiple_roots(editor, roots) +} + +fn longest_common_prefix(paths: &[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 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..].iter().map(|p| p.components()).collect(); + 'components: for first_path_component in first_path_components { + 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) -> 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 dedup_symlinks = config.file_picker.deduplicate_links; - let absolute_root = root.canonicalize().unwrap_or_else(|_| root.clone()); + 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 = 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 +254,10 @@ 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() {