refactor

- adapt to crate layout of git-quote
- add more tests

Author: Byron

git-quote/src/ansi_c.rs

@@ -1,9 +1,12 @@
+///
 pub mod undo {
     use bstr::{BStr, BString};
     use quick_error::quick_error;
 
     quick_error! {
+        /// The error returned by [ansi_c][crate::ansi_c::undo()].
         #[derive(Debug)]
+        #[allow(missing_docs)]
         pub enum Error {
             InvalidInput { message: String, input: BString } {
                 display("{}: {:?}", message, input)

git-quote/src/lib.rs

@@ -1,50 +1,9 @@
-#![deny(rust_2018_idioms)]
+//! Provides functions to quote and possibly unquote strings with different quoting styles.
+#![deny(rust_2018_idioms, missing_docs)]
 #![forbid(unsafe_code)]
 
-use bstr::{BStr, BString, ByteSlice};
-
 ///
 pub mod ansi_c;
 
-/// Transforms the given value to be suitable for use as an argument for Bourne shells by wrapping in single quotes
-pub fn to_single_quoted(mut value: &BStr) -> BString {
-    let mut quoted = BString::new(b"'".to_vec());
-
-    while let Some(pos) = value.find_byteset(b"!'") {
-        quoted.extend_from_slice(&value[..pos]);
-        quoted.extend_from_slice(b"'\\");
-        quoted.push(value[pos]);
-        quoted.push(b'\'');
-
-        value = &value[pos + 1..];
-    }
-
-    quoted.extend_from_slice(value);
-    quoted.push(b'\'');
-    quoted
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::to_single_quoted;
-    use bstr::BStr;
-
-    #[test]
-    fn quoted_strings() {
-        assert_eq!(to_single_quoted("my cool string".into()), "'my cool string'");
-        assert_eq!(to_single_quoted(r"'\''".into()), BStr::new(r"''\''\'\'''\'''"));
-        assert_eq!(
-            to_single_quoted("my 'quoted' string".into()),
-            BStr::new(r"'my '\''quoted'\'' string'")
-        );
-        assert_eq!(to_single_quoted(r"'\!'".into()), BStr::new(r"''\''\'\!''\'''"));
-        assert_eq!(
-            to_single_quoted("my excited string!!!".into()),
-            BStr::new(r"'my excited string'\!''\!''\!''")
-        );
-        assert_eq!(
-            to_single_quoted("\0my `even` ~cooler~ $t\\'ring\\// with \"quotes!\"".into()),
-            BStr::new("'\0my `even` ~cooler~ $t\\'\\''ring\\// with \"quotes'\\!'\"'")
-        );
-    }
-}
+mod single;
+pub use single::single;

git-quote/src/single.rs

@@ -0,0 +1,21 @@
+use bstr::{BStr, BString, ByteSlice};
+
+/// Transforms the given `value` to be suitable for use as an argument for Bourne shells by wrapping it into single quotes.
+///
+/// Every single-quote `'` is escaped with `\'`, every exclamation mark `!` is escaped with `\!`, and the entire string is enclosed
+/// in single quotes.
+pub fn single(mut value: &BStr) -> BString {
+    let mut quoted = BString::new(b"'".to_vec());
+
+    while let Some(pos) = value.find_byteset(b"!'") {
+        quoted.extend_from_slice(&value[..pos]);
+        quoted.push(b'\\');
+        quoted.push(value[pos]);
+
+        value = &value[pos + 1..];
+    }
+
+    quoted.extend_from_slice(value);
+    quoted.push(b'\'');
+    quoted
+}

git-quote/tests/quote.rs

@@ -1,3 +1,39 @@
+mod single {
+    use git_quote::single;
+
+    #[test]
+    fn empty() {
+        assert_eq!(single("".into()), "''");
+    }
+
+    #[test]
+    fn unquoted_becomes_quoted() {
+        assert_eq!(single("a".into()), "'a'");
+        assert_eq!(single("a b".into()), "'a b'");
+        assert_eq!(single("a\nb".into()), "'a\nb'", "newlines play no role");
+    }
+
+    #[test]
+    fn existing_exclamation_mark_gets_escaped() {
+        assert_eq!(single(r"a!b".into()), r"'a\!b'");
+        assert_eq!(single(r"!".into()), r"'\!'");
+        assert_eq!(single(r"\!".into()), r"'\\!'");
+    }
+
+    #[test]
+    fn existing_quote_gets_escaped() {
+        assert_eq!(single(r"a'b".into()), r"'a\'b'");
+        assert_eq!(single(r"'".into()), r"'\''");
+        assert_eq!(single(r"'\''".into()), r"'\'\\'\''");
+    }
+
+    #[test]
+    fn complex() {
+        let expected = "'\0cmd `arg` $var\\\\'ring\\// arg \"quoted\\!\"'";
+        assert_eq!(single("\0cmd `arg` $var\\'ring\\// arg \"quoted!\"".into()), expected);
+    }
+}
+
 mod ansi_c {
     mod undo {
         use bstr::ByteSlice;

git-transport/src/client/blocking_io/file.rs

@@ -10,8 +10,6 @@ use std::{
 
 use bstr::{io::BufReadExt, BStr, BString, ByteSlice};
 
-use git_quote::to_single_quoted;
-
 use crate::{
     client::{self, git, ssh, MessageKind, RequestWriter, SetServiceResponse, WriteMode},
     Protocol, Service,
@@ -215,13 +213,13 @@ impl client::Transport for SpawnProcessOnDemand {
         };
         cmd.stdin = Stdio::piped();
         cmd.stdout = Stdio::piped();
-        if self.ssh_cmd.is_some() {
+        let repo_path = if self.ssh_cmd.is_some() {
             cmd.args.push(service.as_str().into());
-            cmd.args
-                .push(to_single_quoted(self.path.as_ref()).to_os_str_lossy().into_owned());
+            git_quote::single(self.path.as_ref()).to_os_str_lossy().into_owned()
         } else {
-            cmd.args.push(self.path.to_os_str_lossy().into_owned());
-        }
+            self.path.to_os_str_lossy().into_owned()
+        };
+        cmd.args.push(repo_path);
 
         let mut cmd = std::process::Command::from(cmd);
         for env_to_remove in ENV_VARS_TO_REMOVE {