utils: Add PathQuotedDisplay

There's probably an equivalent of this somewhere in a crate, but
basically dealing with `&Path` and printing it is annoying because
we always end up with quotes around a path, even if it's UTF-8
without any spaces.

This takes a Path and displays it in a way that will be parsable
by a shell, and takes care not to emit quotes in the simple case
where a path has no shell metacharacters, just `/`, `.` and
alphanumerics.

Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

Cargo.lock

@@ -11,6 +11,7 @@ anyhow = { workspace = true }
 rustix = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+shlex = "1.3"
 tempfile = { workspace = true }
 tracing = { workspace = true }
 tokio = { workspace = true, features = ["process", "rt", "macros"] }

utils/Cargo.toml

@@ -4,6 +4,8 @@
 //!
 mod command;
 pub use command::*;
+mod path;
+pub use path::*;
 mod iterators;
 pub use iterators::*;
 mod tracing_util;

utils/src/lib.rs

@@ -0,0 +1,64 @@
+use std::fmt::Display;
+use std::os::unix::ffi::OsStrExt;
+use std::path::Path;
+
+/// Helper to format a path.
+#[derive(Debug)]
+pub struct PathQuotedDisplay<'a> {
+    path: &'a Path,
+}
+
+impl<'a> Display for PathQuotedDisplay<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(s) = self.path.to_str() {
+            if s.chars()
+                .all(|c| matches!(c, '/' | '.') || c.is_alphanumeric())
+            {
+                return f.write_str(s);
+            }
+        }
+        if let Ok(r) = shlex::bytes::try_quote(self.path.as_os_str().as_bytes()) {
+            if let Ok(s) = std::str::from_utf8(&r) {
+                return f.write_str(s);
+            }
+        }
+        // Should not happen really
+        return Err(std::fmt::Error);
+    }
+}
+
+impl<'a> PathQuotedDisplay<'a> {
+    /// Given a path, quote it in a way that it would be parsed by a default
+    /// POSIX shell. If the path is UTF-8 with no spaces or shell meta-characters,
+    /// it will be exactly the same as the input.
+    pub fn new<P: AsRef<Path>>(path: &'a P) -> PathQuotedDisplay<'a> {
+        PathQuotedDisplay {
+            path: path.as_ref(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_unquoted() {
+        for v in ["", "foo", "/foo/bar", "/foo/bar/../baz", "/foo9/bar10"] {
+            assert_eq!(v, format!("{}", PathQuotedDisplay::new(&v)));
+        }
+    }
+
+    #[test]
+    fn test_quoted() {
+        let cases = [
+            (" ", "' '"),
+            ("/some/path with spaces/", "'/some/path with spaces/'"),
+            ("/foo/!/bar&", "'/foo/!/bar&'"),
+            (r#"/path/"withquotes'"#, r#""/path/\"withquotes'""#),
+        ];
+        for (v, quoted) in cases {
+            assert_eq!(quoted, format!("{}", PathQuotedDisplay::new(&v)));
+        }
+    }
+}