Improve sorting for the file picker

helix-term/src/application.rs

@@ -120,7 +120,11 @@ impl Application {
             if first.is_dir() {
                 std::env::set_current_dir(&first)?;
                 editor.new_file(Action::VerticalSplit);
-                compositor.push(Box::new(ui::file_picker(".".into(), &config.editor)));
+                compositor.push(Box::new(ui::file_picker(
+                    ".".into(),
+                    Some(".".into()),
+                    &config.editor,
+                )));
             } else {
                 let nr_of_files = args.files.len();
                 editor.open(first.to_path_buf(), Action::VerticalSplit)?;

helix-term/src/commands.rs

@@ -1575,6 +1575,7 @@ fn global_search(cx: &mut Context) {
                         align_view(doc, view, Align::Center);
                     },
                     |_editor, (line_num, path)| Some((path.clone(), Some((*line_num, *line_num)))),
+                    |_, l_score, _, r_score| l_score.cmp(&r_score).reverse(),
                 );
                 compositor.push(Box::new(picker));
             });
@@ -2757,7 +2758,8 @@ fn command_mode(cx: &mut Context) {
 
 fn file_picker(cx: &mut Context) {
     let root = find_root(None).unwrap_or_else(|| PathBuf::from("./"));
-    let picker = ui::file_picker(root, &cx.editor.config);
+    let current_dir = std::env::current_dir().ok();
+    let picker = ui::file_picker(root, current_dir, &cx.editor.config);
     cx.push_layer(Box::new(picker));
 }
 
@@ -2825,6 +2827,7 @@ fn buffer_picker(cx: &mut Context) {
                 .cursor_line(doc.text().slice(..));
             Some((meta.path.clone()?, Some((line, line))))
         },
+        |_, l_score, _, r_score| l_score.cmp(&r_score).reverse(),
     );
     cx.push_layer(Box::new(picker));
 }
@@ -2902,6 +2905,7 @@ fn symbol_picker(cx: &mut Context) {
                         ));
                         Some((path, line))
                     },
+                    |_, l_score, _, r_score| l_score.cmp(&r_score).reverse(),
                 );
                 picker.truncate_start = false;
                 compositor.push(Box::new(picker))
@@ -2964,6 +2968,7 @@ fn workspace_symbol_picker(cx: &mut Context) {
                         ));
                         Some((path, line))
                     },
+                    |_, l_score, _, r_score| l_score.cmp(&r_score).reverse(),
                 );
                 picker.truncate_start = false;
                 compositor.push(Box::new(picker))
@@ -3016,6 +3021,7 @@ pub fn code_action(cx: &mut Context) {
                             }
                         }
                     },
+                    |_, l_score, _, r_score| l_score.cmp(&r_score).reverse(),
                 );
                 compositor.push(Box::new(picker))
             }
@@ -3530,6 +3536,7 @@ fn goto_impl(
                     ));
                     Some((path, line))
                 },
+                |_, l_score, _, r_score| l_score.cmp(&r_score).reverse(),
             );
             compositor.push(Box::new(picker));
         }

helix-term/src/ui/mod.rs

@@ -24,6 +24,10 @@ use helix_core::regex::RegexBuilder;
 use helix_view::{Document, Editor, View};
 
 use std::path::PathBuf;
+use std::time::SystemTime;
+
+/// The bonus that is given to the score of files that are contained in the current directory in the file picker.
+const FILE_CURRENT_DIR_BONUS: i64 = 5;
 
 pub fn regex_prompt(
     cx: &mut crate::commands::Context,
@@ -93,7 +97,11 @@ pub fn regex_prompt(
     )
 }
 
-pub fn file_picker(root: PathBuf, config: &helix_view::editor::Config) -> FilePicker<PathBuf> {
+pub fn file_picker(
+    root: PathBuf,
+    current_dir: Option<PathBuf>,
+    config: &helix_view::editor::Config,
+) -> FilePicker<(PathBuf, SystemTime, bool)> {
     use ignore::{types::TypesBuilder, WalkBuilder};
     use std::time;
 
@@ -136,37 +144,52 @@ pub fn file_picker(root: PathBuf, config: &helix_view::editor::Config) -> FilePi
                 .or_else(|_| metadata.created())
                 .unwrap_or(time::UNIX_EPOCH)
         });
+        let in_current_dir = match &current_dir {
+            Some(current_dir) => entry.path().starts_with(current_dir),
+            None => false,
+        };
 
-        Some((entry.into_path(), time))
+        Some((entry.into_path(), time, in_current_dir))
     });
 
-    let mut files: Vec<_> = if root.join(".git").is_dir() {
+    let files: Vec<_> = if root.join(".git").is_dir() {
         files.collect()
     } else {
         const MAX: usize = 8192;
         files.take(MAX).collect()
     };
 
-    files.sort_by_key(|file| std::cmp::Reverse(file.1));
-
-    let files = files.into_iter().map(|(path, _)| path).collect();
-
     FilePicker::new(
         files,
-        move |path: &PathBuf| {
+        move |(path, _, _)| {
             // format_fn
             path.strip_prefix(&root)
                 .unwrap_or(path)
                 .to_str()
                 .unwrap()
                 .into()
         },
-        move |editor: &mut Editor, path: &PathBuf, action| {
+        move |editor: &mut Editor, (path, _, _), action| {
             editor
                 .open(path.into(), action)
                 .expect("editor.open failed");
         },
-        |_editor, path| Some((path.clone(), None)),
+        |_editor, (path, _, _)| Some((path.clone(), None)),
+        |(_, l_time, l_in_current_dir), mut l_score, (_, r_time, r_in_current_dir), mut r_score| {
+            // Sort the matches of the picker by:
+            // * The closeness of the file name to the search with a small boost being given to files in the current directory
+            // * As a tie-breaker, use the timestamp of the file
+            if *l_in_current_dir {
+                l_score += FILE_CURRENT_DIR_BONUS;
+            }
+            if *r_in_current_dir {
+                r_score += FILE_CURRENT_DIR_BONUS;
+            }
+            l_score
+                .cmp(&r_score)
+                .reverse()
+                .then_with(|| l_time.cmp(r_time).reverse())
+        },
     )
 }
 

helix-term/src/ui/picker.rs

@@ -15,6 +15,7 @@ use tui::widgets::Widget;
 
 use std::{
     borrow::Cow,
+    cmp::Ordering,
     collections::HashMap,
     io::Read,
     path::{Path, PathBuf},
@@ -70,7 +71,7 @@ impl Preview<'_, '_> {
 
     /// Alternate text to show for the preview.
     fn placeholder(&self) -> &str {
-        match *self {
+        match self {
             Self::EditorDocument(_) => "<File preview>",
             Self::Cached(preview) => match preview {
                 CachedPreview::Document(_) => "<File preview>",
@@ -88,9 +89,10 @@ impl<T> FilePicker<T> {
         format_fn: impl Fn(&T) -> Cow<str> + 'static,
         callback_fn: impl Fn(&mut Editor, &T, Action) + 'static,
         preview_fn: impl Fn(&Editor, &T) -> Option<FileLocation> + 'static,
+        sort_fn: impl Fn(&T, i64, &T, i64) -> Ordering + 'static,
     ) -> Self {
         Self {
-            picker: Picker::new(false, options, format_fn, callback_fn),
+            picker: Picker::new(false, options, format_fn, callback_fn, sort_fn),
             truncate_start: true,
             preview_cache: HashMap::new(),
             read_buffer: Vec::with_capacity(1024),
@@ -285,6 +287,9 @@ pub struct Picker<T> {
 
     format_fn: Box<dyn Fn(&T) -> Cow<str>>,
     callback_fn: Box<dyn Fn(&mut Editor, &T, Action)>,
+    /// This function specifies the ordering of any 2 matches given as (l_element, l_matching_score, r_element, r_matching_score).
+    /// The matches are sorted in ascending order, so the highest priority match should be the smallest element in terms of this ordering.
+    sort_fn: Box<dyn Fn(&T, i64, &T, i64) -> Ordering>,
 }
 
 impl<T> Picker<T> {
@@ -293,6 +298,7 @@ impl<T> Picker<T> {
         options: Vec<T>,
         format_fn: impl Fn(&T) -> Cow<str> + 'static,
         callback_fn: impl Fn(&mut Editor, &T, Action) + 'static,
+        sort_fn: impl Fn(&T, i64, &T, i64) -> Ordering + 'static,
     ) -> Self {
         let prompt = Prompt::new(
             "".into(),
@@ -314,6 +320,7 @@ impl<T> Picker<T> {
             truncate_start: true,
             format_fn: Box::new(format_fn),
             callback_fn: Box::new(callback_fn),
+            sort_fn: Box::new(sort_fn),
         };
 
         // TODO: scoring on empty input should just use a fastpath
@@ -344,7 +351,15 @@ impl<T> Picker<T> {
                         .map(|score| (index, score))
                 }),
         );
-        self.matches.sort_unstable_by_key(|(_, score)| -score);
+        self.matches
+            .sort_unstable_by(|(l_idx, l_score), (r_idx, r_score)| {
+                (self.sort_fn)(
+                    &self.options[*l_idx],
+                    *l_score,
+                    &self.options[*r_idx],
+                    *r_score,
+                )
+            });
 
         // reset cursor position
         self.cursor = 0;