Vai al contenuto
code-to-code

Apro l'indice…

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

Git5. GitHub e le pull requestp. 116

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.

git-github-e-pull-request-soluzioni.zip30 KB

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.

  1. Scarico la bacheca con git clone. Nasce progetto/, e origin è il GitHub finto.
  2. Faccio un branch mio, scrivo la riga, fotografo.
  3. Mando il branch con git push -u origin: il -u serve alla prima volta.
  4. La PR: bash unisci-pr.sh avviso-casco, dalla cartella della missione.
  5. Sul mio computer non è successo niente: git switch main e git pull portano il merge. Poi butto il branch.
Terminale
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-casco

Il 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 sbagliatoCosa succedeIl test rosso
git push senza -ufatal: The current branch avviso-casco has no upstream branch: Git non sa dove mandare il branch. Sul GitHub non arriva nientetest_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 pushSul GitHub finto non c'è il branch avviso-casco: il revisore non può unire un branch che non vedegli stessi tre
Tutto giusto, ma niente git pull dopo la PRIl tuo main resta com'era, tre foto sole: sei indietro rispetto a origin/main. Nessun erroretest_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.

  1. Il git push viene respinto: fetch first. Online c'è un commit di Sergio che non ho.
  2. git pull lo scarica e lo unisce al mio con un merge: le righe sono diverse (il mercoledì e il venerdì), niente conflitto.
  3. Adesso il mio branch ha tutto: il git push è un semplice «avanti».
Terminale
git status
git push
git pull --no-edit
git push

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

inizio git push se online c'è un commit che non hai sì: passo respinto, fetch first passo git pull --no-edit passo git push fine il branch è aggiornatogit pushonline c'è un commitche non hairespinto, fetch firstgit pull --no-editgit pushil branch è aggiornatonosì
Il push respinto

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

Comandopulizie-notte (tuo)origin/pulizie-nottepulizie-notte su GitHub
(all'inizio)C3C2C4
git pushC3C2C4 (respinto)
git pull --no-editC5 (merge di C3 e C4)C4C4
git pushC5C5C5
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 sbagliatoCosa succedeIl 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 riuscitotest_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 bastaLe 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 pushHai preso main (Already up to date.), non pulizie-notte: il push è ancora fetch firstgli 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.

  1. git push su main: GH006. Non è un guasto, è la regola: main si cambia solo con una pull request.
  2. Il commit c'è già, e git switch -c crea un branch dal punto in cui sei: il commit è lì, non va rifatto.
  3. push -u del branch, la PR, poi main si aggiorna con git pull: un fast-forward, perché il commit del merge online contiene già il tuo.
Terminale
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-ascensore

Il 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.)

ComandoIl tuo mainavviso-ascensoremain su GitHub
(all'inizio)C4non c'èC3
git pushC4non c'èC3 (respinto)
git switch -c avviso-ascensoreC4C4C3
git push -u origin avviso-ascensoreC4C4 (anche online)C3
bash ../unisci-pr.sh …C4C4C5 (merge di C3 e C4)
git switch main, git pullC5C4C5
C1 ◀── C2 ◀── C3 ◀── C5 ◀── main ◀── HEAD
              ▲       │
              └── C4 ◀┘
                  ▲
                  avviso-ascensore

Dopo 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 sbagliatoCosa succedeIl test rosso
Tutto giusto, ma niente git pull alla fineIl tuo main resta con il commit vecchio, online c'è anche il merge: non sono ugualitest_il_tuo_main_e_aggiornato
git reset --hard origin/main per «togliere» il commit da main, poi un branchIl 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 mainGH006 anche con --force: la protezione non si salta. Lo script si ferma, non è arrivato nientetutti 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.

  1. git switch squadra-menta risponde invalid reference: il mio clone è di prima, non conosce il branch.
  2. git fetch guarda online e scarica le etichette nuove. Poi git switch squadra-menta crea il mio branch dall'etichetta origin/squadra-menta.
  3. Il mio branch nasce da lì, non da main: ha già i compiti di Sergio e Nadia.
  4. Riga, commit, push -u.
  5. La PR ha come base squadra-menta: nello script, il secondo argomento.
  6. Aggiorno il mio squadra-menta con git pull.
Terminale
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-ciclo

Il 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.)

Comandomainsquadra-menta (tuo)badge-ponte-ciclosquadra-menta su GitHub
(all'inizio)C2non c'ènon c'èC4
git fetchC2non c'è (c'è origin/squadra-menta: C4)non c'èC4
git switch squadra-mentaC2C4non c'èC4
git switch -c, commitC2C4C5C4
git push -uC2C4C5 (anche online)C4
bash ../unisci-pr.sh … squadra-mentaC2C4C5C6 (merge di C4 e C5)
git switch squadra-menta, git pullC2C6C5C6
C1 ◀── C2 ◀── main
       ▲
       └── C3 ◀── C4 ◀── C6 ◀── squadra-menta ◀── HEAD
                  ▲       │
                  └── C5 ◀┘
                      ▲
                      badge-ponte-ciclo

main è sempre rimasto a C2: la PR era verso la squadra.

Le trappole.

Il comando sbagliatoCosa succedeIl test rosso
git switch squadra-menta senza git fetchfatal: invalid reference: squadra-menta, e lo script si ferma. Il clone non conosce il branchtest_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 vedetest_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 filetest_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 fineIl tuo squadra-menta resta a C4, online è a C6. Nessun erroretest_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.