hooky-rs 1.0.0

Git hooks helper made in Rust
Documentation 
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

use std::fs;
use std::io::prelude::*;
use std::path;
use std::process::Command;

mod logs;
pub use logs::Logs;

#[cfg(target_family = "unix")]
use std::os::unix::prelude::OpenOptionsExt;

#[cfg(target_family = "windows")]
use std::os::windows::fs::OpenOptionsExt;

pub const ALLOWED_HOOKS: [&str; 13] = [
    "applypatch-msg",
    "commit-msg",
    "post-update",
    "pre-applypatch",
    "pre-commit",
    "pre-merge-commit",
    "pre-push",
    "pre-rebase",
    "pre-receive",
    "prepare-commit-msg",
    "push-to-checkout",
    "sendemail-validate",
    "update",
];

pub fn init(no_pre_commit: bool) {
    let pre_commit_dir = path::Path::new(".hooky");

    if !path::Path::new(".git").exists() {
        Logs::error("git cannot be found");

        return;
    }

    if !pre_commit_dir.exists() {
        fs::create_dir_all(pre_commit_dir).expect("Failed to create .hooky directory");

        if !no_pre_commit {
            let mut file = create_file(pre_commit_dir.join("pre-commit"));

            file.write_all(b"#!/usr/bin/env sh\n# Run pre-commit hooks\n\nexit 0")
                .expect("Failed to write to pre-commit file");

            Logs::info("created pre-commit file");
        }
    }

    Command::new("git")
        .arg("config")
        .arg("core.hooksPath")
        .arg(pre_commit_dir)
        .spawn()
        .expect("Failed to set hooks path");

    Logs::info("hooks path set to .hooky directory");
}

pub fn uninstall() {
    let pre_commit_dir = path::Path::new(".hooky");

    if !path::Path::new(".git").exists() {
        Logs::error("git cannot be found");

        return;
    }

    if !pre_commit_dir.exists() {
        Logs::error("hooky is not installed");

        return;
    }

    Command::new("git")
        .arg("config")
        .arg("--unset")
        .arg("core.hooksPath")
        .spawn()
        .expect("Failed to unset hooks path");

    fs::remove_dir_all(pre_commit_dir).expect("Failed to remove .hooky directory");

    Logs::info("uninstalled hooky");
}

pub fn add_hook(hook: &str) {
    if !ALLOWED_HOOKS.contains(&hook) {
        Logs::error("hook not allowed");

        return;
    }

    let pre_commit_dir = path::Path::new(".hooky");

    if !pre_commit_dir.exists() {
        Logs::error(".hooky directory not found");
        Logs::info("try running `hooky init` first");

        return;
    }

    if !path::Path::new(".git").exists() {
        Logs::error("git cannot be found");

        return;
    }
    let mut file = create_file(pre_commit_dir.join(hook));

    let hook_content = format!("#!/usr/bin/env sh\n# Run {} hook\n\nexit 0", hook);
    file.write_all(hook_content.as_bytes())
        .expect("Failed to write to hook file");

    Logs::info("created hook file");
}

fn create_file<P>(path: P) -> fs::File
where
    P: AsRef<path::Path>,
{
    let mut options = fs::OpenOptions::new();

    options.create(true).write(true);

    #[cfg(target_family = "windows")]
    {
        options.access_mode(0o755);
    }

    #[cfg(target_family = "unix")]
    {
        options.mode(0o755);
    }

    options.open(path).expect("Failed to create file")
}