Recentemente ho biforcato un progetto e applicato diverse correzioni. Ho poi creato una richiesta di pull che è stata accettata.
Qualche giorno dopo un altro cambiamento è stato fatto da un altro collaboratore. Quindi il mio fork non contiene quel cambiamento.
Come posso portare quel cambiamento nel mio fork? Devo cancellare e ricreare il mio fork quando ho altre modifiche da apportare? O c'è un pulsante di aggiornamento?
Nel tuo clone locale del tuo repository biforcato, puoi aggiungere il repository GitHub originale come "remote" ("Remotes" sono come soprannomi per gli URL dei repository - origin
è uno, per esempio). Poi puoi recuperare tutti i rami da quel repository upstream, e fare il rebase del tuo lavoro per continuare a lavorare sulla versione upstream. In termini di comandi questo potrebbe apparire come:
# Add the remote, call it "upstream":
git remote add upstream https://github.com/whoever/whatever.git
# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:
git fetch upstream
# Make sure that you're on your master branch:
git checkout master
# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:
git rebase upstream/master
Se non vuoi riscrivere la storia del tuo ramo master, (per esempio perché altre persone potrebbero averlo clonato) allora dovresti sostituire l'ultimo comando con git merge upstream/master
. Tuttavia, per fare ulteriori richieste di pull che siano il più pulite possibile, è probabilmente meglio fare il rebase.
Se hai fatto il rebase del tuo ramo su upstream/master
potresti aver bisogno di forzare il push per spingerlo al tuo repository biforcato su GitHub. Lo faresti con:
git push -f origin master
Hai solo bisogno di usare la -f
la prima volta dopo aver fatto il rebase.
A partire da maggio 2014, è possibile aggiornare un fork direttamente da GitHub. Questo funziona ancora a partire da settembre 2017, Ma porterà ad una storia di commit sporca.
Update from original
).Ora hai tre opzioni, ma ognuna porterà ad una storia di commit non proprio pulita.
Questo ramo è X commits avanti, Y commits dietro <fork> originale
.Quindi sì, puoi mantenere il tuo repo aggiornato con il suo upstream usando la web UI di GitHub, ma così facendo sporcherai la tua storia dei commit. Attieniti invece a la linea di comando - è facile.
Ecco il documento ufficiale di GitHub su Syncing a fork:
Syncing a fork
Il Setup
Prima di poter sincronizzare, devi aggiungere un remoto che punti al repository upstream. Potresti averlo fatto quando hai fatto il fork in origine.
Suggerimento: sincronizzare il tuo fork aggiorna solo la tua copia locale del repository; non aggiorna il tuo repository su GitHub.
$ git remote -v
origin https://github.com/user/repo.git (fetch)
origin https://github.com/user/repo.git (push)
$ git remote add upstream https://github.com/otheruser/repo.git
Imposta un nuovo telecomando
$ git remote -v
origin https://github.com/user/repo.git (fetch)
origin https://github.com/user/repo.git (push)
upstream https://github.com/otheruser/repo.git (fetch)
upstream https://github.com/otheruser/repo.git (push)
Ci sono due passi necessari per sincronizzare il tuo repository con l'upstream: prima devi fare il fetch dal remoto, poi devi unire il ramo desiderato nel tuo ramo locale.
Il fetch dal repository remoto porterà i suoi rami e i loro rispettivi commit. Questi sono memorizzati nel tuo repository locale sotto rami speciali.
$ git fetch upstream
remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
* [new branch] master -> upstream/master
Ora abbiamo il ramo master dell'upstream memorizzato in un ramo locale, upstream/master
$ git branch -va
* master a422352 My local commit
remotes/origin/HEAD -> origin/master
remotes/origin/master a422352 My local commit
remotes/upstream/master 5fdff0f Some upstream commit
Ora che abbiamo recuperato il repository upstream, vogliamo unire i suoi cambiamenti nel nostro ramo locale. Questo porterà quel ramo in sincronia con l'upstream, senza perdere le nostre modifiche locali.
$ git checkout master
Switched to branch 'master'
$ git merge upstream/master
Updating a422352..5fdff0f
Fast-forward
README | 9 -------
README.md | 7 ++++++
2 files changed, 7 insertions(+), 9 deletions(-)
delete mode 100644 README
create mode 100644 README.md
Se il tuo ramo locale non ha avuto alcun commit unico, git eseguirà invece un "fast-forward":
$ git merge upstream/master Aggiornamento di 34e91da..16c56ad Avanzamento veloce README.md | 5 +++-- 1 file cambiato, 3 inserimenti(+), 2 cancellazioni(-)
Suggerimento: Se vuoi aggiornare il tuo repository su GitHub, segui le istruzioni qui