feat: add support for fish-like abbreviations (#1060)

* feat: add support for fish-like abbreviations

* feat(editor): detect if cursor is in unclosed string

* refactor: move is_inside_string_literal check up

* refactor(engine): prefer String over Vec<u8>

* add example

* fix: use byte offset and don't expand on empty buf

* tests: add tests for abbreviation expansion and quote parsing

* tests: add string lit tests

Author: casedami

examples/abbreviations.rs

@@ -0,0 +1,31 @@
+// Create a default reedline object to handle user input
+// cargo run --example abbreviations
+//
+// You can browse the local (non persistent) history using Up/Down or Ctrl n/p.
+
+use reedline::{DefaultPrompt, Reedline, Signal};
+use std::{collections::HashMap, io};
+
+fn main() -> io::Result<()> {
+    let mut abbrevs = HashMap::new();
+    abbrevs.insert(String::from("ll"), String::from("ls -l"));
+    abbrevs.insert(String::from("gs"), String::from("git status"));
+    // Create a new Reedline engine with a local History that is not synchronized to a file and our
+    // abbreviations
+    let mut line_editor = Reedline::create().with_abbreviations(abbrevs);
+    let prompt = DefaultPrompt::default();
+
+    loop {
+        let sig = line_editor.read_line(&prompt)?;
+        match sig {
+            Signal::Success(buffer) => {
+                println!("We processed: {buffer}");
+            }
+            Signal::CtrlD | Signal::CtrlC => {
+                println!("\nAborted!");
+                break Ok(());
+            }
+            _ => {}
+        }
+    }
+}

src/core_editor/editor.rs

@@ -273,6 +273,53 @@ impl Editor {
         self.line_buffer.get_buffer()
     }
 
+    /// Check if `position` (a byte offset) is inside an unclosed string literal.
+    pub fn is_inside_string_literal(&self, position: usize) -> bool {
+        let buffer = self.get_buffer();
+
+        if buffer.is_empty() || position == 0 {
+            return false;
+        }
+        if !buffer.contains('"') && !buffer.contains('\'') {
+            return false;
+        }
+
+        let bytes = buffer.as_bytes();
+        let mut in_single_quote = false;
+        let mut in_double_quote = false;
+        let mut escaped = false;
+        let mut byte_pos = 0;
+
+        for &byte in bytes {
+            if byte_pos > position {
+                break;
+            }
+
+            if escaped {
+                escaped = false;
+                byte_pos += 1;
+                continue;
+            }
+
+            match byte {
+                b'\\' => {
+                    escaped = true;
+                }
+                b'\'' if !in_double_quote => {
+                    in_single_quote = !in_single_quote;
+                }
+                b'"' if !in_single_quote => {
+                    in_double_quote = !in_double_quote;
+                }
+                _ => {}
+            }
+
+            byte_pos += 1;
+        }
+
+        in_single_quote || in_double_quote
+    }
+
     /// Edit the [`LineBuffer`] in an undo-safe manner.
     pub fn edit_buffer<F>(&mut self, func: F, undo_behavior: UndoBehavior)
     where
@@ -2168,4 +2215,55 @@ mod test {
         assert_eq!(bracket_result, expected_bracket);
         assert_eq!(quote_result, expected_quote);
     }
+
+    #[rstest]
+    // Not inside any string
+    #[case("hello world", 5, false)]
+    #[case("", 0, false)]
+    #[case("no quotes here", 0, false)]
+    // Closed double-quoted string — position is after the closing quote
+    #[case(r#""hello" world"#, 8, false)]
+    // Inside an unclosed double-quoted string
+    #[case(r#""hello world"#, 5, true)]
+    // Closed double-quoted string — position is inside it
+    #[case(r#""hello" world"#, 3, true)]
+    // Inside an unclosed single-quoted string
+    #[case("'hello world", 5, true)]
+    // Closed single-quoted string
+    #[case("'hello' world", 8, false)]
+    // Escaped quote does not open/close a string
+    #[case(r#"say \"hello"#, 6, false)]
+    // Escaped quote inside an open string — still inside
+    #[case(r#""say \"hello"#, 9, true)]
+    // Mixed: single inside double (single quote is literal)
+    #[case(r#""it's fine""#, 5, true)]
+    // Mixed: double inside single (double quote is literal)
+    #[case("'say \"hi\"'", 6, true)]
+    // Position 0 is never inside a string
+    #[case(r#""open"#, 0, false)]
+    // Cyrillic (2-byte UTF-8 chars): char boundary positions
+    #[case("Сегодня хороший день.", 14, false)]
+    #[case("Сегодня 'хороший' день.", 16, true)]
+    #[case("Сегодня 'хороший' день.", 31, false)]
+    #[case("'Сегодня хороший день.", 2, true)]
+    // Emoji (4-byte UTF-8 chars): char boundary positions
+    #[case("this is fire 🔥", 3, false)]
+    #[case("'hello there' 👋🏼", 13, false)]
+    #[case("'this is fire 🔥", 14, true)]
+    #[case("'hello there 👋🏼", 13, true)]
+    // Japanese (3-byte UTF-8 chars): char boundary and mid-char positions
+    #[case("今日はいい日だ。", 6, false)]
+    #[case("'今日はいい日だ。", 6, true)]
+    #[case("'今日はいい日だ。", 7, true)]
+    // Mid-char byte positions within multi-byte sequences are also handled correctly
+    #[case("Сегодня 'хороший' день.", 19, true)]
+    #[case("'hello there 👋🏼", 14, true)]
+    fn test_is_inside_string_literal(
+        #[case] buffer: &str,
+        #[case] position: usize,
+        #[case] expected: bool,
+    ) {
+        let editor = editor_with(buffer);
+        assert_eq!(editor.is_inside_string_literal(position), expected);
+    }
 }

src/engine.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{collections::HashMap, path::PathBuf};
 
 use itertools::Itertools;
 use nu_ansi_term::{Color, Style};
@@ -187,6 +187,8 @@ pub struct Reedline {
     // Engine Menus
     menus: Vec<ReedlineMenu>,
 
+    abbreviations: HashMap<String, String>,
+
     // Text editor used to open the line buffer for editing
     buffer_editor: Option<BufferEditor>,
 
@@ -287,6 +289,7 @@ impl Reedline {
             mouse_click_mode: MouseClickMode::default(),
             cwd: None,
             menus: Vec::new(),
+            abbreviations: HashMap::new(),
             buffer_editor: None,
             cursor_shapes: None,
             bracketed_paste: BracketedPasteGuard::default(),
@@ -619,6 +622,14 @@ impl Reedline {
         self
     }
 
+    /// A builder that adds abbreviations to the Reedline engine
+    ///
+    /// Overwrites any existing abbreviations with the same key.
+    pub fn with_abbreviations(mut self, abbreviations: HashMap<String, String>) -> Self {
+        self.abbreviations.extend(abbreviations);
+        self
+    }
+
     /// A builder that adds the history item id
     #[must_use]
     pub fn with_history_session_id(mut self, session: Option<HistorySessionId>) -> Self {
@@ -1278,6 +1289,9 @@ impl Reedline {
                 if let Some(event) = self.parse_bang_command() {
                     return self.handle_editor_event(prompt, event);
                 }
+                if let Some(event) = self.try_expand_abbreviation_at_cursor(true) {
+                    return self.handle_editor_event(prompt, event);
+                }
 
                 let buffer = self.editor.get_buffer().to_string();
                 match self.validator.as_mut().map(|v| v.validate(&buffer)) {
@@ -1294,13 +1308,21 @@ impl Reedline {
                 if let Some(event) = self.parse_bang_command() {
                     return self.handle_editor_event(prompt, event);
                 }
+                if let Some(event) = self.try_expand_abbreviation_at_cursor(true) {
+                    return self.handle_editor_event(prompt, event);
+                }
+
                 Ok(self.submit_buffer(prompt)?)
             }
             ReedlineEvent::SubmitOrNewline => {
                 #[cfg(feature = "bashisms")]
                 if let Some(event) = self.parse_bang_command() {
                     return self.handle_editor_event(prompt, event);
                 }
+                if let Some(event) = self.try_expand_abbreviation_at_cursor(true) {
+                    return self.handle_editor_event(prompt, event);
+                }
+
                 let cursor_position_in_buffer = self.editor.insertion_point();
                 let buffer = self.editor.get_buffer().to_string();
                 if cursor_position_in_buffer < buffer.len() {
@@ -1322,6 +1344,12 @@ impl Reedline {
                 Ok(EventStatus::Exits(Signal::HostCommand(host_command)))
             }
             ReedlineEvent::Edit(commands) => {
+                // Check if a space was just inserted and try to expand abbreviations
+                if let Some(EditCommand::InsertChar(' ')) = commands.first() {
+                    if let Some(event) = self.try_expand_abbreviation_at_cursor(false) {
+                        return self.handle_editor_event(prompt, event);
+                    }
+                }
                 self.run_edit_commands(&commands);
                 if let Some(menu) = self.menus.iter_mut().find(|men| men.is_active()) {
                     if self.quick_completions && menu.can_quick_complete() {
@@ -1729,6 +1757,56 @@ impl Reedline {
         }
     }
 
+    /// Expands an abbreviation at the word before the cursor, if any exists
+    ///
+    /// Note, expansion does not occur when inside a string.
+    fn try_expand_abbreviation_at_cursor(&mut self, submitted: bool) -> Option<ReedlineEvent> {
+        let buffer = self.editor.get_buffer();
+        let cursor_position_in_buffer = self.editor.insertion_point();
+        if cursor_position_in_buffer == 0 {
+            return None;
+        }
+
+        let (offset, suffix) = match submitted {
+            true => (0, ""),   // expand on <enter>
+            false => (1, " "), // expand on <space>
+        };
+
+        let word_end = cursor_position_in_buffer - offset;
+        let prefix = &buffer[..word_end];
+        let word_start = prefix
+            .char_indices()
+            .rev()
+            .find(|(_, ch)| ch.is_whitespace())
+            .map(|(idx, ch)| idx + ch.len_utf8())
+            .unwrap_or(0); // byte offset of word start
+
+        if word_start >= word_end {
+            // The first char in the buffer is a space or there are consecutive spaces
+            return None;
+        }
+        if self.editor.is_inside_string_literal(word_start) {
+            return None;
+        }
+
+        let word = &buffer[word_start..word_end];
+        if let Some(expansion) = self.abbreviations.get(word) {
+            return Some(ReedlineEvent::Edit(vec![
+                EditCommand::MoveToPosition {
+                    position: word_start,
+                    select: false,
+                },
+                EditCommand::MoveToPosition {
+                    position: word_end,
+                    select: true,
+                },
+                EditCommand::InsertString(format!("{}{}", expansion, suffix)),
+            ]));
+        }
+
+        None
+    }
+
     #[cfg(feature = "bashisms")]
     /// Parses the ! command to replace entries from the history
     fn parse_bang_command(&mut self) -> Option<ReedlineEvent> {
@@ -2358,4 +2436,98 @@ mod tests {
             _ => panic!("Expected Signal::ExternalBreak"),
         }
     }
+
+    fn reedline_with_abbrevs(abbrevs: &[(&str, &str)]) -> Reedline {
+        let map = abbrevs
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect();
+        Reedline::create().with_abbreviations(map)
+    }
+
+    fn set_buffer_at_end(reedline: &mut Reedline, text: &str) {
+        reedline.run_edit_commands(&[
+            EditCommand::Clear,
+            EditCommand::InsertString(text.to_string()),
+        ]);
+    }
+
+    #[test]
+    fn abbreviation_expands_on_submit() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        set_buffer_at_end(&mut reedline, "gc");
+        let event = reedline.try_expand_abbreviation_at_cursor(true);
+        assert!(event.is_some(), "expected expansion on submit");
+        reedline.run_edit_commands(&match event.unwrap() {
+            ReedlineEvent::Edit(cmds) => cmds,
+            _ => panic!("expected Edit event"),
+        });
+        assert_eq!(reedline.current_buffer_contents(), "git commit");
+    }
+
+    #[test]
+    fn abbreviation_no_match_returns_none() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        set_buffer_at_end(&mut reedline, "gx");
+        assert!(reedline.try_expand_abbreviation_at_cursor(true).is_none());
+    }
+
+    #[test]
+    fn abbreviation_empty_buffer_returns_none() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        assert!(reedline.try_expand_abbreviation_at_cursor(true).is_none());
+    }
+
+    #[test]
+    fn abbreviation_expands_last_word_only() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        set_buffer_at_end(&mut reedline, "sudo gc");
+        let event = reedline.try_expand_abbreviation_at_cursor(true);
+        assert!(event.is_some());
+        reedline.run_edit_commands(&match event.unwrap() {
+            ReedlineEvent::Edit(cmds) => cmds,
+            _ => panic!("expected Edit event"),
+        });
+        assert_eq!(reedline.current_buffer_contents(), "sudo git commit");
+    }
+
+    #[test]
+    fn abbreviation_no_expansion_inside_double_quoted_string() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        set_buffer_at_end(&mut reedline, "\"gc");
+        assert!(
+            reedline.try_expand_abbreviation_at_cursor(true).is_none(),
+            "must not expand inside an unclosed double-quoted string"
+        );
+    }
+
+    #[test]
+    fn abbreviation_no_expansion_inside_single_quoted_string() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        set_buffer_at_end(&mut reedline, "'gc");
+        assert!(
+            reedline.try_expand_abbreviation_at_cursor(true).is_none(),
+            "must not expand inside an unclosed single-quoted string"
+        );
+    }
+
+    #[test]
+    fn abbreviation_non_ascii_key_and_expansion() {
+        let mut reedline = reedline_with_abbrevs(&[("café", "coffee shop")]);
+        set_buffer_at_end(&mut reedline, "café");
+        let event = reedline.try_expand_abbreviation_at_cursor(true);
+        assert!(event.is_some(), "expected expansion for non-ASCII key");
+        reedline.run_edit_commands(&match event.unwrap() {
+            ReedlineEvent::Edit(cmds) => cmds,
+            _ => panic!("expected Edit event"),
+        });
+        assert_eq!(reedline.current_buffer_contents(), "coffee shop");
+    }
+
+    #[test]
+    fn abbreviation_leading_spaces_returns_none() {
+        let mut reedline = reedline_with_abbrevs(&[("gc", "git commit")]);
+        set_buffer_at_end(&mut reedline, "   ");
+        assert!(reedline.try_expand_abbreviation_at_cursor(true).is_none());
+    }
 }