feat: Generic hook running

Author: epage

Cargo.toml

@@ -33,6 +33,7 @@ pre-release-replacements = [
 git2 = { version = "0.14", default-features = false }
 log = "0.4"
 itertools = "0.10"
+which = "4"
 
 [dev-dependencies]
 git-fixture = { version = "0.2" }

src/hooks.rs

@@ -0,0 +1,93 @@
+use std::io::Write;
+
+#[derive(Clone, Debug)]
+pub struct Hooks {
+    root: std::path::PathBuf,
+}
+
+impl Hooks {
+    pub fn new(hook_root: impl Into<std::path::PathBuf>) -> Self {
+        Self {
+            root: hook_root.into(),
+        }
+    }
+
+    pub fn with_repo(repo: &git2::Repository) -> Result<Self, git2::Error> {
+        let config = repo.config()?;
+        let root = config
+            .get_path("core.hooksPath")
+            .unwrap_or_else(|_| repo.path().join("hooks"));
+        Ok(Self::new(root))
+    }
+
+    pub fn root(&self) -> &std::path::Path {
+        &self.root
+    }
+
+    pub fn run_hook(
+        &self,
+        repo: &git2::Repository,
+        name: &str,
+        args: &[&str],
+        stdin: Option<&[u8]>,
+        env: &[(&str, &str)],
+    ) -> Result<i32, std::io::Error> {
+        let hook_path = self.root().join(name);
+        if !hook_path.exists() {
+            return Ok(0);
+        }
+
+        let path = {
+            let mut path_components: Vec<std::path::PathBuf> =
+                vec![std::fs::canonicalize(self.root())?];
+            if let Some(path) = std::env::var_os(std::ffi::OsStr::new("PATH")) {
+                path_components.extend(std::env::split_paths(&path));
+            }
+            std::env::join_paths(path_components)
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?
+        };
+
+        let sh_path = crate::utils::git_sh().ok_or_else(|| {
+            std::io::Error::new(std::io::ErrorKind::NotFound, "No `sh` for running hooks")
+        })?;
+
+        // From `githooks(5)`:
+        // > Before Git invokes a hook, it changes its working directory to either $GIT_DIR in a bare
+        // > repository or the root of the working tree in a non-bare repository. An exception are
+        // > hooks triggered during a push (pre-receive, update, post-receive, post-update,
+        // > push-to-checkout) which are always executed in $GIT_DIR.
+        let cwd = if PUSH_HOOKS.contains(&name) {
+            repo.path()
+        } else {
+            repo.workdir().unwrap_or_else(|| repo.path())
+        };
+
+        let mut cmd = std::process::Command::new(sh_path);
+        cmd.arg("-c")
+            .arg(format!("{} \"$@\"", name))
+            .arg(name) // "$@" expands "$1" "$2" "$3" ... but we also must specify $0.
+            .args(args)
+            .env("PATH", path)
+            .current_dir(cwd)
+            .stdin(std::process::Stdio::piped());
+        for (key, value) in env.iter().copied() {
+            cmd.env(key, value);
+        }
+        let mut process = cmd.spawn()?;
+        if let Some(stdin) = stdin {
+            process.stdin.as_mut().unwrap().write_all(stdin)?;
+        }
+        let exit = process.wait()?;
+
+        const SIGNAL_EXIT_CODE: i32 = 1;
+        Ok(exit.code().unwrap_or(SIGNAL_EXIT_CODE))
+    }
+}
+
+const PUSH_HOOKS: &[&str] = &[
+    "pre-receive",
+    "update",
+    "post-receive",
+    "post-update",
+    "push-to-checkout",
+];

src/lib.rs

@@ -1 +1,3 @@
+pub mod hooks;
 pub mod ops;
+pub mod utils;

src/utils.rs

@@ -0,0 +1,26 @@
+/// Path to a shell suitable for running hooks.
+pub fn git_sh() -> Option<std::path::PathBuf> {
+    let exe_name = if cfg!(target_os = "windows") {
+        "bash.exe"
+    } else {
+        "sh"
+    };
+
+    if cfg!(target_os = "windows") {
+        // Prefer git-bash since that is how git will normally be running the hooks
+        if let Some(path) = find_git_bash() {
+            return Some(path);
+        }
+    }
+
+    which::which(exe_name).ok()
+}
+
+fn find_git_bash() -> Option<std::path::PathBuf> {
+    // Git is typically installed at C:\Program Files\Git\cmd\git.exe with the cmd\ directory
+    // in the path, however git-bash is usually not in PATH and is in bin\ directory:
+    let git_path = which::which("git.exe").ok()?;
+    let git_dir = git_path.parent()?.parent()?;
+    let git_bash = git_dir.join("bin").join("bash.exe");
+    git_bash.is_file().then(|| git_bash)
+}