feat: add git utility to call git easily like git(cwd, "log --oneline")

codex · Byron · Byron · commit fa02742da12e · 2026-05-12T11:54:33.000+08:00
Co-authored-by: Sebastian Thiel &lt;sebastian.thiel@icloud.com&gt;
diff --git a/tests/tools/src/lib.rs b/tests/tools/src/lib.rs
@@ -1244,6 +1244,90 @@ pub fn object_hash() -> gix_hash::Kind {
     object_hash_from_env().unwrap_or_default()
 }
 
+/// Run `git` in `current_dir` with shell-like whitespace-separated `arguments`, returning stdout as UTF-8.
+///
+/// Note that Git is run as isolated as possible, just like scripts.
+///
+/// Arguments may be split across multiple lines. Single and double quotes can be used to keep whitespace
+/// within an argument, for example `commit -m 'a message with spaces'`.
+pub fn git(current_dir: impl AsRef<Path>, arguments: &str) -> Result<String> {
+    let args = split_git_arguments(arguments)?;
+    let cwd = current_dir.as_ref();
+    let mut cmd = std::process::Command::new(GIT_PROGRAM);
+    let output = configure_command(&mut cmd, object_hash(), args.iter().map(String::as_str), cwd)
+        .current_dir(cwd)
+        .output()?;
+    if !output.status.success() {
+        return Err(format!(
+            "{cmd:?} failed with status {}\nstdout: {}\nstderr: {}",
+            output.status,
+            output.stdout.as_bstr(),
+            output.stderr.as_bstr()
+        )
+        .into());
+    }
+    Ok(String::from_utf8(output.stdout)?)
+}
+
+fn split_git_arguments(input: &str) -> Result<Vec<String>> {
+    let mut args = Vec::new();
+    let mut arg = String::new();
+    let mut quote = None;
+    let mut has_arg = false;
+    let mut chars = input.chars();
+
+    while let Some(ch) = chars.next() {
+        match quote {
+            Some('\'') => {
+                if ch == '\'' {
+                    quote = None;
+                } else {
+                    arg.push(ch);
+                }
+            }
+            Some('"') => {
+                if ch == '"' {
+                    quote = None;
+                } else if ch == '\\' {
+                    if let Some(next) = chars.next() {
+                        arg.push(next);
+                    }
+                } else {
+                    arg.push(ch);
+                }
+            }
+            Some(_) => unreachable!("only single and double quotes are set"),
+            None => {
+                if ch.is_whitespace() {
+                    if has_arg {
+                        args.push(std::mem::take(&mut arg));
+                        has_arg = false;
+                    }
+                } else if matches!(ch, '\'' | '"') {
+                    quote = Some(ch);
+                    has_arg = true;
+                } else if ch == '\\' {
+                    if let Some(next) = chars.next() {
+                        arg.push(next);
+                    }
+                    has_arg = true;
+                } else {
+                    arg.push(ch);
+                    has_arg = true;
+                }
+            }
+        }
+    }
+
+    if let Some(quote) = quote {
+        return Err(format!("unterminated {quote:?} quote in git arguments").into());
+    }
+    if has_arg {
+        args.push(arg);
+    }
+    Ok(args)
+}
+
 /// Normalize debug-formatted `value` so one snapshot can be reused for SHA-1 and SHA-256 fixtures.
 ///
 /// The helper rewrites 40- and 64-character hexadecimal object IDs to stable `Oid(<n>)`
diff --git a/tests/tools/src/tests.rs b/tests/tools/src/tests.rs
@@ -137,6 +137,71 @@ fn invoke_bash_runs_in_given_working_directory() {
     );
 }
 
+#[test]
+fn split_git_arguments_handles_multiline_whitespace() {
+    assert_eq!(
+        split_git_arguments(
+            "log
+             --graph
+             --oneline",
+        )
+        .expect("valid arguments"),
+        ["log", "--graph", "--oneline"]
+    );
+}
+
+#[test]
+fn split_git_arguments_handles_quoted_arguments() {
+    assert_eq!(
+        split_git_arguments(
+            "commit
+             -m 'subject with spaces'
+             --author=\"A U Thor <author@example.com>\"",
+        )
+        .expect("valid arguments"),
+        [
+            "commit",
+            "-m",
+            "subject with spaces",
+            "--author=A U Thor <author@example.com>"
+        ]
+    );
+}
+
+#[test]
+fn split_git_arguments_handles_empty_quoted_arguments() {
+    assert_eq!(
+        split_git_arguments("diff -- pathspec:''").expect("valid arguments"),
+        ["diff", "--", "pathspec:"]
+    );
+    assert_eq!(
+        split_git_arguments("diff -- ''").expect("valid arguments"),
+        ["diff", "--", ""]
+    );
+}
+
+#[test]
+fn split_git_arguments_handles_escaped_whitespace() {
+    assert_eq!(
+        split_git_arguments(r"add path\ with\ spaces").expect("valid arguments"),
+        ["add", "path with spaces"]
+    );
+}
+
+#[test]
+fn split_git_arguments_concatenates_quoted_and_unquoted_parts() {
+    assert_eq!(
+        split_git_arguments(r#"commit -m prefix" quoted "suffix"#).expect("valid arguments"),
+        ["commit", "-m", "prefix quoted suffix"]
+    );
+}
+
+#[test]
+fn split_git_arguments_rejects_unterminated_quotes() {
+    assert!(split_git_arguments("commit -m 'unterminated").is_err());
+    assert!(split_git_arguments("commit -m \"unterminated").is_err());
+}
+
 #[test]
 fn normalize_debug_snapshot_returns_replaced_ids_by_placeholder_index() {
     let first = gix_hash::ObjectId::from_hex(b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391").expect("valid SHA1");
