Rimettere a posto, 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: il test guarda lo stato in cui hai lasciato il repository, non i comandi. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune sembrano riuscire e si rompono su un test.
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 file sparito
In italiano.
git statusmostradeleted: fermate.txtemodified: tabellone.py: tutti e due sulla scrivania, niente sul set.git restoreli riprende dall'ultima foto. Gli appunti di Marta sono un file nuovo:restorenon lo conosce, quindi non lo tocca.
I comandi.
git status
git restore fermate.txt tabellone.py
git statusLe trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add -A e git commit | Nell'album finisce un file che manca e uno rovinato: il danno diventa «la versione giusta» | test_fermate_txt_e_tornato_com_era, test_tabellone_py_e_tornato_com_era e test_non_c_e_nessun_commit_nuovo |
git restore tabellone.py e basta | Il programma riparte, ma le fermate non ci sono ancora | test_fermate_txt_e_tornato_com_era |
La prima è la più pericolosa: il commit riesce senza un messaggio d'errore, e il danno entra nell'album.
2 · Git te lo chiede
In italiano.
git switch mainsi rifiuta:avvisi.txtè diverso nei due branch e hai una modifica non committata.git stashmette il lavoro a metà nel cassetto: la scrivania torna pulita.- Su
maincorreggi la riga e fai il commit. - Torni su
scala-mobileegit stash popriprende il lavoro, svuotando il cassetto.
I comandi.
git switch main # Git rifiuta: è quello che ti aspetti
git stash
git switch mainApri avvisi.txt e fallo diventare così:
Avvisi di Piazza Query
Ascensore: in servizio.
Scala mobile: in servizio.
Bagni: aperti.git add avvisi.txt
git commit -m "Corregge l'errore di battitura dell'ascensore"
git switch scala-mobile
git stash pop
git stash listIl disegno.
Passo per passo.
| Comando | Sei su | Scrivania | Cassetto | Commit nuovi |
|---|---|---|---|---|
| (all'inizio) | scala-mobile | avvisi.txt con la riga dei bagni a metà | vuoto | nessuno |
git stash | scala-mobile | pulita | 1 voce | nessuno |
git switch main | main | pulita | 1 voce | nessuno |
correzione, git add, git commit | main | pulita | 1 voce | 1 su main |
git switch scala-mobile | scala-mobile | pulita | 1 voce | 1 su main |
git stash pop | scala-mobile | riga dei bagni a metà | vuoto | 1 su main |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Tutto giusto, ma senza git stash pop | Il lavoro a metà resta nel cassetto: sulla scrivania non c'è | test_il_cassetto_e_vuoto e test_il_lavoro_a_meta_e_di_nuovo_sulla_scrivania |
git switch --force main | Git passa su main subito, ma butta il lavoro a metà: non finisce nel cassetto, non torna | test_il_lavoro_a_meta_e_di_nuovo_sulla_scrivania |
La seconda sembra una scorciatoia: il messaggio di Git ti chiedeva di mettere da parte, non di forzare.
3 · In visita in una vecchia foto
In italiano.
git statusdiceHEAD detached at …: sei sopra un commit, senza etichetta.git switch -c corsa-636crea il branch sul commit dove sei e attacca HEAD a lui. Il commit di Sergio adesso ha un'etichetta.
I comandi.
git status
git switch -c corsa-636
git log --onelineLe trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git switch main e poi git branch corsa-636 | Il commit era già rimasto senza etichetta: il branch nasce su main, senza il commit | test_head_non_e_piu_staccata_sei_su_corsa_636 e test_il_branch_ha_il_commit_nuovo_sopra_la_foto_del_mattino |
git branch corsa-636 e basta | L'etichetta c'è, ma HEAD resta staccata: se fai un altro commit, non avanza | test_head_non_e_piu_staccata_sei_su_corsa_636 |
Se sei già tornato su main, non è perso: l'avviso di Git ha il codice del commit, e git branch corsa-636 codice gli dà l'etichetta. Poi git switch corsa-636.
4 · Ricopiare in fondo
In italiano.
- Sei su
orari-sera, il branch che deve spostarsi.git rebase mainprende i tuoi due commit e li rifà uno alla volta sopramain. - I file di
maine quelli dei tuoi commit sono diversi: nessun conflitto, il rebase finisce da solo. mainnon si muove. I due commit hanno codici nuovi e lo stesso messaggio.
I comandi.
git status
git rebase main
git log --oneline --graph --allPasso per passo.
| Comando | HEAD | main | orari-sera | Commit di merge |
|---|---|---|---|---|
| (all'inizio) | orari-sera | 2 commit avanti | 2 commit tuoi, partiti prima | nessuno |
git rebase main | orari-sera | fermo | i 2 commit ricopiati in fondo a main, codici nuovi | nessuno |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git merge main (invece del rebase) | orari-sera contiene main, ma con un commit di merge in mezzo: la storia non è più dritta | test_la_storia_da_main_a_orari_sera_e_dritta e test_i_tuoi_due_commit_hanno_ancora_il_loro_messaggio |
git switch main e git rebase orari-sera | Il rebase va al contrario: ricopia i commit di main sopra orari-sera, e main cambia codici | test_sei_su_orari_sera_e_il_rebase_non_e_a_meta, test_orari_sera_sta_sopra_main, test_i_tuoi_due_commit_hanno_ancora_il_loro_messaggio e test_main_non_si_e_mosso |
La seconda è la più infida: Git non dice niente, ma hai riscritto i commit di Sergio.
5 · Il rumore
In italiano.
git statusmostra.venv/,__pycache__/efermate.pytra i file nuovi.- Il
.gitignorecon le due voci nasconde il rumore. Adessogit statusmostra solo.gitignoreefermate.py. git adddei due file,git commit.
I comandi.
git statusCrea il file .gitignore e scrivici dentro:
.venv/
__pycache__/git status
git add .gitignore fermate.py
git commit -m "Aggiunge le fermate e il .gitignore"
git statusLe trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add . prima di scrivere il .gitignore | I file di .venv/ e __pycache__/ entrano nell'album. Il .gitignore arriva dopo, ma i file già seguiti restano seguiti | test_nell_album_non_c_e_il_rumore |
Il .gitignore scritto, ma nel commit solo fermate.py | Il rumore sparisce da git status, ma il .gitignore resta un file nuovo non committato: i colleghi non lo hanno | test_il_gitignore_e_nell_album e test_la_scrivania_e_pulita |
venv/ e pycache/ nel .gitignore | Non coincidono con .venv/ e __pycache__/: Git continua a mostrarli | test_il_venv_e_la_cache_di_python_sono_ignorati e test_la_scrivania_e_pulita |
6 · Ho committato .vscode
In italiano.
git rm -r --cached .vscodetoglie la cartella dall'album e la lascia sul disco.- Si aggiunge
.vscode/in fondo al.gitignore, senza cancellare le righe che c'erano. - Un commit con tutte e due le cose.
I comandi.
git rm -r --cached .vscode
echo ".vscode/" >> .gitignore
git add .gitignore
git status
git commit -m "Toglie .vscode dall'album e lo ignora"Passo per passo.
| Comando | .vscode/ sul disco | .vscode/ nell'album | .vscode/ ignorato |
|---|---|---|---|
| (all'inizio) | sì | sì | no |
git rm -r --cached .vscode | sì | tolto dal set | no |
echo ".vscode/" >> .gitignore | sì | tolto dal set | sì |
git add .gitignore e git commit | sì | no | sì |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git rm -r .vscode senza --cached | I file escono dall'album e dal disco: Sergio perde le sue impostazioni | test_i_file_di_vscode_sono_ancora_sul_disco |
.vscode/ nel .gitignore e basta | Il .gitignore guarda solo i file non seguiti: .vscode/ è già nell'album, e ci resta | test_nell_album_non_c_e_piu_vscode |
git rm -r --cached .vscode e il commit, ma senza .gitignore | La cartella esce dall'album, ma torna a comparire come nuova in git status | test_vscode_e_ignorato e test_la_scrivania_e_pulita |
La storia: La cucina di Ottavio
Livello 1 · Il primo commit
In italiano.
git init -b maintrasformaprogetto/in un repository.- Il
.gitignorenascondefoto/e gli appunti. Lo si scrive prima digit add .. git add .prende tutto il resto,.gitignorecompreso;git commitscatta la prima foto.
I comandi.
git init -b main
git statusCrea il file .gitignore e scrivici dentro:
foto/
appunti-di-ottavio.txtgit status
git add .
git commit -m "Primo commit: il quaderno di Ottavio"
git statusLe trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add . e git commit prima del .gitignore | Foto e appunti di Ottavio nell'album: il .gitignore poi non li toglie | test_livello_1_foto_e_appunti_non_sono_nell_album |
.gitignore scritto, ma git add solo di README.md, menu.txt e ricette | Il .gitignore non è nel commit | test_livello_1_le_ricette_sono_nell_album e test_livello_1_la_scrivania_e_pulita |
appunti.txt nel .gitignore | Il file si chiama appunti-di-ottavio.txt: la riga non coincide, e gli appunti entrano nell'album | test_livello_1_foto_e_appunti_non_sono_nell_album e test_livello_1_foto_e_appunti_sono_ignorati |
Livello 2 · Il sale e lo zucchero
In italiano.
- I tre file sono sul set. Per riportare tiramisù e panna cotta com'erano, prima li tolgo dal set (
--staged), poi butto le modifiche dalla scrivania. - Sul set resta solo il risotto, e il commit lo fotografa.
I comandi.
git status
git restore --staged ricette/tiramisu.txt ricette/panna-cotta.txt
git restore ricette/tiramisu.txt ricette/panna-cotta.txt
git status
git commit -m "Porta il brodo del risotto a 14 litri"Passo per passo.
| Comando | Scrivania | Set | Album |
|---|---|---|---|
| (all'inizio) | tre file cambiati | tre file | 1 commit |
git restore --staged tiramisu panna-cotta | tiramisù e panna cotta cambiati | solo il risotto | 1 commit |
git restore tiramisu panna-cotta | com'erano | solo il risotto | 1 commit |
git commit | pulita | vuoto | 2 commit |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git restore dei due file, senza --staged, poi git commit | Il comando guarda il set, che ha già la versione sbagliata: non cambia niente. Il commit si porta dietro il pasticcio di Pina | test_livello_2_nella_foto_nuova_c_e_solo_il_risotto, test_livello_2_il_tiramisu_e_com_era e test_livello_2_la_panna_cotta_e_com_era |
git add -A e git commit | Tutto quello che Pina ha cambiato finisce nella foto, sale compreso | gli stessi tre |
Livello 3 · Il cassetto
In italiano.
- Git rifiuta di passare su
main.git stashmette il menu a metà nel cassetto. - Su
maincorreggo «arosto» in «arrosto»,git add,git commit. - Torno su
cena,git stash popriprende il menu a metà, lo finisco (la riga del caffè c'è già) e lo committo. - Torno su
maine uniscocena: le righe cambiate sono diverse, quindi nessun conflitto.
I comandi.
git switch main # Git rifiuta: è voluto
git stash
git switch mainApri menu.txt e correggi la riga del secondo (Secondo: arrosto con patate): il resto del file resta com'è.
git add menu.txt
git commit -m "Corregge l'arrosto nel menu"
git switch cena
git stash pop
git add menu.txt
git commit -m "Finisce il menu della cena"
git switch main
git merge --no-edit cenaPasso per passo.
| Comando | Sei su | Scrivania | Cassetto | main |
|---|---|---|---|---|
| (all'inizio) | cena | menu con il caffè, non committato | vuoto | menu con «arosto» |
git stash | cena | pulita | 1 voce | idem |
git switch main e il commit | main | pulita | 1 voce | «arrosto», 1 commit in più |
git switch cena e git stash pop | cena | menu con il caffè | vuoto | idem |
git commit | cena | pulita | vuoto | idem |
git switch main e git merge --no-edit cena | main | pulita | vuoto | merge: «arrosto» e il caffè |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git stash, la correzione su main, il merge: manca il git stash pop | Il menu a metà resta nel cassetto, e il menu unito non ha la riga del caffè | test_livello_3_il_cassetto_e_vuoto e test_livello_3_il_menu_della_cena_e_finito_e_unito_in_main |
git switch --force main | Passa su main buttando il menu a metà: la riga del caffè non c'è più da nessuna parte | test_livello_3_il_menu_della_cena_e_finito_e_unito_in_main |
Livello 4 · In visita al quaderno di lunedì
In italiano.
git log --onelinemostra il primo commit in fondo.git switch --detachcon il suo codice mi porta lì.- Scrivo
ricette/minestrone.txte faccio il commit: nasce sopra il commit di lunedì, senza etichetta. git switch -c minestronegli dà l'etichetta. Poigit switch mainegit merge --no-edit minestrone.
I comandi.
git log --oneline
git switch --detach CODICE-DEL-PRIMO-COMMITCrea ricette/minestrone.txt e scrivici dentro:
Minestrone
Per 50 persone
Verdure miste: 10 kg
Fagioli: 1 kg
Brodo: 8 litrigit add ricette/minestrone.txt
git commit -m "Scrive il minestrone"
git switch -c minestrone
git switch main
git merge --no-edit minestronePasso per passo.
| Comando | HEAD | main | minestrone | Commit del minestrone |
|---|---|---|---|---|
| (all'inizio) | main | in cima | non c'è | non c'è |
git switch --detach CODICE | sul primo commit | in cima | non c'è | non c'è |
git commit | sul commit nuovo | in cima | non c'è | senza etichetta |
git switch -c minestrone | minestrone | in cima | sul commit nuovo | ha un'etichetta |
git switch main | main | in cima | sul commit nuovo | ha un'etichetta |
git merge --no-edit minestrone | main | merge: ha anche il minestrone | sul commit nuovo | dentro main |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Dalla HEAD staccata, git switch main senza git switch -c | Git avvisa (you are leaving 1 commit behind) ma lascia andare: il commit resta senza etichetta e main non ha il minestrone | test_livello_4_il_branch_minestrone_parte_dal_quaderno_di_lunedi, test_livello_4_sei_su_main_e_il_minestrone_e_unito e test_livello_4_il_minestrone_e_nel_quaderno |
Il minestrone scritto direttamente su main, poi git branch minestrone | Il file c'è, ma il commit sta in cima a main, non sopra il quaderno di lunedì | test_livello_4_il_branch_minestrone_parte_dal_quaderno_di_lunedi |
Livello 5 · Lo zafferano di Pina
In italiano.
git pushè respinto: il GitHub ha un commit che tu non hai.git pullporta i commit di Pina e fa il merge. La stessa riga dello zafferano è cambiata in due modi: conflitto.- Sopra
=======c'è la tua dose (3 g), sotto quella di Pina (2,5 g). La regola di Ottavio dice la più piccola: 2,5 g. Cancello i tre segni. git add,git commitchiude il merge.git pushora riesce.
I comandi.
git push # respinto: è voluto
git pull # si ferma sul conflitto: è volutoApri ricette/risotto.txt e fallo diventare così:
Risotto alla milanese
Per 50 persone
Riso: 5 kg
Brodo: 14 litri
Zafferano: 2,5 g
Burro: 500 ggit add ricette/risotto.txt
git commit -m "Unisce lo zafferano di Pina"
git pushIl disegno.
Passo per passo.
| Comando | Il tuo main | main sul GitHub | Cosa succede |
|---|---|---|---|
| (all'inizio) | 1 commit tuo in più | 1 commit di Pina in più, più i dolci | I due main sono andati in strade diverse |
git push | uguale | uguale | Respinto: fetch first |
git pull | merge a metà | uguale | Conflitto sul risotto; i dolci sono già arrivati |
il file giusto, git add, git commit | merge fatto | uguale | Il merge ha due genitori |
git push | uguale al GitHub | uguale al tuo | Riesce |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nel conflitto, tieni la tua riga (Zafferano: 3 g) | Il merge si chiude, il push riesce, ma contro la regola di Ottavio | test_livello_5_nel_risotto_c_e_la_dose_giusta |
git add e git commit senza togliere i segni | Nel risotto restano <<<<<<<, ======= e >>>>>>> | test_livello_5_nel_risotto_c_e_la_dose_giusta |
git push --force origin main al posto del pull | Il GitHub accetta: il lavoro di Pina (e i dolci) sparisce da main | test_livello_5_nel_risotto_c_e_la_dose_giusta, test_livello_5_con_il_pull_sono_arrivati_i_dolci e test_livello_5_il_pull_ha_fatto_un_commit_di_merge |
Merge fatto e commit, ma niente git push | Il GitHub resta com'era | test_livello_5_il_push_e_riuscito |
Il --force è la trappola da ricordare: Git ti propone git pull, e un forum ti propone --force. Il forum ha torto.
Livello 6 · Il peperoncino
In italiano.
mainè protetto: ci vuole un branch tuo.git switch -c via-il-peperoncino.- Tolgo solo la riga del peperoncino da
ricette/tiramisu.txt,git addegit commit. git push -u origin via-il-peperoncinomanda il branch sul GitHub.bash ../unisci-pr.sh via-il-peperoncinoè la pull request: Ottavio la approva e la unisce.- Il mio
mainnon lo sa ancora:git switch mainegit pull.
I comandi.
git switch -c via-il-peperoncinoApri ricette/tiramisu.txt e cancella la riga Peperoncino: 1 cucchiaino. Il file deve diventare così:
Tiramisù
Per 50 persone
Mascarpone: 2 kg
Uova: 24
Zucchero: 400 g
Savoiardi: 8 pacchi
Caffè: 800 mlgit add ricette/tiramisu.txt
git commit -m "Toglie il peperoncino dal tiramisù"
git push -u origin via-il-peperoncino
bash ../unisci-pr.sh via-il-peperoncino
git switch main
git pullPasso per passo.
| Comando | Il tuo main | main sul GitHub | via-il-peperoncino |
|---|---|---|---|
| (all'inizio) | uguale al GitHub | protetto | non c'è |
git switch -c, il commit | fermo | fermo | sul tuo computer, 1 commit |
git push -u origin via-il-peperoncino | fermo | fermo | anche sul GitHub |
bash ../unisci-pr.sh via-il-peperoncino | fermo | merge della pull request | sul GitHub |
git switch main e git pull | uguale al GitHub | uguale | resta, si può cancellare |
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
La correzione su main, poi git push | GH006: Protected branch update failed: il GitHub respinge, e non è passato niente | test_livello_6_il_branch_e_arrivato_sul_github, test_livello_6_la_pull_request_e_stata_unita, test_livello_6_sul_github_il_tiramisu_e_senza_peperoncino e test_livello_6_il_tuo_main_e_aggiornato |
La pull request unita, ma niente git switch main e git pull | Il GitHub è a posto, il tuo main ha ancora il peperoncino | test_livello_6_il_tuo_main_e_aggiornato |
| Cancellata la riga dello zucchero invece di quella del peperoncino | La pull request passa, ma il tiramisù brucia lo stesso, e non ha lo zucchero | test_livello_6_sul_github_il_tiramisu_e_senza_peperoncino e test_livello_6_il_tuo_main_e_aggiornato |
Il finale
Qui non ci sono i comandi: ci sono solo i passi, perché la risposta la trovi tu.
- Dal livello 6, in
progetto/:git log -p ricette/tiramisu.txt. - Leggi i commit dal più recente: il tuo (
Toglie il peperoncino) ha un-; quello che l'ha messo ha un+sulla stessa riga. - Di quel commit leggi
Author. Poipython storia/verifica.py "Nome Cognome".
Se Ottavio ti dice «No» e ti dà un consiglio, leggilo: ti dice quale pista hai seguito, e quale riga hai saltato.