Vai al contenuto
code-to-code

Apro l'indice…

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

Git6. Rimettere a postop. 132

Rimettere a posto, esercizi spiegati

Sei guai, un comando alla volta

  • 25 minuti di lettura

Sei esempi, uno per guaio. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi la situazione e scrivi su un foglio cosa succede. Prima di aprire la risposta.
  2. In italiano: cosa fa Git, a parole.
  3. Passo per passo: cosa cambia a ogni comando.
  4. Cosa portiamo a casa: la cosa da ricordare.

Puoi rifare ogni esempio sul tuo computer. Nello zip della palestra c'è la cartella esempi/: dalla cartella principale dello zip lancia

Terminale
bash esempi/prepara.sh A       # oppure B, C, D, E, F
cd esempi/progetto

e nasce il tabellone di Lucia Ferri con i suoi tre commit (5c2c617, 1ece7ce, b12df3f), poi quello che serve all'esempio. Ogni volta che vuoi ricominciare, rilancia bash esempi/prepara.sh con la lettera.

I commit che fai tu avranno codici diversi da quelli della pagina: dipendono da chi sei e da quando li fai.


A · Il file cancellato e il file cambiato

Lucia ha cancellato fermate.txt e ha cambiato un orario: nel orari.txt la 6:12 è diventata la 6:21, e ha già fatto git add.

Terminale
git status
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Dove compare ciascun file?

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   orari.txt

Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        deleted:    fermate.txt

orari.txt è sul set (Changes to be committed), fermate.txt è solo sulla scrivania (cancellato, ma non ancora sul set).

Rimettiamo tutto com'era, un pezzo alla volta:

Terminale
git restore fermate.txt           # il file cancellato torna
git restore --staged orari.txt    # dal set alla scrivania: la modifica resta nel file
git restore orari.txt             # e adesso la modifica la butto
git status
$ git status
On branch main
nothing to commit, working tree clean

In italiano. git restore fermate.txt prende il file dall'ultima foto e lo rimette sulla scrivania. Per orari.txt servono due comandi: il primo (--staged) lo toglie dal set e lo lascia sulla scrivania con la sua modifica; il secondo butta la modifica. Se scrivi solo git restore orari.txt, non succede niente: Git guarda il set, che è già uguale alla scrivania.

Il disegno.

inizio git status se il file è già sul set sì: git restore --staged file passo git restore file passo git status finegit statusil file è già sulsetgit restore --staged filegit restore filegit statusfinenosì
Rimettere a posto un file

Passo per passo.

ComandoScrivaniaSetAlbum
(all'inizio)fermate.txt cancellatoorari.txt con la 6:213 commit
git restore fermate.txtfermate.txt c'èorari.txt con la 6:213 commit
git restore --staged orari.txtorari.txt con la 6:21vuoto3 commit
git restore orari.txttutto com'eravuoto3 commit

Cosa portiamo a casa. Un file cancellato torna con git restore. Se è già sul set, prima --staged, poi senza.


B · Un file com'era due foto fa

Stato B. Qualcuno ha tolto Largo Lista da fermate.txt (commit 0d7b32b), e dopo è arrivata un'altra foto, la corsa delle 6:36. L'errore non è nell'ultima foto: git restore fermate.txt non servirebbe, perché l'ultima foto ha già l'errore.

Terminale
git log --oneline
d9cfaae Aggiunge la corsa delle 6:36
0d7b32b Toglie Largo Lista dalle fermate
b12df3f Aggiunge gli orari del mattino
1ece7ce Aggiunge le fermate della Linea Menta
5c2c617 Primo commit: il README del tabellone

Il file giusto era quello di 1ece7ce.

Terminale
git restore --source=1ece7ce fermate.txt
git status
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il file è tornato com'era. E per Git? È una modifica da committare, o no?

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   fermate.txt

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

È una modifica come un'altra: l'ultima foto ha ancora l'errore, e il file sulla scrivania è diverso. git diff mostra la riga che torna:

diff
diff --git a/fermate.txt b/fermate.txt
index 676bb96..3cf4d46 100644
--- a/fermate.txt
+++ b/fermate.txt
@@ -1,4 +1,5 @@
 Porta Codice
 Via Variabile
+Largo Lista
 Ponte Ciclo
 Piazza Query

Per tenerla:

Terminale
git commit -am "Rimette Largo Lista tra le fermate"

In italiano. --source=1ece7ce dice a restore «non guardare l'ultima foto, guarda quella». Il resto è un comando normale: il file cambia sulla scrivania, e sta a te decidere se fotografarlo. La storia non si riscrive: la foto con l'errore (0d7b32b) resta nell'album, e quella nuova lo corregge (regola 1).

Cosa portiamo a casa. git restore --source=codice file riprende un file da qualunque foto. Il codice lo trovi con git log --oneline.


C · Git te lo chiede

Stato C. Lucia è sul branch notte, con una corsa committata (la 6:36) e una riga a metà sulla scrivania (la 6:48).

Terminale
git status --short
git switch main
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Git la lascia andare su main?

 M orari.txt
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

No. orari.txt è diverso tra notte e main, e Lucia ha una modifica non committata su quel file: cambiando branch la perderebbe. Git si rifiuta, e non ha cambiato niente.

La riga è a metà: non è il momento di un commit. Si mette nel cassetto.

Terminale
git stash
git switch main
git switch notte
git stash pop
$ git stash
Saved working directory and index state WIP on notte: aa17689 Aggiunge la corsa delle 6:36
$ git switch main
Switched to branch 'main'
$ git switch notte
Switched to branch 'notte'
$ git stash pop
On branch notte
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   orari.txt

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (e81ae2a5472d1e3ac4fda31e9905cec9cc3429ca)

In italiano. git stash prende le modifiche dalla scrivania e le mette nel cassetto: la scrivania torna come l'ultima foto, e adesso Git lascia cambiare branch. git stash pop le riprende e svuota il cassetto (Dropped).

Passo per passo.

ComandoSei suScrivaniaCassetto
(all'inizio)notteorari.txt con la 6:48vuoto
git stashnottepulita1 voce
git switch mainmainpulita1 voce
git switch nottenottepulita1 voce
git stash popnotteorari.txt con la 6:48vuoto

Cosa portiamo a casa. stash, cambi, stash pop. Dopo il pop, git stash list deve essere vuoto: se scrive ancora qualcosa, qualcosa è rimasto nel cassetto.


D · La HEAD staccata

Stato D: il tabellone di partenza, e basta. Lucia vuole guardare le fermate com'erano nella seconda foto.

Terminale
git switch --detach 1ece7ce
git status
HEAD is now at 1ece7ce Aggiunge le fermate della Linea Menta
$ git status
HEAD detached at 1ece7ce
nothing to commit, working tree clean

Già che c'è, scrive una riga e fa un commit:

Terminale
echo "Vecchia Fiera (solo personale)" >> fermate.txt
git commit -am "Aggiunge Vecchia Fiera alle fermate"
git log --oneline --graph --all
[detached HEAD 4691f61] Aggiunge Vecchia Fiera alle fermate
 1 file changed, 1 insertion(+)
$ git log --oneline --graph --all
* 4691f61 Aggiunge Vecchia Fiera alle fermate
| * b12df3f Aggiunge gli orari del mattino
|/  
* 1ece7ce Aggiunge le fermate della Linea Menta
* 5c2c617 Primo commit: il README del tabellone
C1 ◀── C2 ◀── C3 ◀── main
       ▲
       └── C4 ◀── HEAD

(In git log --oneline --graph --all mancano le etichette, perché il comando non le scrive da solo; nel disegno ci sono.)

Terminale
git switch main
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Cosa dice Git a Lucia, che sta lasciando il commit 4691f61 senza etichetta?

Warning: you are leaving 1 commit behind, not connected to
any of your branches:

  4691f61 Aggiunge Vecchia Fiera alle fermate

If you want to keep it by creating a new branch, this may be a good time
to do so with:

 git branch <new-branch-name> 4691f61

Switched to branch 'main'

Un avviso, con il codice del commit e il comando per salvarlo. Se Lucia non lo legge, il commit resta in giro senza nome.

Due strade, e portano allo stesso posto:

Terminale
git switch -c vecchia-fiera           # prima di andare via, mentre sei ancora lì
git branch vecchia-fiera 4691f61      # dopo, con il codice dell'avviso

Poi git switch main e, se la riga va tenuta, git merge vecchia-fiera.

In italiano. Il commit nasce dove sta HEAD, ma HEAD non è su un branch: nessuna etichetta avanza con lui. git switch -c crea l'etichetta sul commit dove sei e ci attacca HEAD.

Il disegno.

inizio git switch --detach 1ece7ce passo git commit -am "…" se vuoi tenere il commit sì: git switch -c vecchia-fiera no: il commit resta senza etichetta passo git switch main finegit switch --detach 1ece7cegit commit -am "…"vuoi tenere ilcommitil commit resta senzaetichettagit switch -c vecchia-fieragit switch mainfinenosì
Commit a HEAD staccata

Passo per passo.

ComandoHEADmainBranch vecchia-fieraCommit di Lucia
git switch --detach 1ece7cesu 1ece7cesu b12df3fnon c'ènessuno
git commit -am "…"su 4691f61su b12df3fnon c'è4691f61
git switch -c vecchia-fierasu vecchia-fierasu b12df3fsu 4691f614691f61
git switch mainsu mainsu b12df3fsu 4691f614691f61

Cosa portiamo a casa. Guardare una vecchia foto è sicuro. Fare un commit lì sopra va bene, a patto di dargli un'etichetta con git switch -c prima di andare via.


E · Ricopiare in fondo

Stato E. Lucia ha il branch notte con due commit solo suoi, mai mandati a nessuno. Intanto su main Marta Villa ne ha messi altri due (Vecchia Fiera alle fermate, una riga nel README). Lucia vuole i suoi due commit in fondo a main.

Terminale
git log --oneline --graph --all
* 245b655 Precisa gli orari nel README
* 5d6460f Aggiunge Vecchia Fiera alle fermate
| * ffb8095 Aggiunge la corsa delle 6:48
| * aa17689 Aggiunge la corsa delle 6:36
|/  
* b12df3f Aggiunge gli orari del mattino
* 1ece7ce Aggiunge le fermate della Linea Menta
* 5c2c617 Primo commit: il README del tabellone
Terminale
git rebase main
git log --oneline --graph --all
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Dopo il rebase, i due commit di Lucia hanno gli stessi codici di prima (aa17689, ffb8095)? E la storia, com'è?

Successfully rebased and updated refs/heads/notte.
$ git log --oneline --graph --all
* 4f057a0 Aggiunge la corsa delle 6:48
* 226e234 Aggiunge la corsa delle 6:36
* 245b655 Precisa gli orari nel README
* 5d6460f Aggiunge Vecchia Fiera alle fermate
* b12df3f Aggiunge gli orari del mattino
* 1ece7ce Aggiunge le fermate della Linea Menta
* 5c2c617 Primo commit: il README del tabellone

I messaggi sono gli stessi, i codici no: 226e234 e 4f057a0 sono copie, e i vecchi aa17689 e ffb8095 non hanno più nessuna etichetta. La storia è una riga dritta, senza commit di merge.

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

C1 ◀── C2 ◀── C5 ◀── main
       ▲      ▲
       │      └── C3' ◀── C4' ◀── notte ◀── HEAD
       └── C3 ◀── C4          (nessuna etichetta: Git prima o poi li butta)

(Nel disegno C5 è l'ultimo commit di main; nel repository sono due.)

In italiano. Git torna al punto in cui notte era partita, prende i due commit, e li rifa uno alla volta sopra main. Ogni copia ha lo stesso messaggio e le stesse righe cambiate, ma un genitore diverso, quindi un codice diverso. L'etichetta notte salta sulle copie. main non si è mosso: il rebase si lancia sempre dal branch che si sposta.

Passo per passo.

ComandoHEADmainnotteCommit di Lucia
(all'inizio)notte245b655ffb8095aa17689, ffb8095
git rebase mainnotte245b6554f057a0226e234, 4f057a0 (copie)

Il rebase si può abbandonare solo finché è a metà (se per esempio c'è un conflitto): git rebase --abort torna a prima. A rebase finito, git rebase --abort dice fatal: no rebase in progress.

Cosa portiamo a casa. Rebase: dal tuo branch, git rebase main. Commit solo tuoi, mai mandati a nessuno. I codici cambiano.


F · Il rumore, e il .vscode di troppo

Stato F: il tabellone di Lucia, con in più un programma nuovo e tre cartelle che non sono sue.

Terminale
git status
On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .venv/
        .vscode/
        __pycache__/
        tabellone.py

nothing added to commit but untracked files present (use "git add" to track)

tabellone.py è lavoro vero; le altre tre sono rumore. Lucia scrive un .gitignore con due righe (.venv/ e __pycache__/):

Terminale
git status
On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .gitignore
        .vscode/
        tabellone.py

nothing added to commit but untracked files present (use "git add" to track)

.venv/ e __pycache__/ sono spariti. Ma .vscode/ è rimasto, e Lucia, di fretta, scrive:

Terminale
git add .
git commit -m "Aggiunge il tabellone"
git ls-files
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

.vscode/settings.json è finito nell'album?

.gitignore
.vscode/settings.json
README.md
fermate.txt
orari.txt
tabellone.py

Sì. git add . prende tutto quello che non è ignorato, e .vscode/ non era ignorato.

Adesso .vscode/ è nell'album, e scriverlo nel .gitignore non basta più. Lucia lo toglie dall'album, senza toccare il disco:

Terminale
git rm -r --cached .vscode
echo ".vscode/" >> .gitignore
git add .gitignore
git commit -m "Toglie .vscode dall'album"
git status
ls .vscode
git ls-files
$ git rm -r --cached .vscode
rm '.vscode/settings.json'
$ git status
On branch main
nothing to commit, working tree clean
$ ls .vscode
settings.json
$ git ls-files
.gitignore
README.md
fermate.txt
orari.txt
tabellone.py

In italiano. Il .gitignore dice a Git cosa non seguire. Se un file è già seguito, non cambia niente. git rm --cached dice «smetti di seguirlo, ma lascialo dov'è»: il commit che segue registra che il file esce dall'album, e da quel momento il .gitignore fa il suo lavoro.

Il disegno.

inizio .vscode è già nell'album passo git rm -r --cached .vscode passo echo ".vscode/" >> .gitignore passo git add .gitignore passo git commit fine il file resta sul disco.vscode è già nell'albumgit rm -r --cached .vscodeecho ".vscode/" >>.gitignoregit add .gitignoregit commitil file resta sul disco
Togliere un file dall'album

Passo per passo.

Comando.vscode/ sul disco.vscode/ nell'album.vscode/ ignorato
git add . e git commitsìsìno
git rm -r --cached .vscodesìtolto dal setno
echo ".vscode/" >> .gitignoresìtolto dal setsì
git add .gitignore e git commitsìnosì

Cosa portiamo a casa. Il .gitignore si scrive prima del primo git add .. Se la cartella è già nell'album: git rm -r --cached, il .gitignore, un commit. Senza --cached cancelleresti anche i file dal disco.