Rebase Git: i conflitti continuano a bloccare i progressi

Question

Ho un ramo git (chiamato v4), che è stato creato dal master proprio ieri. C'erano un paio di modifiche da padroneggiare, che voglio entrare nella v4. Quindi, in v4, ho provato a fare un rebase dal master, e un file continua a rovinare tutto: un file di testo a riga singola, che contiene il numero di versione. Questo file è app/views/common/version.txt, che prima rebasing contiene questo testo:

v1.4-alpha-02 

Ecco quello che sto facendo:

> 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". 

Il version.txt appare come segue:

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

Così, ho ordinarlo e sembra ora:

v1.4-alpha-02 

e poi ho cercato di portare avanti: in un primo momento provo un commit:

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

Nessuna fortuna lì. Quindi, stavo cercando di aggiungere il file:

git add app/views/common/version.txt 

Nessuna risposta. Nessuna notizia è una buona notizia, immagino. Quindi, cerco di continuare a:

> 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". 

E 'a questo punto, dopo essere andato in tondo con questo, che sto sbattendo la testa dalla scrivania.

Cosa sta succedendo qui? Che cosa sto facendo di sbagliato? Qualcuno può dirmi dritto?

EDIT - per unutbu

ho cambiato il file come lei ha suggerito e ottenere lo stesso errore:

> 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

ho incontrato un problema simile con un rebase. Il mio problema è stato causato dal fatto che uno dei miei commit ha modificato solo un file e, al momento della risoluzione, ho scartato la modifica introdotta in questo commit. Sono stato in grado di risolvere il mio problema saltando il commit corrispondente (git rebase --skip).

È possibile riprodurre questo problema in un archivio di prova. Prima crea il repository.

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

Quindi memorizzare il contenuto originale di version.txt nel 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 

Creare il ramo v4 e modificare il contenuto di 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(-) 

Torna master e modificare il contenuto di version.txt in modo che ci sarà un conflit durante il 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(-) 

Passa di nuovo al v4 ramo e cercare di rebase. Fallisce con un conflitto in version.txt come pianificato.

$ 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 

Noi risolvere il conflitto selezionando il contenuto master di version.txt. Aggiungiamo il file e proviamo a continuare il nostro 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". 

Non funziona! Vediamo cosa cambia git pensa che ci sia nel nostro repository.

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

Ah ah, non c'è cambiamento.Se hai letto in dettaglio il precedente messaggio di errore, git ci ha informato di questo e raccomandiamo di utilizzare git rebase --skip. Ci ha detto "Se non c'è nulla da mettere in scena, è probabile che qualcos'altro abbia già introdotto gli stessi cambiamenti, potresti voler saltare questa patch". Quindi saltiamo il commit e il rebase ha successo.

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

---

Parola di cautela: Si prega di notare che git rebase --skip elimina completamente la commit che git cercato di rebase. Nel nostro caso, questo dovrebbe andar bene visto che git si sta lamentando che questo è un commit vuoto. Se ritieni di aver perso le modifiche una volta completato il rebase, puoi utilizzare git reflog per ottenere l'ID di commit del repository prima del rebase e utilizzare git reset --hard per ripristinare il depot in tale stato (questa è un'altra operazione distruttiva).

Answer 2

Modificare app/views/comuni/version.txt a

v1.4-alpha-01 

A questo punto del rebase, ricorda che stai risolvendo i conflitti di unione per mostrare la progressione del ramo non master.

Così, nel ribasamento da

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

a

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

il conflitto che si sta risolvendo è come creare un * sul ramo argomento.

Così, dopo aver fatto git rebase --abort, i comandi devono essere

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

Answer 3

Il comportamento che stai vedendo non è quello che ci si aspetterebbe da un rebase tipico con solo questo conflitto. Prendi in considerazione l'utilizzo di un ramo separato per eseguire questo rebase (soprattutto se hai già eseguito il push dei commit da remoto che stai effettuando l'inoltro veloce). Inoltre, git mergetool può essere utile per risolvere i conflitti e ricordare di emettere un git add.

In questo esempio minimo, il rebase funziona come previsto. Puoi fornire un esempio che mostri il comportamento che stai vedendo?

#!/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

Ecco alcune idee:

• Prima di avviare il rebase, assicurarsi che non si è nel bel mezzo di un rebase o AM. Do: rm -rf .git/rebase-apply
  • se si utilizza Bash, enhance your bash prompt so it always presents this information automatically
• Un po 'lei ha citato non ho capito: "e poi cercare di portare avanti: in un primo momento provo un commit:" ... perché commettono ? Nel mezzo di un rebase penso che dovresti solo "git add" dopo aver messo in ordine o "git rm" per lanciare le modifiche o confermare la cancellazione di un file. Forse quello ha incasinato qualcosa?
• provare un merge instead of a rebase
• provare some of Ethan Rowe's ideas

Answer 5

Citando da qui: 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

Questo messaggio di errore è il risultato del tuo git commit -a -m "merged". Se aggiusti il ​​file, esegui git add <file> e git rebase --continue, dovrebbe funzionare correttamente. git rebase --continue sta tentando di eseguire un commit, ma scoprendo che non ci sono modifiche in sospeso al commit (perché le hai già commesse).