Branch e merge, le soluzioni
Il ragionamento, i comandi, le trappole
Per ogni missione, sempre lo stesso ordine: in italiano → i comandi → le trappole. Per le più difficili, anche il passo per passo.
La tua strada è diversa ma i test sono verdi? Va bene: i test guardano lo stato finale, non i comandi. Confronta il ragionamento, e leggi comunque le trappole: ognuna è un errore vero, provato contro i test dello zip.
I codici dei commit di Ernesto sono quelli che vedi anche tu dopo prepara.sh. Quelli dei tuoi commit saranno diversi: dipendono da chi sei e da quando li fai.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · Il primo branch
In italiano.
- Creo il branch e ci vado sopra:
git switch -c freni-m12. - Aggiungo la riga a
m12.txt, la metto sul set, scatto la foto. - Torno su
main. - Da
mainunisco il branch.mainera fermo, quindi è un fast-forward.
I comandi.
git switch -c freni-m12
echo "Pastiglie: cambiate il 16 novembre" >> m12.txt
git add m12.txt
git commit -m "Aggiunge le pastiglie dei freni del M12"
git switch main
git merge freni-m12
git log --oneline --graph --all$ git merge freni-m12
Updating 4747be1..61c2884
Fast-forward
m12.txt | 1 +
1 file changed, 1 insertion(+)
$ git log --oneline --graph --all
* 61c2884 (HEAD -> main, freni-m12) Aggiunge le pastiglie dei freni del M12
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git branch freni-m12 al posto di git switch -c freni-m12 | L'etichetta nasce, ma HEAD resta su main: il commit finisce su main, e freni-m12 è rimasto indietro | test_esiste_il_branch_freni_m12_con_un_commit_nuovo, test_main_e_freni_m12_puntano_allo_stesso_commit |
git switch main e basta, senza il merge | Il lavoro è sul branch, ma main non lo ha: la riga non è in m12.txt su main | test_main_e_freni_m12_puntano_allo_stesso_commit, test_il_merge_non_ha_creato_un_commit_nuovo, test_la_riga_delle_pastiglie_e_in_m12_su_main |
git merge main mentre sei su freni-m12 | Git risponde Already up to date.: main non ha niente da dare. E sei ancora sul branch | test_main_e_freni_m12_puntano_allo_stesso_commit, test_il_merge_non_ha_creato_un_commit_nuovo, test_la_riga_delle_pastiglie_e_in_m12_su_main, test_alla_fine_sei_su_main |
La terza è l'errore di chi non ricorda il verso: il merge si lancia da chi riceve.
2 · Le strade si dividono
In italiano.
- Guardo il disegno:
mainelavaggiopartono dallo stesso commit e vanno ognuno per la sua strada. - Sono già su
main, che è chi deve ricevere: lancio il merge da qui. mainè andato avanti, quindi nasce un commit di merge con due genitori.
I comandi.
git log --oneline --graph --all
git merge lavaggio --no-edit
git log --oneline --graph --all$ git log --oneline --graph --all
* 932e653 (HEAD -> main) Aggiorna i freni del M12
| * 8e4b175 (lavaggio) Aggiorna il lavaggio del T28
|/
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12
$ git merge lavaggio --no-edit
Merge made by the 'ort' strategy.
t28.txt | 1 +
1 file changed, 1 insertion(+)
$ git log --oneline --graph --all
* 61579fe (HEAD -> main) Merge branch 'lavaggio'
|\
| * 8e4b175 (lavaggio) Aggiorna il lavaggio del T28
* | 932e653 Aggiorna i freni del M12
|/
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12Il commit di merge, 61579fe, ha come genitori 932e653 (il vecchio main) e 8e4b175 (la punta di lavaggio).
Il disegno.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git switch lavaggio, poi git merge main --no-edit | Il merge funziona, ma al contrario: lavaggio riceve i freni, e main non cambia. Sei sul branch sbagliato | test_l_ultimo_commit_di_main_e_un_commit_di_merge, test_i_genitori_sono_il_vecchio_main_e_lavaggio, test_main_ha_il_lavoro_di_tutti_e_due, test_il_branch_lavaggio_e_rimasto_dov_era, test_alla_fine_sei_su_main |
git merge --ff-only lavaggio | fatal: Not possible to fast-forward, aborting. Le strade si sono divise: spostare l'etichetta non basta | test_l_ultimo_commit_di_main_e_un_commit_di_merge, test_i_genitori_sono_il_vecchio_main_e_lavaggio, test_main_ha_il_lavoro_di_tutti_e_due |
3 · Il merge al contrario
In italiano. Il tuo branch deve ricevere: sei già su sedili-t28, quindi lancio il merge da qui, con main come origine delle novità. Si muove il mio branch. main resta dov'è.
I comandi.
git status
git merge main --no-edit
git log --oneline --graph --all$ git merge main --no-edit
Merge made by the 'ort' strategy.
m12.txt | 2 ++
1 file changed, 2 insertions(+)
$ git log --oneline --graph --all
* 9ea5bf9 (HEAD -> sedili-t28) Merge branch 'main' into sedili-t28
|\
| * cade303 (main) Aggiorna i freni del M12
| * cdd9beb Aggiorna le porte del M12
* | 676e368 Aggiorna i sedili del T28
|/
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12Passo per passo.
| Comando | Dove sta HEAD | Dove sta main | Dove sta sedili-t28 | Commit nuovi |
|---|---|---|---|---|
| (all'inizio) | sedili-t28 | cade303 | 676e368 | 0 |
git merge main --no-edit | sedili-t28 | cade303 | 9ea5bf9 | 1 (il merge) |
I genitori del merge, 9ea5bf9, sono 676e368 (il tuo commit) e cade303 (l'ultimo di main). main non si è mosso.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git switch main, poi git merge sedili-t28 --no-edit | Si muove main, che si prende il tuo lavoro. Il tuo branch resta indietro e sei su main | test_alla_fine_sei_sul_branch_sedili_t28, test_sedili_t28_ha_un_commit_di_merge_con_main, test_il_branch_ha_le_novita_di_main, test_main_e_rimasto_dov_era |
git merge sedili-t28 --no-edit (il nome del tuo branch, mentre sei lì) | Already up to date.: stai unendo il branch con se stesso, non succede niente | test_sedili_t28_ha_un_commit_di_merge_con_main, test_il_branch_ha_le_novita_di_main |
4 · Sul branch sbagliato
In italiano.
- Guardo
git status: la modifica è sulla scrivania, e sono sumain. git switch -c pulizia-t28: il branch nasce qui, e la modifica viene con me.- La metto sul set e scatto la foto.
- Torno su
main, che non ha visto niente.
I comandi.
git status
git switch -c pulizia-t28
git status
git add t28.txt
git commit -m "Aggiunge la pulizia del T28"
git switch main
git log --oneline --graph --all$ git switch -c pulizia-t28
Switched to a new branch 'pulizia-t28'
$ git status
On branch pulizia-t28
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: t28.txt
no changes added to commit (use "git add" and/or "git commit -a")
$ git switch main
Switched to branch 'main'
$ git log --oneline --graph --all
* 405ee1f (pulizia-t28) Aggiunge la pulizia del T28
* 4747be1 (HEAD -> main) Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12Passo per passo.
| Comando | Scrivania | Set | Album | Sei su |
|---|---|---|---|---|
| (all'inizio) | t28.txt modificato | vuoto | 2 commit | main |
git switch -c pulizia-t28 | t28.txt modificato | vuoto | 2 commit | pulizia-t28 |
git add t28.txt | pulita | t28.txt | 2 commit | pulizia-t28 |
git commit -m "…" | pulita | vuoto | 3 commit | pulizia-t28 |
git switch main | pulita | vuoto | 3 commit (uno solo sul branch) | main |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add e git commit prima, poi git switch -c pulizia-t28 | Il commit nasce su main. Il branch nuovo parte da lì e main è avanzato insieme a lui | test_main_e_rimasto_dov_era |
git branch pulizia-t28, poi add e commit | git branch crea l'etichetta ma non ci va sopra: il commit è su main, e il branch è rimasto indietro, senza commit nuovi | test_il_branch_ha_un_commit_nuovo_sopra_quelli_di_ernesto, test_nel_commit_c_e_solo_t28_con_la_riga_della_pulizia, test_main_e_rimasto_dov_era |
5 · Pulizia
In italiano.
- Guardo quali branch ci sono e quali sono dentro
main: nel disegno,freni-m12elavaggiosono sottomain,prova-sediliha un commit in più. - Li cancello con
-d, quello prudente. prova-sedililo lascio: Git non me lo farebbe cancellare comunque.
I comandi.
git log --oneline --graph --all
git branch -d freni-m12
git branch -d lavaggio
git branch$ git log --oneline --graph --all
* 6f69728 (prova-sedili) Prova il tessuto nuovo dei sedili
* 913d8e2 (HEAD -> main) Merge branch 'lavaggio'
|\
| * 8e4b175 (lavaggio) Aggiorna il lavaggio del T28
* | 932e653 (freni-m12) Aggiorna i freni del M12
|/
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12
$ git branch -d freni-m12
Deleted branch freni-m12 (was 932e653).
$ git branch -d lavaggio
Deleted branch lavaggio (was 8e4b175).
$ git branch
* main
prova-sediliIl disegno.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git branch -D freni-m12 lavaggio prova-sedili | -D maiuscola cancella senza chiedere. L'esperimento sui sedili perde la sua etichetta, e il suo commit resta senza nome | test_prova_sedili_c_e_ancora_con_il_suo_commit |
git branch -d prova-sedili per primo | error: the branch 'prova-sedili' is not fully merged. Con set -e lo script si ferma lì, e gli altri due branch restano | test_i_branch_gia_uniti_non_ci_sono_piu |
Il rifiuto di -d non è una trappola: è il freno. Ti dice che quel branch ha lavoro che main non ha.
6 · Il branch del branch
In italiano.
- Disegno:
lavaggio-notturnonasce dalavaggio, quindi il suo ultimo commit contiene anche quello dilavaggio. - Mi basta un merge: unisco
lavaggio-notturnoinmain, e arrivano tutti e due i commit. - Ora tutti e due i branch sono dentro
main: li cancello con-d.
I comandi.
git log --oneline --graph --all
git merge lavaggio-notturno --no-edit
git log --oneline --graph --all
git branch -d lavaggio-notturno
git branch -d lavaggio
git branch$ git log --oneline --graph --all
* 932e653 (HEAD -> main) Aggiorna i freni del M12
| * 31cf5a2 (lavaggio-notturno) Aggiunge il lavaggio notturno del T28
| * 8e4b175 (lavaggio) Aggiorna il lavaggio del T28
|/
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12
$ git merge lavaggio-notturno --no-edit
Merge made by the 'ort' strategy.
t28.txt | 2 ++
1 file changed, 2 insertions(+)
$ git log --oneline --graph --all
* 55b3638 (HEAD -> main) Merge branch 'lavaggio-notturno'
|\
| * 31cf5a2 (lavaggio-notturno) Aggiunge il lavaggio notturno del T28
| * 8e4b175 (lavaggio) Aggiorna il lavaggio del T28
* | 932e653 Aggiorna i freni del M12
|/
* 4747be1 Aggiunge la scheda del T28
* 273505b Aggiunge la scheda del M12
$ git branch -d lavaggio-notturno
Deleted branch lavaggio-notturno (was 31cf5a2).
$ git branch -d lavaggio
Deleted branch lavaggio (was 8e4b175).
$ git branch
* mainPasso per passo.
| Comando | Dove sta HEAD | Dove sta main | lavaggio | lavaggio-notturno | Commit nuovi |
|---|---|---|---|---|---|
| (all'inizio) | main | 932e653 | 8e4b175 | 31cf5a2 | 0 |
git merge lavaggio-notturno --no-edit | main | 55b3638 | 8e4b175 | 31cf5a2 | 1 (il merge) |
git branch -d lavaggio-notturno | main | 55b3638 | 8e4b175 | non c'è | 0 |
git branch -d lavaggio | main | 55b3638 | non c'è | non c'è | 0 |
Va bene anche la strada lunga: git merge lavaggio --no-edit, poi git merge lavaggio-notturno --no-edit, e due commit di merge. È più lunga, ma arriva allo stesso lavoro. L'unica cosa che non funziona è fermarsi a metà.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git merge lavaggio --no-edit e git branch -d lavaggio, ma niente per lavaggio-notturno | Il primo branch è unito e sparisce, ma il secondo ha un commit che main non ha, e resta lì | test_main_ha_il_lavoro_di_lavaggio_notturno, test_i_due_branch_sono_spariti_e_resta_solo_main |
git branch -D lavaggio-notturno lavaggio senza aver unito | Le etichette spariscono, i commit restano senza nome e main non li ha: lavoro perso | test_main_ha_il_lavoro_di_lavaggio, test_main_ha_il_lavoro_di_lavaggio_notturno |