Git-commits squashen: een gids met voorbeelden

Stel, we werken aan een feature voor een inlogformulier en maken de volgende vier commits:

Zodra de feature af is, zijn deze commits voor het totale project te gedetailleerd. We hoeven in de toekomst niet te weten dat we tijdens de ontwikkeling een bug tegenkwamen die is gefixt. Om een schone geschiedenis in de main-branch te garanderen, squashen we deze commits tot één commit:

Commits squashen in Git: interactieve rebase

De meest gebruikte methode om commits te squashen is met een interactieve rebase. We starten die met het commando:

git rebase -i HEAD~<number_of_commits>

Vervang <number_of_commits> door het aantal commits dat je wilt squashen.

In ons geval hebben we vier commits, dus het commando is:

git rebase -i HEAD~4

Het uitvoeren van dit commando opent een interactieve command-line editor:

Het bovenste gedeelte toont de commits, terwijl onderaan opmerkingen staan over hoe je commits kunt squashen.

We zien vier commits. Voor elke commit moeten we beslissen welk commando we uitvoeren. We letten op de commando's pick (p) en squash (s). Om deze vier commits samen te voegen tot één commit, kunnen we de eerste picken en de overige drie squashen.

We passen de commando's toe door de tekst vóór elke commit te wijzigen, specifiek door pick te veranderen in s of squash voor de tweede, derde en vierde commit. Om deze aanpassingen te maken, moeten we de “INSERT”-modus van de command-line editor ingaan door op de i-toets te drukken:

Na het indrukken van i verschijnt onderaan de tekst -- INSERT --, wat aangeeft dat we de insert-modus hebben geactiveerd. Nu kunnen we met de pijltjestoetsen de cursor verplaatsen, tekens verwijderen en typen zoals in een standaard teksteditor:

Als we tevreden zijn met de wijzigingen, moeten we de insert-modus verlaten door op Esc te drukken. De volgende stap is onze wijzigingen opslaan en de editor afsluiten. Hiervoor drukken we eerst op de :-toets om de editor te laten weten dat we een commando willen uitvoeren:

Onderaan de editor zien we nu een dubbelepunt : die ons vraagt een commando in te voeren. Om de wijzigingen op te slaan gebruiken we het commando w, van "write". Om de editor te sluiten gebruik je q, van "quit". Deze commando's kun je combineren tot wq:

Om het commando uit te voeren, drukken we op Enter. Deze actie sluit de huidige editor en opent een nieuwe, waarin we het commitbericht voor de nieuw gesquashte commit kunnen invoeren. De editor toont een standaardbericht dat bestaat uit de berichten van de vier commits die we squashen:

Ik raad aan het bericht aan te passen zodat het de door deze gecombineerde commits geïmplementeerde wijzigingen nauwkeurig weergeeft—het doel van squashen is tenslotte een schone en goed leesbare geschiedenis.

Om met de editor te werken en het bericht te bewerken, drukken we opnieuw op i om de bewerkmodus in te gaan en passen we het bericht naar wens aan.

In dit geval vervangen we het commitbericht door "Implement login form." Om de bewerkmodus te verlaten, drukken we op Esc. Sla vervolgens de wijzigingen op door op : te drukken, het commando wq in te voeren en op Enter te drukken.

De commitgeschiedenis bekijken

Over het algemeen is het lastig om de volledige commitgeschiedenis te onthouden. Om de commitgeschiedenis te bekijken, kunnen we het commando git log gebruiken. In het genoemde voorbeeld—vóór het squashen—zou het uitvoeren van git log het volgende tonen:

Gebruik de pijltjestoetsen omhoog en omlaag om door de lijst met commits te navigeren. Druk op q om af te sluiten.

We kunnen git log gebruiken om te bevestigen dat het squashen gelukt is. Door dit na het squashen uit te voeren, zie je één commit met het nieuwe bericht:

Gesquashte commit pushen

Het bovenstaande commando werkt op de lokale repository. Om de remote repository bij te werken, moeten we onze wijzigingen pushen. Omdat we de commitgeschiedenis hebben gewijzigd, moeten we echter force pushen met de optie --force:

git push --force origin feature/login-form

Force pushen overschrijft de commitgeschiedenis op de remote branch en kan mogelijk anderen die aan die branch werken verstoren. Het is goed om dit vooraf met het team te communiceren.

Een veiligere manier van force pushen, die het risico voor collega's verkleint, is de optie --force-with-lease te gebruiken:

git push --force-with-lease origin feature/login-form

Deze optie zorgt ervoor dat we alleen force pushen als de remote branch sinds onze laatste fetch of pull niet is bijgewerkt.

Specifieke commits squashen

Stel, we hebben vijf commits:

Stel dat we commits 1, 2 en 5 willen behouden en commits 3 en 4 willen squashen.

Bij een interactieve rebase worden commits die gemarkeerd zijn om te squashen samengevoegd met de direct voorafgaande commit. In dit geval willen we dus Commit4 squashen zodat die opgaat in Commit3.

Hiervoor moeten we een interactieve rebase starten die deze twee commits omvat. In dit geval volstaan drie commits, dus gebruiken we het commando:

git rebase -i HEAD~3

Daarna zetten we Commit4 op s zodat die wordt gesquasht met Commit3:

Na het uitvoeren van dit commando en het tonen van de commits zien we dat commits 3 en 4 zijn samengevoegd, terwijl de rest ongewijzigd is gebleven.

Squashen vanaf een specifieke commit

In het commando git rebase -i HEAD~3 is HEAD een afkorting voor de meest recente commit. De ~3-notatie wordt gebruikt om een voorouder van een commit aan te duiden. HEAD~1 verwijst bijvoorbeeld naar de parent van de HEAD-commit.

Bij een interactieve rebase omvatten de beschouwde commits alle voorouder-commits tot aan de commit die in het commando is opgegeven. Let op: de opgegeven commit zelf is niet inbegrepen:

In plaats van HEAD kunnen we ook direct een commit-hash opgeven. Zo heeft Commit2 de hash dbf3cc118d6d7c08ef9c4a326b26dbb1e3fe9ddf, dus het commando:

git rebase -i dbf3cc118d6d7c08ef9c4a326b26dbb1e3fe9ddf

zou een rebase starten die alle commits na Commit2 meeneemt. Als we dus een rebase vanaf een specifieke commit willen starten en die commit ook willen meenemen, kunnen we het commando gebruiken:

git rebase -i <commit-hash>~1

Conflicten oplossen tijdens commits squashen

Wanneer we commits squashen, combineren we meerdere wijzigingen in één commit. Dit kan tot conflicten leiden als wijzigingen overlappen of sterk van elkaar afwijken. Dit zijn enkele veelvoorkomende situaties waarin conflicten kunnen ontstaan:

1. Overlappende wijzigingen: Als twee of meer commits die je squashen wilt dezelfde regels in een bestand of nauw gerelateerde regels hebben gewijzigd, kan Git deze wijzigingen mogelijk niet automatisch samenvoegen.
2. Verschillende wijzigingsstatus: Als de ene commit een stuk code toevoegt en een latere commit datzelfde stuk code wijzigt of verwijdert, kan het squashen van deze commits tot conflicten leiden die je moet oplossen.
3. Hernoemen en wijzigen: Als een commit een bestand hernoemt en daaropvolgende commits veranderingen aanbrengen onder de oude naam, kan het squashen Git in verwarring brengen en een conflict veroorzaken.
4. Wijzigingen aan binaire bestanden: Binaire bestanden laten zich niet goed mergen met tekstgebaseerde diff-tools. Als meerdere commits hetzelfde binaire bestand wijzigen en we proberen ze te squashen, kan een conflict ontstaan omdat Git deze wijzigingen niet automatisch kan samenvoegen.
5. Complexe geschiedenis: Als de commits een complexe geschiedenis hebben met meerdere merges, branches of rebases, kan squashen tot conflicten leiden door het niet-lineaire karakter van de wijzigingen.

Tijdens het squashen probeert Git elke wijziging één voor één toe te passen. Als er tijdens dit proces conflicten optreden, pauzeert Git en kunnen wij ze oplossen.

Conflicten worden gemarkeerd met conflictmarkeringen <<<<<< en >>>>>>. Om de conflicten op te lossen, openen we de bestanden en lossen we ze handmatig op door te kiezen welk deel van de code we willen behouden.

Na het oplossen van conflicten moeten we de opgeloste bestanden stagen met het commando git add. Daarna kunnen we de rebase vervolgen met het volgende commando:

git rebase --continue

Voor meer over Git-conflicten, bekijk deze tutorial over hoe je merge-conflicten in Git oplost.

Alternatieven voor squashen met rebase

Het commando git merge --squash is een alternatief voor git rebase -i om meerdere commits te combineren tot één commit. Dit commando is vooral handig wanneer we wijzigingen van een branch in de main-branch willen opnemen en alle individuele commits tot één willen samenvoegen. Zo squash je met git merge:

1. We gaan naar de target-branch waarin we de wijzigingen willen opnemen.
2. We voeren het commando git merge --squash <branch-name> uit en vervangen <branch-name door de naam van de branch.
3. We committen de wijzigingen met git commit om één commit te maken die alle wijzigingen van de feature-branch vertegenwoordigt.

Stel dat we de wijzigingen van de branch feature/login-form als één commit in main willen opnemen:

git checkout main
git merge --squash feature-branch
git commit -m "Implement login form"

Dit zijn de beperkingen van deze aanpak vergeleken met git rebase -i:

• Graad van controle: Minder controle over individuele commits. Met rebase kun je kiezen welke commits je samenvoegt, terwijl merge alle wijzigingen in één commit dwingt.
• Tussengeschiedenis: Bij merge gaat de individuele commitgeschiedenis van de feature-branch verloren in de main-branch. Dit kan het lastiger maken om de incrementele wijzigingen tijdens de ontwikkeling van de feature te volgen.
• Review vóór commit: Omdat alle wijzigingen als één change set worden gestaged, kun je niet elke commit afzonderlijk reviewen of testen vóór het squashen, in tegenstelling tot een interactieve rebase waarbij je commits sequentieel kunt reviewen en testen.

Conclusie

Regelmatig en kleine commits opnemen in je workflow bevordert samenwerking en duidelijke documentatie, maar kan de projectgeschiedenis ook rommelig maken. Commits squashen biedt een middenweg: belangrijke mijlpalen blijven bewaard, terwijl de ruis van kleine, iteratieve wijzigingen verdwijnt.

Wil je meer leren over Git? Dan raad ik deze resources aan:

• Cursus Git leren
• Git Revert Merge Commit: een gids met voorbeelden
• Basis tot geavanceerde Git-commando's - Cheatsheet
• Git Checkout Remote Branch: stapsgewijze gids
• Git Clone Branch: een uitgebreide tutorial