Git: Comment écraser tous les commits sur une branche

Je crée une nouvelle branche masteravec:

git checkout -b testbranch

J'y fais 20 commits.

Maintenant, je veux écraser ces 20 commits. Je fais ça avec:

git rebase -i HEAD~20

Et si je ne sais pas combien de commits? Existe-t-il un moyen de faire quelque chose comme:

git rebase -i all on this branch

Une autre façon d'écraser tous vos commits est de réinitialiser l'index à master:

 git checkout yourBranch
 git reset $(git merge-base master yourBranch)
 git add -A
 git commit -m "one commit on yourBranch"

Ce n'est pas parfait car cela implique que vous savez de quelle branche "yourBranch" vient.
Remarque: trouver que la branche d'origine n'est pas facile / possible avec Git (la voie visuelle est souvent la plus simple , comme on le voit ici ).

EDIT: vous devrez utiliser git push --force

Karlotcha Hoa ajoute dans les commentaires :

Pour la réinitialisation, vous pouvez faire

git reset $(git merge-base master $(git rev-parse --abbrev-ref HEAD)) 

[Cela] utilise automatiquement la branche sur laquelle vous vous trouvez actuellement.
Et si vous utilisez cela, vous pouvez également utiliser un alias, car la commande ne dépend pas du nom de la branche .

Extraire la branche pour laquelle vous souhaitez écraser toutes les validations en une seule validation. Disons que son appelé, feature_branch.

git checkout feature_branch

Étape 1:

Effectuez une réinitialisation logicielle de votre origin/feature_branchavec votre mastersuccursale locale (selon vos besoins, vous pouvez également réinitialiser avec origine / maître). Cela réinitialisera tous les commits supplémentaires dans votre feature_branch, mais sans modifier localement les modifications de votre fichier.

git reset --soft master

Étape 2:

Ajoutez toutes les modifications dans votre répertoire git repo, au nouveau commit qui va être créé. Et engagez la même chose avec un message.

git add -A && git commit -m "commit message goes here"

Ce que vous faites est assez sujet aux erreurs. Faites juste:

git rebase -i master

qui ne rebase automatiquement que les validations de votre branche sur le dernier master actuel.

Une autre façon simple de le faire: allez sur la branche d'origine et faites a merge --squash. Cette commande ne fait pas le commit "écrasé". lorsque vous le faites, tous les messages de validation de yourBranch sont rassemblés.

$ git checkout master
$ git merge --squash yourBranch
$ git commit # all commit messages of yourBranch in one, really useful
 > [status 5007e77] Squashed commit of the following: ...

En supposant que vous vous dériviez du maître, vous n'avez pas besoin d'entrer yourBranchtout le temps dans l'étape de réinitialisation:

git checkout yourBranch
git reset --soft HEAD~$(git rev-list --count HEAD ^master)
git add -A
git commit -m "one commit on yourBranch"

Explication :

• git rev-list --count HEAD ^mastercompte les validations depuis que vous avez créé votre branche de fonctionnalité à partir du maître, f.ex. 20.
• git reset --soft HEAD~20effectuera une réinitialisation logicielle des 20 derniers commits. Cela laisse vos modifications dans les fichiers, mais supprime les validations.

Utilisation :

Dans mon .bash_profile, j'ai ajouté un alias pour gisquashle faire avec une seule commande:

# squash all commits into one
alias gisquash='git reset --soft HEAD~$(git rev-list --count HEAD ^master)'

Après avoir réinitialisé et validé, vous devez faire a git push --force.

Indice :

Si vous utilisez Gitlab> = 11.0, vous n'avez plus besoin de le faire car il a une option de compression lors de la fusion des branches.

Sur la base de la lecture de plusieurs questions et réponses Stackoverflow sur le squashing, je pense que c'est une bonne doublure pour écraser tous les commits sur une branche:

git reset --soft $(git merge-base master YOUR_BRANCH) && git commit -am "YOUR COMMIT MESSAGE" && git rebase -i master

Cela suppose que master est la branche de base.

Solution pour les personnes qui préfèrent cliquer:

1. Installez sourcetree (c'est gratuit)

2. Vérifiez à quoi ressemblent vos commits. Vous avez probablement quelque chose de similaire à cela

3. Cliquez avec le bouton droit sur la validation parent . Dans notre cas, c'est la branche maître.

4. Vous pouvez écraser le commit avec le précédent en cliquant sur un bouton. Dans notre cas, nous devons cliquer 2 fois. Vous pouvez également modifier le message de validation

5. Les résultats sont impressionnants et nous sommes prêts à pousser!

Note latérale: Si vous poussiez vos validations partielles vers la télécommande, vous devez utiliser la poussée forcée après le squash

Une autre solution consisterait à enregistrer tous les journaux de validation dans un fichier

git log> branch.log

Maintenant, branch.log aura tous les identifiants de commit depuis le début .. faites défiler vers le bas et prenez le premier commit (ce sera difficile dans le terminal) en utilisant le premier commit

git reset --soft

tous les commits seront écrasés

La réinitialisation de Git, comme mentionné dans de nombreuses réponses, est de loin le moyen le plus simple et le plus simple de réaliser ce que vous voulez. Je l'utilise dans le workflow suivant:

(sur la branche développement)

git fetch
git merge origin/master  #so development branch has all current changes from master
git reset origin/master  #will show all changes from development branch to master as unstaged
git gui # do a final review, stage all changes you really want
git commit # all changes in a single commit
git branch -f master #update local master branch
git push origin master #push it

Tout ce git reset, dur, doux, et tout le reste mentionné ici fonctionne probablement (ce n'était pas le cas pour moi) si vous faites les étapes correctement et une sorte de génie.
Si vous êtes le Joe Smo moyen, essayez ceci:
Comment utiliser git merge --squash?

Ça m'a sauvé la vie, et ce sera mon coup de cœur pour le squash, je l'utilise 4 fois depuis que je l'ai découvert. Simple, propre et fondamentalement 1 comamnd. En bref:


si vous êtes sur une branche, appelez-la "my_new_feature" off develop et votre pull request a 35 commits (ou quelque soit le nombre) et vous voulez que ce soit 1.

A. Assurez-vous que votre branche est à jour, continuez développer, obtenir les dernières informations et fusionner et résoudre tous les conflits avec "my_new_feature"
(cette étape, vous devez vraiment la faire dès que vous le pouvez)

B. Obtenir la dernière de développer et de se lancer à un nouvel appel de la branche , il « my_new_feature_squashed »

C. la magie est là.
Vous voulez prendre votre travail de « my_new_feature » à « my_new_feature_squashed »
Bougez donc (tout sur votre nouvelle branche sur laquelle nous développons créé off):
fusion git --squash my_new_feature

Toutes vos modifications seront désormais sur votre nouvelle branche, n'hésitez pas à la tester, puis faites votre 1 commit, push, nouveau PR de cette branche - et attendez la répétition le lendemain.
N'aimez-vous pas le codage? :)

Vous pouvez utiliser l'outil que j'ai créé spécifiquement pour cette tâche:

https://github.com/sheerun/git-squash

Fondamentalement, vous devez appeler git squash masteret vous avez terminé