7.6 Git Tools - Geschiedenis herschrijven

De laatste commit veranderen is waarschijnlijk de meest voorkomende geschiedenis-wijziging die je zult doen. Vaak wil je twee basale dingen aan je laatste commit wijzigen: het commit bericht, of de snapshot dat je zojuist opgeslagen hebt, veranderen door het toevoegen, wijzigen of weghalen van bestanden.

Als je alleen je laatste commit bericht wilt wijzigen, dan is dat heel eenvoudig:

Dat plaatst je in de teksteditor met je laatste commit bericht erin, klaar voor je om het bericht te wijzigen en de editor sluiten. Als je opslaat en de editor sluit, dan schrijft de editor een nieuwe commit met dat bericht en maakt dat je nieuwe laatste commit.

Als je echter de echte inhoud van je laatste commit wilt wijzigen, werkt het proces feitelijk hetzelfde — eerst de wijzigingen doen die je dacht te hebben vergeten, deze stagen en de daaropvolgende git commit --amend vervangt die laatste commit met je nieuwe verbeterde commit.

Je moet wel oppassen met deze techniek, omdat het amenderen de SHA-1 van de commit wijzigt. Het is vergelijkbaar met een hele kleine rebase — niet je laatste commit wijzigen als je deze al gepusht hebt.

Om een commit te wijzigen die verder terug in je geschiedenis ligt, moet je meer complexe instrumenten gebruiken. Git heeft geen geschiedenis-wijzig tool, maar je kunt de rebase tool gebruiken om een serie commits op de HEAD te rebasen waarop ze origineel gebaseerd, in plaats van ze naar een andere te verhuizen. Met de interactieve rebase tool kun je dan na iedere commit die je wilt wijzigen stoppen en het bericht wijzigen, bestanden toevoegen, of doen wat je ook maar wilt. Je kunt rebase interactief uitvoeren door de -i optie aan git rebase toe te voegen. Je moet aangeven hoe ver terug je commits wilt herschrijven door het commando te vertellen op welke commit het moet rebasen.

Bijvoorbeeld, als je de laatste drie commit berichten wilt veranderen, of een van de commit berichten in die groep, dan geef je de ouder van de laatste commit die je wilt wijzigen mee als argument aan git rebase -i, wat HEAD~2^ of HEAD~3 is. Het kan makkelijker zijn om de ~3 te onthouden, omdat je de laatste drie commits probeert te wijzigen; maar hou in gedachten dat je eigenlijk vier commits terug aangeeft; de ouder van de laatste commit die je wilt veranderen:

Onthoud, nogmaals, dat dit een rebase commando is - iedere commit in de reeks HEAD~3..HEAD zal worden herschreven, of je het bericht nu wijzigt of niet. Voeg geen commit toe die je al naar een centrale server gepusht hebt - als je dit doet breng je andere gebruikers in de war omdat je ze een alternatieve versie van dezelfde wijziging te geeft.

Dit commando uitvoeren geeft je een lijst met commits in je tekst editor die er ongeveer zo uit ziet:

Het is belangrijk om op te merken dat deze commits in de tegengestelde volgorde getoond worden dan hoe je ze normaliter ziet als je het log commando gebruikt. Als je een log uitvoert, zie je zoiets als dit:

Merk de omgekeerde volgorde op. De interactieve rebase geeft je een script dat het gaat uitvoeren. Het zal beginnen met de commit die je specificeert op de commando regel (HEAD~3) en de wijzigingen in elk van deze commits van voor naar achter opnieuw afspelen. Het toont de oudste het eerst in plaats van de nieuwste, omdat dat deze de eerste is die zal worden afgespeeld.

Je moet het script zodanig aanpassen dat het stopt bij de commit die je wilt wijzigen. Om dat te doen moet je het woord pick veranderen in het woord edit voor elke commit waarbij je het script wilt laten stoppen. Bijvoorbeeld, om alleen het derde commit bericht te wijzigen verander je het bestand zodat het er zo uitziet:

Als je dit opslaat en de editor sluit, spoelt Git terug naar de laatste commit van die lijst en zet je op de commando regel met de volgende boodschap:

Deze instructies vertellen je precies wat je moet doen. Type

Wijzig het commit bericht en verlaat de editor. Voer vervolgens dit uit

Dit commando zal de andere twee commits automatisch toepassen, en je bent klaar. Als je pick op meerdere regels in edit verandert, dan kan je deze stappen herhalen voor iedere commit die je in edit veranderd hebt. Elke keer zal Git stoppen, je de commit laten wijzigen en verder gaan als je klaar bent.

Je kunt een interactieve rebase ook gebruiken om commits anders te rangschikken of ze geheel te verwijderen. Als je de “added cat-file” commit wilt verwijderen en de volgorde waarin de andere twee commits zijn geïntroduceerd wilt veranderen, dan kun je het rebase script van dit

veranderen in dit:

Als je dan opslaat en de editor sluit, zal Git je branch terugzetten naar de ouder van deze commits, eerst 310154e en dan f7f3f6d toepassen, en dan stoppen. Feitelijk verander je de volgorde van die commits en verwijder je de “added cat-file”-commit volledig.

Het is ook mogelijk een serie commits te pakken en ze in één enkele commit samen te persen (squash) met de interactieve rebase tool. Het script stopt behulpzame instructies in het rebase bericht:

Als je in plaats van “pick” of “edit”, “squash” specificeert zal Git zowel die verandering als de verandering die er direct aan vooraf gaat toepassen, en je helpen om de commit berichten samen te voegen. Dus als je een enkele commit van deze drie commits wil maken, laat je het script er zo uit zien:

Als je de editor opslaat en sluit, zal Git alle drie wijzigingen toepassen en je terug in de editor brengen om de drie commit berichten samen te voegen:

Als je dat opslaat, heb je een enkele commit die de veranderingen van alle drie vorige commits introduceert.

Een commit opsplitsen zal een commit ongedaan maken, en dan net zo vaak gedeeltelijk stagen en committen als het aantal commits waar je mee wilt eindigen. Bijvoorbeeld, stel dat je de middelste van je drie commits wilt splitsen. In plaats van “updated README formatting and added blame” wil je het splitsen in twee commits: “updated README formatting” als eerste, en “added blame” als tweede. Je kunt dat doen in het rebase -i script door de instructie van de commit die je wilt splitsen te veranderen in “edit”:

Dan, als het script je naar de commando regel neemt, reset je die commit, neemt de wijzigingen die zijn gereset en maakt meerdere commits ervan. Als je opslaat en de editor verlaat, spoelt Git terug naar de parent van de eerste commit in de lijst, past de eerste commit toe (f7f3f6d), past de tweede toe (310154e), en zet je dan in de console. Daar kan je een gemengde reset doen van die commit met git reset HEAD^ , wat effectief de commit terugdraait en de gewijzigde bestanden unstaged laat. Nu kan je de wijzigingen die gereset zijn nemen en er meerdere commits van maken, en dan git rebase --continue uitvoeren zodra je klaar bent:

Git zal de laatste commit (a5f4a0d) in het script toepassen, en je geschiedenis zal er zo uitzien:

Nogmaals, dit verandert alle SHA’s van alle commits in de lijst, dus zorg er voor dat er geen commit in die lijst zit die je al naar een gedeelde repository gepusht hebt.

Er is nog een geschiedenis-herschrijvende optie, die je kunt gebruiken als je een groter aantal commits moet herschrijven op een gescripte manier. Bijvoorbeeld, het globaal veranderen van je e-mail adres of een bestand uit iedere commit verwijderen. Dit commando heet filter-branch en het kan grote gedeelten van je geschiedenis herschrijven, dus je moet het niet gebruiken tenzij je project nog niet publiek is gemaakt, en andere mensen nog geen werk hebben gebaseerd op de commits die je op het punt staat te herschrijven. Echter het kan heel handig zijn. Je zult een paar veel gebruikte toepassingen zien zodat je een idee krijgt waar het toe in staat is.