What are Git Hooks

Git hooks are powerful automation tools that allow developers to enforce coding standards, automate testing, and streamline workflows before or after certain Git actions such as commits, pushes, and merges. In this article, we will explore Git hooks, their types, implementation, and real-world use cases while incorporating key topics such as pre-commit hooks, pre-push hooks, pre-receive hooks, commit hooks, skipping hooks, and programmatically managing Git hooks.

Table of Contents

• What Are Git Hooks?
• Why Use Git Hooks?
• Types of Git Hooks
  • Client-Side Hooks
  • Server-Side Hooks
• How to Enable and Use Git Hooks
• Practical Examples of Git Hooks
  • Pre-Commit Hook
  • Commit Message Hook
  • Post-Commit Hook
  • Pre-Push Hook
• Skipping Git Hooks
• Managing Git Hooks Programmatically
• Best Practices for Using Git Hooks
• Conclusion

What Are Git Hooks?

Git hooks are customizable scripts stored in the .git/hooks/ directory of a Git repository. These scripts execute automatically when a specific Git event occurs, such as a commit, push, or merge. Developers can use Git hooks to:

• Enforce coding standards
• Run automated tests
• Generate documentation
• Send notifications
• Automate deployment workflows

Each Git hook is a script file named after the event it triggers (e.g., pre-commit, post-commit, pre-push).

Why Use Git Hooks?

Git hooks provide several advantages: ✅ Ensuring Code Quality: Automatically run linters and formatters before allowing a commit.
✅ Automating Testing: Prevent bad code from being committed by running unit tests.
✅ Enhancing Collaboration: Standardize commit messages and enforce branch naming conventions.
✅ Automating Deployments: Trigger build pipelines and deployment processes automatically.

Types of Git Hooks

Client-Side Hooks

Client-side hooks run on a developer’s local machine and execute before or after operations such as git commit, git push, and git merge.

Server-Side Hooks

Server-side hooks execute on the remote Git server and manage security policies, deployment workflows, and centralized validation.

How to Enable and Use Git Hooks

To use Git hooks, follow these steps:

Step 1: Navigate to the Hooks Directory

cd my-repo/.git/hooks/

Step 2: Rename the Sample Hook

mv pre-commit.sample pre-commit

Step 3: Add Execute Permission

chmod +x pre-commit

Step 4: Write the Hook Script

Edit the pre-commit file and add a script:

#!/bin/bash
echo "Running pre-commit hook"
exit 1

Now, any commit will be blocked with an error message.

Practical Examples of Git Hooks

1. Pre-Commit Hook (Linting & Formatting)

The pre-commit hook runs before a commit is finalized. Below is an example that prevents commits with linting errors:

#!/bin/bash
echo "Running ESLint..."
eslint . || exit 1

2. Commit Message Hook (Enforcing Commit Style)

The commit-msg hook ensures commit messages follow a specific format:

#!/bin/bash
COMMIT_MSG=$(cat "$1")
if ! [[ "$COMMIT_MSG" =~ ^(feat|fix|docs|style|refactor|test|chore):\ .+$ ]]; then
  echo "Error: Commit message must follow the format: <type>: <message>"
  exit 1
fi

3. Post-Commit Hook (Sending Notifications)

The post-commit hook sends notifications after a commit:

#!/bin/bash
echo "New commit added. Notifying team..."
curl -X POST -H "Content-Type: application/json" -d '{"message":"New commit pushed!"}' https://my-slack-webhook-url.com

4. Pre-Push Hook (Running Tests)

The pre-push hook ensures all tests pass before pushing:

#!/bin/bash
echo "Running test suite..."
npm test || exit 1

Skipping Git Hooks

Sometimes, you may need to bypass Git hooks:

Method 1: Using --no-verify

git commit -m "Hotfix" --no-verify
git push --no-verify

Method 2: Deleting the Hook Temporarily

rm .git/hooks/pre-commit

Managing Git Hooks Programmatically

To enforce hooks across a team, store them in a version-controlled directory:

Step 1: Create a Centralized Hooks Directory

mkdir -p .githooks

Step 2: Configure Git to Use the Hooks Directory

git config core.hooksPath .githooks

Best Practices for Using Git Hooks

✔️ Keep Hooks Fast: Long-running hooks slow down development.
✔️ Use Version Control: Store hooks in .githooks/ for consistency.
✔️ Document Hooks: Ensure team members understand their purpose.
✔️ Allow Skipping: Provide a way to disable hooks when needed.

Conclusion

Git hooks are an essential tool for automating development workflows, enforcing standards, and improving team collaboration. By implementing pre-commit hooks, pre-push hooks, commit hooks, and pre-receive hooks, you can create a streamlined Git workflow tailored to your team’s needs.

By understanding and managing Git hooks effectively, developers can prevent bad commits, run automated tests, enforce commit standards, and trigger deployments seamlessly.

Explore More:

• Official Git Hooks Documentation
• GitHub Docs on Hooks
• Atlassian Git Hooks Guide
• Managing Git Repositories with GitLab