Ability to use $file and $pwd in shell commands and formatter args

helix-term/src/commands.rs

@@ -4546,7 +4546,8 @@ fn shell_keep_pipe(cx: &mut Context) {
 
             for (i, range) in selection.ranges().iter().enumerate() {
                 let fragment = range.slice(text);
-                let (_output, success) = match shell_impl(shell, input, Some(fragment)) {
+                let input = input.split(' ').map(Cow::from).collect::<Vec<_>>();
+                let (_output, success) = match shell_impl(doc, shell, &input, Some(fragment)) {
                     Ok(result) => result,
                     Err(err) => {
                         cx.editor.set_error(err.to_string());
@@ -4575,14 +4576,17 @@ fn shell_keep_pipe(cx: &mut Context) {
 }
 
 fn shell_impl(
+    doc: &Document,
     shell: &[String],
-    cmd: &str,
+    args: &[Cow<str>],
     input: Option<RopeSlice>,
 ) -> anyhow::Result<(Tendril, bool)> {
     use std::io::Write;
     use std::process::{Command, Stdio};
     ensure!(!shell.is_empty(), "No shell set");
 
+    let cmd = doc.inject_environment(args.iter()).join(" ");
+
     let mut process = Command::new(&shell[0]);
     process
         .args(&shell[1..])
@@ -4629,7 +4633,7 @@ fn shell_impl(
     Ok((tendril, output.status.success()))
 }
 
-fn shell(cx: &mut compositor::Context, cmd: &str, behavior: &ShellBehavior) {
+fn shell(cx: &mut compositor::Context, cmd: &[Cow<str>], behavior: &ShellBehavior) {
     let pipe = match behavior {
         ShellBehavior::Replace | ShellBehavior::Ignore => true,
         ShellBehavior::Insert | ShellBehavior::Append => false,
@@ -4645,7 +4649,7 @@ fn shell(cx: &mut compositor::Context, cmd: &str, behavior: &ShellBehavior) {
 
     for range in selection.ranges() {
         let fragment = range.slice(text);
-        let (output, success) = match shell_impl(shell, cmd, pipe.then(|| fragment)) {
+        let (output, success) = match shell_impl(doc, shell, cmd, pipe.then(|| fragment)) {
             Ok(result) => result,
             Err(err) => {
                 cx.editor.set_error(err.to_string());
@@ -4692,7 +4696,8 @@ fn shell_prompt(cx: &mut Context, prompt: Cow<'static, str>, behavior: ShellBeha
                 return;
             }
 
-            shell(cx, input, &behavior);
+            let input = input.split(' ').map(Cow::from).collect::<Vec<_>>();
+            shell(cx, &input, &behavior);
         },
     );
 }

helix-term/src/commands/typed.rs

@@ -1448,7 +1448,7 @@ fn append_output(
     }
 
     ensure!(!args.is_empty(), "Shell command required");
-    shell(cx, &args.join(" "), &ShellBehavior::Append);
+    shell(cx, args, &ShellBehavior::Append);
     Ok(())
 }
 
@@ -1462,7 +1462,7 @@ fn insert_output(
     }
 
     ensure!(!args.is_empty(), "Shell command required");
-    shell(cx, &args.join(" "), &ShellBehavior::Insert);
+    shell(cx, args, &ShellBehavior::Insert);
     Ok(())
 }
 
@@ -1472,7 +1472,7 @@ fn pipe(cx: &mut compositor::Context, args: &[Cow<str>], event: PromptEvent) ->
     }
 
     ensure!(!args.is_empty(), "Shell command required");
-    shell(cx, &args.join(" "), &ShellBehavior::Replace);
+    shell(cx, args, &ShellBehavior::Replace);
     Ok(())
 }
 
@@ -1484,9 +1484,10 @@ fn run_shell_command(
     if event != PromptEvent::Validate {
         return Ok(());
     }
-
     let shell = &cx.editor.config().shell;
-    let (output, success) = shell_impl(shell, &args.join(" "), None)?;
+    let doc = doc!(cx.editor);
+
+    let (output, success) = shell_impl(doc, shell, args, None)?;
     if success {
         cx.editor.set_status("Command succeed");
     } else {

helix-view/src/document.rs

@@ -412,7 +412,7 @@ impl Document {
             let text = self.text().clone();
             let mut process = tokio::process::Command::new(&formatter.command);
             process
-                .args(&formatter.args)
+                .args(self.inject_environment(formatter.args.iter()))
                 .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped());
@@ -1081,6 +1081,31 @@ impl Document {
             None => global_config,
         }
     }
+
+    /// Inject variables for this document into an iterator of displayable things.
+    /// Used for when you want to turn something like ["--file" "$file"]
+    /// into [file" "/path/to/current/document.ext"]
+    pub fn inject_environment<T>(&self, strs: T) -> Vec<String>
+    where
+        T: Iterator,
+        <T as Iterator>::Item: Display,
+    {
+        let path = self.path().and_then(|p| p.to_str()).unwrap_or_else(|| {
+            log::error!("No $path found for document: {:?}", self.url());
+            ""
+        });
+        let pwd = std::env::current_dir()
+            .unwrap_or_default()
+            .into_os_string()
+            .into_string()
+            .unwrap_or_else(|err| {
+                log::error!("No $pwd found: {:?}", err);
+                String::new()
+            });
+
+        strs.map(|s| s.to_string().replace("$file", path).replace("$pwd", &pwd))
+            .collect()
+    }
 }
 
 impl Default for Document {
@@ -1125,6 +1150,8 @@ impl Display for FormatterError {
 
 #[cfg(test)]
 mod test {
+    use std::fs;
+
     use super::*;
 
     #[test]
@@ -1283,6 +1310,25 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_inject_environment() {
+        let doc = Document::open(&PathBuf::from(file!()), None, None).unwrap();
+        assert_eq!(
+            doc.inject_environment(["file", "$file"].iter()),
+            [
+                "file",
+                Path::new(env!("CARGO_MANIFEST_DIR"))
+                    .join(file!())
+                    .to_str()
+                    .unwrap()
+            ]
+        );
+        assert_eq!(
+            doc.inject_environment(["pwd", "$pwd"].iter()),
+            ["pwd", env!("CARGO_MANIFEST_DIR")]
+        );
+    }
+
     macro_rules! test_decode {
         ($label:expr, $label_override:expr) => {
             let encoding = encoding::Encoding::for_label($label_override.as_bytes()).unwrap();

helix-view/src/handlers/dap.rs

@@ -300,8 +300,9 @@ impl Editor {
                         None => return false,
                     };
 
+                    let doc = doc!(self);
                     let process = match std::process::Command::new(config.command)
-                        .args(config.args)
+                        .args(doc.inject_environment(config.args.iter()))
                         .arg(arguments.args.join(" "))
                         .spawn()
                     {