pre-commit hook in Git - Commands & Configuration

Introduction

A pre-commit hook is a small script that runs automatically before you save changes to your code repository. It helps catch mistakes early by checking your code or files before they are saved, so you avoid committing errors.

When you want to check code style or formatting before saving changes.

When you want to run tests automatically before committing code.

When you want to prevent committing secrets or sensitive data by mistake.

When you want to ensure commit messages follow a specific format.

When you want to stop commits that break basic rules or guidelines.

Config File - .git/hooks/pre-commit

.git/hooks/pre-commit

#!/bin/sh
# Simple pre-commit hook to check for trailing whitespace

if git diff --cached --check | grep -q 'trailing whitespace'; then
  echo 'Error: Trailing whitespace found. Please remove it before committing.'
  exit 1
fi

exit 0

This script runs before a commit is saved.

It checks the staged changes for trailing whitespace using git diff --cached --check.

If trailing whitespace is found, it prints an error message and stops the commit with exit 1.

If no issues are found, it allows the commit to proceed with exit 0.

Commands

Make the pre-commit hook script executable so Git can run it automatically before commits.

Terminal

chmod +x .git/hooks/pre-commit

Expected Output

No output (command runs silently)

Stage the file 'example.txt' to prepare it for commit. The pre-commit hook will check this staged content.

Terminal

git add example.txt

Expected Output

No output (command runs silently)

Attempt to commit the staged changes. The pre-commit hook runs now and checks for trailing whitespace.

Terminal

git commit -m "Add example file with trailing spaces"

Expected Output

Error: Trailing whitespace found. Please remove it before committing.

Manually run the check that the pre-commit hook uses to find trailing whitespace in staged files.

Terminal

git diff --cached --check

Expected Output

example.txt:3: trailing whitespace.

Key Concept

If you remember nothing else from this pattern, remember: a pre-commit hook automatically checks your staged changes and can stop bad commits before they happen.

Common Mistakes

Not making the pre-commit hook script executable.

Git will not run the hook if it does not have execute permission, so the checks won't happen.

Run 'chmod +x .git/hooks/pre-commit' to make the script executable.

Writing the hook script with syntax errors or wrong commands.

The hook will fail silently or cause errors, preventing commits or not checking properly.

Test the script manually and ensure it runs correctly in the shell before using it as a hook.

Expecting the hook to check unstaged changes.

Pre-commit hooks only check staged changes, so unstaged errors won't be caught.

Always stage your changes with 'git add' before committing to have them checked.

Summary

Create a pre-commit hook script in .git/hooks/pre-commit to run checks before commits.

Make the script executable with chmod +x so Git can run it automatically.

Stage your changes and commit; the hook will run and stop commits if problems are found.

Practice

1. What is the main purpose of a pre-commit hook in Git?

easy

A. To push commits to the remote repository automatically

B. To run scripts before a commit is saved to catch errors early

C. To delete files from the repository before committing

D. To automatically merge branches after a commit

Solution

1. Step 1: Understand what pre-commit hooks do

   Pre-commit hooks run scripts before a commit is finalized to check code or enforce rules.

2. Step 2: Identify the correct purpose

   They help catch errors early by running checks before saving changes.

3. Final Answer:

   To run scripts before a commit is saved to catch errors early -> Option B

4. Quick Check:

   Pre-commit hook purpose = run scripts before commit [OK]

Hint: Pre-commit hooks run before saving commits to catch issues [OK]

Common Mistakes:

• Confusing pre-commit with post-commit hooks
• Thinking hooks automatically push commits
• Believing hooks delete files automatically

2. Which of the following is the correct way to make a pre-commit hook script executable on Linux?

easy

A. chmod +x .git/hooks/pre-commit

B. git enable pre-commit

C. chmod 000 .git/hooks/pre-commit

D. git hook run pre-commit

Solution

1. Step 1: Identify how to make scripts executable

   On Linux, chmod +x sets execute permission on a file.

2. Step 2: Apply to pre-commit hook script

   Running chmod +x .git/hooks/pre-commit makes the hook script executable so Git can run it.

3. Final Answer:

   chmod +x .git/hooks/pre-commit -> Option A

4. Quick Check:

   Make hook executable = chmod +x [OK]

Hint: Use chmod +x to make hook scripts executable [OK]

Common Mistakes:

• Using git commands instead of chmod for permissions
• Setting permissions to 000 disables execution
• Assuming hooks run without executable permission

3. Given this pre-commit hook script content:

#!/bin/sh
if git diff --cached --name-only | grep -q '\.py$'; then
  echo 'Python files changed'
else
  echo 'No Python files changed'
fi

What will be the output if you commit a changed file named app.js?

medium

A. No Python files changed

B. Python files changed

C. Syntax error in script

D. Hook will not run

Solution

1. Step 1: Understand the script logic

   The script checks staged files for names ending with '.py'. If found, it prints 'Python files changed'. Otherwise, it prints 'No Python files changed'.

2. Step 2: Apply to the committed file

   The committed file is 'app.js', which does not end with '.py', so the else branch runs.

3. Final Answer:

   No Python files changed -> Option A

4. Quick Check:

   File extension check = no match = else output [OK]

Hint: Check file extensions in staged files to predict output [OK]

Common Mistakes:

• Assuming any changed file triggers 'Python files changed'
• Confusing staged vs unstaged files
• Ignoring the file extension check

4. You wrote a pre-commit hook script but it does not run when committing. Which of these is the most likely cause?

medium

A. The script is placed outside the .git/hooks directory

B. The script is named pre-commit.sh instead of pre-commit

C. All of the above

D. The script is not executable

Solution

1. Step 1: Check script permissions

   If the script is not executable, Git cannot run it.

2. Step 2: Check script name and location

   The script must be named exactly 'pre-commit' and placed inside the '.git/hooks' folder to be recognized.

3. Step 3: Combine all issues

   Any of these problems will prevent the hook from running, so all are valid causes.

4. Final Answer:

   All of the above -> Option C

5. Quick Check:

   Hook runs only if name, location, and permissions are correct [OK]

Hint: Check name, location, and execute permission for hooks [OK]

Common Mistakes:

• Ignoring file permissions
• Naming script with extensions like .sh
• Placing script outside .git/hooks folder

5. You want a pre-commit hook that prevents commits if any staged file contains the word 'TODO'. Which script snippet correctly implements this?

hard

A. #!/bin/sh
git commit -m 'Check TODOs' || exit 1

B. #!/bin/sh
grep -r 'TODO' . && echo 'TODO found' && exit 1

C. #!/bin/sh
git status | grep 'TODO' && exit 1

D. #!/bin/sh
git diff --cached | grep -q 'TODO' && echo 'Remove TODOs before commit' && exit 1

Solution

1. Step 1: Understand the goal

   The hook must check staged changes for the word 'TODO' and stop commit if found.

2. Step 2: Analyze each option

   #!/bin/sh git diff --cached | grep -q 'TODO' && echo 'Remove TODOs before commit' && exit 1 uses git diff --cached to check staged changes and exits with error if 'TODO' is found, which is correct.
   #!/bin/sh grep -r 'TODO' . && echo 'TODO found' && exit 1 searches all files recursively, not just staged changes.
   #!/bin/sh git commit -m 'Check TODOs' || exit 1 tries to run a commit inside the hook, which is incorrect.
   #!/bin/sh git status | grep 'TODO' && exit 1 checks git status output, which does not show file contents.

3. Final Answer:

   #!/bin/sh git diff --cached | grep -q 'TODO' && echo 'Remove TODOs before commit' && exit 1 -> Option D

4. Quick Check:

   Check staged diff for TODO and exit if found [OK]

Hint: Use git diff --cached to scan staged changes for keywords [OK]

Common Mistakes:

• Searching unstaged files instead of staged
• Running git commit inside hook
• Checking git status output for content