use anyhow::{anyhow, bail, Context, Result};
use std::cell::RefCell;
use std::io::{BufRead, BufReader, Read, Write};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::time::{Duration, Instant};
#[derive(Clone, Default)]
struct CtxData {
dir: Option<PathBuf>,
env: Vec<(String, String)>,
cancel: Option<Arc<AtomicBool>>,
}
thread_local! {
static CTX: RefCell<CtxData> = RefCell::new(CtxData::default());
}
pub(crate) struct Ctx(CtxData);
pub(crate) fn ctx_snapshot() -> Ctx {
Ctx(CTX.with(|ctx| ctx.borrow().clone()))
}
pub(crate) fn ctx_restore(ctx: Ctx) {
CTX.with(|current| *current.borrow_mut() = ctx.0);
}
impl Ctx {
pub(crate) fn with_cancel(mut self, flag: Arc<AtomicBool>) -> Ctx {
self.0.cancel = Some(flag);
self
}
}
fn ctx_cancelled() -> bool {
CTX.with(|ctx| {
ctx.borrow()
.cancel
.as_ref()
.is_some_and(|flag| flag.load(Ordering::Relaxed))
})
}
#[allow(dead_code)] pub fn with_ctx<T>(dir: &Path, env: Vec<(String, String)>, f: impl FnOnce() -> T) -> T {
struct Restore(Option<CtxData>);
impl Drop for Restore {
fn drop(&mut self) {
if let Some(previous) = self.0.take() {
CTX.with(|ctx| *ctx.borrow_mut() = previous);
}
}
}
let previous = CTX.with(|ctx| {
let mut ctx = ctx.borrow_mut();
let previous = ctx.clone();
ctx.dir = Some(dir.to_path_buf());
ctx.env.extend(env);
previous
});
let _restore = Restore(Some(previous));
f()
}
fn command_with(args: &[&str], defaults: &[(&str, &str)]) -> Command {
let mut command = Command::new("git");
command.args(args).envs(defaults.iter().copied());
CTX.with(|ctx| {
let ctx = ctx.borrow();
if let Some(dir) = &ctx.dir {
command.current_dir(dir);
}
command.envs(ctx.env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
});
command
}
pub fn run(args: &[&str]) -> Result<String> {
let started = Instant::now();
let output = command_with(args, &DEFAULT_ENV)
.output()
.with_context(|| format!("could not start git {}", args.join(" ")));
log_call(
args,
output.as_ref().ok().and_then(|o| o.status.code()),
started.elapsed().as_millis(),
);
let output = output?;
if !output.status.success() {
let detail = String::from_utf8_lossy(&output.stderr).trim().to_string();
bail!(
"{}",
if detail.is_empty() {
"git command failed".to_string()
} else {
detail
}
);
}
Ok(into_trimmed(output.stdout))
}
fn into_trimmed(bytes: Vec<u8>) -> String {
let mut text = String::from_utf8(bytes)
.unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
text.truncate(text.trim_end().len());
text
}
pub fn local_branches() -> Result<Vec<String>> {
Ok(parse_lines(&run(&["branch", "--format=%(refname:short)"])?))
}
fn parse_lines(text: &str) -> Vec<String> {
text.lines()
.map(str::trim)
.filter(|line| !line.is_empty())
.map(String::from)
.collect()
}
pub fn current_branch() -> Result<String> {
run(&["symbolic-ref", "--short", "-q", "HEAD"])
.or_else(|_| run(&["rev-parse", "--abbrev-ref", "HEAD"]))
}
pub fn status_lines() -> Result<Vec<String>> {
let status = run(&["status", "--short"])?;
Ok(if status.is_empty() {
vec!["(clean working tree)".into()]
} else {
status.lines().map(str::to_owned).collect()
})
}
#[derive(Debug, Clone)]
pub struct Identity {
pub name: String,
pub email: String,
}
pub fn has_local_config(key: &str) -> bool {
run(&["config", "--local", "--get", key]).is_ok_and(|value| !value.is_empty())
}
pub fn commit(message: &str, date: &str, amend: bool, identity: Option<&Identity>) -> Result<()> {
let args = if amend {
vec!["commit", "--amend", "-m", message]
} else {
vec!["commit", "-m", message]
};
let mut env = vec![("GIT_AUTHOR_DATE", date), ("GIT_COMMITTER_DATE", date)];
if let Some(id) = identity {
if !amend {
env.extend([
("GIT_AUTHOR_NAME", id.name.as_str()),
("GIT_AUTHOR_EMAIL", id.email.as_str()),
]);
}
env.extend([
("GIT_COMMITTER_NAME", id.name.as_str()),
("GIT_COMMITTER_EMAIL", id.email.as_str()),
]);
}
let opts = Opts {
env: &env,
..Opts::default()
};
let out = git_raw(&args, &opts)?;
if !out.ok() {
bail!("{}", legacy_detail(&out, true, "git commit failed"));
}
Ok(())
}
pub fn add_all() -> Result<()> {
let out = git_raw(&["add", "."], &Opts::default())?;
if !out.ok() {
bail!("{}", legacy_detail(&out, false, "git command failed"));
}
Ok(())
}
fn legacy_detail(out: &Out, with_stdout: bool, fallback: &str) -> String {
let stderr = out.stderr.trim();
if !stderr.is_empty() {
return stderr.to_string();
}
let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
if with_stdout && !stdout.is_empty() {
return stdout;
}
fallback.to_string()
}
pub fn branch_name_problem(branch: &str) -> Option<&'static str> {
if branch.is_empty() {
Some("it is empty")
} else if branch.starts_with('-') {
Some("it starts with '-'")
} else if branch.chars().any(|c| c.is_control() || c.is_whitespace()) {
Some("it contains spaces or control characters")
} else {
None
}
}
pub fn check_branch_name(branch: &str) -> Result<()> {
if let Some(problem) = branch_name_problem(branch) {
bail!("invalid branch name '{}': {problem}", branch.escape_debug());
}
if git_ok(&["check-ref-format", "--branch", branch], &Opts::default()).is_err() {
bail!("invalid branch name '{branch}'");
}
Ok(())
}
pub fn check_remote_name(remote: &str) -> Result<()> {
if let Some(problem) = branch_name_problem(remote) {
bail!("invalid remote name '{}': {problem}", remote.escape_debug());
}
Ok(())
}
pub fn push(branch: &str, force: bool, login: Option<&str>) -> Result<()> {
check_branch_name(branch)?;
let lease = force.then(|| format!("--force-with-lease=refs/heads/{branch}"));
let refspec = format!("refs/heads/{branch}:refs/heads/{branch}");
let args = push_args(
"origin",
&refspec,
lease.as_deref(),
false,
login,
force_if_includes(),
);
let args: Vec<&str> = args.iter().map(String::as_str).collect();
let opts = Opts {
timeout: Some(PUSH_TIMEOUT),
..Opts::default()
};
let out = git_raw(&args, &opts)?;
if !out.ok() {
bail!("{}", legacy_detail(&out, false, "git command failed"));
}
Ok(())
}
const PUSH_TIMEOUT: Duration = Duration::from_secs(300);
fn supports_force_if_includes(version: Option<(u32, u32, u32)>) -> bool {
version.is_none_or(|version| version >= (2, 30, 0))
}
fn force_if_includes() -> bool {
static SUPPORTED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
*SUPPORTED.get_or_init(|| supports_force_if_includes(version().ok()))
}
fn push_args(
remote: &str,
refspec: &str,
lease: Option<&str>,
set_upstream: bool,
login: Option<&str>,
if_includes: bool,
) -> Vec<String> {
let mut args = Vec::new();
if let Some(login) = login.filter(|login| !login.is_empty()) {
args.push("-c".to_string());
args.push(format!("credential.https://github.com.username={login}"));
}
args.push("push".into());
if set_upstream {
args.push("-u".into());
}
if let Some(lease) = lease {
args.push(lease.into());
if if_includes {
args.push("--force-if-includes".into());
}
}
args.push(remote.into());
args.push(refspec.into());
args
}
#[derive(Debug, Clone)]
pub struct Commit {
pub hash: String,
pub date: String,
pub subject: String,
pub refs: String,
}
pub fn recent_commits(limit: usize) -> Result<Vec<Commit>> {
let limit = limit.to_string();
let log = match run(&[
"log",
"-n",
&limit,
"--no-color",
"--date=short",
"--format=%h%x1f%ad%x1f%s%x1f%D",
]) {
Ok(log) => log,
Err(e) if e.to_string().contains("does not have any commits") => return Ok(vec![]),
Err(e) => return Err(e),
};
Ok(log
.lines()
.filter(|line| !line.trim().is_empty())
.filter_map(|line| {
let fields: Vec<&str> = line.split('\u{1f}').collect();
match fields[..] {
[hash, date, subject, refs] => Some(Commit {
hash: hash.to_string(),
date: date.to_string(),
subject: subject.to_string(),
refs: refs.to_string(),
}),
_ => None,
}
})
.collect())
}
pub fn remote_branches() -> Result<Vec<String>> {
let out = run(&["branch", "-r", "--no-color", "--format=%(refname:strip=2)"])?;
Ok(out
.lines()
.map(str::trim)
.filter(|b| !b.is_empty() && !b.ends_with("/HEAD"))
.map(str::to_owned)
.collect())
}
pub fn upstream(branch: &str) -> Result<Option<String>> {
let refname = format!("refs/heads/{branch}");
let out = run(&["for-each-ref", "--format=%(upstream:short)", &refname])?;
Ok(if out.is_empty() { None } else { Some(out) })
}
const DEFAULT_ENV: [(&str, &str); 6] = [
("GIT_TERMINAL_PROMPT", "0"),
("GIT_EDITOR", "true"),
("GIT_SEQUENCE_EDITOR", "true"),
("GIT_PAGER", "cat"),
("LC_ALL", "C"),
("GIT_OPTIONAL_LOCKS", "0"),
];
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(120);
const WRITE_TIMEOUT: Duration = Duration::from_secs(30 * 60);
const POLL: Duration = Duration::from_millis(25);
const DRAIN: Duration = if cfg!(test) {
Duration::from_secs(3)
} else {
Duration::from_secs(5)
};
const WRITE_COMMANDS: &[&str] = &[
"add",
"am",
"apply",
"bisect",
"branch",
"checkout",
"cherry-pick",
"clean",
"commit",
"config",
"gc",
"init",
"maintenance",
"merge",
"mv",
"notes",
"pack-refs",
"prune",
"pull",
"read-tree",
"rebase",
"reflog",
"repack",
"replace",
"reset",
"restore",
"revert",
"rm",
"sparse-checkout",
"stash",
"submodule",
"switch",
"symbolic-ref",
"tag",
"update-index",
"update-ref",
"worktree",
];
fn subcommand<'a>(args: &[&'a str]) -> Option<&'a str> {
let mut iter = args.iter();
while let Some(arg) = iter.next() {
match *arg {
"-c" | "-C" | "--git-dir" | "--work-tree" | "--namespace" | "--config-env" => {
iter.next();
}
arg if arg.starts_with('-') => {}
arg => return Some(arg),
}
}
None
}
fn default_timeout(args: &[&str]) -> Option<Duration> {
match subcommand(args) {
Some(sub) if WRITE_COMMANDS.contains(&sub) => Some(WRITE_TIMEOUT),
_ => Some(DEFAULT_TIMEOUT),
}
}
fn log_call(args: &[&str], code: Option<i32>, ms: u128) {
crate::cmdlog::record(args, code, ms);
#[cfg(test)]
LAST_CALL.with(|last| *last.borrow_mut() = Some((args.join(" "), code)));
}
#[cfg(test)]
thread_local! {
static LAST_CALL: RefCell<Option<(String, Option<i32>)>> = const { RefCell::new(None) };
}
fn kill_tree(child: &mut std::process::Child) {
#[cfg(windows)]
{
if let Ok(None) = child.try_wait() {
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
let _ = Command::new("taskkill")
.args(["/PID", &child.id().to_string(), "/T", "/F"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.creation_flags(CREATE_NO_WINDOW)
.status();
}
}
let _ = child.kill();
}
#[derive(Default, Clone, Copy)]
pub struct Opts<'a> {
pub stdin: Option<&'a [u8]>,
pub env: &'a [(&'a str, &'a str)],
pub max_lines: Option<usize>,
pub timeout: Option<Duration>,
pub cancel: Option<&'a AtomicBool>,
}
#[derive(Debug, Default)]
pub struct Out {
pub stdout: Vec<u8>,
pub stderr: String,
pub code: Option<i32>,
pub truncated: bool,
pub cancelled: bool,
}
impl Out {
pub fn ok(&self) -> bool {
self.code == Some(0)
}
pub fn text(&self) -> String {
into_trimmed(self.stdout.clone())
}
}
enum Stop {
Cancelled,
Truncated,
TimedOut,
}
fn exec(args: &[&str], o: &Opts, on_chunk: &mut dyn FnMut(&[u8]) -> bool) -> Result<Out> {
let started = Instant::now();
let mut command = command_with(args, &DEFAULT_ENV);
for (key, value) in o.env {
if value.is_empty() {
command.env_remove(key);
} else {
command.env(key, value);
}
}
command
.stdin(if o.stdin.is_some() {
Stdio::piped()
} else {
Stdio::null()
})
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = match command.spawn() {
Ok(child) => child,
Err(error) => {
log_call(args, None, started.elapsed().as_millis());
return Err(anyhow!(error).context(format!("could not start git {}", args.join(" "))));
}
};
if let (Some(data), Some(mut pipe)) = (o.stdin, child.stdin.take()) {
let data = data.to_vec();
std::thread::spawn(move || {
let _ = pipe.write_all(&data);
});
}
let err_buf = Arc::new(Mutex::new(Vec::new()));
let (err_done_tx, err_done_rx) = mpsc::channel::<()>();
if let Some(mut pipe) = child.stderr.take() {
let err_buf = Arc::clone(&err_buf);
std::thread::spawn(move || {
let _done = err_done_tx;
let mut chunk = [0u8; 8192];
loop {
match pipe.read(&mut chunk) {
Ok(0) => break,
Ok(n) => err_buf
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.extend_from_slice(&chunk[..n]),
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {}
Err(_) => break,
}
}
});
} else {
drop(err_done_tx);
}
let (out_tx, out_rx) = mpsc::sync_channel::<Vec<u8>>(1024);
if let Some(pipe) = child.stdout.take() {
std::thread::spawn(move || {
let mut reader = BufReader::new(pipe);
loop {
let mut chunk = Vec::new();
match reader.read_until(b'\n', &mut chunk) {
Ok(0) | Err(_) => break,
Ok(_) => {
if out_tx.send(chunk).is_err() {
break;
}
}
}
}
});
}
let timeout = o.timeout.or_else(|| default_timeout(args));
let timed_out = || timeout.is_some_and(|limit| started.elapsed() >= limit);
let cancelled = || o.cancel.is_some_and(|flag| flag.load(Ordering::Relaxed)) || ctx_cancelled();
let mut cut_off = false;
let mut drain_deadline: Option<Instant> = None;
let mut lines = 0usize;
let mut handle = |chunk: Vec<u8>| -> bool {
if o.max_lines.is_some_and(|max| lines >= max) {
return false;
}
lines += 1;
on_chunk(&chunk)
};
let mut stop: Option<Stop> = None;
let mut status = None;
loop {
if cancelled() {
stop = Some(Stop::Cancelled);
break;
}
if timed_out() {
stop = Some(Stop::TimedOut);
break;
}
match out_rx.recv_timeout(POLL) {
Ok(chunk) => {
if !handle(chunk) {
stop = Some(Stop::Truncated);
break;
}
}
Err(mpsc::RecvTimeoutError::Disconnected) => break,
Err(mpsc::RecvTimeoutError::Timeout) => {
if let Ok(Some(exit)) = child.try_wait() {
status = Some(exit);
let mut deadline = Instant::now() + DRAIN;
drain_deadline = Some(deadline);
loop {
if cancelled() {
stop = Some(Stop::Cancelled);
break;
}
let left = deadline.saturating_duration_since(Instant::now());
if left.is_zero() || timed_out() {
cut_off = true;
break;
}
match out_rx.recv_timeout(left.min(POLL)) {
Ok(chunk) => {
if !handle(chunk) {
stop = Some(Stop::Truncated);
break;
}
deadline = Instant::now() + DRAIN;
drain_deadline = Some(deadline);
}
Err(mpsc::RecvTimeoutError::Disconnected) => break,
Err(mpsc::RecvTimeoutError::Timeout) => {}
}
}
break;
}
}
}
}
while stop.is_none() && status.is_none() {
match child.try_wait() {
Ok(Some(exit)) => status = Some(exit),
Ok(None) => {
if cancelled() {
stop = Some(Stop::Cancelled);
} else if timed_out() {
stop = Some(Stop::TimedOut);
} else {
std::thread::sleep(POLL);
}
}
Err(_) => break,
}
}
let mut out = Out::default();
if stop.is_some() {
kill_tree(&mut child);
let _ = child.wait();
} else if status.is_none() {
status = child.wait().ok();
}
out.code = if stop.is_some() {
None
} else {
status.and_then(|s| s.code())
};
let grace = if stop.is_some() {
Duration::from_millis(500)
} else {
drain_deadline.map_or(DRAIN, |deadline| {
deadline.saturating_duration_since(Instant::now())
})
};
let _ = err_done_rx.recv_timeout(grace);
out.stderr = String::from_utf8_lossy(
&err_buf
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()),
)
.into_owned();
if cut_off && stop.is_none() {
out.truncated = true;
}
log_call(args, out.code, started.elapsed().as_millis());
match stop {
Some(Stop::TimedOut) => bail!(
"git {} timed out after {}s",
subcommand(args).unwrap_or(""),
timeout.unwrap_or_default().as_secs_f32()
),
Some(Stop::Cancelled) => out.cancelled = true,
Some(Stop::Truncated) => out.truncated = true,
None => {}
}
Ok(out)
}
pub fn git_raw(args: &[&str], o: &Opts) -> Result<Out> {
let mut stdout = Vec::new();
let mut out = exec(args, o, &mut |chunk| {
stdout.extend_from_slice(chunk);
true
})?;
out.stdout = stdout;
Ok(out)
}
pub fn git_ok(args: &[&str], o: &Opts) -> Result<String> {
let out = git_raw(args, o)?;
if out.cancelled {
bail!(crate::input::CANCELLED);
}
if out.truncated || out.ok() {
return Ok(into_trimmed(out.stdout));
}
Err(failure(args, &out))
}
fn failure(args: &[&str], out: &Out) -> anyhow::Error {
let stderr = out.stderr.trim();
if !stderr.is_empty() {
return anyhow!("{stderr}");
}
let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
if !stdout.is_empty() {
return anyhow!("{stdout}");
}
let code = out
.code
.map_or("killed".to_string(), |c| format!("exit {c}"));
anyhow!(
"git {} failed ({code})",
args.first().copied().unwrap_or("")
)
}
pub fn git_stream(args: &[&str], o: &Opts, on_line: &mut dyn FnMut(&[u8]) -> bool) -> Result<Out> {
exec(args, o, &mut |chunk| {
let line = chunk.strip_suffix(b"\n").unwrap_or(chunk);
let line = line.strip_suffix(b"\r").unwrap_or(line);
on_line(line)
})
}
pub fn parse_version(text: &str) -> Option<(u32, u32, u32)> {
let rest = text.trim().strip_prefix("git version ")?;
let token = rest.split_whitespace().next()?;
let mut parts = token.split('.').map(|part| {
let digits: String = part.chars().take_while(char::is_ascii_digit).collect();
digits.parse::<u32>().ok()
});
let major = parts.next()??;
let minor = parts.next()??;
let patch = parts.next().flatten().unwrap_or(0);
Some((major, minor, patch))
}
pub fn version() -> Result<(u32, u32, u32)> {
let text = git_ok(&["--version"], &Opts::default())?;
parse_version(&text).ok_or_else(|| anyhow!("could not read the git version from '{text}'"))
}
fn lease_arg(lease: &str) -> String {
let refname = lease.split_once(':').map_or(lease, |(refname, _)| refname);
if refname.is_empty() {
"--force-with-lease".to_string()
} else {
format!("--force-with-lease={refname}")
}
}
#[allow(dead_code)] pub fn push_to(
remote: &str,
branch: &str,
lease: Option<&str>,
set_upstream: bool,
login: Option<&str>,
) -> Result<String> {
push_to_cancellable(remote, branch, lease, set_upstream, login, None)
}
pub fn push_to_cancellable(
remote: &str,
branch: &str,
lease: Option<&str>,
set_upstream: bool,
login: Option<&str>,
cancel: Option<&AtomicBool>,
) -> Result<String> {
check_remote_name(remote)?;
check_branch_name(branch)?;
let refspec = format!("refs/heads/{branch}:refs/heads/{branch}");
let lease = lease.map(lease_arg);
let args = push_args(
remote,
&refspec,
lease.as_deref(),
set_upstream,
login,
force_if_includes(),
);
let args: Vec<&str> = args.iter().map(String::as_str).collect();
let opts = Opts {
timeout: Some(PUSH_TIMEOUT),
cancel,
..Opts::default()
};
let out = git_raw(&args, &opts)?;
if out.cancelled {
bail!(crate::input::CANCELLED);
}
if !out.ok() {
return Err(failure(&args, &out));
}
let mut report = out.stderr.trim().to_string();
let stdout = out.text();
if !stdout.is_empty() {
if !report.is_empty() {
report.push('\n');
}
report.push_str(&stdout);
}
Ok(report)
}
#[cfg(test)]
mod runner_tests {
use super::*;
use crate::testutil::TempRepo;
#[test]
fn parses_versions() {
let cases = [
("git version 2.43.0.windows.1", Some((2, 43, 0))),
("git version 2.39.3 (Apple Git-146)", Some((2, 39, 3))),
("git version 2.30.1\n", Some((2, 30, 1))),
("git version 2.30", Some((2, 30, 0))),
("git version 3.0.0-rc1", Some((3, 0, 0))),
("git version x.y", None),
("hello", None),
("", None),
];
for (text, expected) in cases {
assert_eq!(parse_version(text), expected, "{text}");
}
let (major, _, _) = version().unwrap();
assert!(major >= 2);
}
#[test]
fn raw_keeps_exit_code() {
let repo = TempRepo::new(1);
let out = repo.run(|| git_raw(&["rev-parse", "--verify", "nope"], &Opts::default()));
let out = out.unwrap();
assert_ne!(out.code, Some(0));
assert!(out.code.is_some());
assert!(!out.cancelled && !out.truncated);
let error = repo.run(|| git_ok(&["rev-parse", "--verify", "nope"], &Opts::default()));
assert!(!error.unwrap_err().to_string().is_empty());
let head = repo
.run(|| git_ok(&["rev-parse", "HEAD"], &Opts::default()))
.unwrap();
assert_eq!(head, repo.git(&["rev-parse", "HEAD"]));
}
#[test]
fn stdin_round_trip() {
let repo = TempRepo::new(0);
let opts = Opts {
stdin: Some(b"hello\n"),
..Opts::default()
};
let oid = repo
.run(|| git_ok(&["hash-object", "--stdin"], &opts))
.unwrap();
assert_eq!(oid, "ce013625030ba8dba906f756967f9e9ca394464a");
}
#[test]
fn max_lines_truncates() {
let repo = TempRepo::new(5);
let opts = Opts {
max_lines: Some(2),
..Opts::default()
};
let out = repo
.run(|| git_raw(&["log", "--format=%H"], &opts))
.unwrap();
assert!(out.truncated);
assert_eq!(out.text().lines().count(), 2);
let out = repo
.run(|| {
git_raw(
&["log", "--format=%H"],
&Opts {
max_lines: Some(5),
..opts
},
)
})
.unwrap();
assert!(!out.truncated && out.ok());
assert_eq!(out.text().lines().count(), 5);
}
#[test]
fn stream_stops_when_asked() {
let repo = TempRepo::new(4);
let mut seen = Vec::new();
let out = repo
.run(|| {
git_stream(&["log", "--format=%s"], &Opts::default(), &mut |line| {
seen.push(String::from_utf8_lossy(line).into_owned());
seen.len() < 2
})
})
.unwrap();
assert!(out.truncated);
assert_eq!(seen, ["commit 4", "commit 3"]);
let mut all = 0;
let out = repo
.run(|| {
git_stream(&["log", "--format=%s"], &Opts::default(), &mut |_| {
all += 1;
true
})
})
.unwrap();
assert!(out.ok() && !out.truncated && out.stdout.is_empty());
assert_eq!(all, 4);
}
const SLOW: [&str; 3] = ["-c", "alias.slow=!sleep 3", "slow"];
#[test]
fn timeout_kills_git() {
let opts = Opts {
timeout: Some(Duration::from_millis(300)),
..Opts::default()
};
let started = Instant::now();
let result = TempRepo::outside().run(|| git_raw(&SLOW, &opts));
assert!(result.unwrap_err().to_string().contains("timed out"));
assert!(started.elapsed() < Duration::from_millis(2500));
}
#[test]
fn cancel_kills_git() {
let repo = TempRepo::new(0);
let flag = AtomicBool::new(false);
let started = Instant::now();
let out = std::thread::scope(|scope| {
scope.spawn(|| {
std::thread::sleep(Duration::from_millis(200));
flag.store(true, Ordering::Relaxed);
});
let opts = Opts {
cancel: Some(&flag),
..Opts::default()
};
TempRepo::outside().run(|| git_raw(&SLOW, &opts))
})
.unwrap();
assert!(out.cancelled && out.code.is_none());
assert!(started.elapsed() < Duration::from_millis(2500));
let opts = Opts {
cancel: Some(&flag),
..Opts::default()
};
let error = repo.run(|| git_ok(&["status"], &opts)).unwrap_err();
assert!(crate::input::is_cancel(&error));
}
#[test]
fn with_ctx_targets_repo_and_restores() {
let a = TempRepo::new(1);
let b = TempRepo::new(2);
let top =
|r: &TempRepo| r.run(|| git_ok(&["rev-list", "--count", "HEAD"], &Opts::default()));
assert_eq!(top(&a).unwrap(), "1");
assert_eq!(top(&b).unwrap(), "2");
a.run(|| {
b.run(|| assert_eq!(run(&["rev-list", "--count", "HEAD"]).unwrap(), "2"));
assert_eq!(run(&["rev-list", "--count", "HEAD"]).unwrap(), "1");
let ctx = ctx_snapshot();
let count = std::thread::spawn(move || {
ctx_restore(ctx);
run(&["rev-list", "--count", "HEAD"]).unwrap()
})
.join()
.unwrap();
assert_eq!(count, "1");
});
assert!(CTX.with(|ctx| ctx.borrow().dir.is_none()));
}
#[test]
fn calls_are_logged() {
let repo = TempRepo::new(1);
let args = ["log", "-1", "--format=%H", "--grep=cmdlog-probe-xyz"];
let out = repo.run(|| git_raw(&args, &Opts::default())).unwrap();
assert_eq!(out.code, Some(0));
let last = LAST_CALL.with(|last| last.borrow().clone());
assert_eq!(last, Some((args.join(" "), Some(0))));
repo.run(|| run(&["rev-parse", "--verify", "nope"]))
.unwrap_err();
let last = LAST_CALL.with(|last| last.borrow().clone()).unwrap();
assert_eq!(last.0, "rev-parse --verify nope");
assert!(last.1.is_some_and(|code| code != 0));
}
#[test]
fn output_is_never_lost_under_load() {
let repo = TempRepo::new(3);
std::thread::scope(|scope| {
for _ in 0..8 {
scope.spawn(|| {
repo.run(|| {
for _ in 0..25 {
let count = git_ok(&["rev-list", "--count", "HEAD"], &Opts::default());
assert_eq!(count.unwrap(), "3");
}
})
});
}
});
}
#[test]
fn leftover_child_holding_stdout_is_cut_off() {
let args = ["-c", "alias.bg=!echo hi; (cd / && sleep 8 &)", "bg"];
let started = Instant::now();
let out = TempRepo::outside()
.run(|| git_raw(&args, &Opts::default()))
.unwrap();
assert_eq!(out.text(), "hi");
assert_eq!(out.code, Some(0));
assert!(out.truncated);
assert!(started.elapsed() < Duration::from_secs(8));
}
#[test]
fn write_commands_get_the_long_write_timeout() {
let write = Some(WRITE_TIMEOUT);
let cases: [(&[&str], Option<Duration>); 12] = [
(&["status"], Some(DEFAULT_TIMEOUT)),
(&["log", "-1"], Some(DEFAULT_TIMEOUT)),
(&["fetch", "origin"], Some(DEFAULT_TIMEOUT)),
(
&["-c", "core.x=1", "rev-parse", "HEAD"],
Some(DEFAULT_TIMEOUT),
),
(&["add", "."], write),
(&["commit", "--amend", "-m", "x"], write),
(&["-c", "credential.helper=x", "stash", "push", "-u"], write),
(&["-C", "dir", "rebase", "--continue"], write),
(&["--no-pager", "cherry-pick", "abc"], write),
(&["update-ref", "refs/x", "abc"], write),
(&["reset", "--hard"], write),
(&[], Some(DEFAULT_TIMEOUT)),
];
for (args, expected) in cases {
assert_eq!(default_timeout(args), expected, "{args:?}");
}
for sub in [
"apply", "am", "revert", "merge", "switch", "checkout", "restore", "clean", "branch",
"tag", "config", "worktree", "gc", "prune", "pull",
] {
assert_eq!(default_timeout(&[sub]), write, "{sub}");
}
assert_eq!(WRITE_TIMEOUT, Duration::from_secs(1800));
}
#[test]
fn slow_callback_does_not_cut_off_the_drain() {
let args = [
"-c",
"alias.late=!echo a; (cd / && sleep 1 && echo b && echo c) &",
"late",
];
let mut seen = Vec::new();
let out = TempRepo::outside()
.run(|| {
git_stream(&args, &Opts::default(), &mut |line| {
let line = String::from_utf8_lossy(line).into_owned();
if line == "b" {
std::thread::sleep(DRAIN + Duration::from_millis(500));
}
seen.push(line);
true
})
})
.unwrap();
assert_eq!(seen, ["a", "b", "c"]);
assert_eq!(out.code, Some(0));
assert!(!out.truncated);
}
#[test]
fn ctx_cancel_flag_kills_git() {
let flag = Arc::new(AtomicBool::new(false));
let ctx = ctx_snapshot().with_cancel(Arc::clone(&flag));
let started = Instant::now();
let out = std::thread::scope(|scope| {
scope.spawn(|| {
std::thread::sleep(Duration::from_millis(200));
flag.store(true, Ordering::Relaxed);
});
scope
.spawn(move || {
ctx_restore(ctx);
TempRepo::outside().run(|| git_raw(&SLOW, &Opts::default()))
})
.join()
.unwrap()
})
.unwrap();
assert!(out.cancelled && out.code.is_none());
assert!(started.elapsed() < Duration::from_millis(2500));
}
#[test]
fn force_if_includes_needs_git_2_30() {
assert!(supports_force_if_includes(Some((2, 30, 0))));
assert!(supports_force_if_includes(Some((2, 43, 1))));
assert!(supports_force_if_includes(Some((3, 0, 0))));
assert!(!supports_force_if_includes(Some((2, 29, 9))));
assert!(!supports_force_if_includes(Some((1, 9, 0))));
assert!(supports_force_if_includes(None));
assert_eq!(
push_args(
"o",
"r",
Some("--force-with-lease=refs/heads/a"),
false,
None,
false
),
["push", "--force-with-lease=refs/heads/a", "o", "r"]
);
}
#[test]
fn branch_names_are_validated() {
for bad in ["", "-f", "--mirror", "--delete", "a b", "x\ny", "tab\t"] {
assert!(branch_name_problem(bad).is_some(), "{bad:?}");
}
for good in ["main", "feat/x", "release-1.0", "ünï"] {
assert!(branch_name_problem(good).is_none(), "{good}");
}
let repo = TempRepo::new(1);
repo.run(|| {
assert!(check_branch_name("main").is_ok());
assert!(check_branch_name("feat/x").is_ok());
for bad in ["--mirror", "a..b", "x~1", "end.lock", "-f"] {
assert!(check_branch_name(bad).is_err(), "{bad}");
}
assert!(check_remote_name("origin").is_ok());
assert!(check_remote_name("--upload-pack=x").is_err());
assert!(check_remote_name("").is_err());
});
}
#[test]
fn lease_drops_the_expected_oid() {
assert_eq!(
lease_arg("refs/heads/feat:0123abcd"),
"--force-with-lease=refs/heads/feat"
);
assert_eq!(
lease_arg("refs/heads/feat"),
"--force-with-lease=refs/heads/feat"
);
assert_eq!(lease_arg(""), "--force-with-lease");
assert_eq!(
push_args(
"origin",
"refs/heads/a:refs/heads/a",
Some("--force-with-lease"),
true,
Some("me"),
true
),
[
"-c",
"credential.https://github.com.username=me",
"push",
"-u",
"--force-with-lease",
"--force-if-includes",
"origin",
"refs/heads/a:refs/heads/a",
]
);
assert_eq!(
push_args("o", "r", None, false, Some(""), true),
["push", "o", "r"]
);
}
#[test]
fn push_rejects_option_like_names_and_pushes_refspec() {
let repo = TempRepo::new(1).with_remote();
repo.run(|| {
for bad in ["--mirror", "-f", "--delete", ""] {
assert!(push(bad, false, None).is_err(), "{bad}");
assert!(push_to("origin", bad, None, false, None).is_err(), "{bad}");
}
assert!(push_to("--mirror", "main", None, false, None).is_err());
});
let remote = repo.remote_path();
let remote = remote.to_string_lossy();
assert_eq!(
repo.git(&["--git-dir", &remote, "rev-parse", "main"]),
repo.git(&["rev-parse", "HEAD"])
);
repo.write("n.txt", "n\n");
repo.git(&["add", "."]);
repo.git(&["commit", "-q", "-m", "next"]);
repo.run(|| push("main", false, None)).unwrap();
assert_eq!(
repo.git(&["--git-dir", &remote, "rev-parse", "main"]),
repo.git(&["rev-parse", "HEAD"])
);
repo.git(&["commit", "-q", "--amend", "-m", "next (amended)"]);
repo.run(|| push("main", true, None)).unwrap();
assert_eq!(
repo.git(&["--git-dir", &remote, "rev-parse", "main"]),
repo.git(&["rev-parse", "HEAD"])
);
repo.git(&["commit", "-q", "--amend", "-m", "again"]);
let error = repo
.run(|| push("main", false, None))
.unwrap_err()
.to_string();
assert!(error.contains("rejected"), "{error}");
}
#[test]
fn push_to_cancellable_honours_cancel() {
let repo = TempRepo::new(1).with_remote();
let flag = AtomicBool::new(true);
let error = repo
.run(|| push_to_cancellable("origin", "main", None, false, None, Some(&flag)))
.unwrap_err();
assert!(crate::input::is_cancel(&error));
let report = repo.run(|| push_to_cancellable("origin", "main", None, false, None, None));
assert!(report.is_ok(), "{report:?}");
}
#[test]
fn legacy_commit_and_add_keep_their_errors() {
let repo = TempRepo::new(1);
let error = repo
.run(|| commit("x", "2026-01-02 10:00:00", false, None))
.unwrap_err();
assert!(error.to_string().contains("nothing to commit"), "{error}");
repo.write("a.txt", "a\n");
repo.run(add_all).unwrap();
assert!(repo
.git(&["diff", "--cached", "--name-only"])
.contains("a.txt"));
let id = Identity {
name: "Ann".into(),
email: "ann@example.com".into(),
};
repo.run(|| commit("add a", "2026-01-02 10:00:00", false, Some(&id)))
.unwrap();
assert_eq!(
repo.git(&["log", "-1", "--format=%an|%ae|%s"]),
"Ann|ann@example.com|add a"
);
let outside = TempRepo::outside();
assert!(!outside.run(add_all).unwrap_err().to_string().is_empty());
}
#[test]
fn run_uses_c_locale() {
let repo = TempRepo::new(0);
let german = vec![
("LANG".to_string(), "de_DE.UTF-8".to_string()),
("LANGUAGE".to_string(), "de".to_string()),
];
let commits = repo.run(|| with_ctx(repo.path(), german, || recent_commits(5)));
assert!(commits.unwrap().is_empty());
}
}
#[cfg(test)]
mod plumbing_tests {
use super::*;
#[test]
fn trims_end_but_keeps_leading_space() {
assert_eq!(into_trimmed(b" M file\n\n".to_vec()), " M file");
}
#[test]
fn invalid_utf8_is_lossy() {
assert_eq!(into_trimmed(vec![b'a', 0xff, b'\n']), "a\u{fffd}");
}
#[test]
fn parses_branch_lines() {
assert_eq!(
parse_lines("main\n dev \n\nfeat/x"),
["main", "dev", "feat/x"]
);
}
}