¿Hay una opción git-merge?dry-run?

Solo tuve que implementar un método que encuentra automáticamente conflictos entre un repositorio y su remoto. Esta solución hace la fusión en memoria para que no toque el índice, ni el árbol de trabajo. Creo que esta es la forma más segura posible de resolver este problema. Así es como funciona:

1. Trae el control remoto a tu repositorio. Por ejemplo: git fetch origin master
2. Ejecute git merge-base: git merge-base FETCH_HEAD master
3. Ejecute git merge-tree: git merge-tree mergebase master FETCH_HEAD (mergebase es el id hexadecimal que merge-base impresa en el paso anterior)

Ahora supongamos que desea fusionar el maestro remoto con su maestro local, pero puede usar cualquier rama. git merge-tree ejecutará la fusión en memoria e imprimirá el resultado en la salida estándar. Grep para el patrón << o >>. O puede imprimir la salida en un archivo y verificarlo. Si encuentras una línea que comienza con 'cambiado en ambos', entonces lo más probable es que haya un conflicto.

Mi solución simple de fuerza bruta para esto es:

1: crear una rama pre-master (desde master por supuesto)
2: fusionar todas las cosas que desea hacer a este pre-maestro
entonces puedes ver cómo ocurrió la fusión sin tocar al maestro.
3a: fusionar pre-master en master o
3b: fusionar todas las ramas liberadas por aspirantes a maestro

De todos modos me gustaría seguir @orange80 aconsejar.

Deshacer una fusión con git es tan fácil que ni siquiera debería preocuparse por el simulacro:

$ git pull $REMOTE $BRANCH
# uh oh, that wasn't right
$ git reset --hard ORIG_HEAD
# all is right with the world

EDITAR: Como se indica en los comentarios a continuación, si tiene cambios en su directorio de trabajo o área de ensayo, probablemente querrá guardarlos antes de hacer lo anterior (de lo contrario desaparecerán siguiendo el git reset anterior)

Hice un alias para hacer esto y funciona como un encanto, hago esto:

 git config --global alias.mergetest '!f(){ git merge --no-commit --no-ff "$1"; git merge --abort; echo "Merge aborted"; };f '

Ahora solo llamo

git mergetest <branchname>

Para averiguar si hay algún conflicto.

Sólo diff su rama actual contra la rama remota, esto le dirá lo que va a cambiar al hacer un pull/combinar.

#see diff between current master and remote branch
git diff master origin/master

Utilizo el comando request-pull git para hacerlo. Le permite ver cada cambio que ocurriría al fusionar, pero sin hacer nada en sus repositorios locales o remotos.

Por ejemplo, imagine que desea fusionar una rama llamada "feature-x" en su rama maestra

git request-pull master origin feature-x

Le mostrará un resumen de lo que sucedería (sin hacer nada):

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 agrega el parámetro -p, también obtendrá el texto completo del parche, exactamente como si estabas haciendo un git diff en cada archivo cambiado.

Me sorprende que nadie haya sugerido usar parches todavía.

Digamos que te gustaría probar una fusión de your_branch en master (asumo que has master comprobado):

$ git diff master your_branch > your_branch.patch
$ git apply --check your_branch.patch
$ rm your_branch.patch

Eso debería hacer el truco.

Si obtienes errores como

error: patch failed: test.txt:1
error: test.txt: patch does not apply

Eso significa que el parche no tuvo éxito y una fusión produciría conflictos. Sin salida significa que el parche está limpio y que sería capaz de combinar fácilmente la rama

Tenga en cuenta que esto no realmente cambiará su árbol de trabajo (aparte de crear el archivo de parche, por supuesto, pero puede eliminarlo de forma segura después). De la documentación de 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".

Nota para cualquier persona que sea más inteligente / con más experiencia con git que yo: por favor, hágamelo saber si estoy equivocado aquí y este método muestra un comportamiento diferente al de una fusión regular. Parece extraño que en los años 8+ que esta pregunta ha existido nadie sugeriría esta solución aparentemente obvia.

Esto podría ser interesante: De la documentación:

Si ha intentado una fusión que dio lugar a conflictos complejos y desea empieza de nuevo, puedes recuperarte con git merge ab abort.

Pero también podrías hacerlo de la manera ingenua (pero lenta):

rm -Rf /tmp/repository
cp -r repository /tmp/
cd /tmp/repository
git merge ...
...if successful, do the real merge. :)

(Nota: No funcionará solo clonando en /tmp, necesitará una copia, para asegurarse de que los cambios no confirmados no entren en conflicto).

Soy consciente de que esta es una vieja pregunta, pero es la primera en aparecer en una búsqueda de Google.

Git introdujo una opción when ff-only al fusionar.

De: http://git-scm.com/docs/git-merge

---

--ff-only

Rechazar fusionar y salir con un estado distinto de cero a menos que el ENCABEZADO actual ya esté actualizado o la fusión se pueda resolver como un avance rápido.

Hacer esto intentará fusionar y avance rápido, y si no puede abortar y le indica que el avance rápido no se pudo realizar, pero deja su rama de trabajo intacta. Si puede avanzar rápidamente, entonces realizará la fusión en su rama de trabajo. Esta opción también está disponible en git pull. Por lo tanto, usted podría hacer lo siguiente:

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

Uso git log para ver qué ha cambiado en una rama de características desde la rama maestra

git log does_this_branch..contain_this_branch_changes

Por ejemplo, para ver qué commits hay en una rama de características que ha/no se ha fusionado con master:

git log master..feature_branch

Si quieres avanzar rápidamente de B a A, entonces debes asegurarte de que git log B..A no te muestra nada, es decir, A no tiene nada que B no tenga. Pero incluso si B..A tiene algo, es posible que todavía pueda fusionarse sin conflictos, por lo que lo anterior muestra dos cosas: que habrá un avance rápido, y por lo tanto no obtendrá un conflicto.

Haga una copia temporal de su copia de trabajo, luego combínela y diffie las dos.