FEAT: Add labelled buffer picker

helix-term/src/commands.rs

@@ -45,7 +45,7 @@ use helix_view::{
     document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
     editor::Action,
     info::Info,
-    input::KeyEvent,
+    input::{Event, KeyEvent, KeyModifiers},
     keyboard::KeyCode,
     theme::Style,
     tree,
@@ -58,10 +58,13 @@ use insert::*;
 use movement::Movement;
 
 use crate::{
-    compositor::{self, Component, Compositor},
+    compositor::{self, Component, Compositor, EventResult},
     filter_picker_entry,
     job::Callback,
-    ui::{self, overlay::overlaid, Picker, PickerColumn, Popup, Prompt, PromptEvent},
+    ui::{
+        self, overlay::overlaid, picker::PickerSideEffect, Picker, PickerColumn, Popup, Prompt,
+        PromptEvent,
+    },
 };
 
 use crate::job::{self, Jobs};
@@ -78,6 +81,7 @@ use std::{
 
 use std::{
     borrow::Cow,
+    iter,
     path::{Path, PathBuf},
 };
 
@@ -402,6 +406,7 @@ impl MappableCommand {
         file_explorer_in_current_buffer_directory, "Open file explorer at current buffer's directory",
         file_explorer_in_current_directory, "Open file explorer at current working directory",
         code_action, "Perform code action",
+        labelled_buffer_picker, "Open labelled buffer picker",
         buffer_picker, "Open buffer picker",
         jumplist_picker, "Open jumplist picker",
         symbol_picker, "Open symbol picker",
@@ -3113,36 +3118,79 @@ fn file_explorer_in_current_directory(cx: &mut Context) {
     }
 }
 
-fn buffer_picker(cx: &mut Context) {
+fn iter_newbase(n: u32, base: u32) -> impl Iterator<Item = u32> {
+    let mut num = n;
+    let mut divisor = 1;
+    while divisor * base <= n {
+        divisor *= base;
+    }
+    iter::from_fn(move || {
+        if divisor <= 0 {
+            return None;
+        }
+        let digit = num / divisor;
+        num %= divisor;
+        divisor /= base;
+        Some(digit)
+    })
+}
+
+fn ord_label_nopad(ord: u32, labels: &[char]) -> impl Iterator<Item = char> + '_ {
+    iter_newbase(ord, labels.len() as u32)
+        .map(|i| labels.get(i as usize))
+        .filter_map(|o| o)
+        .map(|r| *r)
+}
+
+fn ord_label(ord: u32, max: u32, labels: &[char]) -> Vec<char> {
+    let max_len = ord_label_nopad(max, labels).count();
+    let label_nopad: Vec<char> = ord_label_nopad(ord, labels).collect();
+    iter::repeat(labels[0])
+        .take(max_len - label_nopad.len())
+        .chain(label_nopad.into_iter())
+        .collect()
+}
+
+#[derive(Clone)]
+struct BufferMeta {
+    id: DocumentId,
+    label: Vec<char>,
+    path: Option<PathBuf>,
+    is_modified: bool,
+    is_current: bool,
+    focused_at: std::time::Instant,
+}
+
+fn get_buffers(cx: &mut Context) -> Vec<BufferMeta> {
     let current = view!(cx.editor).doc;
 
-    struct BufferMeta {
+    let labels = &cx.editor.config().buffer_picker.label_alphabet;
-        id: DocumentId,
-        path: Option<PathBuf>,
-        is_modified: bool,
-        is_current: bool,
-        focused_at: std::time::Instant,
-    }
 
-    let new_meta = |doc: &Document| BufferMeta {
+    let new_meta = |(i, doc): (usize, &Document)| BufferMeta {
         id: doc.id(),
         path: doc.path().cloned(),
         is_modified: doc.is_modified(),
         is_current: doc.id() == current,
         focused_at: doc.focused_at,
+        label: ord_label(i as u32, cx.editor.documents.len() as u32, labels),
     };
 
-    let mut items = cx
+    cx.editor
-        .editor
         .documents
         .values()
+        .enumerate()
         .map(new_meta)
-        .collect::<Vec<BufferMeta>>();
+        .collect::<Vec<BufferMeta>>()
+}
 
-    // mru
+fn get_buffers_mru(cx: &mut Context) -> Vec<BufferMeta> {
-    items.sort_unstable_by_key(|item| std::cmp::Reverse(item.focused_at));
+    let mut buffers = get_buffers(cx);
+    buffers.sort_unstable_by_key(|item| std::cmp::Reverse(item.focused_at));
+    buffers
+}
 
-    let columns = [
+fn get_buffer_picker_columns<T>() -> impl IntoIterator<Item = PickerColumn<BufferMeta, T>> {
+    [
         PickerColumn::new("id", |meta: &BufferMeta, _| meta.id.to_string().into()),
         PickerColumn::new("flags", |meta: &BufferMeta, _| {
             let mut flags = String::new();
@@ -3165,10 +3213,97 @@ fn buffer_picker(cx: &mut Context) {
                 .to_string()
                 .into()
         }),
-    ];
+    ]
-    let picker = Picker::new(columns, 2, items, (), |cx, meta, action| {
+}
-        cx.editor.switch(meta.id, action);
+
-    })
+fn get_labelled_buffer_picker_columns<T>() -> impl IntoIterator<Item = PickerColumn<BufferMeta, T>>
+{
+    iter::once(PickerColumn::new("label", |meta: &BufferMeta, _| {
+        (&meta.label).into()
+    }))
+    .chain(get_buffer_picker_columns())
+}
+
+fn labelled_buffer_picker(cx: &mut Context) {
+    let items = get_buffers(cx);
+
+    let labels = &cx.editor.config().buffer_picker.label_alphabet;
+    let max_label = ord_label_nopad(cx.editor.documents.len() as u32, labels).count();
+
+    let mut chars_read = 0;
+    let mut matching: Vec<bool> = iter::repeat(true).take(items.len()).collect();
+
+    let picker = Picker::new(
+        get_labelled_buffer_picker_columns(),
+        2,
+        items.clone(),
+        (),
+        |cx, meta, action| {
+            cx.editor.switch(meta.id, action);
+        },
+    )
+    .with_text_typing_handler(
+        move |event: &Event, cx: &mut compositor::Context| -> (PickerSideEffect, EventResult) {
+            if let Event::Key(KeyEvent {
+                code: KeyCode::Char(c),
+                modifiers: KeyModifiers::NONE,
+            }) = event
+            {
+                chars_read += 1;
+                if chars_read > max_label {
+                    // TODO: raise message that match failed (invalid key sequence)
+                    chars_read = 0;
+                    matching.iter_mut().for_each(|v| *v = true);
+                    return (PickerSideEffect::None, EventResult::Consumed(None));
+                }
+                let idx = chars_read - 1;
+                items.iter().enumerate().for_each(|(i, item)| {
+                    if *c != item.label[idx] {
+                        matching[i] = false;
+                    }
+                });
+                let nmatches = matching.iter().fold(0, |acc, &c| acc + c as i32);
+                if nmatches == 0 {
+                    // TODO: raise message that match failed (invalid key sequence)
+                    chars_read = 0;
+                    matching.iter_mut().for_each(|v| *v = true);
+                } else if nmatches == 1 {
+                    // unique match found
+                    let match_idx = matching
+                        .iter()
+                        .enumerate()
+                        .find(|(_, c)| **c)
+                        .map(|(i, _)| i)
+                        .unwrap();
+                    cx.editor.switch(items[match_idx].id, Action::Replace);
+                    return (PickerSideEffect::Close, EventResult::Consumed(None));
+                }
+            }
+            (PickerSideEffect::None, EventResult::Consumed(None))
+        },
+    )
+    .with_preview(|editor, meta| {
+        let doc = &editor.documents.get(&meta.id)?;
+        let lines = doc.selections().values().next().map(|selection| {
+            let cursor_line = selection.primary().cursor_line(doc.text().slice(..));
+            (cursor_line, cursor_line)
+        });
+        Some((meta.id.into(), lines))
+    });
+    cx.push_layer(Box::new(overlaid(picker)));
+}
+
+fn buffer_picker(cx: &mut Context) {
+    let items = get_buffers_mru(cx);
+    let picker = Picker::new(
+        get_buffer_picker_columns(),
+        2,
+        items,
+        (),
+        |cx, meta, action| {
+            cx.editor.switch(meta.id, action);
+        },
+    )
     .with_preview(|editor, meta| {
         let doc = &editor.documents.get(&meta.id)?;
         let lines = doc.selections().values().next().map(|selection| {

helix-term/src/keymap/default.rs

@@ -57,6 +57,7 @@ pub fn default() -> HashMap<Mode, KeyTrie> {
             "p" => goto_previous_buffer,
             "k" => move_line_up,
             "j" => move_line_down,
+            "o" => labelled_buffer_picker,
             "." => goto_last_modification,
             "w" => goto_word,
         },

helix-term/src/ui/picker.rs

@@ -29,14 +29,10 @@ use tui::{
 use tui::widgets::Widget;
 
 use std::{
-    borrow::Cow,
+    borrow::Cow, collections::HashMap, io::Read, path::Path, sync::{
-    collections::HashMap,
-    io::Read,
-    path::Path,
-    sync::{
         atomic::{self, AtomicUsize},
         Arc,
-    },
+    }
 };
 
 use crate::ui::{Prompt, PromptEvent};
@@ -238,6 +234,11 @@ impl<T, D> Column<T, D> {
 type DynQueryCallback<T, D> =
     fn(&str, &mut Editor, Arc<D>, &Injector<T, D>) -> BoxFuture<'static, anyhow::Result<()>>;
 
+pub enum PickerSideEffect {
+    Close,
+    None,
+}
+
 pub struct Picker<T: 'static + Send + Sync, D: 'static> {
     columns: Arc<[Column<T, D>]>,
     primary_column: usize,
@@ -250,6 +251,7 @@ pub struct Picker<T: 'static + Send + Sync, D: 'static> {
 
     cursor: u32,
     prompt: Prompt,
+    custom_handle_event: Option<Box<dyn FnMut(&Event, &mut Context) -> (PickerSideEffect, EventResult)>>,
     query: PickerQuery,
 
     /// Whether to show the preview panel (default true)
@@ -378,6 +380,7 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
             version,
             cursor: 0,
             prompt,
+            custom_handle_event: None,
             query,
             truncate_start: true,
             show_preview: true,
@@ -408,6 +411,14 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
         self
     }
 
+    pub fn with_text_typing_handler<C>(mut self, handle_event: C) -> Self
+    where 
+        C: FnMut(&Event, &mut Context) -> (PickerSideEffect, EventResult) + 'static,
+    {
+        self.custom_handle_event = Some(Box::new(handle_event));
+        self
+    }
+
     pub fn with_preview(
         mut self,
         preview_fn: impl for<'a> Fn(&'a Editor, &'a T) -> Option<FileLocation<'a>> + 'static,
@@ -516,6 +527,17 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
         EventResult::Consumed(None)
     }
 
+    fn typing_handle_event(&mut self, event: &Event, cx: &mut Context) -> EventResult {
+        self
+            .custom_handle_event.as_mut()
+            .map(|handler| (handler)(event, cx))
+            .map(|(se, ev)| match se {
+                PickerSideEffect::Close => self.close_from_event(),
+                PickerSideEffect::None => ev,
+            })
+            .unwrap_or_else(|| self.prompt_handle_event(event, cx))
+    }
+
     fn handle_prompt_change(&mut self, is_paste: bool) {
         // TODO: better track how the pattern has changed
         let line = self.prompt.line();
@@ -698,28 +720,33 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
         let line_area = area.clip_right(count.len() as u16 + 1);
 
         // render the prompt first since it will clear its background
-        self.prompt.render(line_area, surface, cx);
+        if self.custom_handle_event.is_none() {
+            self.prompt.render(line_area, surface, cx);
 
-        surface.set_stringn(
+            surface.set_stringn(
-            (area.x + area.width).saturating_sub(count.len() as u16 + 1),
+                (area.x + area.width).saturating_sub(count.len() as u16 + 1),
-            area.y,
+                area.y,
-            &count,
+                &count,
-            (count.len()).min(area.width as usize),
+                (count.len()).min(area.width as usize),
-            text_style,
+                text_style,
-        );
+            );
 
-        // -- Separator
+            // -- Separator
-        let sep_style = cx.editor.theme.get("ui.background.separator");
+            let sep_style = cx.editor.theme.get("ui.background.separator");
-        let borders = BorderType::line_symbols(BorderType::Plain);
+            let borders = BorderType::line_symbols(BorderType::Plain);
-        for x in inner.left()..inner.right() {
+            for x in inner.left()..inner.right() {
-            if let Some(cell) = surface.get_mut(x, inner.y + 1) {
+                if let Some(cell) = surface.get_mut(x, inner.y + 1) {
-                cell.set_symbol(borders.horizontal).set_style(sep_style);
+                    cell.set_symbol(borders.horizontal).set_style(sep_style);
+                }
             }
         }
 
+        // We only reserve space if prompt is drawn
+        let clip = if self.custom_handle_event.is_some() { 0 } else { 2 };
+
         // -- Render the contents:
         // subtract area of prompt from top
-        let inner = inner.clip_top(2);
+        let inner = inner.clip_top(clip);
         let rows = inner.height.saturating_sub(self.header_height()) as u32;
         let offset = self.cursor - (self.cursor % std::cmp::max(1, rows));
         let cursor = self.cursor.saturating_sub(offset);
@@ -984,6 +1011,29 @@ impl<T: 'static + Send + Sync, D: 'static + Send + Sync> Picker<T, D> {
             );
         }
     }
+
+    pub fn close_from_event(&mut self) -> EventResult {
+        // if the picker is very large don't store it as last_picker to avoid
+        // excessive memory consumption
+        let callback: compositor::Callback = if self.matcher.snapshot().item_count() > 100_000
+        {
+            Box::new(|compositor: &mut Compositor, _ctx| {
+                // remove the layer
+                compositor.pop();
+            })
+        } else {
+            // stop streaming in new items in the background, really we should
+            // be restarting the stream somehow once the picker gets
+            // reopened instead (like for an FS crawl) that would also remove the
+            // need for the special case above but that is pretty tricky
+            self.version.fetch_add(1, atomic::Ordering::Relaxed);
+            Box::new(|compositor: &mut Compositor, _ctx| {
+                // remove the layer
+                compositor.last_picker = compositor.pop();
+            })
+        };
+        EventResult::Consumed(Some(callback))
+    }
 }
 
 impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I, D> {
@@ -1018,34 +1068,11 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I,
 
         let key_event = match event {
             Event::Key(event) => *event,
-            Event::Paste(..) => return self.prompt_handle_event(event, ctx),
+            Event::Paste(..) => return self.typing_handle_event(event, ctx),
             Event::Resize(..) => return EventResult::Consumed(None),
             _ => return EventResult::Ignored(None),
         };
 
-        let close_fn = |picker: &mut Self| {
-            // if the picker is very large don't store it as last_picker to avoid
-            // excessive memory consumption
-            let callback: compositor::Callback = if picker.matcher.snapshot().item_count() > 100_000
-            {
-                Box::new(|compositor: &mut Compositor, _ctx| {
-                    // remove the layer
-                    compositor.pop();
-                })
-            } else {
-                // stop streaming in new items in the background, really we should
-                // be restarting the stream somehow once the picker gets
-                // reopened instead (like for an FS crawl) that would also remove the
-                // need for the special case above but that is pretty tricky
-                picker.version.fetch_add(1, atomic::Ordering::Relaxed);
-                Box::new(|compositor: &mut Compositor, _ctx| {
-                    // remove the layer
-                    compositor.last_picker = compositor.pop();
-                })
-            };
-            EventResult::Consumed(Some(callback))
-        };
-
         match key_event {
             shift!(Tab) | key!(Up) | ctrl!('p') => {
                 self.move_by(1, Direction::Backward);
@@ -1065,7 +1092,7 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I,
             key!(End) => {
                 self.to_end();
             }
-            key!(Esc) | ctrl!('c') => return close_fn(self),
+            key!(Esc) | ctrl!('c') => return self.close_from_event(),
             alt!(Enter) => {
                 if let Some(option) = self.selection() {
                     (self.callback_fn)(ctx, option, Action::Replace);
@@ -1103,26 +1130,26 @@ impl<I: 'static + Send + Sync, D: 'static + Send + Sync> Component for Picker<I,
                             ctx.editor.set_error(err.to_string());
                         }
                     }
-                    return close_fn(self);
+                    return self.close_from_event();
                 }
             }
             ctrl!('s') => {
                 if let Some(option) = self.selection() {
                     (self.callback_fn)(ctx, option, Action::HorizontalSplit);
                 }
-                return close_fn(self);
+                return self.close_from_event();
             }
             ctrl!('v') => {
                 if let Some(option) = self.selection() {
                     (self.callback_fn)(ctx, option, Action::VerticalSplit);
                 }
-                return close_fn(self);
+                return self.close_from_event();
             }
             ctrl!('t') => {
                 self.toggle_preview();
             }
             _ => {
-                self.prompt_handle_event(event, ctx);
+                return self.typing_handle_event(event, ctx);
             }
         }
 

helix-tui/src/text.rs

@@ -436,6 +436,12 @@ impl<'a> From<Vec<Spans<'a>>> for Text<'a> {
     }
 }
 
+impl<'a> From<&Vec<char>> for Text<'a> {
+    fn from(chars: &Vec<char>) -> Text<'a> {
+        chars.iter().collect::<String>().into()
+    }
+}
+
 impl<'a> From<Text<'a>> for String {
     fn from(text: Text<'a>) -> String {
         String::from(&text)

helix-view/src/editor.rs

@@ -219,6 +219,25 @@ impl Default for FilePickerConfig {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case", default, deny_unknown_fields)]
+pub struct BufferPickerConfig {
+    /// labels characters used in buffer picker
+    #[serde(
+        serialize_with = "serialize_alphabet",
+        deserialize_with = "deserialize_alphabet"
+    )]
+    pub label_alphabet: Vec<char>,
+}
+
+impl Default for BufferPickerConfig {
+    fn default() -> Self {
+        Self {
+            label_alphabet: "sadflewcmpghio".chars().collect(),
+        }
+    }
+}
+
 fn serialize_alphabet<S>(alphabet: &[char], serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
@@ -313,6 +332,7 @@ pub struct Config {
     /// Whether to display infoboxes. Defaults to true.
     pub auto_info: bool,
     pub file_picker: FilePickerConfig,
+    pub buffer_picker: BufferPickerConfig,
     /// Configuration of the statusline elements
     pub statusline: StatusLineConfig,
     /// Shape for cursor in each mode
@@ -985,6 +1005,7 @@ impl Default for Config {
             completion_trigger_len: 2,
             auto_info: true,
             file_picker: FilePickerConfig::default(),
+            buffer_picker: BufferPickerConfig::default(),
             statusline: StatusLineConfig::default(),
             cursor_shape: CursorShapeConfig::default(),
             true_color: false,