Domanda Come aggiorno un repository biforcato GitHub?


Recentemente ho biforcato un progetto e applicato diverse correzioni. Ho quindi creato una richiesta di pull che è stata poi accettata.

Pochi giorni dopo un altro contribuente ha apportato un'altra modifica. Quindi la mia forcella non contiene quel cambiamento.

Come posso ottenere quel cambiamento nella mia forcella? Devo cancellare e ricreare la mia forcella quando ho ulteriori modifiche da apportare? O c'è un pulsante di aggiornamento?


2829
2017-08-30 13:53


origine


risposte:


Nel tuo clone locale del tuo repository biforcuto, puoi aggiungere il repository GitHub originale come "remoto". ("I telecomandi" sono come soprannomi per gli URL dei repository - origin è uno, per esempio.) Quindi è possibile recuperare tutti i rami da quel repository upstream e rebase il lavoro per continuare a lavorare sulla versione upstream. In termini di comandi che potrebbero 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 si desidera riscrivere la cronologia del proprio ramo principale, (ad esempio perché altre persone potrebbero averlo clonato), è necessario sostituire l'ultimo comando con git merge upstream/master. Tuttavia, per effettuare ulteriori richieste di pull il più possibile pulite, è probabilmente meglio effettuare il rebase.


Se hai ribasato il tuo ramo su upstream/master potrebbe essere necessario forzare la spinta per inviarla al proprio repository biforcato su GitHub. Lo faresti con:

git push -f origin master

Hai solo bisogno di usare il -f la prima volta dopo aver rideterminato.


3097
2017-08-30 14:01



A partire da maggio 2014, è possibile aggiornare un fork direttamente da GitHub. Questo funziona ancora a partire da settembre 2017, MA porterà a una storia di commit sporca.

  1. Apri la tua forchetta su GitHub.
  2. Clicca su Pull Requests.
  3. Clicca su Nuova richiesta di pull. Per impostazione predefinita, GitHub confronta l'originale con la tua forcella e non dovrebbe esserci nulla da confrontare se non hai apportato alcuna modifica.
  4. Clic commutazione della base se vedi quel link. Altrimenti, imposta manualmente il forcella di base scendi alla tua forchetta, e il forchetta al monte. Ora GitHub confronterà la tua forcella con l'originale e dovresti vedere tutte le ultime modifiche. enter image description here
  5. Crea richiesta di pull e assegna un nome prevedibile alla tua richiesta di pull (ad es. Update from original).
  6. Scorri fino a Unisci richiesta pull, ma non fare clic ancora su nulla.

Ora hai tre opzioni, ma ognuna porterà a una cronologia del commit meno che pulita.

  1. L'impostazione predefinita creerà un brutto commit di unione.
  2. Se fai clic sul menu a discesa e scegli "Squash and merge", tutti i commit intermedi verranno schiacciati in uno solo. Questo è molto spesso qualcosa che non vuoi.
  3. Se clicchi Rebase e unione, tutti i commit saranno fatti "con" tu, i PR originali si collegheranno al tuo PR e GitHub mostrerà This branch is X commits ahead, Y commits behind <original fork>.

Quindi sì, puoi mantenere aggiornato il tuo repository con il suo upstream usando l'interfaccia utente web di GitHub, ma così facendo imbriglierai la cronologia dei commit. Attenersi a la riga di comando invece - è facile.


642
2018-05-25 07:31



Ecco il documento ufficiale di GitHub su Sincronizzazione di una forcella:

Sincronizzazione di una forcella

Il set up

Prima di poter eseguire la sincronizzazione, è necessario aggiungere un telecomando che punta al repository upstream. Potresti averlo fatto quando avevi originariamente forked.

Suggerimento: la sincronizzazione della forcella aggiorna solo la copia locale del repository; non aggiorna il tuo repository su GitHub.

$ git remote -v
# List the current remotes
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
# Set a new remote

$ git remote -v
# Verify new remote
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)

Sincronizzazione

Sono necessari due passaggi per sincronizzare il repository con l'upstream: in primo luogo è necessario recuperare dal telecomando, quindi è necessario unire il ramo desiderato nel ramo locale.

Recupero

Il recupero dal repository remoto porterà le sue filiali e i rispettivi commit. Questi sono memorizzati nel tuo repository locale sotto rami speciali.

$ git fetch upstream
# Grab the upstream remote's branches
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 principale di upstream memorizzato in un ramo locale, upstream / master

$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

Fusione

Ora che abbiamo recuperato il repository upstream, vogliamo unire le sue modifiche nel nostro ramo locale. Questo porterà quel ramo in sincronia con l'upstream, senza perdere le nostre modifiche locali.

$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
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 la tua filiale locale non ha nessun commit unico, git eseguirà invece un "avanzamento rapido":

$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

Suggerimento: se desideri aggiornare il tuo repository su GitHub, segui le istruzioni Qui


365
2017-10-21 23:04



Molte risposte finiscono per spostare la forcella uno si impegna in anticipo del repository principale. Questa risposta riepiloga i passi trovati Qui quale volontà sposta la tua forcella allo stesso commit del genitore.

  1. Cambia la directory nel tuo repository locale.

    • Passa al ramo principale se non lo sei git checkout master
  2. Aggiungi il genitore come repository remoto, git remote add upstream <repo-location>

  3. Problema git fetch upstream
  4. Problema git rebase upstream/master

    • A questo punto si controlla che si impegna ciò che verrà unito digitando git status
  5. Problema git push origin master

Per ulteriori informazioni su questi comandi, fare riferimento a passaggio 3.


81
2017-08-05 14:59



Da novembre 2013 è stata aperta una richiesta non ufficiale di funzionalità con GitHub per chiedere loro di aggiungere un metodo molto semplice e intuitivo per mantenere un fork locale sincronizzato con upstream:

https://github.com/isaacs/github/issues/121

Nota: poiché la richiesta della funzione non è ufficiale, è anche consigliabile contattare support@github.com per aggiungere il tuo supporto per una funzionalità come questa da implementare. La richiesta non ufficiale di funzionalità sopra potrebbe essere utilizzata come prova della quantità di interesse in questo essere implementato.


39
2018-02-21 10:42



Prefazione: La tua forcella è "l'origine" e il repository che hai biforcato è il "monte".

Supponiamo che tu abbia già clonato la tua forcella sul tuo computer con un comando come questo:

git clone git@github.com:your_name/project_name.git
cd project_name

Se viene indicato, è necessario continuare in questo ordine:

  1. Aggiungi "upstream" al tuo repository clonato ("origine"):

    git remote add upstream git@github.com:original_author/project_name.git
    
  2. Recupera i commit (e rami) dal "monte":

    git fetch upstream
    
  3. Passa al ramo "master" della tua forcella ("origine"):

    git checkout master
    
  4. Conserva le modifiche del tuo ramo "master":

    git stash
    
  5. Unisci le modifiche dal ramo "master" del "upstream" al ramo "master" della tua "origine":

    git merge upstream/master
    
  6. Risolvi i conflitti di unione, se ce ne sono e commetti l'unione

    git commit -am "Merged from upstream"
    
  7. Spingere le modifiche alla forcella

    git push
    
  8. Ripristina le modifiche memorizzate (se presenti)

    git stash pop
    
  9. Hai finito! Congratulazioni!

GitHub fornisce anche istruzioni per questo argomento: Sincronizzazione di una forcella


29
2018-03-16 12:24



Alla data di questa risposta, GitHub non ha (o devo dire non più?) questa funzione nell'interfaccia web. Puoi, tuttavia, chiedere support@github.com per aggiungere il tuo voto per quello.

Nel frattempo, l'utente di GitHub bardiharborow ha creato uno strumento per fare proprio questo: https://upriver.github.io/

La fonte è qui: https://github.com/upriver/upriver.github.io


21
2017-09-14 14:22