hk 1.45.0

A tool for managing git hooks
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::Result;
use std::fs;
#[cfg(unix)]
use std::os::unix::fs::PermissionsExt;
use std::path::PathBuf;

#[derive(Debug, clap::Args)]
pub struct CheckExecutablesHaveShebangs {
    /// Files to check
    #[clap(required = true)]
    pub files: Vec<PathBuf>,
}

impl CheckExecutablesHaveShebangs {
    pub async fn run(&self) -> Result<()> {
        let mut found_issues = false;

        for file_path in &self.files {
            if is_executable(file_path)? && !has_shebang(file_path)? {
                println!("{}", file_path.display());
                found_issues = true;
            }
        }

        if found_issues {
            return Err(eyre::eyre!("Executable files without shebangs found"));
        }

        Ok(())
    }
}

fn is_executable(path: &PathBuf) -> Result<bool> {
    let metadata = fs::metadata(path)?;

    // Skip directories
    if metadata.is_dir() {
        return Ok(false);
    }

    #[cfg(unix)]
    {
        let permissions = metadata.permissions();
        // Check if any execute bit is set
        Ok(permissions.mode() & 0o111 != 0)
    }

    #[cfg(not(unix))]
    {
        // On Windows, we can't reliably check execute permissions via file attributes.
        // Return false so we don't incorrectly flag files.
        Ok(false)
    }
}

fn has_shebang(path: &PathBuf) -> Result<bool> {
    let content = fs::read(path)?;

    // Skip binary files
    if content.contains(&0) {
        return Ok(true); // Don't flag binary files as missing shebangs
    }

    // Check if file starts with #!
    Ok(content.len() >= 2 && content[0] == b'#' && content[1] == b'!')
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    #[cfg(unix)]
    use std::os::unix::fs::PermissionsExt;
    use tempfile::NamedTempFile;

    #[test]
    fn test_has_shebang_true() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"#!/bin/bash\necho hello").unwrap();

        let result = has_shebang(&file.path().to_path_buf()).unwrap();
        assert!(result);
    }

    #[test]
    fn test_has_shebang_false() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"echo hello").unwrap();

        let result = has_shebang(&file.path().to_path_buf()).unwrap();
        assert!(!result);
    }

    #[test]
    fn test_has_shebang_with_env() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"#!/usr/bin/env python\nprint('hello')").unwrap();

        let result = has_shebang(&file.path().to_path_buf()).unwrap();
        assert!(result);
    }

    #[test]
    fn test_binary_file_not_flagged() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"\x7fELF\x02\x01\x01\x00").unwrap();

        // Binary files should return true (not flagged as missing shebang)
        let result = has_shebang(&file.path().to_path_buf()).unwrap();
        assert!(result);
    }

    #[test]
    #[cfg(unix)]
    fn test_is_executable() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"#!/bin/bash\necho hello").unwrap();

        // Make file executable
        let mut perms = fs::metadata(file.path()).unwrap().permissions();
        perms.set_mode(0o755);
        fs::set_permissions(file.path(), perms).unwrap();

        let result = is_executable(&file.path().to_path_buf()).unwrap();
        assert!(result);
    }

    #[test]
    #[cfg(unix)]
    fn test_not_executable() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"#!/bin/bash\necho hello").unwrap();

        // Ensure file is not executable
        let mut perms = fs::metadata(file.path()).unwrap().permissions();
        perms.set_mode(0o644);
        fs::set_permissions(file.path(), perms).unwrap();

        let result = is_executable(&file.path().to_path_buf()).unwrap();
        assert!(!result);
    }

    #[test]
    fn test_empty_file() {
        let file = NamedTempFile::new().unwrap();
        fs::write(file.path(), b"").unwrap();

        let result = has_shebang(&file.path().to_path_buf()).unwrap();
        assert!(!result);
    }
}