Git rebase: los conflictos siguen bloqueando el progreso

Question

Tengo una rama git (llamada v4), que se creó a partir del maestro ayer. Hubo un par de cambios en el maestro, que quiero entrar en v4. Entonces, en v4, traté de hacer una rebase desde el maestro, y un archivo sigue arruinando cosas: un archivo de texto de una línea, que contiene el número de versión. Este archivo es app/views/common/version.txt, que antes del cambio de base contiene este texto:

v1.4-alpha-02 

Esto es lo que estoy haciendo:

> git rebase master 
First, rewinding head to replay your work on top of it... 
Applying: new version, new branch 
error: patch failed: app/views/common/version.txt:1 
error: app/views/common/version.txt: patch does not apply 
Using index info to reconstruct a base tree... 
Falling back to patching base and 3-way merge... 
Auto-merging app/views/common/version.txt 
CONFLICT (content): Merge conflict in app/views/common/version.txt 
Failed to merge in the changes. 
Patch failed at 0001 new version, new branch 

When you have resolved this problem run "git rebase --continue". 
If you would prefer to skip this patch, instead run "git rebase --skip". 
To restore the original branch and stop rebasing run "git rebase --abort". 

El version.txt ahora se ve así:

<<<<<<< HEAD:app/views/common/version.txt 
v1.4-alpha-02 
======= 
v1.4-alpha-01 
>>>>>>> new version, new branch:app/views/common/version.txt 

Por lo tanto, ponerlo en orden y se ve así ahora:

v1.4-alpha-02 

y luego traté de continuar: en un primer momento lo intento una confirmación:

> git commit -a -m "merged" 
# Not currently on any branch. 
nothing to commit (working directory clean) 

no hay suerte. Por lo tanto, estaba tratando de agregar el archivo:

git add app/views/common/version.txt 

Sin respuesta. No hay noticias son buenas noticias, supongo. Por lo tanto, trato de continuar:

> git rebase --continue 
Applying: new version, new branch 
No changes - did you forget to use 'git add'? 

When you have resolved this problem run "git rebase --continue". 
If you would prefer to skip this patch, instead run "git rebase --skip". 
To restore the original branch and stop rebasing run "git rebase --abort". 

Es en este punto, después de dar vueltas y vueltas con esto, que estoy golpeando la cabeza de la mesa.

¿Qué está pasando aquí? ¿Qué estoy haciendo mal? ¿Alguien me puede aclarar?

EDITAR - para unutbu

me cambió el archivo como usted sugiere y obtener el mismo error:

> git rebase master 
First, rewinding head to replay your work on top of it... 
Applying: new version, new branch 
error: patch failed: app/views/common/version.txt:1 
error: app/views/common/version.txt: patch does not apply 
Using index info to reconstruct a base tree... 
Falling back to patching base and 3-way merge... 
Auto-merging app/views/common/version.txt 
CONFLICT (content): Merge conflict in app/views/common/version.txt 
Failed to merge in the changes. 
Patch failed at 0001 new version, new branch 

When you have resolved this problem run "git rebase --continue". 
If you would prefer to skip this patch, instead run "git rebase --skip". 
To restore the original branch and stop rebasing run "git rebase --abort". 

Answer 1

me encontré con un problema similar con un rebase. Mi problema fue causado porque uno de mis commits solo cambió un archivo, y cuando resolví, descarté el cambio introducido en este commit. Pude resolver mi problema omitiendo la confirmación correspondiente (git rebase --skip).

Puede reproducir este problema en un archivo de prueba. Primero crea el repositorio.

$ mkdir failing-merge 
$ cd failing-merge 
$ git init 
Initialized empty Git repository in $HOME/failing-merge/.git/ 

luego confirmar el contenido original de version.txt en master.

$ echo v1.4-alpha-02 > version.txt 
$ git add version.txt 
$ git commit -m initial 
[master (root-commit) 2eef0a5] initial 
1 files changed, 1 insertions(+), 0 deletions(-) 
create mode 100644 version.txt 

Crear la rama v4 y cambiar el contenido de version.txt.

$ git checkout -b v4 
Switched to a new branch 'v4' 
$ echo v1.4-alpha-03 > version.txt 
$ git add version.txt 
$ git commit -m v4 
[v4 1ef8c9b] v4 
1 files changed, 1 insertions(+), 1 deletions(-) 

Volver a master y cambiar el contenido de version.txt por lo que habrá un conflit durante el rebase.

$ git checkout master 
Switched to branch 'master' 
$ echo v1.4-alpha-04 > version.txt 
$ git add version.txt 
$ git commit -m master 
[master 7313eb3] master 
1 files changed, 1 insertions(+), 1 deletions(-) 

interruptor de nuevo a v4 rama y tratar de rebasar. Falla con un conflit en version.txt según lo planeado.

$ git checkout v4 
Switched to branch 'v4' 
$ git rebase master 
First, rewinding head to replay your work on top of it... 
Applying: v4 
Using index info to reconstruct a base tree... 
Falling back to patching base and 3-way merge... 
Auto-merging version.txt 
CONFLICT (content): Merge conflict in version.txt 
Recorded preimage for 'version.txt' 
Failed to merge in the changes. 
Patch failed at 0001 v4 

When you have resolved this problem run "git rebase --continue". 
If you would prefer to skip this patch, instead run "git rebase --skip". 
To restore the original branch and stop rebasing run "git rebase --abort". 
$ cat version.txt 
<<<<<<< HEAD 
v1.4-alpha-04 
======= 
v1.4-alpha-03 
>>>>>>> v4 

resolvemos el conflicto mediante la selección de los contenidos de masterversion.txt. Agregamos el archivo y tratamos de continuar nuestra rebase.

$ echo v1.4-alpha-04 > version.txt 
$ git add version.txt 
$ git rebase --continue 
Applying: v4 
No changes - did you forget to use 'git add'? 
If there is nothing left to stage, chances are that something else 
already introduced the same changes; you might want to skip this patch. 

When you have resolved this problem run "git rebase --continue". 
If you would prefer to skip this patch, instead run "git rebase --skip". 
To restore the original branch and stop rebasing run "git rebase --abort". 

¡No funciona! Veamos qué cambios git piensan que hay en nuestro repositorio.

$ git status 
# Not currently on any branch. 
nothing to commit (working directory clean) 

Ah ah, no hay cambios.Si lee en detalle el mensaje de error anterior, git nos informó de esto y recomendó usar git rebase --skip. Nos dijo "Si no queda nada para el escenario, es probable que otra cosa ya haya introducido los mismos cambios, es posible que desee omitir este parche". Así que saltamos la confirmación y la rebase tiene éxito.

$ git rebase --skip 
HEAD is now at 7313eb3 master 

---

Una advertencia: Tenga en cuenta que git rebase --skip caerá por completo el commit que git trató de rebasar. En nuestro caso, esto debería estar bien, ya que git se queja de que se trata de una confirmación vacía. Si crees que has perdido los cambios una vez completada la rebase, puedes usar git reflog para obtener la identificación de confirmación de tu repositorio antes de la rebase, y usar git reset --hard para volver a tu depósito en ese estado (esta es otra operación destructiva).

Answer 2

Cambio app/views/comunes/version.txt a

v1.4-alpha-01 

En este punto de la rebase, recuerde que está resolviendo conflictos de combinación para mostrar la progresión de la rama no maestra.

Así que, en cambio de base de

 A---B---C topic 
    /
D---E---F---G master 

a

   A*--B*--C* topic 
      /
D---E---F---G master 

el conflicto está resolviendo está en cómo crear un * en la rama tema.

Así que después de hacer git rebase --abort, los comandos deben ser

git checkout topic 
git rebase master 
< make edits to resolve conflicts > 
git add . 
git rebase --continue 

Answer 3

El comportamiento que se está viendo no es lo que se espera de un rebase típica con sólo este conflicto. Considere usar una rama separada para hacer esta rebase (especialmente si ya ha enviado las confirmaciones de forma remota que está reenviando). Además, git mergetool puede ser útil para resolver conflictos y recordar emitir un git add.

En este ejemplo mínimo, la rebase funciona como se esperaba. ¿Puedes dar un ejemplo que muestre el comportamiento que estás viendo?

#!/bin/bash 

cd /tmp 
mkdir rebasetest 
cd rebasetest 
git init 
echo 'v1.0' > version.txt 
git add version.txt 
git commit -m 'initial commit' 
git checkout -b v4 
echo 'v1.4-alpha-01' > version.txt 
git add version.txt 
git commit -m 'created v4' 
git checkout master 
git merge v4 
echo 'v1.4-alpha-01-rc1' > version.txt 
git add version.txt 
git commit -m 'upped version on master to v1.4-alpha-01-rc1' 
git checkout v4 
echo 'v1.4-alpha-02' > version.txt 
git add version.txt 
git commit -m 'starting work on alpha-02' 

git rebase master 
echo 'v1.4-alpha-02' > version.txt 
git add version.txt 
git rebase --continue 

Answer 4

Aquí están algunas ideas:

• Antes de iniciar el rebase, asegurarse de que no está en el medio de un rebase o AM. Foro: rm -rf .git/rebase-apply
  • si utiliza Bash, enhance your bash prompt so it always presents this information automatically
• Un bit que usted ha mencionado que no entendía: "y luego tratar de continuar: en un primer intento de una confirmación:" ... ¿por qué cometen ? En el medio de una rebase, creo que solo deberías "agregar git" después de ordenar o "git rm" para lanzar cambios o confirmar una eliminación de archivos. Quizás eso arruinó algo?
• probar un merge instead of a rebase
• tratar some of Ethan Rowe's ideas

Answer 5

Citando aquí: http://wholemeal.co.nz/node/9

Huh?!? No, I didn't forget to use git add, I did it ... like ... 2 seconds ago!

Turns out that because there is no change from the patch git suspects something has gone wrong. Git expects a patch to have been applied, but the file has remained unchanged.

The error message is not very intuitive, but it does contain the answer. We just need to tell rebase to skip this patch. It's also not necessary to fix the conflict markers in the file. You will end up with the file version from the branch you are rebasing on.

$ git rebase --skip 

Answer 6

Ese mensaje de error es el resultado de git commit -a -m "merged". Si solo arreglas el archivo, ejecuta git add <file> y git rebase --continue, debería funcionar bien. git rebase --continue está intentando realizar una confirmación, pero descubriendo que no hay cambios pendientes para confirmar (porque ya los cometiste).