rhusky 0.0.2

Git hooks manager for Rust projects - like Husky, but for 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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

# Rhusky

[![Crates.io](https://img.shields.io/crates/v/rhusky.svg)](https://crates.io/crates/rhusky)
[![Documentation](https://docs.rs/rhusky/badge.svg)](https://docs.rs/rhusky)
[![CI](https://github.com/dataroadinc/rhusky/actions/workflows/ci.yml/badge.svg)](https://github.com/dataroadinc/rhusky/actions/workflows/ci.yml)
[![License: CC BY-SA 4.0](https://img.shields.io/badge/License-CC_BY--SA_4.0-lightgrey.svg)](https://creativecommons.org/licenses/by-sa/4.0/)

Git hooks manager for Rust projects. Like Husky, but for Rust.

Inspired by [Sloughi](https://github.com/01walid/sloughi) and the
Node.js [Husky](https://typicode.github.io/husky/) project.

## Why Rhusky?

- **Truly idempotent**: Never overwrites your existing hook scripts
- **No magic**: Just sets `core.hooksPath` in git config
- **CI-aware**: Skips installation in CI environments
- **Zero dependencies**: Pure Rust, no external crates

## Installation

Add rhusky to your build-dependencies:

```toml
[build-dependencies]
rhusky = "0.0.1"
```

Create a `build.rs` file at the root of your project:

```rust
fn main() {
    rhusky::Rhusky::new()
        .hooks_dir(".githooks")       // Custom hooks directory (default: ".githooks")
        .skip_in_env("GITHUB_ACTIONS") // Skip when this env var is set (CI always skipped)
        .with_default_hooks()          // Create default hooks if they don't exist
        .install()
        .ok();
}
```

Create your hooks directory and add your hooks:

```bash
mkdir -p .githooks
cat > .githooks/pre-commit << 'EOF'
#!/bin/sh
cargo fmt --check
cargo clippy -- -D warnings
EOF
chmod +x .githooks/pre-commit
```

## Configuration

### Custom hooks directory

```rust
rhusky::Rhusky::new()
    .hooks_dir(".git-hooks")  // default is ".githooks"
    .install()
    .ok();
```

### Skip in CI environments

By default, installation is skipped when the `CI` environment
variable is set. Add more:

```rust
rhusky::Rhusky::new()
    .skip_in_env("GITHUB_ACTIONS")
    .skip_in_env("GITLAB_CI")
    .install()
    .ok();
```

### Default hooks

Optionally create default hook scripts for Rust projects:

```rust
rhusky::Rhusky::new()
    .with_default_hooks()
    .install()
    .ok();
```

This creates three hooks (if they don't already exist):

- **pre-commit**: Runs `cargo +nightly fmt --check` and
  `cargo +nightly clippy` on staged Rust files
- **commit-msg**: Validates conventional commit format with
  mandatory scope (e.g., `feat(api): add endpoint`)
- **post-commit**: Verifies the commit is signed

Existing hooks are never overwritten.

## How it works

Rhusky sets Git's `core.hooksPath` configuration to point to your
hooks directory. This tells Git to look for hooks in that directory
instead of the default `.git/hooks/`.

Unlike other tools, Rhusky:

1. **Never overwrites existing hooks** - truly idempotent
2. **Optionally creates defaults** - use `with_default_hooks()` or
   manage your own
3. **Minimal by default** - just sets git config unless you opt in

## Recommended hooks

### pre-commit

```bash
#!/bin/sh
cargo +nightly fmt --check
cargo +nightly clippy --all-targets -- -D warnings
```

### commit-msg

```bash
#!/bin/sh
# Verify conventional commit format with Cocogitto
if command -v cog &> /dev/null; then
    cog verify --file "$1"
fi
```

## Comparison with similar tools

| Feature | Rhusky | [Sloughi] | [cargo-husky] | [husky-rs] |
| ------- | ------ | --------- | ------------- | ---------- |
| Sets `core.hooksPath` | Yes | Yes | No | No |
| Creates hook files | Optional | Yes | Yes | Yes |
| Overwrites existing hooks | Never | [Yes][sloughi-issue] | Yes | Yes |
| Zero dependencies | Yes | Yes | No | No |
| Customizable hooks dir | Yes | Yes | Limited | Limited |
| CI-aware | Yes | Yes | No | No |

[Sloughi]: https://crates.io/crates/sloughi
[cargo-husky]: https://crates.io/crates/cargo-husky
[husky-rs]: https://crates.io/crates/husky
[sloughi-issue]: https://github.com/01walid/sloughi/issues/2

### Sloughi

[Sloughi](https://github.com/01walid/sloughi) was the inspiration
for Rhusky. It uses the same `core.hooksPath` approach but creates
default hook files on every `cargo build`, overwriting any custom
hooks you've written. Rhusky fixes this by never creating or
modifying hook files.

### cargo-husky

[cargo-husky](https://github.com/rhysd/cargo-husky) copies hook
scripts into `.git/hooks/` rather than using `core.hooksPath`. This
means hooks aren't easily shareable via version control and can
conflict with other tools that manage `.git/hooks/`.

### husky-rs

[husky-rs](https://github.com/pksunkara/husky-rs) also copies hooks
into `.git/hooks/`. Like cargo-husky, it doesn't use the modern
`core.hooksPath` approach and overwrites existing hooks.

## License

[![CC BY-SA 4.0](https://licensebuttons.net/l/by-sa/4.0/88x31.png)](https://creativecommons.org/licenses/by-sa/4.0/)