GitHub e le pull request, 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 com'è finito il repository, non i comandi che hai scritto. Confronta il ragionamento, e leggi comunque le trappole: alcune passano quasi tutto e si rompono su un test solo.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
Nello zip delle soluzioni, accanto a ogni prepara.sh c'è soluzione.sh. bash prepara.sh && bash soluzione.sh fa la missione al posto tuo.
La palestra
1 · Il primo giro
In italiano.
- Scarico la bacheca con
git clone. Nasceprogetto/, eoriginè il GitHub finto. - Faccio un branch mio, scrivo la riga, fotografo.
- Mando il branch con
git push -u origin: il-userve alla prima volta. - La PR:
bash unisci-pr.sh avviso-casco, dalla cartella della missione. - Sul mio computer non è successo niente:
git switch mainegit pullportano il merge. Poi butto il branch.
git clone github.git progetto
cd progetto
git switch -c avviso-casco
echo "- Il casco si indossa sempre in galleria" >> bacheca.txt
git add bacheca.txt
git commit -m "Aggiunge l'avviso del casco"
git push -u origin avviso-casco
bash ../unisci-pr.sh avviso-casco
git switch main
git pull
git branch -d avviso-cascoIl bash ../unisci-pr.sh ha i due punti perché sei dentro progetto/. Il push stampa il percorso del GitHub finto, che sarà il tuo:
$ git push -u origin avviso-casco
To /home/tu/git-github-e-pull-request/palestra/01-il-primo-giro/github.git
* [new branch] avviso-casco -> avviso-casco
branch 'avviso-casco' set up to track 'origin/avviso-casco'.
$ bash ../unisci-pr.sh avviso-casco
Pull request #1 unita: avviso-casco → main.
$ git switch main
Switched to branch 'main'
Your branch is up to date with 'origin/main'.
$ git pull
Updating 9290146..790e133
Fast-forward
bacheca.txt | 1 +
1 file changed, 1 insertion(+)(Prima della riga Updating, git pull stampa due righe From … con il percorso e il passaggio di origin/main: le ho tolte.) Il codice del merge (790e133) sul tuo computer sarà un altro.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git push senza -u | fatal: The current branch avviso-casco has no upstream branch: Git non sa dove mandare il branch. Sul GitHub non arriva niente | test_main_sul_github_ha_la_riga_del_casco, test_e_arrivata_con_una_pull_request, test_il_branch_avviso_casco_e_cancellato |
La PR senza push | Sul GitHub finto non c'è il branch avviso-casco: il revisore non può unire un branch che non vede | gli stessi tre |
Tutto giusto, ma niente git pull dopo la PR | Il tuo main resta com'era, tre foto sole: sei indietro rispetto a origin/main. Nessun errore | test_il_tuo_main_e_aggiornato |
La terza è la più subdola: non dà nessun messaggio. Il guaio arriva dopo, quando fai un altro branch da un main vecchio.
2 · Il push respinto
In italiano.
- Il
git pushviene respinto:fetch first. Online c'è un commit di Sergio che non ho. git pulllo scarica e lo unisce al mio con un merge: le righe sono diverse (il mercoledì e il venerdì), niente conflitto.- Adesso il mio branch ha tutto: il
git pushè un semplice «avanti».
git status
git push
git pull --no-edit
git pushIl primo git push finisce male: è voluto (nello zip la riga ha un || true che tiene lo script in piedi). Il --no-edit tiene il messaggio del merge che Git ha già scritto.
Il disegno.
Passo per passo. (C1 è il primo commit, C2 quello di Nadia sul lunedì, C3 il tuo venerdì, C4 quello di Sergio sul mercoledì, C5 il merge.)
| Comando | pulizie-notte (tuo) | origin/pulizie-notte | pulizie-notte su GitHub |
|---|---|---|---|
| (all'inizio) | C3 | C2 | C4 |
git push | C3 | C2 | C4 (respinto) |
git pull --no-edit | C5 (merge di C3 e C4) | C4 | C4 |
git push | C5 | C5 | C5 |
C1 ◀── C2 ◀── C4 ◀── C5 ◀── pulizie-notte ◀── HEAD
▲ │
└── C3 ◀──────┘$ git pull --no-edit
Auto-merging pulizie.txt
Merge made by the 'ort' strategy.
pulizie.txt | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)Auto-merging pulizie.txt vuol dire che tutti e due avete toccato lo stesso file, ma righe lontane: Git le mette insieme da solo.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git push --force | + a6ed46d...edc678f pulizie-notte -> pulizie-notte (forced update): il tuo branch sostituisce quello online, e il mercoledì di Sergio sparisce dall'album. Tutto sembra riuscito | test_sul_github_ci_sono_tutte_e_due_le_righe, test_il_commit_di_sergio_non_e_sparito, test_le_due_storie_sono_state_unite |
git pull --no-edit e basta | Le foto di Sergio sono da te, ma non hai mandato niente: online manca ancora il venerdì | test_sul_github_ci_sono_tutte_e_due_le_righe, test_il_tuo_branch_e_uguale_a_quello_del_github, test_le_due_storie_sono_state_unite |
git pull origin main, poi git push | Hai preso main (Already up to date.), non pulizie-notte: il push è ancora fetch first | gli stessi tre |
Il --force è la trappola da ricordare: un push forzato non dà errori e butta il lavoro di un collega. Se Git ti dice fetch first, il rimedio è pull, mai --force.
3 · main è protetto
In italiano.
git pushsumain:GH006. Non è un guasto, è la regola:mainsi cambia solo con una pull request.- Il commit c'è già, e
git switch -ccrea un branch dal punto in cui sei: il commit è lì, non va rifatto. push -udel branch, la PR, poimainsi aggiorna congit pull: un fast-forward, perché il commit del merge online contiene già il tuo.
git push
git switch -c avviso-ascensore
git push -u origin avviso-ascensore
bash ../unisci-pr.sh avviso-ascensore
git switch main
git pull
git branch -d avviso-ascensoreIl primo git push finisce male: è voluto. Il rifiuto:
$ git push
remote: error: GH006: Protected branch update failed for refs/heads/main.
remote: main è protetto: ci si arriva solo con una pull request.
remote: Fai un branch tuo (git switch -c nome), poi git push -u origin nome.
To ../github.git
! [remote rejected] main -> main (pre-receive hook declined)
error: failed to push some refs to '../github.git'Passo per passo. (C1–C3 sono i commit di Sergio, C4 il tuo avviso, C5 il merge della PR.)
| Comando | Il tuo main | avviso-ascensore | main su GitHub |
|---|---|---|---|
| (all'inizio) | C4 | non c'è | C3 |
git push | C4 | non c'è | C3 (respinto) |
git switch -c avviso-ascensore | C4 | C4 | C3 |
git push -u origin avviso-ascensore | C4 | C4 (anche online) | C3 |
bash ../unisci-pr.sh … | C4 | C4 | C5 (merge di C3 e C4) |
git switch main, git pull | C5 | C4 | C5 |
C1 ◀── C2 ◀── C3 ◀── C5 ◀── main ◀── HEAD
▲ │
└── C4 ◀┘
▲
avviso-ascensoreDopo git switch main Git dice Your branch is ahead of 'origin/main' by 1 commit: il tuo main ha ancora il commit, e quello online non lo sa ancora. Il git pull risolve: il merge online ha il tuo commit tra i genitori, quindi basta spostare main in avanti.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Tutto giusto, ma niente git pull alla fine | Il tuo main resta con il commit vecchio, online c'è anche il merge: non sono uguali | test_il_tuo_main_e_aggiornato |
git reset --hard origin/main per «togliere» il commit da main, poi un branch | Il commit non c'è più: il branch nasce uguale a main, e la PR dice There isn't anything to compare. Il lavoro è perso (a meno di recuperarlo con strumenti che non servono in questo libro) | test_main_sul_github_ha_l_avviso_dell_ascensore, test_e_arrivato_con_una_pull_request |
git push --force origin main | GH006 anche con --force: la protezione non si salta. Lo script si ferma, non è arrivato niente | tutti e quattro |
reset --hard non serve in questo libro, ed è la trappola più costosa. Non devi togliere il commit da main: ti basta un'etichetta nuova, e main si rimette a posto da solo con il pull.
4 · La pull request verso la squadra
In italiano.
git switch squadra-mentarispondeinvalid reference: il mio clone è di prima, non conosce il branch.git fetchguarda online e scarica le etichette nuove. Poigit switch squadra-mentacrea il mio branch dall'etichettaorigin/squadra-menta.- Il mio branch nasce da lì, non da
main: ha già i compiti di Sergio e Nadia. - Riga, commit,
push -u. - La PR ha come base
squadra-menta: nello script, il secondo argomento. - Aggiorno il mio
squadra-mentacongit pull.
git switch squadra-menta
git fetch
git switch squadra-menta
git switch -c badge-ponte-ciclo
echo "Tu: registro dei badge di Ponte Ciclo" >> compiti.txt
git add compiti.txt
git commit -m "Aggiunge il registro dei badge di Ponte Ciclo"
git push -u origin badge-ponte-ciclo
bash ../unisci-pr.sh badge-ponte-ciclo squadra-menta
git switch squadra-menta
git pull
git branch -d badge-ponte-cicloIl primo git switch finisce male: è voluto. Le risposte, in ordine:
$ git switch squadra-menta
fatal: invalid reference: squadra-menta
$ git fetch
From ../github
* [new branch] squadra-menta -> origin/squadra-menta
$ git switch squadra-menta
Switched to a new branch 'squadra-menta'
branch 'squadra-menta' set up to track 'origin/squadra-menta'.Passo per passo. (C1–C2 sono di Ernesto su main, C3–C4 di Sergio e Nadia su squadra-menta, C5 il tuo commit, C6 il merge della PR.)
| Comando | main | squadra-menta (tuo) | badge-ponte-ciclo | squadra-menta su GitHub |
|---|---|---|---|---|
| (all'inizio) | C2 | non c'è | non c'è | C4 |
git fetch | C2 | non c'è (c'è origin/squadra-menta: C4) | non c'è | C4 |
git switch squadra-menta | C2 | C4 | non c'è | C4 |
git switch -c, commit | C2 | C4 | C5 | C4 |
git push -u | C2 | C4 | C5 (anche online) | C4 |
bash ../unisci-pr.sh … squadra-menta | C2 | C4 | C5 | C6 (merge di C4 e C5) |
git switch squadra-menta, git pull | C2 | C6 | C5 | C6 |
C1 ◀── C2 ◀── main
▲
└── C3 ◀── C4 ◀── C6 ◀── squadra-menta ◀── HEAD
▲ │
└── C5 ◀┘
▲
badge-ponte-ciclomain è sempre rimasto a C2: la PR era verso la squadra.
Le trappole.
| Il comando sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git switch squadra-menta senza git fetch | fatal: invalid reference: squadra-menta, e lo script si ferma. Il clone non conosce il branch | test_il_tuo_branch_e_nato_dalla_squadra, test_la_squadra_sul_github_ha_la_tua_riga, test_e_arrivata_con_una_pull_request, test_la_tua_squadra_menta_e_aggiornata |
bash unisci-pr.sh badge-ponte-ciclo (senza la base) | La PR va verso main, la base di default: la tua riga finisce in main e la squadra non la vede | test_la_squadra_sul_github_ha_la_tua_riga, test_e_arrivata_con_una_pull_request, test_main_non_si_tocca |
Il branch nato da main (git fetch, poi git switch -c senza passare da squadra-menta) | compiti.txt non esiste in main: lo crei tu da zero, e la PR dà This branch has conflicts that must be resolved: le due storie hanno creato lo stesso file | test_il_tuo_branch_e_nato_dalla_squadra, test_la_squadra_sul_github_ha_la_tua_riga, test_e_arrivata_con_una_pull_request, test_la_tua_squadra_menta_e_aggiornata |
Tutto giusto, ma senza git pull alla fine | Il tuo squadra-menta resta a C4, online è a C6. Nessun errore | test_la_tua_squadra_menta_e_aggiornata |
Su GitHub vero, la base sbagliata si corregge senza rifare niente: pulsante Edit in cima alla PR, o gh pr edit --base squadra-menta. Con il GitHub finto la PR è già unita, quindi qui non si può: si ripete la missione con bash prepara.sh.