Customizing Git Hooks

Workflow automation with customized Git hooks can improve your team’s output and adherence to best practices significantly.

How to customize Git hooks for various automation tasks:

• Pre-Commit Hooks:
  • Triggered before a commit is made. It executes the defined actions (such as running tests, linting, etc.) and can prevent the commit if any checks fail.
  • Code Linting: To enforce code style standards, use programs like Pylint, ESLint, or RuboCop.
  • Static Analysis: Utilize tools for static analysis to find possible problems early.
  • Verify that dependencies are compatible and up to date by doing dependency checking.
  • Utilize unit tests to identify issues before they are added to the repository.

Example: Pre-commit Hook for Code Linting’:

#!/bin/bash
# Run the linter
linter_output=$(npm run lint)
# If the linter found issues, print them and exit with a non-zero status
if [[ $linter_output == *"ERROR"* ]]; then
  echo "Linting errors found, aborting commit:"
  echo $linter_output
  exit 1
fi
# If there were no issues, exit with success
exit 0

• Prepare-Commit-Msg Hooks: Commit Message Templates: Pre-fill commit messages with templates containing required information (e.g., Jira ticket number).
  • Commit-Msg Hooks: Commit Message Validation: Enforce rules for commit message formatting and content.
• Post-Commit Hooks: Notification: Send notifications to team members or update issue trackers.

Example of “Post-commit Hook for Automated Push“:

#!/bin/bash
# Push the commit to the remote repository
git push origin master
# Exit with success
exit 0

• Pre-Push Hooks:
  • Code Review: Integrate with code review tools to ensure code quality before pushing.
  • Branch Protection: Prevent pushing to protected branches without necessary approvals.

• Pre-Rebase Hooks:
  • Branch Policy Enforcement: Check if the branch is allowed to be rebased based on your team’s policies.
• Post-Rewrite Hooks:
  • Documentation Update: Automatically update documentation or release notes after history rewriting.
• Pre-Receive Hooks (Server-Side):
  • Enforce Policies: Check if incoming changes meet certain criteria (e.g., code coverage, required reviewers).
• Update Hooks (Server-Side):
  • Enforce Branch Policies: Ensure that updates to branches follow your team’s workflow.
• Post-Receive Hooks (Server-Side):
  • Deployment Automation: Automatically trigger deployment pipelines after changes are pushed.

A pre-commit hook that runs tests before allowing a commit:

#!/bin/bash
run_test(){
    npm test
}
run_lint(){
    eslint .
}
run_formatting(){
    prettier --check .
}
run_test
run_lint
run_formatting
if [$? -ne 0 ]; then
    echo "Checks Failed. Aborting commit."
    exit 1
fi
exit 0

A post-merge hook that notifies team members after a successful merge.

#!/bin/bash
notify_team(){
    slack-cli -c react-assets-gh-bot "New changes into main branch"
}
if[ $? -eq 0]; then
    notify_team
fi

Git is a distributed version control system that monitors changes to a project. Git hooks are scripts that run in response to Git events such as commit or push. They automate tasks, enforce rules, and can be tailored to your project’s requirements. A pre-commit hook, for example, can detect errors in the code, whereas a post-receive hook can send email notifications. Customizing these hooks can help streamline your workflow and make Git a more versatile tool.

There are two types of Git Hooks: server-side and client-side. Client-side hooks function locally, while server-side hooks run on the Git server. Git hooks are commonly used to run tests before committing changes, enforce code-style guidelines, and notify team members after successful pushes.