Vai al contenuto
code-to-code

Apro l'indice…

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

Git1. Il grafop. 15

Il grafo, le soluzioni

I disegni giusti, le risposte, le trappole

Per ogni scenario, sempre lo stesso ordine: in italiano → il disegno e le risposte → le trappole. Per i più difficili, anche il passo per passo: dove stanno HEAD e le etichette dopo ogni comando.

Il tuo disegno è diverso ma i test sono verdi? Va bene. Controlla solo che le frecce vadano all'indietro e che ogni etichetta stia sul commit giusto.

Le soluzioni complete

La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.

git-grafo-soluzioni.zip19 KB

La palestra

1 · Il primo turno

In italiano. Sergio fa tre commit in fila: C1, C2, C3, con main sull'ultimo. Poi git switch -c straordinari crea un'etichetta nuova su C3 e sposta HEAD lì. Il commit successivo, C4, nasce dove sta HEAD (regola 3): nasce sopra C3 e solo straordinari avanza.

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

Le risposte.

domanda 1: 4
domanda 2: C2
domanda 3: straordinari

Da HEAD torni indietro: C4, C3, C2, C1. HEAD non si conta, perché non è un commit.

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: 5Hai contato HEAD come se fosse un commit: è «tu sei qui», non una fototest_domanda_1_quanti_commit_da_head
domanda 2: C4Hai scelto il commit dopo: le frecce vanno all'indietro, non in avanti (regola 2)test_domanda_2_il_genitore_di_c3

2 · Un branch per la notte

In italiano. C1 e C2 stanno su main. Nadia crea notte su C2 e fa tre commit: C3, C4, C5. A ogni commit si sposta notte; main non lo tocca nessuno, quindi resta su C2.

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

Le risposte.

domanda 1: C2
domanda 2: 5
domanda 3: 3

Da notte si raggiungono C5, C4, C3 e poi, tornando indietro, anche C2 e C1: cinque. Quelli che main non ha sono i tre fatti su notte.

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: C5Hai spostato main insieme a notte: un commit fatto su un branch fa avanzare solo quel branchtest_domanda_1_dove_punta_main
domanda 3: 5Hai contato anche C1 e C2, che si raggiungono da tutte e due le etichettetest_domanda_3_quanti_in_piu

3 · Il salto in avanti

In italiano. Ernesto fa C1 e C2 su main, crea freni e fa C3 e C4. Poi torna su main e unisce freni. Chi riceve è main, che è fermo su C2: da quando è nato freni non ha fatto niente. Regola 5: nessun commit nuovo, l'etichetta main salta su C4.

Prima del merge:

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

Dopo:

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

Le risposte.

domanda 1: no
domanda 2: 4
domanda 3: C4

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: sìHai disegnato un commit di merge: ma main non era andato avanti, quindi basta spostare l'etichettatest_domanda_1_il_merge_crea_un_commit
domanda 2: 5Hai dato un numero anche al merge, che non esiste: C5 non nasce maitest_domanda_2_quanti_commit_in_tutto

4 · Due strade

In italiano.

  1. Marta fa C1 e C2 su main.
  2. Crea sabato e ci fa C3.
  3. Torna su main e fa C4: ora main e sabato hanno storie diverse.
  4. Da main unisce sabato: nasce C5, con due genitori, C4 e C3.
C1 ◀── C2 ◀── C4 ◀── C5 ◀── main ◀── HEAD
       ▲             │
       └── C3 ◀──────┘
           ▲
           sabato

Le risposte.

domanda 1: C5
domanda 2: C2
domanda 3: C3

Le due strade partono da C2: è l'ultimo commit che hanno in comune. sabato non si muove: il merge l'ha lanciato Marta da main.

Passo per passo.

ComandoHEADmainsabatoCommit nuovi
due commitmainC2non c'èC1, C2
git switch -c sabatosabatoC2C2nessuno
commitsabatoC2C3C3
git switch mainmainC2C3nessuno
commitmainC4C3C4
git merge sabatomainC5C3C5 (genitori C4 e C3)

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: C4Hai scelto l'ultimo commit fatto su main: il commit con due frecce è quello del merge, C5test_domanda_1_commit_con_due_genitori
domanda 3: C5Hai spostato anche sabato sul merge: si muove solo l'etichetta del branch che ricevetest_domanda_3_dove_punta_sabato

5 · Il merge al contrario

In italiano.

  1. Lucia fa C1 e C2 su main.
  2. Crea festivi e ci fa C3.
  3. Torna su main e fa C4 e C5.
  4. Passa su festivi e lancia git merge main. Qui riceve festivi: nasce C6, con due genitori, C3 (dove stava festivi) e C5 (dove sta main).

Chi riceve si muove: festivi va su C6. main ha solo dato, e resta su C5.

C1 ◀── C2 ◀── C4 ◀── C5 ◀── main
       ▲             ▲
       │             └───────┐
       └── C3 ◀───────────── C6 ◀── festivi ◀── HEAD

Le risposte.

domanda 1: C5
domanda 2: C6
domanda 3: 4

Da main si raggiungono C5, C4, C2, C1: quattro. Il commit C3, fatto su festivi, per main non esiste.

Passo per passo.

ComandoHEADmainfestiviCommit nuovi
due commitmainC2non c'èC1, C2
git switch -c festivi + commitfestiviC2C3C3
git switch main + due commitmainC5C3C4, C5
git switch festivifestiviC5C3nessuno
git merge mainfestiviC5C6C6 (genitori C3 e C5)

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: C6Hai spostato main sul merge: ma il merge l'ha lanciato festivi, e main non ha ricevuto nientetest_domanda_1_dove_punta_main
domanda 3: 6Hai contato tutti i commit del grafo: da main C3 e C6 non si raggiungonotest_domanda_3_quanti_commit_da_main

6 · Due branch in fila

In italiano.

  1. Lucia fa C1 su main.
  2. Crea avvisi da C1 e ci fa C2. Torna su main.
  3. Crea fermate da C1 e ci fa C3. Torna su main.
  4. Unisce avvisi: main è ancora su C1, che è il genitore di C2. Nessuna strada divisa: l'etichetta salta su C2 (regola 5).
  5. Unisce fermate: adesso main è su C2, ma C3 è nato da C1. Le strade sono divise: nasce C4, con due genitori, C2 e C3 (regola 4).
C1 ◀── C2 ◀── C4 ◀── main ◀── HEAD
▲      ▲      │
│      avvisi │
└── C3 ◀──────┘
    ▲
    fermate

Le risposte.

domanda 1: 1
domanda 2: C2 e C3
domanda 3: 4

Passo per passo.

ComandoHEADmainavvisifermateCommit nuovi
commitmainC1non c'ènon c'èC1
git switch -c avvisi + commitavvisiC1C2non c'èC2
git switch main, git switch -c fermate + commitfermateC1C2C3C3
git switch mainmainC1C2C3nessuno
git merge avvisimainC2C2C3nessuno (salto)
git merge fermatemainC4C2C3C4 (genitori C2 e C3)

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: 2Hai disegnato un commit di merge per ogni merge: il primo era un salto in avanti, senza committest_domanda_1_quanti_commit_di_merge
domanda 2: C1 e C3Hai messo C1 come genitore: al secondo merge main era già su C2, non più su C1test_domanda_2_i_due_genitori

7 · Il branch del branch

In italiano.

  1. Nadia fa C1 su main.
  2. Crea turni e ci fa C2.
  3. Da turni crea turni-notte e ci fa C3 e C4.
  4. Torna su turni e unisce turni-notte. turni non si è mosso da quando è nato turni-notte: salto, nessun commit nuovo. turni va su C4.
  5. Torna su main, fa C5.
  6. Unisce turni: stavolta main è andato avanti, le strade sono divise. Nasce C6, con due genitori, C5 e C4.
C1 ◀── C5 ◀───────────── C6 ◀── main ◀── HEAD
▲                        │
└── C2 ◀── C3 ◀── C4 ◀───┘
                  ▲
                  turni, turni-notte

Le risposte.

domanda 1: no
domanda 2: C4 e C5
domanda 3: 6

Da main arrivano tutti: C6, poi C5 e C4, e tornando indietro C3, C2, C1. Sono sei, e non sette: il primo merge non ha creato nessun commit.

Passo per passo.

ComandoHEADmainturniturni-notteCommit nuovi
commitmainC1non c'ènon c'èC1
git switch -c turni + committurniC1C2non c'èC2
git switch -c turni-notte + due committurni-notteC1C2C4C3, C4
git switch turniturniC1C2C4nessuno
git merge turni-notteturniC1C4C4nessuno (salto)
git switch main + commitmainC5C4C4C5
git merge turnimainC6C4C4C6 (genitori C5 e C4)

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: sìHai disegnato un merge anche per il primo: ma turni non si era mosso, e l'etichetta saltatest_domanda_1_il_primo_merge
domanda 3: 7Hai dato un numero anche al primo merge, che non esiste: C5 è il commit di main, C6 il merge verotest_domanda_3_quanti_commit_da_main

8 · Il commit sbagliato

In italiano.

  1. Ernesto fa C1 su main.
  2. Crea scheda-m16 e ci fa C2: ha scritto il treno sbagliato.
  3. Se ne accorge e fa C3, che corregge. Non cancella C2: regola 1.
  4. Torna su main e unisce: main non si era mosso, quindi salta su C3.
  5. git branch -d scheda-m16 toglie l'etichetta. I commit restano, e main li raggiunge.
C1 ◀── C2 ◀── C3 ◀── main ◀── HEAD

Le risposte.

domanda 1: 3
domanda 2: sì
domanda 3: 1

L'unico branch che resta è main. Ma C2, l'errore, è ancora nel grafo: lo trovi nell'album, con C3 sopra che lo corregge.

Le trappole.

La risposta sbagliataCosa succedeIl test rosso
domanda 1: 2Hai tolto dal conto i commit del branch cancellato: ma branch -d toglie l'etichetta, non i committest_domanda_1_quanti_commit_da_main
domanda 2: noHai creduto che la correzione cancelli l'errore: la correzione è un commit nuovo, C2 restatest_domanda_2_il_commit_sbagliato_resta