Git
Écrasement

Remarques

Squash Recent Commits sans relancer

Si vous voulez écraser les x commits précédents en un seul, vous pouvez utiliser les commandes suivantes:

git reset --soft HEAD~x
git commit

Remplacer x par le nombre de validations précédentes que vous souhaitez inclure dans le commit écrasé.

Rappelez-vous que cela créera un nouveau commit, en oubliant essentiellement les informations sur les x commits précédents, x compris leur auteur, leur message et leur date. Vous voulez sans doute d'abord copier-coller un message de validation existant.

Squashing Commits pendant une rebase

Les validations peuvent être écrasées lors d'un git rebase . Il est recommandé que vous compreniez le changement avant d'essayer d'écraser les commits de cette manière.

1. Déterminez la validation à partir de laquelle vous souhaitez effectuer une réinitialisation et notez son hachage de validation.

2. Exécutez git rebase -i [commit hash] .

   Sinon, vous pouvez taper HEAD~4 au lieu d'un hachage de validation, pour afficher le dernier commit et 4 autres commits avant le dernier.

3. Dans l'éditeur qui s'ouvre lors de l'exécution de cette commande, déterminez les validations que vous souhaitez écraser. Remplacez pick au début de ces lignes par squash pour les écraser dans le commit précédent.

4. Après avoir sélectionné les validations que vous souhaitez écraser, vous serez invité à écrire un message de validation.

Journalisation des commits pour déterminer où rebaser

> git log --oneline
612f2f7 This commit should not be squashed
d84b05d This commit should be squashed
ac60234 Yet another commit
36d15de Rebase from here
17692d1 Did some more stuff
e647334 Another Commit
2e30df6 Initial commit

> git rebase -i 36d15de

À ce stade, votre éditeur de choix apparaît où vous pouvez décrire ce que vous voulez faire avec les commits. Git fournit de l'aide dans les commentaires. Si vous le laissez tel quel, rien ne se passera car chaque validation sera conservée et leur ordre sera le même qu’avant la rebase. Dans cet exemple, nous appliquons les commandes suivantes:

pick ac60234 Yet another commit
squash d84b05d This commit should be squashed
pick 612f2f7 This commit should not be squashed

# Rebase 36d15de..612f2f7 onto 36d15de (3 command(s))
#
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like "squash", but discard this commit's log message
# x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

Journal Git après avoir écrit le message de validation

> git log --oneline
77393eb This commit should not be squashed
e090a8c Yet another commit
36d15de Rebase from here
17692d1 Did some more stuff
e647334 Another Commit
2e30df6 Initial commit

Autosquash: Valider le code que vous voulez écraser lors d'un rebase

Compte tenu de l’histoire suivante, imaginez que vous apportez une modification que vous voulez écraser dans le commit bbb2222 A second commit :

$ git log --oneline --decorate
ccc3333 (HEAD -> master) A third commit
bbb2222 A second commit
aaa1111 A first commit
9999999 Initial commit

Une fois que vous avez effectué vos modifications, vous pouvez les ajouter à l'index comme d'habitude, puis les valider en utilisant l'argument --fixup avec une référence à la validation dans laquelle vous voulez écraser:

$ git add .
$ git commit --fixup bbb2222
[my-feature-branch ddd4444] fixup! A second commit

Cela créera un nouveau commit avec un message de validation que Git pourra reconnaître lors d'un rebase interactif:

$ git log --oneline --decorate
ddd4444 (HEAD -> master) fixup! A second commit
ccc3333 A third commit
bbb2222 A second commit
aaa1111 A first commit
9999999 Initial commit

Ensuite, faites un rebase interactif avec l'argument --autosquash :

$ git rebase --autosquash --interactive HEAD~4

Git vous proposera d’écraser le commit que vous avez fait avec le commit --fixup dans la bonne position:

pick aaa1111 A first commit
pick bbb2222 A second commit
fixup ddd4444 fixup! A second commit
pick ccc3333 A third commit

Pour éviter d'avoir à taper --autosquash à chaque rebase, vous pouvez activer cette option par défaut:

$ git config --global rebase.autosquash true

Squashing Commit Au cours de la fusion

Vous pouvez utiliser git merge --squash pour écraser les modifications introduites par une branche dans un seul commit. Aucun engagement ne sera créé.

git merge --squash <branch>
git commit

Cela équivaut plus ou moins à utiliser git reset , mais est plus pratique lorsque les modifications incorporées ont un nom symbolique. Comparer:

git checkout <branch>
git reset --soft $(git merge-base master <branch>)
git commit

Autosquashing et corrections

Lors de la validation des modifications, il est possible de spécifier que la validation sera à l’avenir écrasée par une autre validation et que cela peut être fait comme ça,

git commit --squash=[commit hash of commit to which this commit will be squashed to]

On pourrait aussi utiliser --fixup=[commit hash] alternativement pour corriger.

Il est également possible d'utiliser des mots du message de validation au lieu du hachage de validation, comme cela,

git commit --squash :/things

où le plus récent engagement avec le mot «choses» serait utilisé.

Le message de ces commits commencerait par 'fixup!' ou 'squash!' suivi du reste du message de validation auquel ces commits seront écrasés.

Lors du --autosquash doit être utilisée pour utiliser la fonctionnalité de récupération automatique / correction.