Vai al contenuto
code-to-code

Apro l'indice…

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

Git6. Rimettere a postop. 126

Rimettere a posto

Quando qualcosa è andato storto, e come si riparte

  • 10 minuti di lettura

Per cinque capitoli hai fatto le cose giuste. Questo è il capitolo delle cose sbagliate: un file cancellato, un branch che non si lascia cambiare, un commit finito nel posto sbagliato, una cartella che non dovevi mettere nell'album. Capita a tutti, tutti i giorni. La buona notizia è che Git ha quasi sempre un'uscita, e quasi sempre è un comando solo.

Per leggere i disegni servono i capitoli Il grafo e Il giro di ogni giorno; per i branch, Branch e merge.

Cosa è successo, come rimetti a posto

Cosa è successoCosa fai
Ho cancellato un file, o l'ho rovinato, e non ho fatto commitgit restore file
Voglio un file com'era due foto fagit restore --source=1ece7ce file
Git non mi lascia cambiare branch: Your local changes … would be overwrittengit stash, cambio branch, poi git stash pop
Sono in HEAD detached e ho fatto dei commit da teneregit switch -c nome
Ho dei commit solo miei e main è andato avantigit rebase main (dal tuo branch)
git status è pieno di .venv/ e __pycache__/un file .gitignore
Ho committato .vscode/git rm -r --cached .vscode, il .gitignore, un commit

Ogni riga ha la sua sezione. I codici dei commit che trovi nel capitolo sono quelli degli esempi dello zip della palestra; i tuoi saranno diversi.

restore: riprendere un file

git restore file lo conosci dal capitolo 2: butta le modifiche e rimette il file com'è nell'ultima foto. Funziona uguale se il file non c'è più: è proprio il modo di riavere un file cancellato.

Terminale
git status                   # deleted: fermate.txt
git restore fermate.txt      # il file è di nuovo sulla scrivania

Se non vuoi l'ultima foto ma una più vecchia, dici da quale commit prenderlo:

Terminale
git restore --source=1ece7ce fermate.txt

Il file torna com'era in quel commit, e per Git adesso è una modifica come un'altra: la vedi in git status, e se la vuoi tenere fai git add e git commit.

scrivania ── git add ──▶ set ── git commit ──▶ album
   ▲                      │                      │
   │                      │                      │
   ├─ git restore --staged┘                      │
   └─────────────── git restore ─────────────────┘

stash: il cassetto, quando Git te lo chiede

Sei sul branch notte e hai una riga scritta a metà. Provi a tornare su main e Git risponde:

error: Your local changes to the following files would be overwritten by checkout:
        orari.txt
Please commit your changes or stash them before you switch branches.
Aborting

Traduzione: «orari.txt è diverso nei due branch, e tu l'hai pure cambiato. Se cambio branch, la tua riga si perde. Fai un commit, oppure mettila da parte (stash)». Il commit non è una buona idea: la riga è a metà. Si mette nel cassetto:

                      git stash
   scrivania  ──────────────────────▶  cassetto
              ◀──────────────────────
                    git stash pop
Terminale
git stash          # la scrivania torna pulita, le modifiche stanno nel cassetto
git switch main    # adesso Git ti lascia andare
# …fai quello che dovevi fare su main…
git switch notte
git stash pop      # le modifiche tornano sulla scrivania, il cassetto si svuota

git stash list ti dice cosa c'è nel cassetto. Se è vuoto, non scrive niente.

Il cassetto non è un salvataggio. È una tasca: ci metti le cose per dieci minuti. Non è in nessun branch, non va sul GitHub, e nessuno ti avvisa se te ne dimentichi (la riga stash@{0} resta lì finché non la riprendi). Se un lavoro deve restare più di un'ora, fai un commit su un branch tuo. E se il stash pop incontra un cambiamento sulla stessa riga, va in conflitto come un merge: lo risolvi come nel capitolo I conflitti, e il cassetto non si svuota da solo.

La HEAD staccata

Di solito HEAD sta sopra un branch: «tu sei qui, e qui c'è un'etichetta che avanza con i tuoi commit». Se invece la punti a un commit, la HEAD è staccata:

C1 ◀── C2 ◀── C3 ◀── main
       ▲
       HEAD

Ci arrivi senza volerlo, di solito: git checkout 1ece7ce (il vecchio modo di guardare una foto), git switch --detach 1ece7ce, o a metà di un rebase. Git avvisa:

Note: switching to '1ece7ce'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by switching back to a branch.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -c with the switch command. Example:

  git switch -c <new-branch-name>

Guardare va benissimo. Il pericolo è un altro: se fai un commit da lì e poi torni su main, il commit non ha nessuna etichetta, e nessuno ti dice più dove sta.

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

Per uscire:

Dove seiCosa fai
Hai solo guardatogit switch main (o git switch - per tornare dov'eri)
Hai fatto commit da tenereprima git switch -c nome: l'etichetta nasce sul tuo commit e HEAD ci si attacca. Poi puoi tornare su main
C1 ◀── C2 ◀── C3 ◀── main
       ▲
       └── C4 ◀── corsa ◀── HEAD

Se hai già lasciato la HEAD staccata e Git ti ha stampato Warning: you are leaving 1 commit behind, in quel messaggio c'è il codice del commit: git branch nome codice ci attacca un'etichetta (la regola 1 lo conferma: un commit non si cancella da solo).

Il rebase: ricopiare in fondo

Hai un branch tuo, notte, con due commit. Intanto main è andato avanti. Con un merge i due fogli si pinzano (un commit nuovo con due genitori). Con il rebase Git ricopia i tuoi commit in fondo a main, come se tu avessi cominciato dopo:

C1 ◀── C2 ◀── C5 ◀── main
       ▲
       └── C3 ◀── C4 ◀── notte ◀── HEAD
Terminale
git switch notte    # il rebase si lancia dal branch che vuoi spostare
git rebase main
C1 ◀── C2 ◀── C5 ◀── main
       ▲      ▲
       │      └── C3' ◀── C4' ◀── notte ◀── HEAD
       └── C3 ◀── C4          (nessuna etichetta: Git prima o poi li butta)

Le copie hanno codici nuovi (C3', C4'): un commit non si sposta mai (regola 1), si fa una copia. Il risultato è una storia dritta, senza commit di merge. Se una copia va in conflitto, è il caso del capitolo I conflitti: sopra ======= c'è main, sotto il tuo commit.

Quando sìQuando no
I commit sono solo tuoi, mai mandati a nessunoI commit sono già sul GitHub, o li ha già un collega
Vuoi una storia dritta prima della pull requestNon sei sicuro: il merge non fa danni

Perché «mai su commit condivisi»? Perché le copie hanno codici nuovi: se un collega ha ancora gli originali, le due storie non combaciano più, e il git push viene respinto. A quel punto Git suggerisce di forzare: non farlo, sovrascriveresti il lavoro degli altri.

Ci ripensi a metà? git rebase --abort torna a prima.

.gitignore: i file che Git non deve guardare

Un file .gitignore nella cartella principale elenca cosa Git deve fingere di non vedere, una riga per voce:

ini
.venv/
__pycache__/
.env
.vscode/
  • Il / in fondo vuol dire «cartella». Il punto fa parte del nome: .venv/, non venv/.
  • .venv/ è il venv, __pycache__/ è la cache di Python, .env tiene le password, .vscode/ le impostazioni del tuo VS Code.
  • Le righe che cominciano con # sono commenti.
  • Il .gitignore è un file come gli altri: va nell'album, così lo hanno tutti.

Ignora solo i file che Git non segue ancora. Un file già in un commit resta seguito, anche se poi lo scrivi nel .gitignore. Per questo il .gitignore si scrive prima del primo git add ..

«Ho committato .vscode»

Succede il giorno in cui qualcuno scrive git add . senza guardare. La cartella è nell'album, con dentro i percorsi del tuo computer. Il .gitignore da solo non la toglie. Servono tre mosse:

Terminale
git rm -r --cached .vscode     # toglie dall'album, il disco non si tocca
echo ".vscode/" >> .gitignore
git add .gitignore
git commit -m "Toglie .vscode dall'album"

--cached è la parola che conta. Senza, git rm -r .vscode cancella anche i file dal disco.

E il collega? Alla prossima git pull due cose possono succedere. Se aveva già una sua .vscode/ non seguita, Git non la sovrascrive e si ferma:

error: The following untracked working tree files would be overwritten by merge:
        .vscode/settings.json
Please move or remove them before you merge.
Aborting

(muovi il file, git pull, rimettilo). Quando invece arriva il commit che toglie .vscode/ dall'album, Git toglie i file anche a lui, dal suo disco: le sue impostazioni vanno ricreate (e da quel momento il .gitignore le protegge).

Ricorda

  • git restore file riprende un file dall'ultima foto; con --source=codice, da una foto più vecchia. Quello che butti non torna.
  • Se Git rifiuta di cambiare branch per le tue modifiche: git stash, cambi, git stash pop. Il cassetto è una tasca, non un salvataggio.
  • HEAD staccata: guardare va bene; se hai fatto commit da tenere, git switch -c nome prima di andartene.
  • Il rebase ricopia i tuoi commit in fondo a main, con codici nuovi. Solo su commit mai condivisi; git rebase --abort per ripensarci.
  • .gitignore: .venv/, __pycache__/, .env, .vscode/. Si scrive prima del primo git add ., e vale solo per i file non ancora nell'album.
  • Già nell'album? git rm -r --cached cartella, il .gitignore, un commit.