Vai al contenuto
code-to-code

Apro l'indice…

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

Git5. GitHub e le pull requestp. 103

GitHub e le pull request, esercizi spiegati

Cinque esempi, un comando alla volta

  • 25 minuti di lettura

Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi la situazione e scrivi su un foglio cosa succede. Prima di aprire la risposta.
  2. In italiano: cosa fa Git, a parole.
  3. Passo per passo: dove sono le etichette a ogni comando.
  4. Cosa portiamo a casa: la cosa da ricordare.

Puoi rifare ogni esempio sul tuo computer. Nello zip della palestra c'è la cartella esempi/: dalla cartella principale dello zip lancia

Terminale
bash esempi/prepara.sh
cd esempi/progetto

Nasce il tabellone di Lucia Ferri sul GitHub finto (la cartella esempi/github.git, con main protetto) e il tuo clone in esempi/progetto, con i soliti tre commit (5c2c617, 1ece7ce, b12df3f). Due esempi hanno bisogno di un collega che lavora «intanto»: per loro c'è bash ../intanto-marta.sh, e ti dico io quando. Ogni volta che vuoi ricominciare, rilancia bash esempi/prepara.sh.

I commit tuoi e quelli di Marta che vedrai qui sotto hanno i codici di una prova fatta con ora e autore fissi. Sul tuo computer i tuoi commit avranno codici diversi: dipendono da chi sei e da quando li fai. Quelli di Marta e di Lucia sono uguali.


A · Il clone e origin

Sei sul tuo computer, appena clonato il tabellone. Cosa sai dell'album online?

Terminale
git remote -v
git branch -a
git status
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Chi è origin? Quanti branch hai tu, e quanti remoti? Cosa dice git status sul rapporto con origin/main?

$ git remote -v
origin	../github.git (fetch)
origin	../github.git (push)
$ git branch -a
* main
  remotes/origin/HEAD -> origin/main
  remotes/origin/main
$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
  • origin è l'indirizzo da cui hai clonato: due righe, una per scaricare (fetch) e una per mandare (push). Qui è ../github.git, il GitHub finto; con GitHub vero è un indirizzo https://…. Se cloni a mano con git clone github.git progetto, vedi il percorso intero della cartella.
  • Hai un branch tuo, main (l'asterisco dice che ci sei sopra), e due etichette remote: origin/main e origin/HEAD, che dice solo «il branch normale di origin è main».
  • up to date with 'origin/main' vuol dire: tu e l'etichetta origin/main siete allo stesso commit. Attenzione: di quello che c'è adesso online Git non sa niente, sa solo l'ultima volta che ha guardato.

Il clone ha scaricato tutte e tre le foto. Un clone a mano, dalla cartella dello zip, risponde così:

$ git clone github.git progetto
Cloning into 'progetto'...
done.

In italiano.

  1. git clone copia l'album online in una cartella nuova.
  2. Ricorda da dove l'ha preso e lo chiama origin.
  3. Ti mette su main, uguale a origin/main.

Passo per passo.

ComandoIl tuo mainorigin/mainmain su GitHub
(prima del clone)non c'ènon c'èC3 (b12df3f)
git clone github.git progettoC3C3C3
C1 ◀── C2 ◀── C3 ◀── main ◀── HEAD
              ▲
              origin/main

Cosa portiamo a casa. origin è un nome per un indirizzo. origin/main è un'etichetta tua, aggiornata solo quando fai fetch, pull o push.


B · Mandare un branch

Vuoi aggiungere la corsa festiva delle 7:00. Fai un branch, scrivi la riga, fai il commit. Poi:

Terminale
git push
git push -u origin festivi

I passi prima:

Terminale
git switch -c festivi
echo "07:00 M12 per Largo Lista, solo festivi" >> orari.txt
git add orari.txt
git commit -m "Aggiunge la corsa festiva delle 7:00"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il primo git push funziona? E dopo il secondo, cosa dice git branch -vv?

$ git push
fatal: The current branch festivi has no upstream branch.
To push the current branch and set the remote as upstream, use

    git push --set-upstream origin festivi

To have this happen automatically for branches without a tracking
upstream, see 'push.autoSetupRemote' in 'git help config'.

$ git push -u origin festivi
To ../github.git
 * [new branch]      festivi -> festivi
branch 'festivi' set up to track 'origin/festivi'.
$ git branch -vv
* festivi 625927b [origin/festivi] Aggiunge la corsa festiva delle 7:00
  main    b12df3f [origin/main] Aggiunge gli orari del mattino

Il primo no: festivi è nato sul tuo computer, e Git non sa dove mandarlo. Il secondo glielo dice (origin, e il nome) e con -u ricorda il collegamento: [origin/festivi] tra parentesi quadre in git branch -vv. Da adesso, su questo branch, git push da solo basta.

E se provi a mandare il commit direttamente su main?

Terminale
git push origin festivi:main
$ git push origin festivi:main
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] festivi -> main (pre-receive hook declined)
error: failed to push some refs to '../github.git'

festivi:main si legge «il mio festivi diventa il main di origin». GitHub (qui, il finto) risponde GH006: main è protetto. Le tre righe remote: sono scritte da lui, non da Git.

In italiano.

  1. Il branch festivi esiste solo da te.
  2. git push -u origin festivi lo crea anche online, e collega i due.
  3. Su main non si scrive: ci si arriva con una pull request.

Passo per passo.

Comandofestivi (tuo)origin/festivifestivi su GitHub
git commitC4non c'ènon c'è
git pushC4non c'ènon c'è (Git si rifiuta)
git push -u origin festiviC4C4C4
C1 ◀── C2 ◀── C3 ◀── main
              ▲
              └── C4 ◀── festivi ◀── HEAD
                  ▲
                  origin/festivi

Cosa portiamo a casa. Un branch nuovo si manda la prima volta con git push -u origin nome. Dopo basta git push. E main protetto risponde GH006.


C · Fetch e pull

Torna su main: git switch main. Intanto Marta ha fatto una pull request, unita in main sul GitHub. Per vederla succedere, in un altro terminale, o prima di continuare, da esempi/progetto:

Terminale
bash ../intanto-marta.sh main

Stampa «Pull request #1 unita: readme-chi-aggiorna → main.». Sul tuo computer non è cambiato niente: prima prova a indovinare.

Terminale
git status
git fetch
git status
git pull
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il primo git status sa già che Marta ha fatto la PR? E dopo git fetch? Il tuo README.md è cambiato?

$ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
$ git fetch
From ../github
   b12df3f..398e2c9  main                -> origin/main
 * [new branch]      readme-chi-aggiorna -> origin/readme-chi-aggiorna
$ git status
On branch main
Your branch is behind 'origin/main' by 2 commits, and can be fast-forwarded.
  (use "git pull" to update your local branch)

nothing to commit, working tree clean
$ git pull
Updating b12df3f..398e2c9
Fast-forward
 README.md | 2 ++
 1 file changed, 2 insertions(+)
  • Il primo git status non lo sa: parla con l'etichetta origin/main, che è ferma all'ultima volta. «Up to date» vuol dire «come l'ultima volta che ho guardato».
  • git fetch va a guardare. Si sposta origin/main (da b12df3f a 398e2c9) e arriva anche l'etichetta origin/readme-chi-aggiorna. Il tuo main e la tua scrivania non si muovono: il README.md è ancora il vecchio.
  • Il secondo git status adesso lo sa: sei indietro di 2 commit (la modifica di Marta e il commit di merge della PR), e basta un fast-forward.
  • git pull fa il merge: avanza l'etichetta, e il README.md cambia.

In italiano. fetch scarica e aggiorna le etichette origin/…. pull fa fetch e poi, subito, il merge di origin/main nel branch su cui sei. Qui main non aveva niente di suo, quindi l'etichetta salta in avanti.

Passo per passo.

ComandoIl tuo mainorigin/mainmain su GitHub
(dopo la PR di Marta)C3C3C4
git fetchC3C4C4
git pullC4C4C4

(Per non fare un disegno grosso, tutta la PR di Marta, i suoi due commit, è un commit solo: C4.)

dopo git fetch
C1 ◀── C2 ◀── C3 ◀── C4 ◀── origin/main
              ▲
              main ◀── HEAD

dopo git pull
C1 ◀── C2 ◀── C3 ◀── C4 ◀── main ◀── HEAD
                     ▲
                     origin/main

Cosa portiamo a casa. git fetch per guardare, senza rischi. git pull per guardare e unire. git status ti parla solo dell'ultima volta che hai guardato.


D · Il push respinto

Torna sul tuo branch: git switch festivi. Aggiungi una seconda corsa e fai il commit:

Terminale
echo "07:30 M14 per Largo Lista, solo festivi" >> orari.txt
git add orari.txt
git commit -m "Aggiunge la corsa festiva delle 7:30"

Intanto Marta ha fatto push sullo stesso festivi (un file nuovo: avvisi-festivi.txt). Da esempi/progetto:

Terminale
bash ../intanto-marta.sh festivi

Adesso tu scrivi:

Terminale
git push
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il push passa? Se no, cosa fai? Dopo la cura, quanti genitori ha il commit nuovo?

$ git push
To ../github.git
 ! [rejected]        festivi -> festivi (fetch first)
error: failed to push some refs to '../github.git'
hint: Updates were rejected because the remote contains work that you do not
hint: have locally. This is usually caused by another repository pushing to
hint: the same ref. If you want to integrate the remote changes, use
hint: 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Respinto, fetch first: online c'è una foto che tu non hai. Per vedere la situazione:

$ git fetch
From ../github
   625927b..8cfd4ea  festivi    -> origin/festivi
$ git status
On branch festivi
Your branch and 'origin/festivi' have diverged,
and have 1 and 1 different commits each, respectively.
  (use "git pull" if you want to integrate the remote branch with yours)

nothing to commit, working tree clean

diverged: le due storie si sono separate, una foto di qua (la tua delle 7:30) e una di là (quella di Marta). Sono su file diversi, quindi pull le unisce da solo:

$ git pull --no-edit
Merge made by the 'ort' strategy.
 avvisi-festivi.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 avvisi-festivi.txt
$ git push
To ../github.git
   8cfd4ea..52c1026  festivi -> festivi

Il commit nuovo (52c1026, il codice sarà diverso) ha due genitori: la tua foto delle 7:30 e quella di Marta. È un merge, come nel capitolo Branch e merge.

In italiano.

  1. Git rifiuta il push perché sovrascriverebbe la foto di Marta.
  2. git pull porta la sua foto da te e unisce le due storie con un merge.
  3. Adesso il tuo festivi ha tutto, quindi il push è un semplice «avanti».

--no-edit serve perché il merge apre un editor per il messaggio: così tieni quello che Git ha già scritto. Se l'editor si apre lo stesso, esci con nano: Ctrl+O, Invio, Ctrl+X, con vim: Esc, poi :wq e Invio.

Il disegno.

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

Passo per passo.

Comandofestivi (tuo)origin/festivifestivi su GitHub
(dopo il commit e il push di Marta)C6C4C5
git pushC6C4C5 (respinto)
git fetchC6C5C5
git pull --no-editC7 (merge)C5C5
git pushC7C7C7

(C4 è la corsa delle 7:00, C5 gli avvisi di Marta, C6 la tua corsa delle 7:30, C7 il merge.)

C1 ◀── C2 ◀── C3 ◀── C4 ◀── C5 ◀── origin/festivi
                     ▲
                     └── C6 ◀── festivi ◀── HEAD

dopo git pull
C1 ◀── C2 ◀── C3 ◀── C4 ◀── C5 ◀── C7 ◀── festivi ◀── HEAD
                     ▲             │
                     └── C6 ◀──────┘

Cosa portiamo a casa. fetch first si cura con git pull, poi git push. Se lo stesso file fosse stato cambiato nelle stesse righe, git pull avrebbe fatto un conflitto: si risolve come nel capitolo I conflitti.


E · La pull request, e dopo

Il tuo festivi è online, con la corsa delle 7:00, quella delle 7:30 e gli avvisi di Marta. Va in main. Su GitHub ti basta il pulsante Compare & pull request; da terminale:

Terminale
gh pr create --base main --fill

(Con il GitHub finto non c'è gh: qui la PR la fa unisci-pr.sh, come se Ernesto Pozzi avesse letto Files changed, scelto Review changes → Approve e premuto Merge pull request.)

Terminale
bash ../unisci-pr.sh festivi
git status
git switch main
git pull
git branch -d festivi
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Subito dopo la PR, cosa è cambiato sul tuo computer? E dopo git switch main?

$ bash ../unisci-pr.sh festivi
Pull request #2 unita: festivi → main.
$ git status
On branch festivi
Your branch is up to date with 'origin/festivi'.

nothing to commit, working tree clean
$ git switch main
Switched to branch 'main'
Your branch is up to date with 'origin/main'.
$ git pull
From ../github
   398e2c9..d079680  main       -> origin/main
Updating 398e2c9..d079680
Fast-forward
 avvisi-festivi.txt | 1 +
 orari.txt          | 2 ++
 2 files changed, 3 insertions(+)
 create mode 100644 avvisi-festivi.txt
$ git branch -d festivi
Deleted branch festivi (was 52c1026).

Sul tuo computer niente: il merge l'ha fatto GitHub, sul suo album. Anche dopo git switch main, Git dice «up to date», perché guarda ancora l'etichetta vecchia. Solo git pull va a guardare e porta le novità: tre righe e un file nuovo, con un fast-forward. Il codice del merge della PR (d079680) sarà diverso sul tuo computer. git branch -d ha buttato l'etichetta festivi: le foto restano nella storia di main.

In italiano.

  1. La PR ha una base (main) e un compare (festivi). Il revisore legge, approva, e GitHub crea il commit di merge online.
  2. Per avere le novità servono git switch main e git pull.
  3. Il branch unito non serve più: git branch -d festivi.

Passo per passo.

ComandoIl tuo mainorigin/mainmain su GitHub
(prima della PR)C4C4C4
bash ../unisci-pr.sh festiviC4C4C6 (merge della PR)
git switch mainC4C4C6
git pullC6C6C6

Per semplicità, nel disegno la PR di Marta è un commit solo (C4) e tutto il lavoro di festivi un altro (C5). Il merge della PR è C6, con due genitori.

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

Cosa portiamo a casa. La PR si fa su GitHub, l'aggiornamento si fa a casa tua. Finita la PR: git switch main, git pull, git branch -d nome.