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


Me estoy uniendo en una sucursal remota que puede tener muchos conflictos. ¿Cómo puedo saber si tendrá conflictos o no?

No veo nada como un --dry-run en git-merge.


579
2018-02-01 19:18


origen


Respuestas:


Como se indicó anteriormente, pase el --no-commit bandera, pero para evitar un compromiso de avance rápido, también pase --no-ff, al igual que:

$ git merge --no-commit --no-ff $BRANCH

Para examinar los cambios por etapas:

$ git diff --cached

Y puede deshacer la fusión, incluso si se trata de una combinación de avance rápido:

$ git merge --abort

632
2018-02-01 19:57



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

  1. Busca el control remoto en 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 la identificación hexadecimal que se fusionó base en el paso anterior)

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


194
2018-06-08 19:04



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

1: crear una rama premaster (desde el maestro del curso)
2: combine todas las cosas que desea hacer con este premaster
   entonces puedes ver cómo se produjo la fusión sin tocar maestro entonces.
3a: fusionar premaster en master o
3b: fusionar todas las ramas lanzadas aspirantes en maestro

De todos modos, seguiría @ orange80 advice.


45
2018-05-16 16:29



Deshacer una fusión con git es tan fácil que ni siquiera deberías preocuparte por el funcionamiento en seco:

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

EDITAR: Como se señala en los comentarios a continuación, si tiene cambios en su directorio de trabajo o área de preparación, probablemente querrá esconderlos antes de hacer lo anterior (de lo contrario, desaparecerán después de la git reset encima)


43
2018-02-01 21:24



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 saber si hay conflictos.


27
2018-04-18 06:10



Simplemente difiera su rama actual de la rama remota, esto le dirá qué va a cambiar cuando realice un pull / merge.

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

24
2017-12-10 03:31



Yo uso el petición-extracción git comando para hacerlo. Le permite ver cada cambio que sucedería al fusionarse, pero sin hacer nada en sus repositorios locales o remotos.

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

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 -pparámetro, también obtendrá el texto completo del parche, exactamente como si estuviera haciendo un git diff en cada archivo modificado.


17
2018-06-26 10:24



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

Supongamos que desea probar una combinación de your_branch dentro master (Supongo que tienes master controlado):

$ 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 obtiene 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 generaría conflictos. Sin resultados significa que el parche está limpio y usted podría fusionar fácilmente la rama


Tenga en cuenta que esto no en realidad cambie su árbol de trabajo (aparte de crear el archivo de parche, por supuesto, pero puede eliminarlo con seguridad 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".

Tenga en cuenta a cualquiera que sea más inteligente / más experimentado con git que yo: por favor, hágame saber si me equivoco aquí y este método muestra un comportamiento diferente al de una fusión regular. Parece extraño que en los más de 8 años que ha existido esta pregunta, nadie sugiera esta solución aparentemente obvia.


14
2017-09-14 06:32



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

Si probó una combinación que dio lugar a conflictos complejos y desea   comenzar de nuevo, puedes recuperar con git merge --aborto.

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 la clonación a / tmp, necesitaría una copia, para asegurarse de que los cambios no comprometidos no entren en conflicto).


7
2017-12-17 03:00



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

Git introdujo una opción --ff-only cuando se fusiona.

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


--ff-only

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

Al hacer esto, intentará fusionarse y avanzar rápidamente, y si no puede abortar, le indicará que el avance rápido no se pudo realizar, pero deja intacta su rama de trabajo. 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, podrías 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

7
2017-07-02 23:20



Uso git log para ver qué ha cambiado en una rama de funciones desde la rama principal

git log does_this_branch..contain_this_branch_changes

p.ej. - para ver qué commits están en una rama de características que se ha fusionado / no para masterizar:

git log master..feature_branch

5
2018-02-06 18:01