Comment mettre à jour un dépôt GitHub forked?

j'ai récemment bifurqué un projet et appliqué plusieurs correctifs. J'ai alors créé une demande pull qui a ensuite été acceptée.

quelques jours plus tard, un autre changement a été apporté par un autre donateur. Donc ma fourchette ne contient pas ce changement.

Comment puis-je mettre ce changement dans ma fourchette? Dois-je supprimer et recréer ma fourchette lorsque j'ai d'autres modifications à apporter? Ou est-il un bouton de mise à jour?

2906
demandé sur nbro 2011-08-30 17:53:00
la source

16 ответов

dans votre clone local de votre dépôt en forme de fourche, vous pouvez ajouter le dépôt GitHub original en tant que"distant". ("Télécommandes" sont comme des surnoms pour les Url des dépôts - origin est une, par exemple.) Vous pouvez alors récupérer toutes les branches de ce dépôt amont, et rebaser votre travail pour continuer à travailler sur la version amont. En termes de commandes qui pourraient ressembler à:

# 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

si vous ne voulez pas réécrire l'histoire de votre maître branche, (par exemple parce que d'autres personnes peuvent l'avoir cloné) alors vous devriez remplacer la dernière commande par git merge upstream/master . Cependant, pour faire d'autres requêtes pull qui sont aussi propres que possible, il est probablement préférable de rebaser.


si vous avez rebasé votre branche sur upstream/master vous pourriez avoir besoin de forcer la poussée afin de la pousser vers votre propre dépôt fourchu sur GitHub. Vous le feriez avec:

git push -f origin master

Vous n' besoin d'utiliser le -f la première fois après que vous avez relocalisée.

3179
répondu Mark Longair 2018-04-09 14:19:46
la source

à partir de mai 2014, il est possible de mettre à jour une fourche directement à partir de GitHub. Cela fonctionne toujours à partir de septembre 2017, mais il mènera à une dirty commit histoire.

  1. ouvrez votre fourche sur GitHub.
  2. Cliquez sur Pull request .
  3. cliquez sur New Pull Request . Par défaut, GitHub comparera l'original avec votre fourchette, et là il ne devrait pas y avoir de comparaison si vous n'avez pas fait de changements.
  4. , Cliquez sur changement de base si vous voyez ce lien. Dans le cas contraire, réglez manuellement la fourche de base à votre fourche, et la fourche de tête à l'amont. Maintenant GitHub va comparer votre fourche avec l'original, et vous devriez voir tous les derniers changements. enter image description here
  5. crée la requête et attribue un nom prévisible à votre requête Update from original .
  6. Faites défiler vers le bas jusqu'à demande de fusion , mais ne cliquez sur rien encore.

Maintenant vous avez trois options, mais chacune va conduire à une histoire de propagation moins que nette.

  1. la valeur par défaut va créer un laid merge commit.
  2. Si vous cliquez sur le la liste déroulante et choisissez "Squash and merge", toutes les propagations intermédiaires seront écrasées en une seule. C'est souvent quelque chose que vous ne voulez pas.
  3. si vous cliquez sur Rebase et fusionner , toutes les propagations seront faites" avec "vous, le PRs original sera lié à votre PR, et GitHub affichera This branch is X commits ahead, Y commits behind <original fork> .

donc oui, vous pouvez garder votre rapport à jour avec son upstream en utilisant L'interface utilisateur de GitHub web, mais faire ainsi sully votre commit histoire. S'en tenir à la ligne de commande à la place - c'est facile.

650
répondu lobzik 2017-09-26 23:41:33
la source

voici le document officiel de GitHub sur synchroniser une fourchette :

la Synchronisation d'une fourche

L'Installation

avant de pouvoir synchroniser, vous devez ajouter une télécommande qui pointe vers le dépôt amont. Vous avez peut-être fait ça quand vous avez initialement bifurqué.

Conseil: synchroniser votre fork ne met à jour que votre copie locale du dépôt; il ne mettez à jour votre dépôt sur 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)

Synchronisation

il y a deux étapes nécessaires pour synchroniser votre dépôt avec l'amont: vous devez d'abord récupérer à distance, puis fusionner la branche désirée dans votre branche locale.

Chercher

La commande

à partir du dépôt distant introduira ses branches et leurs propagations respectives. Elles sont stockées dans votre dépôt local sous branches spéciales.

$ 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

nous avons maintenant la branche principale de l'amont stockée dans une branche locale, amont/maître

$ 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

Fusion

maintenant que nous avons récupéré le dépôt amont, nous voulons fusionner ses modifications dans notre branche locale. Cela permettra de synchroniser cette branche avec l'amont, sans perdre de vue les changements locaux.

$ 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

si votre branche locale n'avait pas d'unique commits, git va plutôt effectuer un "fast-forward":

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

conseil: si vous voulez mettre à jour votre dépôt sur GitHub, suivez les instructions ici

377
répondu jumpnett 2015-09-21 22:38:46
la source

beaucoup de réponses en fin de déplacement de votre fourche un commit en plus de la mère de référentiel. Cette réponse résume les étapes trouvées ici qui va déplacer votre fourche à la même propagation que le parent .

  1. changer le répertoire à votre dépôt local.

    • passer à la branche principale, si vous n'êtes pas git checkout master
  2. Ajouter le parent comme un référentiel à distance git remote add upstream <repo-location>

  3. Problème git fetch upstream
  4. Problème git rebase upstream/master

    • à ce stade, vous vérifiez ce qui sera fusionné en tapant git status
  5. Problème git push origin master

pour plus d'information sur ces commandes, reportez-vous à étape 3 .

83
répondu Sahar Rabinoviz 2016-04-19 07:49:14
la source

depuis Novembre 2013, il y a eu une demande non officielle de fonctionnalité ouverte avec GitHub pour leur demander d'ajouter une méthode très simple et intuitive pour garder une fourche locale en synchronisation avec l'amont:

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

Note: puisque la demande de fonctionnalité n'est pas officielle, il est également conseillé de contacter [email protected] pour ajouter votre support pour une fonctionnalité comme celle-ci à être implémentée. La chronique non officielle la demande ci-dessus pourrait être utilisée comme preuve du montant d'intérêt dans cette mise en œuvre.

39
répondu isedwards 2016-04-19 07:50:46
la source

Avant-propos: votre fourche est" l'origine "et le dépôt d'où vous avez tiré est"l'amont".

supposons que vous avez déjà cloné votre fourchette à votre ordinateur avec une commande comme celle-ci:

git clone [email protected]:your_name/project_name.git
cd project_name

si cela est donné, vous devez continuer dans cet ordre:

  1. ajouter le" amont " à votre dépôt cloné ("origine"):

    git remote add upstream [email protected]:original_author/project_name.git
    
  2. Extraire le commet (et des branches) à partir de la "en amont":

    git fetch upstream
    
  3. passer en mode "maître" de la branche de la fourche ("origine"):

    git checkout master
    
  4. stockez les changements de votre branche" master":

    git stash
    
  5. fusionner les changements de la branche "maître" de la "amont" dans votre la branche "maître" de votre" origine":

    git merge upstream/master
    
  6. résolvez les conflits de fusion s'il y en a et commettez votre Fusion

    git commit -am "Merged from upstream"
    
  7. Pousser les modifications de votre fourche

    git push
    
  8. récupérez vos modifications cachées (le cas échéant)

    git stash pop
    
  9. C'est fini! Félicitations!

GitHub fournit également des instructions pour ce sujet: synchroniser une fourche

29
répondu Benny Neugebauer 2016-12-09 16:53:15
la source

si, comme moi, vous ne commettez jamais rien directement au maître , ce que vous devriez vraiment, vous pouvez faire ce qui suit.

à partir du clone local de votre fourche, créez votre télécommande amont. Vous n'avez besoin de le faire qu'une fois:

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

ensuite, chaque fois que vous voulez rattraper la branche principale du dépôt amont, vous devez:

git checkout master
git pull upstream master

en supposant que vous n'avez jamais rien commis sur le maître toi-même, tu devrais déjà avoir fini. Maintenant, vous pouvez pousser votre maître local à votre fourche GitHub distante d'origine. Vous pouvez également rebaser votre branche de développement sur votre master local maintenant à jour.

donc après la configuration initiale en amont et la sortie maître, tout ce que vous avez à faire est d'exécuter la commande suivante pour synchroniser votre maître avec l'amont: git pull upstream master .

25
répondu Slion 2018-06-08 10:25:04
la source

en date de cette réponse, GitHub n'a pas ( ou devrais-je dire plus? ) cette fonctionnalité dans l'interface web. Vous pouvez cependant demander [email protected] pour ajouter votre vote pour qui.

entre-temps, l'utilisateur de GitHub bardiharborow a créé un outil pour faire ceci: https://upriver.github.io /

Source: https://github.com/upriver/upriver.github.io

21
répondu Lucero 2016-09-14 17:22:15
la source

si vous utilisez Github pour Windows, alors maintenant ils ont une fonctionnalité d'un seul clic pour mettre à jour les fourches:

  1. sélectionnez le dépôt dans L'interface utilisateur.
  2. cliquez sur" Mise à jour de l'utilisateur/branche".
12
répondu ShitalShah 2018-01-25 10:06:46
la source

suivez les étapes ci-dessous. Je les ai essayé et il m'a aidé.

Caisse de votre succursale

syntaxe: git branch your developmentbranch

exemple: git checkout master

Pull référentiel source direction générale pour obtenir la dernière version du code

syntaxe: git pull https://github.com/tastejs/awesome-app-ideas master

Example: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

8
répondu Venkat.R 2016-04-19 07:49:53
la source

en fait, il est possible de créer une branche dans votre fourche à partir de n'importe quelle propagation de l'amont dans le navigateur:

  • Open https://github.com/<repo>/commits/<hash> , où repo est votre fourchette, et hash est plein hachage de commit que vous pouvez trouver dans l'interface web amont. Par exemple, je peux ouvrir https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , qui indique linux master comme le temps de l'écriture.
  • Cliquez sur l'Arbre: ...." bouton.
  • tapez le nom de la nouvelle succursale et appuyez sur entrez

Enter image description here

vous pouvez alors rapporter cette branche à votre clone local, et vous n'aurez pas à repousser toutes ces données à GitHub quand vous poussez les édits au-dessus de cette propagation. Ou utiliser le web interface de changer quelque chose dans cette branche.

comment ça marche (c'est une supposition, Je ne sais pas comment exactement GitHub le fait): les fourches partagent le stockage d'objets et utilisent namespaces pour séparer les références des utilisateurs. Vous pouvez donc accéder à toutes les propagations par votre fourche, même si elles n'existaient pas au moment de la fourche.

8
répondu max630 2018-01-19 06:22:48
la source

je mets à jour mes repos fourchés avec cette ligne:

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

utilisez ceci si vous ne voulez pas ajouter un autre terminal distant à votre projet, comme d'autres solutions publiées ici.

4
répondu R.Bravo 2017-09-08 05:00:37
la source

en complément de cette réponse, je cherchais un moyen de mettre à jour toutes les branches distantes de mon repo cloné ( origine ) à partir de en amont branches en une seule fois. Voilà comment j'ai fait.

cela suppose que vous avez déjà configuré un amont pointant vers le dépôt source (où origine était bifurqué de) et que vous l'avez synchronisé avec git fetch upstream .

puis exécuter:

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 première partie de cette commande Liste toutes les têtes dans le upstream remote repo et supprime le SHA-1 suivi du préfixe refs/heads/ de nom de branche.

puis pour chacune de ces branches, il pousse la copie locale de la en amont remote tracking branch ( refs/remotes/upstream/<branch> sur le côté local) directement à la branche distante sur origin ( refs/heads/<branch> sur côté distant).

L'une de ces commandes de synchronisation de branche peut échouer pour l'une des deux raisons suivantes: soit la branche upstream a été réécrite, soit vous avez poussé commits sur cette branche à votre fourche. Dans le premier cas où vous n'avez rien fait à la branche sur votre fourche, il est sûr de pousser avec force (ajouter le commutateur -f ; i.e. git push -f dans la commande ci-dessus). Dans l'autre cas, ceci est normal car votre branche de fourche ont diverged et vous ne pouvez pas vous attendre à ce que la commande sync fonctionne tant que vos propagations n'auront pas été fusionnées dans upstream .

4
répondu Thomas Guyot-Sionnest 2018-06-08 07:31:05
la source

Android Studio a maintenant appris à travailler avec les dépôts GitHub fork (vous n'avez même pas besoin d'ajouter un dépôt distant "upstream" par commande de console).

Open menu VCS Git

et faites attention aux deux derniers éléments du menu contextuel:

  • Rebase mon GitHub fourche

  • "Create Pull Request

essayez-les. J'utilise le premier à synchroniser mon dépôt local. Quoi qu'il en soit, les branches du dépôt distant parent ("upstream") seront accessibles dans Android Studio après avoir cliqué sur "Rebase my GitHub fork", et vous pourrez les utiliser facilement.

(J'utilise Android Studio 3.0 avec les plugins" git integration "et" GitHub".)

Enter image description here

3
répondu alexshr 2018-01-19 06:25:32
la source

lorsque vous avez cloné votre dépôt bifurqué, allez sur le chemin de répertoire où réside votre clone et sur les quelques lignes de votre Terminal 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

et voilà, c'est bon. Toutes les modifications mises à jour dans le dépôt principal seront insérées dans votre dépôt fork.

la commande" fetch " est indispensable pour rester à jour dans un projet: ce n'est que lors de l'exécution d'un "git fetch" que vous serez informé des changements de votre collègues poussé vers le serveur distant.

vous pouvez toujours visiter ici pour d'autres questions

3
répondu Prateek Chanda 2018-03-10 05:21:30
la source

Qui dépend de la taille de votre référentiel et comment vous fourchue.

S'il s'agit d'un dépôt assez grand, vous avez peut-être voulu le gérer d'une manière particulière (par exemple, l'historique de dépôt). Fondamentalement, vous pouvez obtenir des différences entre les versions actuelles et amont, les propager et ensuite choisir de nouveau à maître.

Essayez de lire celui-ci . Il décrit comment gérer de grands dépôts Git et comment les changement.

1
répondu s0nicYouth 2017-05-11 01:05:32
la source

Autres questions sur git github