Squashing commits in Git - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the command to start an interactive rebase for the last 3 commits.

Git

git rebase -i HEAD~[1]

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

A3

B4

C2

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong number after HEAD~

Forgetting the -i flag for interactive mode

The command git rebase -i HEAD~3 opens an interactive rebase for the last 3 commits, allowing you to squash them.

2fill in blank

medium

Complete the command to squash the current commit into the previous one during interactive rebase.

Git

In the editor, replace 'pick' with '[1]' for the commit to squash.

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

Afixup

Bdrop

Cedit

Dsquash

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'fixup' when you want to edit the message

Using 'edit' which pauses rebase for changes

Replacing 'pick' with 'squash' combines the commit with the previous one and allows editing the commit message.

3fill in blank

hard

Fix the error in the command to abort an ongoing rebase.

Git

git rebase --[1]

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

Areset

Bcontinue

Cabort

Dskip

Attempts:

3 left

💡 Hint

Common Mistakes

Using '--continue' instead of '--abort'

Using '--skip' which skips the current patch

The command git rebase --abort stops the rebase and returns to the original state.

4fill in blank

hard

Fill both blanks to create a new commit message during squash.

Git

After squashing, edit the message and save with [1] then exit with [2].

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

A:wq

B:q!

C:w

D:x

Attempts:

3 left

💡 Hint

Common Mistakes

Using ':q!' which discards changes

Using ':w' without quitting

In the editor, :wq writes (saves) and quits, and :x also saves and exits. Both are valid ways to save the commit message and exit.

5fill in blank

hard

Fill all three blanks to squash commits and push changes safely.

Git

git rebase -i HEAD~[1] && git push origin [2] --[3]

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

A3

Bmain

Cforce-with-lease

Dmaster

Attempts:

3 left

💡 Hint

Common Mistakes

Using '--force' instead of '--force-with-lease'

Pushing to wrong branch name

Use HEAD~3 to rebase last 3 commits, push to branch main, and use --force-with-lease to safely force push after rewriting history.

Practice

1. What is the main purpose of squashing commits in Git?

easy

A. To revert the last commit without changing history

B. To combine multiple commits into one for a cleaner history

C. To create a new branch from the current commit

D. To delete all commits from the repository

Solution

1. Step 1: Understand commit history management

   Squashing is used to combine several commits into a single commit to simplify the commit history.

2. Step 2: Identify the purpose of squashing

   This helps keep the project history clean and easier to read by reducing clutter from many small commits.

3. Final Answer:

   To combine multiple commits into one for a cleaner history -> Option B

4. Quick Check:

   Squashing = combine commits [OK]

Hint: Squash = combine commits to clean history [OK]

Common Mistakes:

• Thinking squashing deletes commits permanently
• Confusing squashing with branching
• Believing squashing reverts commits

2. Which Git command starts an interactive rebase to squash commits?

easy

A. git commit --squash HEAD~3

B. git merge -i HEAD~3

C. git rebase -i HEAD~3

D. git reset --soft HEAD~3

Solution

1. Step 1: Identify the command for interactive rebase

   The command to start an interactive rebase is git rebase -i followed by the commit range.

2. Step 2: Confirm the correct syntax

   git rebase -i HEAD~3 opens the last 3 commits for editing, allowing squashing.

3. Final Answer:

   git rebase -i HEAD~3 -> Option C

4. Quick Check:

   Interactive rebase = git rebase -i [OK]

Hint: Use git rebase -i to start squashing commits [OK]

Common Mistakes:

• Using git merge -i which does not exist
• Trying git commit --squash which is invalid
• Confusing reset with rebase for squashing

3. Given these commits:

commit1: Add README
commit2: Fix typo
commit3: Update README formatting

If you run git rebase -i HEAD~3 and squash commit2 and commit3 into commit1, what will the commit history show?

medium

A. One commit combining messages from commit1, commit2, and commit3

B. Three separate commits unchanged

C. One commit with message from commit1 only

D. Two commits: commit1 and combined commit2+commit3

Solution

1. Step 1: Understand squash behavior in interactive rebase

   Squashing merges commits into one, combining their changes and commit messages.

2. Step 2: Result of squashing commit2 and commit3 into commit1

   The final commit will include all changes and combined commit messages from all three commits.

3. Final Answer:

   One commit combining messages from commit1, commit2, and commit3 -> Option A

4. Quick Check:

   Squash merges commits and messages [OK]

Hint: Squash merges commits and their messages together [OK]

Common Mistakes:

• Assuming only the first commit message remains
• Expecting commits to stay separate after squash
• Thinking squash deletes commit messages

4. You ran git rebase -i HEAD~4 to squash commits but got a conflict error. What should you do next?

medium

A. Manually fix the conflicts, then run git rebase --continue

B. Abort the rebase with git rebase --abort and try again

C. Run git reset --hard to discard all changes

D. Push your changes immediately to remote to fix conflicts

Solution

1. Step 1: Understand conflict during rebase

   A conflict means Git needs you to fix code differences manually before continuing.

2. Step 2: Resolve conflicts and continue rebase

   Fix the conflicts in files, then run git rebase --continue to proceed with squashing.

3. Final Answer:

   Manually fix the conflicts, then run git rebase --continue -> Option A

4. Quick Check:

   Fix conflicts + git rebase --continue [OK]

Hint: Fix conflicts manually then git rebase --continue [OK]

Common Mistakes:

• Aborting rebase without trying to fix conflicts
• Using git reset --hard which discards work
• Pushing incomplete changes to remote

5. You squashed commits locally and want to update the remote branch. What is the correct command to push your changes safely?

hard

A. git push --all origin

B. git push origin main

C. git push --no-verify origin main

D. git push --force-with-lease origin main

Solution

1. Step 1: Understand effect of squashing on commit history

   Squashing rewrites commit history, so the remote branch history differs from local.

2. Step 2: Use force push safely

   To update remote with rewritten history, use git push --force-with-lease to avoid overwriting others' work accidentally.

3. Final Answer:

   git push --force-with-lease origin main -> Option D

4. Quick Check:

   Force push safely after squash [OK]

Hint: Use git push --force-with-lease after squash [OK]

Common Mistakes:

• Using normal git push causing rejection
• Using --no-verify which skips hooks but not force push
• Pushing all branches unnecessarily