Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Git4. I conflittip. 76

I conflitti

Quando Git non sa scegliere e aspetta te

  • 10 minuti di lettura

Hai unito tanti branch e non è mai successo niente. Poi un giorno scrivi git merge e Git risponde:

CONFLICT (content): Merge conflict in orari.txt
Automatic merge failed; fix conflicts and then commit the result.

Niente panico. Un conflitto non è un errore e non butta via niente: Git si ferma e ti chiede una cosa sola, «tra queste due versioni, quale tengo?». Tutto il lavoro delle due storie è ancora al suo posto.

Questo capitolo parte da qui. Per i disegni dei commit e delle etichette serve il capitolo Il grafo; per git merge serve Branch e merge.

Quando nasce un conflitto

Un merge usa tre fotografie: quella da cui le due strade sono partite, la tua, e quella che arriva. Per ogni riga Git confronta quello che è cambiato.

  • Cambia una strada sola: Git prende quella modifica, da solo.
  • Cambiano righe diverse: Git le prende tutte e due, da solo.
  • Cambia la stessa riga, in due modi diversi: Git non può sapere quale sia quella giusta. Conflitto.

Un esempio. Lucia Ferri e Marta Villa lavorano sul tabellone di Porta Codice. Lucia, su main, scrive che la corsa delle 6:12 parte dal binario 2. Marta, sul branch notturno, che parte dal binario 1.

C1 ◀── C2 ◀── C3 ◀── C5 ◀── main ◀── HEAD
              ▲
              └── C4 ◀── notturno

C4 e C5 hanno cambiato la stessa riga di orari.txt. Se Lucia lancia git merge notturno, Git si ferma.

Cosa dice Git

Il merge è rimasto a metà. git status lo dice chiaramente:

On branch main
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to mark resolution)
        both modified:   orari.txt

no changes added to commit (use "git add" and/or "git commit -a")

Leggi le tre frasi che contano:

  • You have unmerged paths: c'è un merge non finito.
  • both modified: orari.txt: il file è stato cambiato da tutti e due, ed è lì che devi lavorare.
  • use "git merge --abort" to abort the merge: l'uscita di emergenza, più sotto.

I file che non sono in conflitto Git li ha già sistemati.

L'anatomia di un conflitto

Apri il file. Git ha scritto tutte e due le versioni, separate da tre segni:

06:00 M12 per Piazza Query
<<<<<<< HEAD
06:12 M14 per Piazza Query, binario 2
=======
06:12 M14 per Piazza Query, binario 1
>>>>>>> notturno
06:24 M16 per Piazza Query
SegnoVuol dire
<<<<<<< HEADQui comincia la zona contesa. Sotto c'è la versione di dove sei tu (HEAD)
=======Il muro in mezzo: sopra la tua, sotto quella che arriva
>>>>>>> notturnoQui finisce la zona. Dopo il segno c'è il nome di quello che stai unendo

Quindi: sopra ======= la versione di dove sei (HEAD), sotto quella che arriva. Le righe fuori dalla zona (la 6:00, la 6:24) vanno bene così.

Se in un conflitto vedi anche una riga con |||||||, qualcuno ha attivato lo stile diff3: in mezzo compare anche la versione di partenza. Le altre due parti si leggono uguale.

Risolvere, in quattro mosse

  1. Scegli. Decidi cosa deve esserci: una delle due righe, o una terza che unisce le due.
  2. Cancella i tre segni. Il file deve tornare un file normale, senza <<<<<<<, ======= e >>>>>>>. Git non controlla: se li lasci, finiscono nel commit.
  3. git add orari.txt. Vuol dire «questo l'ho sistemato».
  4. git commit -m "…". Chiude il merge. Il commit nasce con due genitori, come ogni merge.
Terminale
git merge notturno                       # si ferma: conflitto
# apri orari.txt, scegli, togli i segni
git add orari.txt
git commit -m "Unisce le due versioni della 6:12"

Il git add sembra strano: non stai aggiungendo niente di nuovo. Sta nel significato: finché il file non passa dal set, per Git è ancora in conflitto, e git commit risponde Committing is not possible because you have unmerged files.

I pulsanti di VS Code

Aprendo un file in conflitto, VS Code mette sopra ogni zona dei pulsanti:

PulsanteCosa fa
Accept Current ChangeTiene la parte sopra ======= (HEAD)
Accept Incoming ChangeTiene la parte sotto (quella che arriva)
Accept Both ChangesTiene tutte e due, una sotto l'altra: prima la corrente
Compare ChangesLe mette una accanto all'altra

Tolgono i segni al posto tuo, ma la scelta resta tua. Dopo il clic rileggi sempre il file: «Accept Both» su due righe che dicevano la stessa cosa ti lascia una riga doppia, e a volte la riga giusta è una terza che non c'è.

La via di fuga: git merge --abort

Hai aperto il file e hai capito che non è il momento (la scelta spetta a un collega, o hai unito il branch sbagliato)? Annulla tutto:

Terminale
git merge --abort

Il repository torna com'era prima del merge: niente commit nuovo, niente segni, scrivania pulita. Funziona solo mentre il merge è a metà. Dopo il commit è un'altra storia: fatal: There is no merge to abort (MERGE_HEAD missing).

Il conflitto sul tuo branch

Prima di chiedere una pull request conviene portare main dentro il tuo branch, per scoprire i conflitti a casa tua. Funziona in tutto e per tutto come prima, ma HEAD adesso è il tuo branch:

<<<<<<< HEAD
06:12 M14 per Piazza Query, binario 1        ← il tuo branch (dove sei)
=======
06:12 M14 per Piazza Query, binario 2        ← main (quella che arriva)
>>>>>>> main

La regola non cambia: sopra c'è dove sei, sotto c'è quello che arriva. Cambia chi sono i due. Se il merge è un altro (un collega ha fatto git pull), il conflitto è lo stesso: lo vedrai nel capitolo GitHub e le pull request.

Nel rebase, HEAD è al contrario

Il rebase ricopia i tuoi commit in fondo a main, uno alla volta (lo spiega meglio il capitolo Rimettere a posto). Se uno di loro tocca una riga che main ha già cambiato, c'è un conflitto, e questa volta i segni sono capovolti:

<<<<<<< HEAD
06:12 M14 per Piazza Query, binario 2        ← main, su cui Git sta ricopiando
=======
06:12 M14 per Piazza Query, binario 1        ← il tuo commit
>>>>>>> 93ec653 (Mette la 6:12 al binario 1)

Perché? Durante il rebase Git parte da main e ci rimette sopra i tuoi commit, uno per volta. «Dove sei» è main, e il tuo commit è «quello che arriva». Quindi sopra c'è main, sotto c'è il tuo. Per tenere il tuo lavoro devi tenere la parte sotto: «Accept Current» in un rebase tiene main e butta il tuo commit.

Sopra =======Sotto =======
Mergedove sei (HEAD)quello che arriva
Merge sul tuo branchil tuo branchmain
Rebasemainil tuo commit

Si chiude con git add e poi git rebase --continue (non git commit). Si scappa con git rebase --abort.

Ricorda

  • Un conflitto nasce quando due storie cambiano la stessa riga. Niente è perso: Git aspetta te.
  • git status dice both modified; il file contiene tutte e due le versioni.
  • Sopra ======= c'è dove sei (HEAD), sotto quello che arriva. Nel rebase è al contrario.
  • Scegli, togli i tre segni, git add, git commit. Poi rileggi.
  • git merge --abort torna a prima del merge, ma solo finché il merge è a metà.
  • Nel rebase: git add, poi git rebase --continue.