Existe-t-il une option git-merge --dry-run?
Je fusionne dans une branche distante qui peut avoir beaucoup de conflits. Comment puis-je savoir s'il y aura des conflits ou non?
Je ne vois rien comme un --dry-run sur git-merge.
Comme indiqué précédemment, transmettez l'indicateur --no-commit, mais pour éviter une validation en avance rapide, transmettez également --no-ff, comme suit:
$ git merge --no-commit --no-ff $BRANCH
Pour examiner les changements mis en scène:
$ git diff --cached
Et vous pouvez annuler la fusion, même s'il s'agit d'une fusion à avance rapide:
$ git merge --abort
Il me suffisait de mettre en œuvre une méthode qui détecte automatiquement les conflits entre un référentiel et son distant. Cette solution effectue la fusion en mémoire afin de ne pas toucher l'index, ni l'arbre de travail. Je pense que c'est le moyen le plus sûr possible de résoudre ce problème. Voilà comment cela fonctionne:
- Récupérez la télécommande dans votre référentiel. Par exemple:
git fetch Origin master - Exécutez git merge-base:
git merge-base FETCH_HEAD master - Exécutez git merge-tree:
git merge-tree mergebase master FETCH_HEAD(mergebase est l'id hexadécimal que la base de fusion imprimée à l'étape précédente)
Supposons maintenant que vous souhaitiez fusionner le maître distant avec votre maître local, mais que vous puissiez utiliser toutes les branches. git merge-tree exécutera la fusion en mémoire et imprimera le résultat sur la sortie standard. Grep pour le motif << ou >>. Ou vous pouvez imprimer le résultat dans un fichier et le vérifier. Si vous trouvez une ligne commençant par "modifié dans les deux", il y aura probablement un conflit.
Ma solution simple de force brute à ceci est:
Créer une branche "pré-master" (à partir de master of course)
Fusionner toutes les choses que vous voulez dans ce pré-maître.
Ensuite, vous pouvez voir comment la fusion s’est produite sans toucher au maître.- Fusionner le pré-master en master OU
- Fusionner toutes les branches libérées par wannabe dans le master
Quoi qu'il en soit, je suivrais le conseil de @ orange80.
Il est si facile d'annuler une fusion avec git que vous ne devriez même pas vous inquiéter de la situation difficile:
$ git pull $REMOTE $BRANCH
# uh oh, that wasn't right
$ git reset --hard ORIG_HEAD
# all is right with the world
EDIT: Comme indiqué dans les commentaires ci-dessous, si vous avez des modifications dans votre répertoire de travail ou dans votre zone de stockage intermédiaire, vous voudrez probablement les stocker avant de procéder à la procédure ci-dessus (sinon, elles disparaîtront à la suite du git reset ci-dessus).
J'ai fait un alias pour faire cela et fonctionne comme un charme, je fais ceci:
git config --global alias.mergetest '!f(){ git merge --no-commit --no-ff "$1"; git merge --abort; echo "Merge aborted"; };f '
Maintenant je viens d'appeler
git mergetest <branchname>
Pour savoir s'il y a des conflits.
Diffusez simplement votre branche actuelle contre la branche distante, cela vous indiquera ce qui va changer lorsque vous effectuez une extraction/fusion.
#see diff between current master and remote branch
git diff master Origin/master
J'utilise la commande request-pull git pour le faire. Il vous permet de voir tous les changements qui se produiraient lors de la fusion mais sans rien faire sur vos référentiels locaux ou distants .
Par exemple, imaginons que vous souhaitiez fusionner une branche nommée "feature-x" dans votre branche principale.
git request-pull master Origin feature-x
vous montrera un résumé de ce qui se passerait (sans rien faire):
The following changes since commit fc01dde318:
Layout updates (2015-06-25 11:00:47 +0200)
are available in the git repository at:
http://fakeurl.com/myrepo.git/ feature-x
for you to fetch changes up to 841d3b41ad:
----------------------------------------------------------------
john (2):
Adding some layout
Refactoring
ioserver.js | 8 +++---
package.json | 7 +++++-
server.js | 4 +--
layout/ldkdsd.js | 277 +++++++++++++++++++++++++++++++++++++
4 files changed, 289 insertions(+), 7 deletions(-)
create mode 100644 layout/ldkdsd.js
Si vous ajoutez le paramètre -p, vous obtiendrez également le texte intégral du correctif, exactement comme si vous utilisiez un diff git sur chaque fichier modifié.
Je suis surpris que personne n'ait encore suggéré d'utiliser des correctifs.
Supposons que vous souhaitiez tester une fusion de your_branch dans master (je suppose que vous avez master extrait):
$ git diff master your_branch > your_branch.patch
$ git apply --check your_branch.patch
$ rm your_branch.patch
Cela devrait faire l'affaire.
Si vous obtenez des erreurs comme
error: patch failed: test.txt:1
error: test.txt: patch does not apply
cela signifie que le correctif n'a pas abouti et qu'une fusion produirait des conflits. Pas de sortie signifie que le patch est propre et que vous pourrez facilement fusionner la branche.
Notez que ceci not changera réellement votre arbre de travail (mis à part la création du fichier de correctif bien sûr, mais vous pouvez le supprimer en toute sécurité par la suite). À partir de la documentation git-apply:
--check
Instead of applying the patch, see if the patch is applicable to the
current working tree and/or the index file and detects errors. Turns
off "apply".
Remarque à l'intention des personnes plus intelligentes/plus expérimentées avec git que moi: faites-le-moi savoir si je me trompe et cette méthode affiche un comportement différent de celui d'une fusion normale. Il semble étrange que cette question existe depuis plus de 8 ans et que personne ne suggèrera cette solution apparemment évidente
Je suis conscient que c'est une vieille question, mais c'est la première à apparaître sur une recherche Google.
Git a introduit une option --ff-only lors de la fusion.
De: http://git-scm.com/docs/git-merge
- ff-only
Refusez la fusion et quittez avec un statut différent de zéro sauf si le HEAD actuel est déjà à jour ou si la fusion peut être résolue en avance rapide.
Cela tentera de fusionner et d’avancer rapidement. Si ce n’est pas possible, cela avorte et vous avertit que l’avance rapide ne peut pas être effectuée, mais laisse votre branche en état de marche. S'il peut avancer rapidement, il fusionnera sur votre branche active. Cette option est également disponible sur git pull. Ainsi, vous pourriez faire ce qui suit:
git pull --ff-only Origin branchA #See if you can pull down and merge branchA
git merge --ff-only branchA branchB #See if you can merge branchA into branchB
Cela pourrait être intéressant: Dans la documentation:
Si vous avez essayé une fusion qui a entraîné des conflits complexes et que vous souhaitez recommencer, vous pouvez récupérer avec git merge --abort.
Mais vous pouvez aussi le faire de manière naïve (mais lente):
rm -Rf /tmp/repository
cp -r repository /tmp/
cd /tmp/repository
git merge ...
...if successful, do the real merge. :)
(Remarque: le clonage dans/tmp ne fonctionnera pas, il vous faudra une copie pour vous assurer que les modifications non validées ne seront pas en conflit).
J'utilise le journal git pour voir ce qui a changé sur une branche de la branche principale
git log does_this_branch..contain_this_branch_changes
par exemple. - pour voir quelles sont les commises dans une branche de fonctionnalité qui a/n'a pas été fusionnée avec le maître:
git log master..feature_branch
Si vous souhaitez effectuer une avance rapide de B vers A, vous devez vous assurer que le journal git B..A ne vous indique rien, c’est-à-dire que A n’a rien que B ne possède pas. Mais même si B..A a quelque chose, vous pourrez peut-être encore fusionner sans conflits. Ce qui précède montre donc deux choses: il y aura une avance rapide et vous ne créerez donc pas de conflit.