pre-commit hook in Git - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a pre-commit hook script that runs before a commit.

Git

#!/bin/sh

[1]

Drag options to blanks, or click blank then click option'

Aecho "Running pre-commit checks..."

Bgit commit -m 'auto commit'

Cgit push origin main

Drm -rf /

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to run git commit inside the pre-commit hook causes recursion.

Using destructive commands like rm in the hook.

The pre-commit hook script should start by printing a message to indicate it is running checks before the commit.

2fill in blank

medium

Complete the code to prevent a commit if a Python file contains syntax errors.

Git

for file in $(git diff --cached --name-only --diff-filter=ACM | grep '\.py$'); do
  python -m py_compile $[1] || exit 1
 done

Drag options to blanks, or click blank then click option'

Afilename

Bfiles

Cfile

Dfilepath

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name not defined in the loop.

Forgetting to exit with code 1 to stop the commit.

The variable file holds the filename in the loop and is used to check syntax.

3fill in blank

hard

Fix the error in the pre-commit hook that tries to run tests but fails due to wrong command.

Git

echo "Running tests..."
[1]
if [ $? -ne 0 ]; then
  echo "Tests failed, aborting commit."
  exit 1
fi

Drag options to blanks, or click blank then click option'

Anpm test

Bnpm tests

Cnpm testing

Dnpm run test

Attempts:

3 left

💡 Hint

Common Mistakes

Using npm test which may work but is less explicit.

Using commands that do not exist like npm tests.

The correct command to run tests with npm is npm run test.

4fill in blank

hard

Fill both blanks to create a pre-commit hook that checks for trailing whitespace and aborts commit if found.

Git

if git diff --cached --check | grep [1]; then
  echo "Trailing whitespace found in [2]. Commit aborted."
  exit 1
fi

Drag options to blanks, or click blank then click option'

A--quiet

B--cached

Cfiles

Dstaged files

Attempts:

3 left

💡 Hint

Common Mistakes

Using grep without options prints lines but does not help conditionally.

Referring to unstaged files instead of staged files.

The --quiet option makes grep silent but returns status. The message refers to staged files where the whitespace was found.

5fill in blank

hard

Fill all three blanks to create a pre-commit hook that formats Python files with black and adds them back to staging.

Git

for file in $(git diff --cached --name-only --diff-filter=ACM | grep '\.py$'); do
  black [1]
  git add [2]
done

exit [3]

Drag options to blanks, or click blank then click option'

A$file

Bfile

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the $ before the variable name.

Exiting with 1 which aborts the commit even if formatting succeeded.

The variable $file is used to format and add each Python file. The script exits with 0 to allow the commit.

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