Comment utiliser git merge --squash?

J'ai un serveur Git distant, voici le scénario que je souhaite effectuer:

• Pour chaque bug / fonctionnalité, je crée une branche Git différente

• Je continue de valider mon code dans cette branche Git avec des messages Git non officiels

• Dans le référentiel supérieur, nous devons faire un commit pour un bug avec le message officiel Git

Alors, comment puis-je fusionner ma branche vers une branche distante afin qu'ils obtiennent un seul commit pour tous mes enregistrements (je veux même fournir un message de commit pour cela)?

Supposons que votre branche de correction de bogues soit appelée bugfixet que vous souhaitiez la fusionner en master:

git checkout master
git merge --squash bugfix
git commit

Cela prendra toutes les bugfixvalidations de la branche, les écrasera en 1 commit et les fusionnera avec votre masterbranche.

Explication :

git checkout master

Bascule vers votre mastersuccursale.

git merge --squash bugfix

Prend toutes les validations de la bugfixbranche et les fusionne avec votre branche actuelle.

git commit

Crée une validation unique à partir des modifications fusionnées.

L'omission du -mparamètre vous permet de modifier un projet de message de validation contenant tous les messages de vos validations écrasées avant de finaliser votre validation.

Ce qui a finalement clarifié cela pour moi, c'est un commentaire montrant que:

git checkout main
git merge --squash feature

est l'équivalent de faire:

git checkout feature
git diff main > feature.patch
git checkout main
patch -p1 < feature.patch
git add .

Lorsque je veux fusionner une branche de fonctionnalité avec 105 (!!) validations et les avoir toutes écrasées en une seule, je ne veux pas git rebase -i origin/masterparce que je dois résoudre séparément les conflits de fusion pour chacune des validations intermédiaires (ou au moins celles qui git ne peut pas se comprendre). L'utilisation git merge --squashme donne le résultat que je veux, d'un seul commit pour fusionner une branche de fonctionnalité entière. Et, je n'ai besoin que de faire au plus une résolution manuelle des conflits.

Vous souhaitez fusionner avec l'option de squash. C'est si vous voulez le faire une branche à la fois.

git merge --squash feature1

Si vous souhaitez fusionner toutes les branches en même temps que les validations simples, rebasez d'abord de manière interactive et écrasez chaque fonctionnalité, puis fusionnez le poulpe:

git checkout feature1
git rebase -i master

Squash dans un commit puis répétez pour les autres fonctionnalités.

git checkout master
git merge feature1 feature2 feature3 ...

Cette dernière fusion est une "fusion de poulpe" car elle fusionne beaucoup de branches à la fois.

J'espère que cela t'aides

Si vous l'avez déjà git merge bugfixactivé main, vous pouvez réduire votre commit de fusion en un seul avec:

git reset --soft HEAD^1
git commit

Fusionner la newFeaturebranche masteravec un commit personnalisé:

git merge --squash newFeature && git commit -m 'Your custom commit message';

Si à la place, vous

git merge --squash newFeature && git commit

vous obtiendrez un message de validation qui comprendra toutes les validations de newFeaturebranche, que vous pouvez personnaliser.

Je l'explique en détail ici: https://youtu.be/FQNAIacelT4

Je sais que cette question ne concerne pas spécifiquement Github, mais puisque Github est si largement utilisé et que c'est la réponse que je cherchais, je la partagerai ici.

Github a la possibilité d'effectuer des fusions de squash, selon les options de fusion activées pour le référentiel.

Si les fusions de squash sont activées, l'option "Squash and merge" devrait apparaître dans la liste déroulante sous le bouton "Merge".

Supposons que vous ayez travaillé dans feature / task1 avec plusieurs validations.

1. Accédez à votre branche de projet (project / my_project)

   git checkout project/my_project
   

2. Créer une nouvelle branche (feature / task1_bugfix)

   git checkout -b feature/task1_bugfix
   

3. Marge avec l' --squashoption

   git merge --squash feature/task1
   

4. Créer un seul commit

   git commit -am "add single comments"
   

5. Poussez votre branche

   git push --set-upstream origin feature/task1_bugfix
   

Pour Git

Créer une nouvelle fonctionnalité

via Terminal / Shell:

git checkout origin/feature/<featurename>
git merge --squash origin/feature/<featurename>

Cela ne le valide pas, vous permet de le consulter en premier.

Ensuite, validez et terminez la fonctionnalité de cette nouvelle branche, et supprimez / ignorez l'ancienne (celle que vous avez développée).

si vous obtenez une erreur: la validation n'est pas possible car vous avez des fichiers non fusionnés.

git checkout master
git merge --squash bugfix
git add .
git commit -m "Message"

correction de tous les fichiers de conflit

git add . 

vous pouvez également utiliser

git add [filename]

Pour écraser votre succursale locale avant de la pousser:

1. extraire la branche en question sur laquelle travailler si elle n'est pas déjà extraite.

2. Trouvez le sha du plus ancien commit que vous souhaitez conserver.

3. Créer / extraire une nouvelle branche (tmp1) à partir de ce commit.

   git checkout -b tmp1 <sha1-of-commit>

4. Fusionnez la branche d'origine dans la nouvelle écrasement.

   git merge --squash <original branch>

5. Validez les modifications qui ont été créées par la fusion, avec un message de validation récapitulatif.

   git commit -m <msg>

6. Découvrez la branche d'origine que vous souhaitez écraser.

   git checkout <branch>

7. Réinitialisez le commit d'origine que vous souhaitez conserver.

   git reset --soft <sha1>

8. Rebase cette branche en fonction de la nouvelle branche tmp1.

   git rebase tmp1

9. C'est tout - supprimez maintenant la branche temporaire tmp1 une fois que vous êtes sûr que tout va bien.

Vous pouvez utiliser l'outil que j'ai créé pour faciliter ce processus: git-squash . Par exemple, pour écraser toutes les validations sur la branche de fonctionnalité qui a été branchée à partir de la branche principale, écrivez:

git squash master
git push --force