Add destroyed-symlinks builtin hook (#1851)

Closes #1848

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: j178

crates/prek/src/hooks/builtin_hooks/mod.rs

@@ -41,6 +41,7 @@ pub(crate) enum BuiltinHooks {
     CheckVcsPermalinks,
     CheckXml,
     CheckYaml,
+    DestroyedSymlinks,
     DetectPrivateKey,
     EndOfFileFixer,
     FileContentsSorter,
@@ -85,6 +86,7 @@ impl BuiltinHooks {
             }
             Self::CheckXml => pre_commit_hooks::check_xml(hook, filenames).await,
             Self::CheckYaml => pre_commit_hooks::check_yaml(hook, filenames).await,
+            Self::DestroyedSymlinks => pre_commit_hooks::destroyed_symlinks(hook, filenames).await,
             Self::DetectPrivateKey => pre_commit_hooks::detect_private_key(hook, filenames).await,
             Self::EndOfFileFixer => pre_commit_hooks::fix_end_of_file(hook, filenames).await,
             Self::FileContentsSorter => {
@@ -273,6 +275,20 @@ impl BuiltinHook {
                     ..Default::default()
                 },
             },
+            BuiltinHooks::DestroyedSymlinks => BuiltinHook {
+                id: "destroyed-symlinks".to_string(),
+                name: "detect destroyed symlinks".to_string(),
+                entry: "destroyed-symlinks".to_string(),
+                priority: None,
+                options: HookOptions {
+                    description: Some(
+                        "detects symlinks that were replaced with regular files whose contents are the original symlink target path.".to_string(),
+                    ),
+                    types: Some(tags::TAG_SET_FILE),
+                    stages: Some([Stage::PreCommit, Stage::PrePush, Stage::Manual].into()),
+                    ..Default::default()
+                },
+            },
             BuiltinHooks::DetectPrivateKey => BuiltinHook {
                 id: "detect-private-key".to_string(),
                 name: "detect private key".to_string(),

crates/prek/src/hooks/pre_commit_hooks/destroyed_symlinks.rs

@@ -0,0 +1,235 @@
+use std::io::Write as _;
+use std::path::Path;
+use std::str;
+
+use anyhow::{Context, Result};
+use rustc_hash::FxHashSet;
+
+use crate::git;
+use crate::hook::Hook;
+
+const ORDINARY_CHANGED_ENTRY_MARKER: &str = "1";
+const PERMS_LINK: u32 = 0o120_000;
+const PERMS_NONEXIST: u32 = 0;
+
+pub(crate) async fn destroyed_symlinks(hook: &Hook, filenames: &[&Path]) -> Result<(i32, Vec<u8>)> {
+    let status_output = git_status_output(hook.work_dir()).await?;
+    let entries = status_output
+        .split(|&byte| byte == b'\0')
+        .filter_map(|entry| match parse_ordinary_changed_entry(entry) {
+            Ok(Some(entry)) => Some(Ok(entry)),
+            Ok(None) => None,
+            Err(err) => Some(Err(err)),
+        });
+
+    let destroyed_links = find_destroyed_symlinks(hook, filenames, entries).await?;
+    if destroyed_links.is_empty() {
+        return Ok((0, Vec::new()));
+    }
+
+    let mut output = Vec::new();
+    writeln!(output, "Destroyed symlinks:")?;
+    for destroyed_link in &destroyed_links {
+        writeln!(output, "- {}", destroyed_link.display())?;
+    }
+    let destroyed_links_shell = destroyed_links
+        .iter()
+        .map(|path| path.to_string_lossy().into_owned())
+        .collect::<Vec<_>>();
+    writeln!(output, "You should unstage affected files:")?;
+    writeln!(
+        output,
+        "\tgit reset HEAD -- {}",
+        shlex::try_join(destroyed_links_shell.iter().map(String::as_str))?
+    )?;
+    writeln!(
+        output,
+        "And retry commit. As a long term solution you may try to explicitly tell git that your environment does not support symlinks:"
+    )?;
+    writeln!(output, "\tgit config core.symlinks false")?;
+
+    Ok((1, output))
+}
+
+async fn git_status_output(work_dir: &Path) -> Result<Vec<u8>> {
+    Ok(git::git_cmd("git status")?
+        .current_dir(work_dir)
+        .arg("status")
+        .arg("--porcelain=v2")
+        .arg("-z")
+        // Query the whole project with a single pathspec to avoid one-argv-entry-per-file
+        // command lines that can exceed the platform limit for very large commits.
+        .arg("--")
+        .arg(".")
+        .check(true)
+        .output()
+        .await?
+        .stdout)
+}
+
+async fn find_destroyed_symlinks<'a>(
+    hook: &Hook,
+    filenames: &[&Path],
+    entries: impl IntoIterator<Item = Result<OrdinaryChangedEntry<'a>>>,
+) -> Result<Vec<&'a Path>> {
+    if filenames.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let filenames = filenames.iter().copied().collect::<FxHashSet<_>>();
+    let relative_prefix = hook.project().relative_path();
+    let mut destroyed_links = Vec::new();
+
+    for entry in entries {
+        let entry = entry?;
+        // `git status -z` reports paths relative to the repository root, so strip the project
+        // prefix before comparing against the requested filenames.
+        let Ok(entry_path) = entry.path.strip_prefix(relative_prefix) else {
+            continue;
+        };
+        if !filenames.contains(entry_path) {
+            continue;
+        }
+
+        // We only care about entries that used to be symlinks in HEAD but are
+        // now staged as regular files. Still-a-symlink entries are fine, and a
+        // deleted symlink is not a "destroyed symlink" case.
+        if entry.head_mode != PERMS_LINK
+            || entry.index_mode == PERMS_LINK
+            || entry.index_mode == PERMS_NONEXIST
+        {
+            continue;
+        }
+
+        if is_destroyed_symlink(hook.work_dir(), &entry).await? {
+            destroyed_links.push(entry_path);
+        }
+    }
+
+    Ok(destroyed_links)
+}
+// Parsed from `git status --porcelain=v2` ordinary changed entries:
+// `1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>`
+// See: https://git-scm.com/docs/git-status#_changed_tracked_entries
+#[derive(Debug, PartialEq, Eq)]
+struct OrdinaryChangedEntry<'a> {
+    // `<mH>`: The octal file mode in HEAD.
+    head_mode: u32,
+    // `<mI>`: The octal file mode in the index.
+    index_mode: u32,
+    // `<hH>`: The object name in HEAD.
+    head_hash: &'a str,
+    // `<hI>`: The object name in the index.
+    index_hash: &'a str,
+    // `<path>`: The pathname, reported relative to the repository root when
+    // using `git status --porcelain=v2 -z`.
+    path: &'a Path,
+}
+
+fn parse_ordinary_changed_entry(line: &[u8]) -> Result<Option<OrdinaryChangedEntry<'_>>> {
+    if line.is_empty() {
+        return Ok(None);
+    }
+
+    let mut fields = line.splitn(9, |&byte| byte == b' ');
+    let mut next_field = || {
+        fields
+            .next()
+            .context("malformed `git status --porcelain=v2` output")
+    };
+    let parse_mode = |field| -> Result<u32> { Ok(u32::from_str_radix(str::from_utf8(field)?, 8)?) };
+    let marker = next_field()?;
+    // `git status --porcelain=v2` emits several record types. We only parse
+    // ordinary changed entries (`1 ...`) here and let callers skip the rest.
+    if marker != ORDINARY_CHANGED_ENTRY_MARKER.as_bytes() {
+        return Ok(None);
+    }
+
+    let _xy = next_field()?;
+    let _sub = next_field()?;
+    let head_mode = parse_mode(next_field()?)?;
+    let index_mode = parse_mode(next_field()?)?;
+    let _mode_worktree = next_field()?;
+    let head_hash = str::from_utf8(next_field()?)?;
+    let index_hash = str::from_utf8(next_field()?)?;
+    let path = Path::new(str::from_utf8(next_field()?)?);
+
+    Ok(Some(OrdinaryChangedEntry {
+        head_mode,
+        index_mode,
+        head_hash,
+        index_hash,
+        path,
+    }))
+}
+
+async fn is_destroyed_symlink(work_dir: &Path, entry: &OrdinaryChangedEntry<'_>) -> Result<bool> {
+    // If the staged blob is byte-for-byte identical to the old symlink blob, we
+    // already know this is a destroyed symlink: the path used to be stored as a
+    // symlink target and is now staged as a regular file with the same contents.
+    if entry.head_hash == entry.index_hash {
+        return Ok(true);
+    }
+
+    let index_size = git_object_size(work_dir, entry.index_hash).await?;
+    let head_size = git_object_size(work_dir, entry.head_hash).await?;
+    // Formatting hooks may have appended a trailing newline or converted LF to
+    // CRLF, so allow the staged file to grow by at most two bytes before doing
+    // the more expensive content comparison.
+    if index_size > head_size.saturating_add(2) {
+        return Ok(false);
+    }
+
+    let head_content = git_object_content(work_dir, entry.head_hash).await?;
+    let index_content = git_object_content(work_dir, entry.index_hash).await?;
+
+    // Match upstream behavior by ignoring trailing ASCII whitespace here. That
+    // keeps "path", "path\n", and "path\r\n" in the destroyed-symlink bucket.
+    Ok(head_content.trim_ascii_end() == index_content.trim_ascii_end())
+}
+
+async fn git_object_size(work_dir: &Path, object: &str) -> Result<u64> {
+    let output = git::git_cmd("git cat-file")?
+        .current_dir(work_dir)
+        .arg("cat-file")
+        .arg("-s")
+        .arg(object)
+        .check(true)
+        .output()
+        .await?;
+
+    Ok(str::from_utf8(&output.stdout)?.trim_ascii().parse()?)
+}
+
+async fn git_object_content(work_dir: &Path, object: &str) -> Result<Vec<u8>> {
+    Ok(git::git_cmd("git cat-file")?
+        .current_dir(work_dir)
+        .arg("cat-file")
+        .arg("-p")
+        .arg(object)
+        .check(true)
+        .output()
+        .await?
+        .stdout)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_ordinary_changed_entry_supports_spaces_in_paths() -> Result<()> {
+        let entry = parse_ordinary_changed_entry(
+            b"1 M. N... 120000 100644 100644 headhash indexhash path with spaces.txt",
+        )?
+        .expect("entry should parse");
+
+        assert_eq!(entry.head_mode, PERMS_LINK);
+        assert_eq!(entry.index_mode, 0o100_644);
+        assert_eq!(entry.head_hash, "headhash");
+        assert_eq!(entry.index_hash, "indexhash");
+        assert_eq!(entry.path, Path::new("path with spaces.txt"));
+
+        Ok(())
+    }
+}

crates/prek/src/hooks/pre_commit_hooks/mod.rs

@@ -16,6 +16,7 @@ mod check_toml;
 mod check_vcs_permalinks;
 mod check_xml;
 mod check_yaml;
+mod destroyed_symlinks;
 mod detect_private_key;
 mod file_contents_sorter;
 mod fix_byte_order_marker;
@@ -36,6 +37,7 @@ pub(crate) use check_toml::check_toml;
 pub(crate) use check_vcs_permalinks::check_vcs_permalinks;
 pub(crate) use check_xml::check_xml;
 pub(crate) use check_yaml::check_yaml;
+pub(crate) use destroyed_symlinks::destroyed_symlinks;
 pub(crate) use detect_private_key::detect_private_key;
 pub(crate) use file_contents_sorter::file_contents_sorter;
 pub(crate) use fix_byte_order_marker::fix_byte_order_marker;
@@ -62,6 +64,7 @@ pub(crate) enum PreCommitHooks {
     CheckToml,
     CheckXml,
     CheckYaml,
+    DestroyedSymlinks,
     MixedLineEnding,
     DetectPrivateKey,
     NoCommitToBranch,
@@ -98,6 +101,7 @@ impl PreCommitHooks {
             Self::CheckToml => check_toml(hook, filenames).await,
             Self::CheckYaml => check_yaml(hook, filenames).await,
             Self::CheckXml => check_xml(hook, filenames).await,
+            Self::DestroyedSymlinks => destroyed_symlinks(hook, filenames).await,
             Self::MixedLineEnding => mixed_line_ending(hook, filenames).await,
             Self::DetectPrivateKey => detect_private_key(hook, filenames).await,
             Self::NoCommitToBranch => no_commit_to_branch(hook).await,