sr_core/

hooks.rs

//! Automatic git hook management.
//!
//! Keeps `.githooks/` in sync with the `hooks` section of `sr.yaml`.
//! Hook scripts are thin shims that delegate to `sr hook run <name>`.

use std::collections::BTreeSet;
use std::hash::{Hash, Hasher};
use std::path::Path;

use crate::config::{DEFAULT_CONFIG_FILE, HooksConfig};

/// Marker comment embedded in generated hook scripts to identify sr-managed hooks.
const GENERATED_MARKER: &str = "# Generated by sr";

/// File storing the hash of the hooks config for staleness detection.
const HASH_FILE: &str = ".sr-hooks-hash";

/// Sync `.githooks/` with the hooks config. Returns `Ok(true)` if changes were made.
///
/// - Writes shim scripts for configured hooks
/// - Removes sr-managed shims no longer in config
/// - Backs up conflicting non-sr-managed hooks
/// - Updates the hash file
/// - Sets `core.hooksPath`
pub fn sync_hooks(
    repo_root: &Path,
    config: &HooksConfig,
) -> Result<bool, crate::error::ReleaseError> {
    let hooks_dir = repo_root.join(".githooks");
    let hash_path = hooks_dir.join(HASH_FILE);
    let current_hash = config_hash(config);

    // Fast path: already in sync.
    if let Ok(stored) = std::fs::read_to_string(&hash_path)
        && stored.trim() == current_hash
    {
        return Ok(false);
    }

    let configured: BTreeSet<&str> = config
        .hooks
        .iter()
        .filter(|(_, entries)| !entries.is_empty())
        .map(|(name, _)| name.as_str())
        .collect();

    if configured.is_empty() {
        let removed = remove_stale_hooks(&hooks_dir, &configured)?;
        // Clean up hash file too.
        let _ = std::fs::remove_file(&hash_path);
        return Ok(removed);
    }

    std::fs::create_dir_all(&hooks_dir).map_err(|e| {
        crate::error::ReleaseError::Config(format!("failed to create .githooks: {e}"))
    })?;

    let mut changed = false;

    for &hook_name in &configured {
        let hook_path = hooks_dir.join(hook_name);
        let expected = shim_script(hook_name);

        match std::fs::read_to_string(&hook_path) {
            Ok(existing) if existing == expected => {
                // Already correct.
            }
            Ok(existing) if existing.contains(GENERATED_MARKER) => {
                // Sr-managed but outdated — overwrite.
                write_shim(&hook_path, &expected)?;
                changed = true;
            }
            Ok(_) => {
                // Non-sr-managed hook conflicts — back up and replace.
                let backup = hooks_dir.join(format!("{hook_name}.bak"));
                std::fs::rename(&hook_path, &backup).map_err(|e| {
                    crate::error::ReleaseError::Config(format!(
                        "failed to backup .githooks/{hook_name}: {e}"
                    ))
                })?;
                eprintln!("backed up .githooks/{hook_name} → .githooks/{hook_name}.bak");
                write_shim(&hook_path, &expected)?;
                changed = true;
            }
            Err(_) => {
                // Does not exist — create.
                write_shim(&hook_path, &expected)?;
                changed = true;
            }
        }
    }

    if remove_stale_hooks(&hooks_dir, &configured)? {
        changed = true;
    }

    // Write hash file.
    std::fs::write(&hash_path, &current_hash).map_err(|e| {
        crate::error::ReleaseError::Config(format!("failed to write hooks hash: {e}"))
    })?;

    if changed {
        set_hooks_path(repo_root);
    }

    Ok(changed)
}

/// Check whether hooks need syncing (cheap hash comparison).
pub fn needs_sync(repo_root: &Path, config: &HooksConfig) -> bool {
    let hash_path = repo_root.join(".githooks").join(HASH_FILE);
    match std::fs::read_to_string(&hash_path) {
        Ok(stored) => stored.trim() != config_hash(config),
        Err(_) => {
            // No hash file — need sync if there are hooks configured.
            !config.hooks.is_empty()
        }
    }
}

/// Compute a deterministic hash of the hooks config.
fn config_hash(config: &HooksConfig) -> String {
    let json = serde_json::to_string(&config.hooks).unwrap_or_default();
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    json.hash(&mut hasher);
    format!("{:016x}", hasher.finish())
}

/// Generate the canonical shim script for a hook.
fn shim_script(hook_name: &str) -> String {
    format!(
        "#!/usr/bin/env sh\n\
         {GENERATED_MARKER} — edit the hooks section in {config} to modify.\n\
         exec sr hook run {hook_name} -- \"$@\"\n",
        config = DEFAULT_CONFIG_FILE,
    )
}

/// Write a shim script and set it executable.
fn write_shim(path: &Path, content: &str) -> Result<(), crate::error::ReleaseError> {
    std::fs::write(path, content)
        .map_err(|e| crate::error::ReleaseError::Config(format!("failed to write hook: {e}")))?;

    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).map_err(|e| {
            crate::error::ReleaseError::Config(format!("failed to chmod hook: {e}"))
        })?;
    }

    if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
        eprintln!("synced .githooks/{name}");
    }

    Ok(())
}

/// Remove sr-managed hooks not in the configured set. Returns `true` if any were removed.
fn remove_stale_hooks(
    hooks_dir: &Path,
    configured: &BTreeSet<&str>,
) -> Result<bool, crate::error::ReleaseError> {
    if !hooks_dir.is_dir() {
        return Ok(false);
    }

    let mut removed = false;
    let entries = std::fs::read_dir(hooks_dir).map_err(|e| {
        crate::error::ReleaseError::Config(format!("failed to read .githooks: {e}"))
    })?;

    for entry in entries {
        let entry = entry.map_err(|e| crate::error::ReleaseError::Config(e.to_string()))?;
        let path = entry.path();

        if !path.is_file() {
            continue;
        }

        let name = match path.file_name().and_then(|n| n.to_str()) {
            Some(n) => n.to_string(),
            None => continue,
        };

        // Skip the hash file and backup files.
        if name == HASH_FILE || name.ends_with(".bak") {
            continue;
        }

        // Only remove sr-managed hooks.
        if !is_sr_managed(&path) {
            continue;
        }

        if !configured.contains(name.as_str()) {
            std::fs::remove_file(&path).map_err(|e| {
                crate::error::ReleaseError::Config(format!(
                    "failed to remove .githooks/{name}: {e}"
                ))
            })?;
            eprintln!("removed stale .githooks/{name}");
            removed = true;
        }
    }

    Ok(removed)
}

/// Check if a hook file was generated by sr.
fn is_sr_managed(path: &Path) -> bool {
    std::fs::read_to_string(path)
        .map(|content| content.contains(GENERATED_MARKER))
        .unwrap_or(false)
}

/// Set `core.hooksPath` to `.githooks/`.
fn set_hooks_path(repo_root: &Path) {
    let _ = std::process::Command::new("git")
        .args(["config", "core.hooksPath", ".githooks/"])
        .current_dir(repo_root)
        .status();
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::HookEntry;
    use std::collections::BTreeMap;

    fn make_config(hooks: &[(&str, Vec<HookEntry>)]) -> HooksConfig {
        let mut map = BTreeMap::new();
        for (name, entries) in hooks {
            map.insert(name.to_string(), entries.clone());
        }
        HooksConfig { hooks: map }
    }

    #[test]
    fn creates_hook_scripts() {
        let dir = tempfile::tempdir().unwrap();
        let config = make_config(&[("pre-commit", vec![HookEntry::Simple("echo hi".into())])]);

        let changed = sync_hooks(dir.path(), &config).unwrap();
        assert!(changed);

        let hook = dir.path().join(".githooks/pre-commit");
        assert!(hook.exists());
        let content = std::fs::read_to_string(&hook).unwrap();
        assert!(content.contains("sr hook run pre-commit"));
        assert!(content.contains(GENERATED_MARKER));
    }

    #[test]
    fn idempotent_returns_false() {
        let dir = tempfile::tempdir().unwrap();
        let config = make_config(&[(
            "commit-msg",
            vec![HookEntry::Simple("sr hook commit-msg".into())],
        )]);

        assert!(sync_hooks(dir.path(), &config).unwrap());
        // Second call — hash matches, no changes.
        assert!(!sync_hooks(dir.path(), &config).unwrap());
    }

    #[test]
    fn removes_stale_hooks() {
        let dir = tempfile::tempdir().unwrap();
        let hooks_dir = dir.path().join(".githooks");
        std::fs::create_dir_all(&hooks_dir).unwrap();

        // Write a sr-managed hook that won't be in config.
        std::fs::write(
            hooks_dir.join("pre-push"),
            format!("{GENERATED_MARKER}\nold script"),
        )
        .unwrap();

        // Write a non-sr-managed hook that should be left alone.
        std::fs::write(hooks_dir.join("post-checkout"), "#!/bin/sh\necho custom").unwrap();

        let config = make_config(&[("pre-commit", vec![HookEntry::Simple("echo hi".into())])]);

        sync_hooks(dir.path(), &config).unwrap();

        assert!(
            !hooks_dir.join("pre-push").exists(),
            "stale sr-managed hook should be removed"
        );
        assert!(
            hooks_dir.join("post-checkout").exists(),
            "non-sr-managed hook should be preserved"
        );
        assert!(hooks_dir.join("pre-commit").exists());
    }

    #[test]
    fn backs_up_conflicting_hooks() {
        let dir = tempfile::tempdir().unwrap();
        let hooks_dir = dir.path().join(".githooks");
        std::fs::create_dir_all(&hooks_dir).unwrap();

        // Write a non-sr-managed hook with the same name as a configured hook.
        let custom_content = "#!/bin/sh\necho custom commit-msg hook";
        std::fs::write(hooks_dir.join("commit-msg"), custom_content).unwrap();

        let config = make_config(&[(
            "commit-msg",
            vec![HookEntry::Simple("sr hook commit-msg".into())],
        )]);

        sync_hooks(dir.path(), &config).unwrap();

        // Original should be backed up.
        let backup = hooks_dir.join("commit-msg.bak");
        assert!(backup.exists());
        assert_eq!(std::fs::read_to_string(&backup).unwrap(), custom_content);

        // New hook should be the shim.
        let content = std::fs::read_to_string(hooks_dir.join("commit-msg")).unwrap();
        assert!(content.contains("sr hook run commit-msg"));
    }

    #[test]
    fn empty_config_cleans_up() {
        let dir = tempfile::tempdir().unwrap();
        let hooks_dir = dir.path().join(".githooks");
        std::fs::create_dir_all(&hooks_dir).unwrap();

        std::fs::write(
            hooks_dir.join("pre-commit"),
            format!("{GENERATED_MARKER}\nscript"),
        )
        .unwrap();
        std::fs::write(hooks_dir.join(".sr-hooks-hash"), "oldhash").unwrap();

        let config = make_config(&[]);
        sync_hooks(dir.path(), &config).unwrap();

        assert!(!hooks_dir.join("pre-commit").exists());
        assert!(!hooks_dir.join(".sr-hooks-hash").exists());
    }

    #[test]
    fn needs_sync_detects_changes() {
        let dir = tempfile::tempdir().unwrap();
        let config = make_config(&[("pre-commit", vec![HookEntry::Simple("echo hi".into())])]);

        assert!(needs_sync(dir.path(), &config));

        sync_hooks(dir.path(), &config).unwrap();
        assert!(!needs_sync(dir.path(), &config));

        // Change config.
        let config2 =
            make_config(&[("pre-commit", vec![HookEntry::Simple("echo changed".into())])]);
        assert!(needs_sync(dir.path(), &config2));
    }
}