Fix whitespace handling in command-mode completion

helix-core/src/shellwords.rs

@@ -1,9 +1,9 @@
 use std::borrow::Cow;
 
 /// Auto escape for shellwords usage.
-pub fn escape(input: &str) -> Cow<'_, str> {
+pub fn escape(input: Cow<str>) -> Cow<str> {
     if !input.chars().any(|x| x.is_ascii_whitespace()) {
-        Cow::Borrowed(input)
+        input
     } else if cfg!(unix) {
         Cow::Owned(input.chars().fold(String::new(), |mut buf, c| {
             if c.is_ascii_whitespace() {
@@ -17,18 +17,18 @@ pub fn escape(input: &str) -> Cow<'_, str> {
     }
 }
 
+enum State {
+    OnWhitespace,
+    Unquoted,
+    UnquotedEscaped,
+    Quoted,
+    QuoteEscaped,
+    Dquoted,
+    DquoteEscaped,
+}
+
 /// Get the vec of escaped / quoted / doublequoted filenames from the input str
 pub fn shellwords(input: &str) -> Vec<Cow<'_, str>> {
-    enum State {
-        OnWhitespace,
-        Unquoted,
-        UnquotedEscaped,
-        Quoted,
-        QuoteEscaped,
-        Dquoted,
-        DquoteEscaped,
-    }
-
     use State::*;
 
     let mut state = Unquoted;
@@ -140,6 +140,70 @@ pub fn shellwords(input: &str) -> Vec<Cow<'_, str>> {
     args
 }
 
+/// Checks that the input ends with an ascii whitespace character which is
+/// not escaped.
+///
+/// # Examples
+///
+/// ```rust
+/// use helix_core::shellwords::ends_with_whitespace;
+/// assert_eq!(ends_with_whitespace(" "), true);
+/// assert_eq!(ends_with_whitespace(":open "), true);
+/// assert_eq!(ends_with_whitespace(":open foo.txt "), true);
+/// assert_eq!(ends_with_whitespace(":open"), false);
+/// #[cfg(unix)]
+/// assert_eq!(ends_with_whitespace(":open a\\ "), false);
+/// #[cfg(unix)]
+/// assert_eq!(ends_with_whitespace(":open a\\ b.txt"), false);
+/// ```
+pub fn ends_with_whitespace(input: &str) -> bool {
+    use State::*;
+
+    // Fast-lane: the input must end with a whitespace character
+    // regardless of quoting.
+    if !input.ends_with(|c: char| c.is_ascii_whitespace()) {
+        return false;
+    }
+
+    let mut state = Unquoted;
+
+    for c in input.chars() {
+        state = match state {
+            OnWhitespace => match c {
+                '"' => Dquoted,
+                '\'' => Quoted,
+                '\\' if cfg!(unix) => UnquotedEscaped,
+                '\\' => OnWhitespace,
+                c if c.is_ascii_whitespace() => OnWhitespace,
+                _ => Unquoted,
+            },
+            Unquoted => match c {
+                '\\' if cfg!(unix) => UnquotedEscaped,
+                '\\' => Unquoted,
+                c if c.is_ascii_whitespace() => OnWhitespace,
+                _ => Unquoted,
+            },
+            UnquotedEscaped => Unquoted,
+            Quoted => match c {
+                '\\' if cfg!(unix) => QuoteEscaped,
+                '\\' => Quoted,
+                '\'' => OnWhitespace,
+                _ => Quoted,
+            },
+            QuoteEscaped => Quoted,
+            Dquoted => match c {
+                '\\' if cfg!(unix) => DquoteEscaped,
+                '\\' => Dquoted,
+                '"' => OnWhitespace,
+                _ => Dquoted,
+            },
+            DquoteEscaped => Dquoted,
+        }
+    }
+
+    matches!(state, OnWhitespace)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -247,15 +311,15 @@ mod test {
     #[test]
     #[cfg(unix)]
     fn test_escaping_unix() {
-        assert_eq!(escape("foobar"), Cow::Borrowed("foobar"));
-        assert_eq!(escape("foo bar"), Cow::Borrowed("foo\\ bar"));
-        assert_eq!(escape("foo\tbar"), Cow::Borrowed("foo\\\tbar"));
+        assert_eq!(escape("foobar".into()), Cow::Borrowed("foobar"));
+        assert_eq!(escape("foo bar".into()), Cow::Borrowed("foo\\ bar"));
+        assert_eq!(escape("foo\tbar".into()), Cow::Borrowed("foo\\\tbar"));
     }
 
     #[test]
     #[cfg(windows)]
     fn test_escaping_windows() {
-        assert_eq!(escape("foobar"), Cow::Borrowed("foobar"));
-        assert_eq!(escape("foo bar"), Cow::Borrowed("\"foo bar\""));
+        assert_eq!(escape("foobar".into()), Cow::Borrowed("foobar"));
+        assert_eq!(escape("foo bar".into()), Cow::Borrowed("\"foo bar\""));
     }
 }

helix-term/src/commands/typed.rs

@@ -2183,10 +2183,11 @@ pub(super) fn command_mode(cx: &mut Context) {
             static FUZZY_MATCHER: Lazy<fuzzy_matcher::skim::SkimMatcherV2> =
                 Lazy::new(fuzzy_matcher::skim::SkimMatcherV2::default);
 
-            // simple heuristic: if there's no just one part, complete command name.
-            // if there's a space, per command completion kicks in.
-            // we use .this over split_whitespace() because we care about empty segments
-            if input.split(' ').count() <= 1 {
+            let parts = shellwords::shellwords(input);
+            let ends_with_whitespace = shellwords::ends_with_whitespace(input);
+
+            if parts.is_empty() || (parts.len() == 1 && !ends_with_whitespace) {
+                // If the command has not been finished yet, complete commands.
                 let mut matches: Vec<_> = typed::TYPABLE_COMMAND_LIST
                     .iter()
                     .filter_map(|command| {
@@ -2202,19 +2203,28 @@ pub(super) fn command_mode(cx: &mut Context) {
                     .map(|(name, _)| (0.., name.into()))
                     .collect()
             } else {
-                let parts = shellwords::shellwords(input);
-                let part = parts.last().unwrap();
+                // Otherwise, use the command's completer and the last shellword
+                // as completion input.
+                let part = if parts.len() == 1 {
+                    &Cow::Borrowed("")
+                } else {
+                    parts.last().unwrap()
+                };
 
                 if let Some(typed::TypableCommand {
                     completer: Some(completer),
                     ..
                 }) = typed::TYPABLE_COMMAND_MAP.get(&parts[0] as &str)
                 {
+                    let part_len = shellwords::escape(part.clone()).len();
+
                     completer(editor, part)
                         .into_iter()
                         .map(|(range, file)| {
+                            let file = shellwords::escape(file);
+
                             // offset ranges to input
-                            let offset = input.len() - part.len();
+                            let offset = input.len() - part_len;
                             let range = (range.start + offset)..;
                             (range, file)
                         })

helix-term/src/ui/prompt.rs

@@ -1,6 +1,5 @@
 use crate::compositor::{Component, Compositor, Context, Event, EventResult};
 use crate::{alt, ctrl, key, shift, ui};
-use helix_core::shellwords;
 use helix_view::input::KeyEvent;
 use helix_view::keyboard::KeyCode;
 use std::{borrow::Cow, ops::RangeFrom};
@@ -336,10 +335,7 @@ impl Prompt {
 
         let (range, item) = &self.completion[index];
 
-        // since we are using shellwords to parse arguments, make sure
-        // that whitespace in files is properly escaped.
-        let item = shellwords::escape(item);
-        self.line.replace_range(range.clone(), &item);
+        self.line.replace_range(range.clone(), item);
 
         self.move_end();
     }