pretty print binary path when possible

Co-authored-by: Alex Huszagh <[email protected]>

Author: Emilgardis

src/docker/engine.rs

@@ -5,8 +5,8 @@ use std::process::Command;
 use crate::errors::*;
 use crate::extensions::CommandExt;
 
-const DOCKER: &str = "docker";
-const PODMAN: &str = "podman";
+pub const DOCKER: &str = "docker";
+pub const PODMAN: &str = "podman";
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum EngineType {

src/errors.rs

@@ -28,7 +28,7 @@ pub enum CommandError {
 }
 
 impl CommandError {
-    /// Attach valuable information to this CommandError
+    /// Attach valuable information to this [`CommandError`](Self)
     pub fn to_section_report(self) -> eyre::Report {
         match &self {
             CommandError::NonZeroExitCode { stderr, stdout, .. } => {

src/extensions.rs

@@ -4,10 +4,13 @@ use std::process::{Command, ExitStatus, Output};
 
 use crate::errors::*;
 
+pub const STRIPPED_BINS: &[&str] = &[crate::docker::DOCKER, crate::docker::PODMAN, "cargo"];
+
 pub trait CommandExt {
     fn print_verbose(&self, verbose: bool);
     fn status_result(
         &self,
+        verbose: bool,
         status: ExitStatus,
         output: Option<&Output>,
     ) -> Result<(), CommandError>;
@@ -19,44 +22,57 @@ pub trait CommandExt {
     ) -> Result<ExitStatus, CommandError>;
     fn run_and_get_stdout(&mut self, verbose: bool) -> Result<String>;
     fn run_and_get_output(&mut self, verbose: bool) -> Result<std::process::Output>;
-    fn command_pretty(&self) -> String;
+    fn command_pretty(&self, verbose: bool, strip: impl for<'a> Fn(&'a str) -> bool) -> String;
 }
 
 impl CommandExt for Command {
-    fn command_pretty(&self) -> String {
+    fn command_pretty(&self, verbose: bool, strip: impl for<'a> Fn(&'a str) -> bool) -> String {
         // a dummy implementor of display to avoid using unwraps
-        struct C<'c>(&'c Command);
-        impl std::fmt::Display for C<'_> {
+        struct C<'c, F>(&'c Command, bool, F);
+        impl<F> std::fmt::Display for C<'_, F>
+        where
+            F: for<'a> Fn(&'a str) -> bool,
+        {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 let cmd = self.0;
-                write!(f, "{}", cmd.get_program().to_string_lossy())?;
+                write!(
+                    f,
+                    "{}",
+                    // if verbose, never strip, if not, let user choose
+                    crate::file::pretty_path(cmd.get_program(), move |c| if self.1 {
+                        false
+                    } else {
+                        self.2(c)
+                    })
+                )?;
                 let args = cmd.get_args();
                 if args.len() > 1 {
-                    write!(f, " ")?;
                     write!(
                         f,
-                        "{}",
+                        " {}",
                         shell_words::join(args.map(|o| o.to_string_lossy()))
                     )?;
                 }
                 Ok(())
             }
         }
-        format!("{}", C(self))
+        format!("{}", C(self, verbose, strip))
     }
 
     fn print_verbose(&self, verbose: bool) {
+        // TODO: introduce verbosity levels, v = 1, strip cmd, v > 1, don't strip cmd
         if verbose {
             if let Some(cwd) = self.get_current_dir() {
-                println!("+ {:?} {}", cwd, self.command_pretty());
+                println!("+ {:?} {}", cwd, self.command_pretty(true, |_| false));
             } else {
-                println!("+ {}", self.command_pretty());
+                println!("+ {}", self.command_pretty(true, |_| false));
             }
         }
     }
 
     fn status_result(
         &self,
+        verbose: bool,
         status: ExitStatus,
         output: Option<&Output>,
     ) -> Result<(), CommandError> {
@@ -65,7 +81,8 @@ impl CommandExt for Command {
         } else {
             Err(CommandError::NonZeroExitCode {
                 status,
-                command: self.command_pretty(),
+                command: self
+                    .command_pretty(verbose, |ref cmd| STRIPPED_BINS.iter().any(|f| f == cmd)),
                 stderr: output.map(|out| out.stderr.clone()).unwrap_or_default(),
                 stdout: output.map(|out| out.stdout.clone()).unwrap_or_default(),
             })
@@ -75,7 +92,7 @@ impl CommandExt for Command {
     /// Runs the command to completion
     fn run(&mut self, verbose: bool, silence_stdout: bool) -> Result<(), CommandError> {
         let status = self.run_and_get_status(verbose, silence_stdout)?;
-        self.status_result(status, None)
+        self.status_result(verbose, status, None)
     }
 
     /// Runs the command to completion
@@ -91,15 +108,16 @@ impl CommandExt for Command {
         self.status()
             .map_err(|e| CommandError::CouldNotExecute {
                 source: Box::new(e),
-                command: self.command_pretty(),
+                command: self
+                    .command_pretty(verbose, |ref cmd| STRIPPED_BINS.iter().any(|f| f == cmd)),
             })
             .map_err(Into::into)
     }
 
     /// Runs the command to completion and returns its stdout
     fn run_and_get_stdout(&mut self, verbose: bool) -> Result<String> {
         let out = self.run_and_get_output(verbose)?;
-        self.status_result(out.status, Some(&out))
+        self.status_result(verbose, out.status, Some(&out))
             .map_err(CommandError::to_section_report)?;
         out.stdout().map_err(Into::into)
     }
@@ -114,7 +132,8 @@ impl CommandExt for Command {
         self.output().map_err(|e| {
             CommandError::CouldNotExecute {
                 source: Box::new(e),
-                command: self.command_pretty(),
+                command: self
+                    .command_pretty(verbose, |ref cmd| STRIPPED_BINS.iter().any(|f| f == cmd)),
             }
             .to_section_report()
         })

src/file.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+use std::ffi::OsStr;
 use std::fs::{self, File};
 use std::io::Read;
 use std::path::{Path, PathBuf};
@@ -36,6 +38,55 @@ fn _canonicalize(path: &Path) -> Result<PathBuf> {
     }
 }
 
+/// Pretty format a file path. Also removes the path prefix from a command if wanted
+pub fn pretty_path(path: impl AsRef<Path>, strip: impl for<'a> Fn(&'a str) -> bool) -> String {
+    let path = path.as_ref();
+    // TODO: Use Path::file_prefix
+    let file_stem = path.file_stem();
+    let file_name = path.file_name();
+    let path = if let (Some(file_stem), Some(file_name)) = (file_stem, file_name) {
+        if let Some(file_name) = file_name.to_str() {
+            if strip(file_name) {
+                Cow::Borrowed(file_stem)
+            } else {
+                Cow::Borrowed(path.as_os_str())
+            }
+        } else {
+            Cow::Borrowed(path.as_os_str())
+        }
+    } else {
+        maybe_canonicalize(path)
+    };
+
+    if let Some(path) = path.to_str() {
+        shell_escape(path).to_string()
+    } else {
+        format!("{path:?}")
+    }
+}
+
+pub fn shell_escape(string: &str) -> Cow<'_, str> {
+    let escape: &[char] = if cfg!(target_os = "windows") {
+        &['%', '$', '`', '!', '"']
+    } else {
+        &['$', '\'', '\\', '!', '"']
+    };
+
+    if string.contains(escape) {
+        Cow::Owned(format!("{string:?}"))
+    } else if string.contains(' ') {
+        Cow::Owned(format!("\"{string}\""))
+    } else {
+        Cow::Borrowed(string)
+    }
+}
+
+pub fn maybe_canonicalize(path: &Path) -> Cow<'_, OsStr> {
+    canonicalize(path)
+        .map(|p| Cow::Owned(p.as_os_str().to_owned()))
+        .unwrap_or_else(|_| path.as_os_str().into())
+}
+
 pub fn write_file(path: impl AsRef<Path>, overwrite: bool) -> Result<File> {
     let path = path.as_ref();
     fs::create_dir_all(
@@ -57,3 +108,55 @@ pub fn write_file(path: impl AsRef<Path>, overwrite: bool) -> Result<File> {
     open.open(&path)
         .wrap_err(format!("couldn't write to file `{}`", path.display()))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[cfg(target_family = "windows")]
+    fn pretty_path_windows() {
+        assert_eq!(
+            pretty_path("C:\\path\\bin\\cargo.exe", |f| f.contains("cargo")),
+            "cargo".to_string()
+        );
+        assert_eq!(
+            pretty_path("C:\\Program Files\\Docker\\bin\\docker.exe", |_| false),
+            "\"C:\\Program Files\\Docker\\bin\\docker.exe\"".to_string()
+        );
+        assert_eq!(
+            pretty_path("C:\\Program Files\\single'quote\\cargo.exe", |c| c
+                .contains("cargo")),
+            "cargo".to_string()
+        );
+        assert_eq!(
+            pretty_path("C:\\Program Files\\single'quote\\cargo.exe", |_| false),
+            "\"C:\\Program Files\\single'quote\\cargo.exe\"".to_string()
+        );
+        assert_eq!(
+            pretty_path("C:\\Program Files\\%not_var%\\cargo.exe", |_| false),
+            "\"C:\\\\Program Files\\\\%not_var%\\\\cargo.exe\"".to_string()
+        );
+    }
+
+    #[test]
+    #[cfg(target_family = "unix")]
+    fn pretty_path_linux() {
+        assert_eq!(
+            pretty_path("/usr/bin/cargo", |f| f.contains("cargo")),
+            "cargo".to_string()
+        );
+        assert_eq!(
+            pretty_path("/home/user/my rust/bin/cargo", |_| false),
+            "\"/home/user/my rust/bin/cargo\"".to_string(),
+        );
+        assert_eq!(
+            pretty_path("/home/user/single'quote/cargo", |c| c.contains("cargo")),
+            "cargo".to_string()
+        );
+        assert_eq!(
+            pretty_path("/home/user/single'quote/cargo", |_| false),
+            "\"/home/user/single'quote/cargo\"".to_string()
+        );
+    }
+}

src/rustup.rs

@@ -54,7 +54,7 @@ pub fn available_targets(toolchain: &str, verbose: bool) -> Result<AvailableTarg
             eyre::bail!("{toolchain} is a custom toolchain. To use it, you'll need to set the environment variable `CROSS_CUSTOM_TOOLCHAIN=1`")
         }
         return Err(cmd
-            .status_result(output.status, Some(&output))
+            .status_result(verbose, output.status, Some(&output))
             .unwrap_err()
             .to_section_report());
     }