Di recente ho modificato un progetto e ho applicato diverse correzioni. Ho quindi creato una richiesta pull che è stata poi accettata.

Alcuni giorni dopo, un'altra persona ha apportato un'altra modifica. Quindi il mio fork non contiene quel cambiamento.

Come posso ottenere quel cambiamento nel mio fork? Devo eliminare e ricreare il mio fork quando devo apportare ulteriori modifiche? O c'è un pulsante di aggiornamento?

Nel clone locale del repository a forcella, è possibile aggiungere il repository GitHub originale come "remoto". (I "telecomandi" sono come i soprannomi per gli URL dei repository - ne originè uno, ad esempio.) Quindi puoi recuperare tutti i rami da quel repository upstream e rifare 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 ramo principale, (ad esempio perché altre persone potrebbero averlo clonato), è necessario sostituire l'ultimo comando con git merge upstream/master. Tuttavia, per fare ulteriori richieste pull il più pulite possibile, probabilmente è meglio rifare il passo.

Se hai modificato nuovamente il tuo ramo, upstream/masterpotresti dover forzare il push per inviarlo al tuo repository biforcato su GitHub. Lo faresti con:

git push -f origin master

Hai solo bisogno di usare -fla prima volta dopo aver riformulato.

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

1. Apri la forcella su GitHub.
2. Clicca su Pull Requests.
3. Clicca su New Pull Request. Per impostazione predefinita, GitHub confronta l'originale con il tuo fork e non ci dovrebbe essere nulla da confrontare se non hai apportato modifiche.
4. Clicca switching the basese vedi quel link. Altrimenti, imposta manualmente il base forkmenu a discesa sul fork e su head forka monte. Ora GitHub confronterà il tuo fork con l'originale e dovresti vedere tutte le ultime modifiche.
5. Create pull requeste assegna un nome prevedibile alla tua richiesta pull (ad es Update from original.).
6. Scorri verso il basso fino a Merge pull request, ma non fare ancora clic su nulla.

Ora hai tre opzioni, ma ognuna porterà a una cronologia di commit poco 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 gli commit intermedi verranno ridotti in uno. Questo è spesso qualcosa che non vuoi.
3. Facendo clic su Rebase and merge, tutti i commit verranno effettuati "con" te, i PR originali verranno collegati al tuo PR e verrà visualizzato GitHub This branch is X commits ahead, Y commits behind <original fork>.

Quindi sì, puoi mantenere aggiornato il tuo repository con il suo upstream utilizzando l'interfaccia utente Web di GitHub, ma facendo ciò rovinerai la tua cronologia di commit. Attenersi invece alla riga di comando : è facile.

Ecco il documento ufficiale di GitHub su Sincronizzare un fork :

Sincronizzare una forcella

Il set up

Prima di poter eseguire la sincronizzazione, è necessario aggiungere un telecomando che punti al repository upstream. Potresti averlo fatto quando hai originariamente biforcato.

Suggerimento: la sincronizzazione del fork 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: prima devi recuperare dal telecomando, quindi unire il ramo desiderato nel tuo ramo locale.

Recupero

Il recupero dal repository remoto porterà nelle sue filiali e nei 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 dell'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 i nostri cambiamenti 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 avuto alcun commit univoco, 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

Molte risposte finiscono per spostare il fork di un commit prima del repository principale. Questa risposta riepiloga i passaggi qui trovati che sposteranno il fork sullo stesso commit del genitore .

1. Cambia 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 al passaggio 3 .

Se, come me, non commetti mai nulla direttamente al master , cosa che dovresti davvero, puoi fare quanto segue.

Dal clone locale del fork, creare il telecomando a monte. Devi farlo una sola volta:

git remote add upstream https://github.com/whoever/whatever.git

Quindi, ogni volta che si desidera raggiungere il ramo master del repository upstream, è necessario:

git checkout master
git pull upstream master

Supponendo che tu non abbia mai commesso nulla sul master da solo, dovresti già averlo fatto. Ora puoi spingere il tuo master locale sul tuo fork GitHub remoto originale. Potresti anche rifare il tuo ramo di sviluppo sul tuo master locale ora aggiornato.

Dopo l'installazione iniziale a monte e il checkout principale, tutto ciò che devi fare è eseguire il seguente comando per sincronizzare il tuo master con upstream: git pull upstream master .

Premessa: il tuo fork è "origine" e il repository da cui hai effettuato il fork è "upstream".

Supponiamo che tu abbia già clonato il tuo fork sul tuo computer con un comando come questo:

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

Se viene fornito, è necessario continuare in questo ordine:

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

   git remote add upstream git@github.com:original_author/project_name.git
   

2. Recupera i commit (e le filiali) dal "monte":

   git fetch upstream
   

3. Passa al ramo "master" della forcella ("origine"):

   git checkout master
   

4. Blocca le modifiche del tuo ramo "master":

   git stash
   

5. Unisci le modifiche dal ramo "principale" del "monte" nel tuo ramo "principale" della tua "origine":

   git merge upstream/master
   

6. Risolvi eventuali conflitti di unione e commetti la tua unione

   git commit -am "Merged from upstream"
   

7. Spingi le modifiche alla forcella

   git push
   

8. Ripristina le modifiche nascoste (se presenti)

   git stash pop
   

9. Hai finito! Congratulazioni!

GitHub fornisce anche istruzioni per questo argomento: Sincronizzare un fork

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 l'upstream:

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

Nota: poiché la richiesta di funzionalità non è ufficiale, è consigliabile contattare anche support@github.comper aggiungere il proprio supporto per l'implementazione di una funzionalità come questa. La richiesta di funzionalità non ufficiale di cui sopra potrebbe essere utilizzata come prova della quantità di interesse per l'implementazione.

Alla data di questa risposta, GitHub non ha ( o dovrei dire non più? ) Questa funzionalità nell'interfaccia web. Tuttavia, puoi chiedere support@github.comdi aggiungere il tuo voto.

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

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

Se stai usando GitHub per Windows o Mac, ora hanno una funzione con un clic per aggiornare le forcelle:

1. Seleziona il repository nell'interfaccia utente.
2. Fai clic sul pulsante "Aggiorna da utente / ramo" in alto.

In realtà, è possibile creare un ramo nel fork da qualsiasi commit dell'upstream nel browser:

• Apri https://github.com/<repo>/commits/<hash>, dove repo è il tuo fork e l' hash è hash completo di commit che puoi trovare nell'interfaccia web upstream. Ad esempio, posso aprire https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , che indica linux masterl'ora della scrittura.
• Fai clic sul pulsante "Albero: ....".
• Digitare il nome del nuovo ramo e premere Enter

È quindi possibile recuperare quel ramo nel clone locale e non sarà necessario inviare nuovamente tutti i dati a GitHub quando si esegue il push delle modifiche in cima a quel commit. Oppure usa l'interfaccia web per cambiare qualcosa in quel ramo.

Come funziona (è un'ipotesi, non so come faccia esattamente GitHub): le forcelle condividono l'archiviazione degli oggetti e usano gli spazi dei nomi per separare i riferimenti degli utenti. Quindi puoi accedere a tutti gli commit tramite il fork, anche se non esistevano al momento del fork.

Seguire i passaggi seguenti. Li ho provati e mi ha aiutato.

Vai alla tua filiale

Sintassi: git branch yourDevelopmentBranch
Esempio: git checkout master

Estrarre il ramo del repository di origine per ottenere il codice più recente

Sintassi: git pull https://github.com/tastejs/awesome-app-ideas master
Esempio: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

Aggiorna i miei repository biforcati con questa riga:

git pull https://github.com/forkuser/forkedrepo.git branch

Utilizzare questo se non si desidera aggiungere un altro endpoint remoto al progetto, come altre soluzioni pubblicate qui.

Come complemento a questa risposta, stavo cercando un modo per aggiornare tutti i rami remoti del mio repository clonato ( origine ) dai rami a monte in una volta sola. È così che l'ho fatto.

Ciò presuppone che abbiate già configurato un puntamento remoto a monte nel repository di origine (da cui l' origine è stata biforcuta) e lo avete sincronizzato git fetch upstream.

Quindi eseguire:

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git push origin refs/remotes/upstream/$branch:refs/heads/$branch; done

La prima parte di questo comando elenca tutti gli head nel repository remoto upstream e rimuove SHA-1 seguito dal refs/heads/prefisso del nome del ramo.

Quindi, per ciascuno di questi rami, invia la copia locale del ramo di tracciamento remoto a monte ( refs/remotes/upstream/<branch>sul lato locale) direttamente al ramo remoto sull'origine ( refs/heads/<branch>sul lato remoto).

Uno qualsiasi di questi comandi di sincronizzazione dei rami potrebbe non riuscire per uno dei due motivi: o il ramo a monte è stato riscritto o è stato inviato il commit su quel ramo al fork. Nel primo caso in cui non hai impegnato nulla sul ramo della tua forcella, puoi spingere con forza (Aggiungi l' opzione -f ; cioè git push -fnel comando sopra). Nell'altro caso questo è normale poiché il ramo della forcella è divergente e non puoi aspettarti che il comando di sincronizzazione funzioni fino a quando i tuoi commit non sono stati uniti nuovamente a monte .

L' app "Pull" è una soluzione automatica di impostazione e dimenticanza. Sincronizzerà il ramo predefinito del fork con il repository upstream.

Visita l'URL, fai clic sul pulsante verde "Installa" e seleziona i repository in cui desideri abilitare la sincronizzazione automatica.

Il ramo viene aggiornato una volta all'ora direttamente su GitHub, sul tuo computer locale devi estrarre il ramo principale per assicurarti che la tua copia locale sia sincronizzata.

Android Studio ora ha imparato a lavorare con i repository fork di GitHub (non è nemmeno necessario aggiungere un repository remoto "upstream" tramite il comando della console).

Apri il menu VCS → Git

E presta attenzione alle ultime due voci del menu popup:

• Sostituisci la mia forcella GitHub

• Crea richiesta pull

Provali. Uso il primo per sincronizzare il mio repository locale. In ogni caso, i rami del repository remoto principale ("upstream") saranno accessibili in Android Studio dopo aver fatto clic su "Rebase my GitHub fork" e sarai in grado di operare facilmente con essi.

(Uso Android Studio 3.0 con i plug-in "Integrazione Git" e "GitHub".)

Dopo aver clonato il repository biforcato, vai al percorso della directory in cui risiede il clone e le poche righe nel tuo terminale Git Bash.

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

E lì sei a posto. Tutte le modifiche aggiornate nel repository principale verranno inserite nel repository fork.

Il comando "fetch" è indispensabile per rimanere aggiornati in un progetto: solo quando si esegue un "git fetch" sarai informato sulle modifiche che i tuoi colleghi hanno inviato al server remoto.

Puoi ancora visitare qui per ulteriori domande

Se imposti il ​​tuo upstream. Verificare con git remote -v, quindi questo sarà sufficiente.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push

Dipende dalle dimensioni del tuo repository e da come lo hai modificato.

Se si tratta di un repository abbastanza grande, potresti averlo voluto gestire in modo speciale (ad es. Eliminare la cronologia). Fondamentalmente, è possibile ottenere differenze tra le versioni correnti e upstream, eseguirne il commit e quindi riprendere a padroneggiare.

Prova a leggere questo . Descrive come gestire grandi repository Git e come integrarli con le ultime modifiche.

Vorrei aggiungere alla risposta di @ krlmlr .

Inizialmente, il repository biforcuta è un ramo di nome: master. Se stai lavorando su una nuova funzionalità o una correzione, in genere crei un nuovo ramo featuree apporti le modifiche.

Se si desidera che il repository a forcella sia sincronizzato con il repository principale, è possibile impostare un file di configurazione ( pull.yml) per l' app Pull ( nel ramo della funzione ), in questo modo:

version: "1"
rules:
  - base: feature
    upstream: master
    mergeMethod: merge
  - base: master
    upstream: parent_repo:master
    mergeMethod: hardreset

Ciò mantiene aggiornato il masterramo del repository a forcella con il repository principale. Mantiene aggiornato il featureramo del repository biforcato tramite il masterramo del repository biforcato unendo lo stesso. Ciò presuppone che il featureramo sia il ramo predefinito che contiene il file di configurazione.

Qui due mergemethodssono in gioco, uno è quello hardresetche aiuta a forzare la sincronizzazione delle modifiche nel masterramo del repository biforcato con il repository principale e l'altro è merge. Questo metodo viene utilizzato per unire le modifiche apportate dall'utente nel featureramo e le modifiche apportate a causa della forzatura della sincronizzazione nel masterramo. In caso di conflitto di unione, l'app pull ti consentirà di scegliere il prossimo corso d'azione durante la richiesta pull.

Puoi leggere le configurazioni di base e avanzate e varie mergemethods qui .

Attualmente sto usando questa configurazione nel mio repository biforcato qui per assicurarmi che un miglioramento richiesto qui rimanga aggiornato.

Ci sono due cose principali su come mantenere un repository biforcuto sempre aggiornato per sempre.

1. Creare i rami dal fork fork e apportare le modifiche lì .

Pertanto, quando la richiesta pull viene accettata, è possibile eliminare in modo sicuro il ramo poiché il codice fornito sarà attivo nel master del repository biforcato quando lo si aggiorna con l'upstream. In questo modo il tuo master sarà sempre in buone condizioni per creare un nuovo ramo per fare un altro cambiamento.

2. Creare un processo pianificato per il fork master per eseguire automaticamente l'aggiornamento .

Questo può essere fatto con cron . Ecco un esempio di codice se lo fai in Linux.

$ crontab -e

inserire questo codice su crontab fileper eseguire il lavoro su base oraria.

0 * * * * sh ~/cron.sh

quindi creare il cron.shfile di script e un'interazione git con ssh-agent e / o aspettarsi come di seguito

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="git@github.com:<username>/$REPOSITORY.git"   
UPSTREAM=git@github.com:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git push origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

Controlla il tuo repository biforcato. Di tanto in tanto mostrerà sempre questa notifica:

Questo ramo è anche con <upstream>: maestro .

Usa questi comandi (in caso fortunato)

git remote -v
git pull
git fetch upstream
git checkout master
git merge upstream/master --no-ff
git add .
git commit -m"Sync with upstream repository."
git push -v