pre-commit hook in Git - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of a simple pre-commit hook script

What will be the output when you try to commit with this pre-commit hook script in .git/hooks/pre-commit?

Git

#!/bin/sh

echo "Checking commit message length..."
MSG=$(head -n1 .git/COMMIT_EDITMSG)
LEN=$(echo -n "$MSG" | wc -c)
if [ $LEN -lt 10 ]; then
  echo "Commit message too short. Please write at least 10 characters."
  exit 1
fi
exit 0

A Commit is blocked with message: "Commit message too short. Please write at least 10 characters."

B Commit proceeds but prints "Commit message too short. Please write at least 10 characters."

C Commit is blocked with message: "Checking commit message length..." only

D Commit proceeds without any message

💡 Hint

Think about what happens if the commit message is shorter than 10 characters.

The script checks the first line of the commit message. If it is shorter than 10 characters, it prints an error and exits with status 1, blocking the commit.

🧠 Conceptual

intermediate

Purpose of pre-commit hooks in Git

Which of the following best describes the main purpose of a pre-commit hook in Git?

A To run checks or scripts before a commit is finalized

B To automatically merge branches before committing

C To push commits to the remote repository automatically

D To delete untracked files before committing

💡 Hint

Think about what happens right before a commit is saved.

Pre-commit hooks run scripts or checks before the commit is finalized, allowing you to prevent bad commits or enforce rules.

❓ Troubleshoot

advanced

Why does the pre-commit hook not run?

You created a pre-commit hook script in .git/hooks/pre-commit but it does not run when committing. What is the most likely reason?

A The commit message is empty

B The script file is named <code>pre-commit.sh</code> instead of <code>pre-commit</code>

C The script file is missing execute permissions

D The Git repository is not initialized

💡 Hint

Check the file permissions of the hook script.

Git only runs hook scripts that have execute permissions. Without it, the script is ignored.

🔀 Workflow

advanced

Order of operations in a pre-commit hook script

You want to create a pre-commit hook that first checks code style with flake8 and then runs tests with pytest. Which order of commands in the script ensures the commit is blocked if either check fails?

Git

#!/bin/sh

# Commands to run

A

2
3
1

B

1
2
3

C

3
2
1

D

2
1
3

💡 Hint

The script should stop at the first failure to block the commit.

Running flake8 first and then pytest ensures style is checked before tests. If either fails, the script exits with non-zero status, blocking the commit.

✅ Best Practice

expert

Best practice for sharing pre-commit hooks across a team

What is the best practice to ensure all team members use the same pre-commit hooks without manually copying scripts into their .git/hooks directories?

A Add the hook scripts to the repository and instruct everyone to copy them manually

B Use a tool like <code>pre-commit</code> framework to manage hooks via configuration files

C Commit the <code>.git/hooks</code> directory to the repository

D Send the hook scripts by email to each team member

💡 Hint

Think about automation and consistency for teams.

The pre-commit framework allows defining hooks in a config file that is version controlled, so all team members can install and run the same hooks easily.

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