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

git merge squash

Question

Me estoy fusionando 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 .

Answer 1

Como se señaló anteriormente, pase el indicador --no-commit , pero para evitar un envío rápido, también pase --no-ff , así:

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

Para examinar los cambios por etapas:

$ git diff --cached

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

$ git merge --abort

Answer 2

Deshacer una fusión con git es tan fácil que ni siquiera debería preocuparse por la ejecución 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 indica en los comentarios a continuación, si tiene cambios en su directorio de trabajo o área de preparación, es probable que desee guardarlos antes de hacer lo anterior (de lo contrario, desaparecerán después del git reset anterior)

Answer 3

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

Si probó una combinación que dio lugar a conflictos complejos y desea volver a empezar, puede recuperar con git merge --abort .

Pero también puedes hacerlo de forma 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á simplemente clonando a / tmp, necesitaría una copia para asegurarse de que los cambios no confirmados no entren en conflicto).

Answer 4

Haga una copia temporal de su copia de trabajo, luego únase a eso y difunda los dos.

Answer 5

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 algún conflicto.

Answer 6

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

Digamos que te gustaría probar una combinación de your_branch en master (supongo que tienes master revisado):

$ 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 podría fusionar fácilmente la rama

Tenga en cuenta que esto no cambiará realmente su árbol de trabajo (aparte de crear el archivo de parche, por supuesto, pero luego puede eliminarlo de manera segura). 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 cualquier persona que sea más inteligente / más experimentada con git que yo: hágame saber si estoy equivocado aquí y este método muestra un comportamiento diferente al de una combinación regular. Parece extraño que en los más de 8 años que haya existido esta pregunta, nadie sugiera esta solución aparentemente obvia.

Answer 7

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

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

De todos modos seguiría el consejo de @ orange80.

Answer 8

Si desea avanzar rápidamente de B a A, debe asegurarse de que git log B..A no le muestre nada, es decir, A no tiene nada que B no tenga. Pero incluso si B..A tiene algo, aún puede fusionarse sin conflictos, por lo que lo anterior muestra dos cosas: que habrá un avance rápido y, por lo tanto, no tendrá un conflicto.

Answer 9

Simplemente difunda su rama actual contra la rama remota, esto le dirá qué va a cambiar cuando realice una extracción / fusión.

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

Answer 10

Solo tuve que implementar un método que encuentra automáticamente conflictos entre un repositorio y su remoto. Esta solución se fusiona en la 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. Traiga el control remoto a su 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ó en la base del paso anterior)

Ahora suponga que desea combinar el maestro remoto con su maestro local, pero puede usar cualquier rama. git merge-tree ejecutará la combinación en la 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 encuentra una línea que comienza con ''cambiado en ambos'', lo más probable es que haya un conflicto.

Answer 11

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

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

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

--f-solo

Se niega a fusionarse 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, y si no puede abortar y le indica que no se pudo realizar el avance rápido, pero deja su rama de trabajo sin tocar. 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

Answer 12

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

git log does_this_branch..contain_this_branch_changes

por ejemplo, para ver qué confirmaciones están en una rama de función que se ha fusionado o no con el maestro:

git log master..feature_branch

Answer 13

Utilizo el comando request-pull git para hacerlo. Le permite ver todos los cambios que ocurrirían 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 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 del parche completo, exactamente como si estuviera haciendo un git diff en cada archivo modificado.