Rewrite command line parsing, add flags and expansions (#12527)

Co-authored-by: Pascal Kuthe <pascalkuthe@pm.me>

helix-term/src/commands.rs

@@ -20,7 +20,7 @@ pub use typed::*;
 use helix_core::{
     char_idx_at_visual_offset,
     chars::char_is_word,
-    comment,
+    command_line, comment,
     doc_formatter::TextFormat,
     encoding, find_workspace,
     graphemes::{self, next_grapheme_boundary},
@@ -33,7 +33,7 @@ use helix_core::{
     object, pos_at_coords,
     regex::{self, Regex},
     search::{self, CharMatcher},
-    selection, shellwords, surround,
+    selection, surround,
     syntax::{BlockCommentToken, LanguageServerFeature},
     text_annotations::{Overlay, TextAnnotations},
     textobject,
@@ -58,7 +58,6 @@ use insert::*;
 use movement::Movement;
 
 use crate::{
-    args,
     compositor::{self, Component, Compositor},
     filter_picker_entry,
     job::Callback,
@@ -211,7 +210,7 @@ use helix_view::{align_view, Align};
 pub enum MappableCommand {
     Typable {
         name: String,
-        args: Vec<String>,
+        args: String,
         doc: String,
     },
     Static {
@@ -246,16 +245,19 @@ impl MappableCommand {
     pub fn execute(&self, cx: &mut Context) {
         match &self {
             Self::Typable { name, args, doc: _ } => {
-                let args: Vec<Cow<str>> = args.iter().map(Cow::from).collect();
                 if let Some(command) = typed::TYPABLE_COMMAND_MAP.get(name.as_str()) {
                     let mut cx = compositor::Context {
                         editor: cx.editor,
                         jobs: cx.jobs,
                         scroll: None,
                     };
-                    if let Err(e) = (command.fun)(&mut cx, &args[..], PromptEvent::Validate) {
+                    if let Err(e) =
+                        typed::execute_command(&mut cx, command, args, PromptEvent::Validate)
+                    {
                         cx.editor.set_error(format!("{}", e));
                     }
+                } else {
+                    cx.editor.set_error(format!("no such command: '{name}'"));
                 }
             }
             Self::Static { fun, .. } => (fun)(cx),
@@ -629,13 +631,8 @@ impl std::str::FromStr for MappableCommand {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if let Some(suffix) = s.strip_prefix(':') {
-            let mut typable_command = suffix.split(' ').map(|arg| arg.trim());
-            let name = typable_command
-                .next()
-                .ok_or_else(|| anyhow!("Expected typable command name"))?;
-            let args = typable_command
-                .map(|s| s.to_owned())
-                .collect::<Vec<String>>();
+            let (name, args, _) = command_line::split(suffix);
+            ensure!(!name.is_empty(), "Expected typable command name");
             typed::TYPABLE_COMMAND_MAP
                 .get(name)
                 .map(|cmd| {
@@ -647,7 +644,7 @@ impl std::str::FromStr for MappableCommand {
                     MappableCommand::Typable {
                         name: cmd.name.to_owned(),
                         doc,
-                        args,
+                        args: args.to_string(),
                     }
                 })
                 .ok_or_else(|| anyhow!("No TypableCommand named '{}'", s))
@@ -3384,7 +3381,7 @@ pub fn command_palette(cx: &mut Context) {
                     .iter()
                     .map(|cmd| MappableCommand::Typable {
                         name: cmd.name.to_owned(),
-                        args: Vec::new(),
+                        args: String::new(),
                         doc: cmd.doc.to_owned(),
                     }),
             );

helix-term/src/keymap.rs

@@ -601,11 +601,7 @@ mod tests {
                     MappableCommand::select_all,
                     MappableCommand::Typable {
                         name: "pipe".to_string(),
-                        args: vec!{
-                            "sed".to_string(),
-                            "-E".to_string(),
-                            "'s/\\s+$//g'".to_string()
-                        },
+                        args: "sed -E 's/\\s+$//g'".to_string(),
                         doc: "".to_string(),
                     },
                 })

helix-term/tests/integration.rs

@@ -17,9 +17,9 @@ mod test {
 
     mod auto_indent;
     mod auto_pairs;
+    mod command_line;
     mod commands;
     mod languages;
     mod movement;
-    mod prompt;
     mod splits;
 }

helix-term/tests/test/command_line.rs

@@ -0,0 +1,92 @@
+use super::*;
+
+use helix_core::diagnostic::Severity;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn history_completion() -> anyhow::Result<()> {
+    test_key_sequence(
+        &mut AppBuilder::new().build()?,
+        Some(":asdf<ret>:theme d<C-n><tab>"),
+        Some(&|app| {
+            assert!(!app.editor.is_err());
+        }),
+        false,
+    )
+    .await?;
+
+    Ok(())
+}
+
+async fn test_statusline(
+    line: &str,
+    expected_status: &str,
+    expected_severity: Severity,
+) -> anyhow::Result<()> {
+    test_key_sequence(
+        &mut AppBuilder::new().build()?,
+        Some(&format!("{line}<ret>")),
+        Some(&|app| {
+            let (status, &severity) = app.editor.get_status().unwrap();
+            assert_eq!(
+                severity, expected_severity,
+                "'{line}' printed {severity:?}: {status}"
+            );
+            assert_eq!(status.as_ref(), expected_status);
+        }),
+        false,
+    )
+    .await
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn variable_expansion() -> anyhow::Result<()> {
+    test_statusline(r#":echo %{cursor_line}"#, "1", Severity::Info).await?;
+    // Double quotes can be used with expansions:
+    test_statusline(
+        r#":echo "line%{cursor_line}line""#,
+        "line1line",
+        Severity::Info,
+    )
+    .await?;
+    // Within double quotes you can escape the percent token for an expansion by doubling it.
+    test_statusline(
+        r#":echo "%%{cursor_line}""#,
+        "%{cursor_line}",
+        Severity::Info,
+    )
+    .await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn unicode_expansion() -> anyhow::Result<()> {
+    test_statusline(r#":echo %u{20}"#, " ", Severity::Info).await?;
+    test_statusline(r#":echo %u{0020}"#, " ", Severity::Info).await?;
+    test_statusline(r#":echo %u{25CF}"#, "●", Severity::Info).await?;
+    // Not a valid Unicode codepoint:
+    test_statusline(
+        r#":echo %u{deadbeef}"#,
+        "'echo': could not interpret 'deadbeef' as a Unicode character code",
+        Severity::Error,
+    )
+    .await?;
+
+    Ok(())
+}
+
+#[cfg(unix)]
+#[tokio::test(flavor = "multi_thread")]
+async fn shell_expansion() -> anyhow::Result<()> {
+    test_statusline(
+        r#":echo %sh{echo "hello world"}"#,
+        "hello world",
+        Severity::Info,
+    )
+    .await?;
+
+    // Shell expansion is recursive.
+    test_statusline(":echo %sh{echo '%{cursor_line}'}", "1", Severity::Info).await?;
+
+    Ok(())
+}

helix-term/tests/test/prompt.rs

@@ -1,16 +0,0 @@
-use super::*;
-
-#[tokio::test(flavor = "multi_thread")]
-async fn test_history_completion() -> anyhow::Result<()> {
-    test_key_sequence(
-        &mut AppBuilder::new().build()?,
-        Some(":asdf<ret>:theme d<C-n><tab>"),
-        Some(&|app| {
-            assert!(!app.editor.is_err());
-        }),
-        false,
-    )
-    .await?;
-
-    Ok(())
-}