Vai al contenuto
code-to-code

Apro l'indice…

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

Git6. Rimettere a postop. 151

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.

git-rimettere-a-posto-soluzioni.zip55 KB

La palestra

1 · Il file sparito

In italiano.

  1. git status mostra deleted: fermate.txt e modified: tabellone.py: tutti e due sulla scrivania, niente sul set.
  2. git restore li riprende dall'ultima foto. Gli appunti di Marta sono un file nuovo: restore non lo conosce, quindi non lo tocca.

I comandi.

Terminale
git status
git restore fermate.txt tabellone.py
git status

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git add -A e git commitNell'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 bastaIl programma riparte, ma le fermate non ci sono ancoratest_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.

  1. git switch main si rifiuta: avvisi.txt è diverso nei due branch e hai una modifica non committata.
  2. git stash mette il lavoro a metà nel cassetto: la scrivania torna pulita.
  3. Su main correggi la riga e fai il commit.
  4. Torni su scala-mobile e git stash pop riprende il lavoro, svuotando il cassetto.

I comandi.

Terminale
git switch main                # Git rifiuta: è quello che ti aspetti
git stash
git switch main

Apri avvisi.txt e fallo diventare così:

Avvisi di Piazza Query
Ascensore: in servizio.
Scala mobile: in servizio.
Bagni: aperti.
Terminale
git add avvisi.txt
git commit -m "Corregge l'errore di battitura dell'ascensore"
git switch scala-mobile
git stash pop
git stash list

Il disegno.

inizio git switch main se hai modifiche non committate sì: passo Git rifiuta il cambio passo git stash passo git switch main passo correggi, git add, git commit passo git switch scala-mobile passo git stash pop finegit switch mainhai modifiche noncommittateGit rifiuta il cambiogit stashgit switch maincorreggi, git add, gitcommitgit switch scala-mobilegit stash popfinenosì
Cambiare branch con il lavoro a metà

Passo per passo.

ComandoSei suScrivaniaCassettoCommit nuovi
(all'inizio)scala-mobileavvisi.txt con la riga dei bagni a metàvuotonessuno
git stashscala-mobilepulita1 vocenessuno
git switch mainmainpulita1 vocenessuno
correzione, git add, git commitmainpulita1 voce1 su main
git switch scala-mobilescala-mobilepulita1 voce1 su main
git stash popscala-mobileriga dei bagni a metàvuoto1 su main

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
Tutto giusto, ma senza git stash popIl 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 mainGit passa su main subito, ma butta il lavoro a metà: non finisce nel cassetto, non tornatest_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.

  1. git status dice HEAD detached at …: sei sopra un commit, senza etichetta.
  2. git switch -c corsa-636 crea il branch sul commit dove sei e attacca HEAD a lui. Il commit di Sergio adesso ha un'etichetta.

I comandi.

Terminale
git status
git switch -c corsa-636
git log --oneline

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git switch main e poi git branch corsa-636Il commit era già rimasto senza etichetta: il branch nasce su main, senza il committest_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 bastaL'etichetta c'è, ma HEAD resta staccata: se fai un altro commit, non avanzatest_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.

  1. Sei su orari-sera, il branch che deve spostarsi. git rebase main prende i tuoi due commit e li rifà uno alla volta sopra main.
  2. I file di main e quelli dei tuoi commit sono diversi: nessun conflitto, il rebase finisce da solo.
  3. main non si muove. I due commit hanno codici nuovi e lo stesso messaggio.

I comandi.

Terminale
git status
git rebase main
git log --oneline --graph --all

Passo per passo.

ComandoHEADmainorari-seraCommit di merge
(all'inizio)orari-sera2 commit avanti2 commit tuoi, partiti primanessuno
git rebase mainorari-serafermoi 2 commit ricopiati in fondo a main, codici nuovinessuno

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git merge main (invece del rebase)orari-sera contiene main, ma con un commit di merge in mezzo: la storia non è più drittatest_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-seraIl rebase va al contrario: ricopia i commit di main sopra orari-sera, e main cambia codicitest_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.

  1. git status mostra .venv/, __pycache__/ e fermate.py tra i file nuovi.
  2. Il .gitignore con le due voci nasconde il rumore. Adesso git status mostra solo .gitignore e fermate.py.
  3. git add dei due file, git commit.

I comandi.

Terminale
git status

Crea il file .gitignore e scrivici dentro:

ini
.venv/
__pycache__/
Terminale
git status
git add .gitignore fermate.py
git commit -m "Aggiunge le fermate e il .gitignore"
git status

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git add . prima di scrivere il .gitignoreI file di .venv/ e __pycache__/ entrano nell'album. Il .gitignore arriva dopo, ma i file già seguiti restano seguititest_nell_album_non_c_e_il_rumore
Il .gitignore scritto, ma nel commit solo fermate.pyIl rumore sparisce da git status, ma il .gitignore resta un file nuovo non committato: i colleghi non lo hannotest_il_gitignore_e_nell_album e test_la_scrivania_e_pulita
venv/ e pycache/ nel .gitignoreNon coincidono con .venv/ e __pycache__/: Git continua a mostrarlitest_il_venv_e_la_cache_di_python_sono_ignorati e test_la_scrivania_e_pulita

6 · Ho committato .vscode

In italiano.

  1. git rm -r --cached .vscode toglie la cartella dall'album e la lascia sul disco.
  2. Si aggiunge .vscode/ in fondo al .gitignore, senza cancellare le righe che c'erano.
  3. Un commit con tutte e due le cose.

I comandi.

Terminale
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 .vscodesìtolto dal setno
echo ".vscode/" >> .gitignoresìtolto dal setsì
git add .gitignore e git commitsìnosì

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git rm -r .vscode senza --cachedI file escono dall'album e dal disco: Sergio perde le sue impostazionitest_i_file_di_vscode_sono_ancora_sul_disco
.vscode/ nel .gitignore e bastaIl .gitignore guarda solo i file non seguiti: .vscode/ è già nell'album, e ci restatest_nell_album_non_c_e_piu_vscode
git rm -r --cached .vscode e il commit, ma senza .gitignoreLa cartella esce dall'album, ma torna a comparire come nuova in git statustest_vscode_e_ignorato e test_la_scrivania_e_pulita

La storia: La cucina di Ottavio

Livello 1 · Il primo commit

In italiano.

  1. git init -b main trasforma progetto/ in un repository.
  2. Il .gitignore nasconde foto/ e gli appunti. Lo si scrive prima di git add ..
  3. git add . prende tutto il resto, .gitignore compreso; git commit scatta la prima foto.

I comandi.

Terminale
git init -b main
git status

Crea il file .gitignore e scrivici dentro:

ini
foto/
appunti-di-ottavio.txt
Terminale
git status
git add .
git commit -m "Primo commit: il quaderno di Ottavio"
git status

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git add . e git commit prima del .gitignoreFoto e appunti di Ottavio nell'album: il .gitignore poi non li toglietest_livello_1_foto_e_appunti_non_sono_nell_album
.gitignore scritto, ma git add solo di README.md, menu.txt e ricetteIl .gitignore non è nel committest_livello_1_le_ricette_sono_nell_album e test_livello_1_la_scrivania_e_pulita
appunti.txt nel .gitignoreIl file si chiama appunti-di-ottavio.txt: la riga non coincide, e gli appunti entrano nell'albumtest_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.

  1. 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.
  2. Sul set resta solo il risotto, e il commit lo fotografa.

I comandi.

Terminale
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.

ComandoScrivaniaSetAlbum
(all'inizio)tre file cambiatitre file1 commit
git restore --staged tiramisu panna-cottatiramisù e panna cotta cambiatisolo il risotto1 commit
git restore tiramisu panna-cottacom'eranosolo il risotto1 commit
git commitpulitavuoto2 commit

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git restore dei due file, senza --staged, poi git commitIl comando guarda il set, che ha già la versione sbagliata: non cambia niente. Il commit si porta dietro il pasticcio di Pinatest_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 commitTutto quello che Pina ha cambiato finisce nella foto, sale compresogli stessi tre

Livello 3 · Il cassetto

In italiano.

  1. Git rifiuta di passare su main. git stash mette il menu a metà nel cassetto.
  2. Su main correggo «arosto» in «arrosto», git add, git commit.
  3. Torno su cena, git stash pop riprende il menu a metà, lo finisco (la riga del caffè c'è già) e lo committo.
  4. Torno su main e unisco cena: le righe cambiate sono diverse, quindi nessun conflitto.

I comandi.

Terminale
git switch main               # Git rifiuta: è voluto
git stash
git switch main

Apri menu.txt e correggi la riga del secondo (Secondo: arrosto con patate): il resto del file resta com'è.

Terminale
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 cena

Passo per passo.

ComandoSei suScrivaniaCassettomain
(all'inizio)cenamenu con il caffè, non committatovuotomenu con «arosto»
git stashcenapulita1 voceidem
git switch main e il commitmainpulita1 voce«arrosto», 1 commit in più
git switch cena e git stash popcenamenu con il caffèvuotoidem
git commitcenapulitavuotoidem
git switch main e git merge --no-edit cenamainpulitavuotomerge: «arrosto» e il caffè

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git stash, la correzione su main, il merge: manca il git stash popIl 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 mainPassa su main buttando il menu a metà: la riga del caffè non c'è più da nessuna partetest_livello_3_il_menu_della_cena_e_finito_e_unito_in_main

Livello 4 · In visita al quaderno di lunedì

In italiano.

  1. git log --oneline mostra il primo commit in fondo. git switch --detach con il suo codice mi porta lì.
  2. Scrivo ricette/minestrone.txt e faccio il commit: nasce sopra il commit di lunedì, senza etichetta.
  3. git switch -c minestrone gli dà l'etichetta. Poi git switch main e git merge --no-edit minestrone.

I comandi.

Terminale
git log --oneline
git switch --detach CODICE-DEL-PRIMO-COMMIT

Crea ricette/minestrone.txt e scrivici dentro:

Minestrone
Per 50 persone
Verdure miste: 10 kg
Fagioli: 1 kg
Brodo: 8 litri
Terminale
git add ricette/minestrone.txt
git commit -m "Scrive il minestrone"
git switch -c minestrone
git switch main
git merge --no-edit minestrone

Passo per passo.

ComandoHEADmainminestroneCommit del minestrone
(all'inizio)mainin cimanon c'ènon c'è
git switch --detach CODICEsul primo commitin cimanon c'ènon c'è
git commitsul commit nuovoin cimanon c'èsenza etichetta
git switch -c minestroneminestronein cimasul commit nuovoha un'etichetta
git switch mainmainin cimasul commit nuovoha un'etichetta
git merge --no-edit minestronemainmerge: ha anche il minestronesul commit nuovodentro main

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
Dalla HEAD staccata, git switch main senza git switch -cGit avvisa (you are leaving 1 commit behind) ma lascia andare: il commit resta senza etichetta e main non ha il minestronetest_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 minestroneIl 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.

  1. git push è respinto: il GitHub ha un commit che tu non hai.
  2. git pull porta i commit di Pina e fa il merge. La stessa riga dello zafferano è cambiata in due modi: conflitto.
  3. 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.
  4. git add, git commit chiude il merge. git push ora riesce.

I comandi.

Terminale
git push                      # respinto: è voluto
git pull                      # si ferma sul conflitto: è voluto

Apri 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 g
Terminale
git add ricette/risotto.txt
git commit -m "Unisce lo zafferano di Pina"
git push

Il disegno.

inizio git push se online c'è un commit di Pina sì: passo git pull passo tieni 2,5 g, via i segni passo git add risotto.txt passo git commit passo git push finegit pushonline c'è un commitdi Pinagit pulltieni 2,5 g, via i segnigit add risotto.txtgit commitgit pushfinenosì
Il push respinto con conflitto

Passo per passo.

ComandoIl tuo mainmain sul GitHubCosa succede
(all'inizio)1 commit tuo in più1 commit di Pina in più, più i dolciI due main sono andati in strade diverse
git pushugualeugualeRespinto: fetch first
git pullmerge a metàugualeConflitto sul risotto; i dolci sono già arrivati
il file giusto, git add, git commitmerge fattougualeIl merge ha due genitori
git pushuguale al GitHubuguale al tuoRiesce

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
Nel conflitto, tieni la tua riga (Zafferano: 3 g)Il merge si chiude, il push riesce, ma contro la regola di Ottaviotest_livello_5_nel_risotto_c_e_la_dose_giusta
git add e git commit senza togliere i segniNel risotto restano <<<<<<<, ======= e >>>>>>>test_livello_5_nel_risotto_c_e_la_dose_giusta
git push --force origin main al posto del pullIl GitHub accetta: il lavoro di Pina (e i dolci) sparisce da maintest_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 pushIl GitHub resta com'eratest_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.

  1. main è protetto: ci vuole un branch tuo. git switch -c via-il-peperoncino.
  2. Tolgo solo la riga del peperoncino da ricette/tiramisu.txt, git add e git commit.
  3. git push -u origin via-il-peperoncino manda il branch sul GitHub.
  4. bash ../unisci-pr.sh via-il-peperoncino è la pull request: Ottavio la approva e la unisce.
  5. Il mio main non lo sa ancora: git switch main e git pull.

I comandi.

Terminale
git switch -c via-il-peperoncino

Apri 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 ml
Terminale
git 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 pull

Passo per passo.

ComandoIl tuo mainmain sul GitHubvia-il-peperoncino
(all'inizio)uguale al GitHubprotettonon c'è
git switch -c, il commitfermofermosul tuo computer, 1 commit
git push -u origin via-il-peperoncinofermofermoanche sul GitHub
bash ../unisci-pr.sh via-il-peperoncinofermomerge della pull requestsul GitHub
git switch main e git pulluguale al GitHubugualeresta, si può cancellare

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
La correzione su main, poi git pushGH006: Protected branch update failed: il GitHub respinge, e non è passato nientetest_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 pullIl GitHub è a posto, il tuo main ha ancora il peperoncinotest_livello_6_il_tuo_main_e_aggiornato
Cancellata la riga dello zucchero invece di quella del peperoncinoLa pull request passa, ma il tiramisù brucia lo stesso, e non ha lo zuccherotest_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.

  1. Dal livello 6, in progetto/: git log -p ricette/tiramisu.txt.
  2. Leggi i commit dal più recente: il tuo (Toglie il peperoncino) ha un -; quello che l'ha messo ha un + sulla stessa riga.
  3. Di quel commit leggi Author. Poi python 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.