git2-hooks: allows customizing what places to look for hooks (gitui-org#1975)

* allows customizing what places to look for hooks

Author: extrawurst

Cargo.lock

@@ -17,7 +17,7 @@ crossbeam-channel = "0.5"
 easy-cast = "0.5"
 fuzzy-matcher = "0.3"
 git2 = "0.17"
-git2-hooks = { path = "../git2-hooks", version = "0.2" }
+git2-hooks = { path = "../git2-hooks", version = "0.3" }
 log = "0.4"
 # git2 = { path = "../../extern/git2-rs", features = ["vendored-openssl"]}
 # git2 = { git="https://github.com/extrawurst/git2-rs.git", rev="fc13dcc", features = ["vendored-openssl"]}

asyncgit/Cargo.toml

@@ -14,10 +14,13 @@ pub enum HookResult {
 impl From<git2_hooks::HookResult> for HookResult {
 fn from(v: git2_hooks::HookResult) -> Self {
 match v {
-git2_hooks::HookResult::Ok => Self::Ok,
-git2_hooks::HookResult::NotOk { stdout, stderr } => {
-Self::NotOk(format!("{stdout}{stderr}"))
-}
+git2_hooks::HookResult::Ok { .. }
+| git2_hooks::HookResult::NoHookFound => Self::Ok,
+git2_hooks::HookResult::RunNotSuccessful {
+stdout,
+stderr,
+..
+} => Self::NotOk(format!("{stdout}{stderr}")),
 }
 }
 }
@@ -34,7 +37,7 @@ pub fn hooks_commit_msg(
 
 let repo = repo(repo_path)?;
 
-Ok(git2_hooks::hooks_commit_msg(&repo, msg)?.into())
+Ok(git2_hooks::hooks_commit_msg(&repo, None, msg)?.into())
 }
 
 /// this hook is documented here <https://git-scm.com/docs/githooks#_pre_commit>
@@ -44,7 +47,7 @@ pub fn hooks_pre_commit(repo_path: &RepoPath) -> Result<HookResult> {
 
 let repo = repo(repo_path)?;
 
-Ok(git2_hooks::hooks_pre_commit(&repo)?.into())
+Ok(git2_hooks::hooks_pre_commit(&repo, None)?.into())
 }
 
 ///
@@ -53,7 +56,7 @@ pub fn hooks_post_commit(repo_path: &RepoPath) -> Result<HookResult> {
 
 let repo = repo(repo_path)?;
 
-Ok(git2_hooks::hooks_post_commit(&repo)?.into())
+Ok(git2_hooks::hooks_post_commit(&repo, None)?.into())
 }
 
 #[cfg(test)]

asyncgit/src/sync/hooks.rs

@@ -1,11 +1,12 @@
 [package]
 name = "git2-hooks"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["extrawurst <mail@rusticorn.com>"]
 edition = "2021"
 description = "adds git hooks support based on git2-rs"
 homepage = "https://github.com/extrawurst/gitui"
 repository = "https://github.com/extrawurst/gitui"
+documentation = "https://docs.rs/git2-hooks/"
 readme = "README.md"
 license = "MIT"
 categories = ["development-tools"]

git2-hooks/Cargo.toml

@@ -2,3 +2,7 @@
 
 adds git hook functionality on top of git2-rs
 
+## todo
+
+- [ ] unittest coverage symlinks from `.git/hooks/<hook>` -> `X`
+- [ ] unittest coverage `~` expansion inside `core.hooksPath`

git2-hooks/README.md

@@ -3,6 +3,10 @@ use thiserror::Error;
 ///
 #[derive(Error, Debug)]
 pub enum HooksError {
+///
+#[error("git error:{0}")]
+Git(#[from] git2::Error),
+
 ///
 #[error("io error:{0}")]
 Io(#[from] std::io::Error),

git2-hooks/src/error.rs

@@ -12,56 +12,106 @@ pub struct HookPaths {
 pub pwd: PathBuf,
 }
 
+const CONFIG_HOOKS_PATH: &str = "core.hooksPath";
+const DEFAULT_HOOKS_PATH: &str = "hooks";
+
 impl HookPaths {
-pub fn new(repo: &Repository, hook: &str) -> Result<Self> {
+/// `core.hooksPath` always takes precendence.
+/// If its defined and there is no hook `hook` this is not considered
+/// an error or a reason to search in other paths.
+/// If the config is not set we go into search mode and
+/// first check standard `.git/hooks` folder and any sub path provided in `other_paths`.
+///
+/// Note: we try to model as closely as possible what git shell is doing.
+pub fn new(
+repo: &Repository,
+other_paths: Option<&[&str]>,
+hook: &str,
+) -> Result<Self> {
 let pwd = repo
 .workdir()
 .unwrap_or_else(|| repo.path())
 .to_path_buf();
 
 let git_dir = repo.path().to_path_buf();
-let hooks_path = repo
-.config()
-.and_then(|config| config.get_string("core.hooksPath"))
-.map_or_else(
-|e| {
-log::error!("hookspath error: {}", e);
-repo.path().to_path_buf().join("hooks/")
-},
-PathBuf::from,
-);
 
-let hook = hooks_path.join(hook);
+if let Some(config_path) = Self::config_hook_path(repo)? {
+let hooks_path = PathBuf::from(config_path);
+
+let hook = hooks_path.join(hook);
+
+let hook = shellexpand::full(
+hook.as_os_str()
+.to_str()
+.ok_or(HooksError::PathToString)?,
+)?;
 
-let hook = shellexpand::full(
-hook.as_os_str()
-.to_str()
-.ok_or(HooksError::PathToString)?,
-)?;
+let hook = PathBuf::from_str(hook.as_ref())
+.map_err(|_| HooksError::PathToString)?;
 
-let hook = PathBuf::from_str(hook.as_ref())
-.map_err(|_| HooksError::PathToString)?;
+return Ok(Self {
+git: git_dir,
+hook,
+pwd,
+});
+}
 
 Ok(Self {
 git: git_dir,
-hook,
+hook: Self::find_hook(repo, other_paths, hook),
 pwd,
 })
 }
 
-pub fn is_executable(&self) -> bool {
+fn config_hook_path(repo: &Repository) -> Result<Option<String>> {
+Ok(repo.config()?.get_string(CONFIG_HOOKS_PATH).ok())
+}
+
+/// check default hook path first and then followed by `other_paths`.
+/// if no hook is found we return the default hook path
+fn find_hook(
+repo: &Repository,
+other_paths: Option<&[&str]>,
+hook: &str,
+) -> PathBuf {
+let mut paths = vec![DEFAULT_HOOKS_PATH.to_string()];
+if let Some(others) = other_paths {
+paths.extend(
+others
+.iter()
+.map(|p| p.trim_end_matches('/').to_string()),
+);
+}
+
+for p in paths {
+let p = repo.path().to_path_buf().join(p).join(hook);
+if p.exists() {
+return p;
+}
+}
+
+repo.path()
+.to_path_buf()
+.join(DEFAULT_HOOKS_PATH)
+.join(hook)
+}
+
+/// was a hook file found and is it executable
+pub fn found(&self) -> bool {
 self.hook.exists() && is_executable(&self.hook)
 }
 
 /// this function calls hook scripts based on conventions documented here
 /// see <https://git-scm.com/docs/githooks>
 pub fn run_hook(&self, args: &[&str]) -> Result<HookResult> {
-let arg_str = format!("{:?} {}", self.hook, args.join(" "));
+let hook = self.hook.clone();
+
+let arg_str = format!("{:?} {}", hook, args.join(" "));
 // Use -l to avoid "command not found" on Windows.
 let bash_args =
 vec!["-l".to_string(), "-c".to_string(), arg_str];
 
-log::trace!("run hook '{:?}' in '{:?}'", self.hook, self.pwd);
+log::trace!("run hook '{:?}' in '{:?}'", hook, self.pwd);
 
 let git_bash = find_bash_executable()
 .unwrap_or_else(|| PathBuf::from("bash"));
@@ -78,19 +128,24 @@ impl HookPaths {
 .output()?;
 
 if output.status.success() {
-Ok(HookResult::Ok)
+Ok(HookResult::Ok { hook })
 } else {
 let stderr =
 String::from_utf8_lossy(&output.stderr).to_string();
 let stdout =
 String::from_utf8_lossy(&output.stdout).to_string();
 
-Ok(HookResult::NotOk { stdout, stderr })
+Ok(HookResult::RunNotSuccessful {
+code: output.status.code(),
+stdout,
+stderr,
+hook,
+})
 }
 }
 }
 
-#[cfg(not(windows))]
+#[cfg(unix)]
 fn is_executable(path: &Path) -> bool {
 use std::os::unix::fs::PermissionsExt;