Question Comment mettre à jour un référentiel fork GitHub?


J'ai récemment forké un projet et appliqué plusieurs correctifs. J'ai alors créé une requête de traction qui a ensuite été acceptée.

Quelques jours plus tard un autre changement a été fait par un autre contributeur. Donc, ma fourche ne contient pas ce changement.

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


2829
2017-08-30 13:53


origine


Réponses:


Dans votre clone local de votre référentiel bifurqué, vous pouvez ajouter le référentiel GitHub d'origine en tant que "distant". ("Remotes" sont comme des surnoms pour les URL des dépôts - origin est un, par exemple.) Ensuite, vous pouvez récupérer toutes les branches de ce référentiel en 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'historique de votre branche principale, (par exemple parce que d'autres personnes l'ont cloné), vous devez remplacer la dernière commande par git merge upstream/master. Cependant, pour faire d'autres demandes d'extraction aussi propres que possible, il est probablement préférable de rebaser.


Si vous avez rebasé votre branche sur upstream/master vous devrez peut-être forcer le push pour le pousser vers votre propre dépôt forké sur GitHub. Vous le feriez avec:

git push -f origin master

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


3098
2017-08-30 14:01



Depuis mai 2014, il est possible de mettre à jour une fourchette directement depuis GitHub. Cela fonctionne toujours à partir de septembre 2017, MAIS cela conduira à un sale historique de commit.

  1. Ouvrez votre fourche sur GitHub.
  2. Cliquer sur Tirer des demandes.
  3. Cliquer sur Nouvelle demande de tirage. Par défaut, GitHub compare l'original avec votre fourche, et il ne devrait y avoir aucune comparaison si vous n'avez effectué aucun changement.
  4. Cliquez sur changer la base si vous voyez ce lien. Sinon, définissez manuellement fourche de base descendre à votre fourchette, et le fourchette à 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éer une requête de traction et attribuez un nom prévisible à votre demande d'extraction (par exemple, Update from original).
  6. Faites défiler jusqu'à Fusionner demande de traction, mais ne cliquez sur rien pour le moment.

Maintenant vous avez trois options, mais chacune conduira à un historique de commit moins que propre.

  1. La valeur par défaut créera un commit de fusion moche.
  2. Si vous cliquez sur la liste déroulante et que vous choisissez "Squash and merge", tous les commits intermédiaires seront écrasés en un. C'est le plus souvent quelque chose que vous ne voulez pas.
  3. Si vous cliquez Rebase et fusionne, tous les commits seront faits "avec" vous, les PR originaux seront liés à votre PR, et GitHub affichera This branch is X commits ahead, Y commits behind <original fork>.

Donc oui, vous pouvez garder votre repo mis à jour avec son upstream en utilisant l'interface web de GitHub, mais cela va souiller votre historique de commit. S'en tenir à la ligne de commande Au lieu de cela, c'est facile.


642
2018-05-25 07:31



Voici le document officiel de GitHub sur Synchroniser une fourche:

Synchroniser une fourche

La mise en place

Avant de pouvoir effectuer une synchronisation, vous devez ajouter une télécommande qui pointe vers le référentiel en amont. Vous avez peut-être fait cela lorsque vous avez commencé à bifurquer.

Astuce: La synchronisation de votre fourche ne met à jour que votre copie locale du référentiel; il ne met pas à 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 aller chercher à partir de la télécommande, puis vous devez fusionner la branche souhaitée dans votre branche locale.

Aller chercher

Récupérer à partir du référentiel distant apportera ses branches et leurs commits respectifs. Ceux-ci sont stockés dans votre référentiel local sous des 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 master en amont stockée dans une branche locale, en amont / 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

Fusionner

Maintenant que nous avons récupéré le référentiel amont, nous souhaitons fusionner ses modifications dans notre branche locale. Cela va synchroniser cette branche avec l'amont, sans perdre nos 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'a pas de commits uniques, git effectuera plutôt un "fast-forward":

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

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


365
2017-10-21 23:04



Beaucoup de réponses finissent par bouger votre fourchette un engagement à l'avance du référentiel parent. Cette réponse résume les étapes trouvées ici Qui va déplacez votre fourche vers le même commit que le parent.

  1. Changez le répertoire vers votre dépôt local.

    • Passer à la branche principale si vous n'êtes pas git checkout master
  2. Ajoutez le parent en tant que référentiel distant, git remote add upstream <repo-location>

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

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

Pour plus d'informations sur ces commandes, reportez-vous à étape 3.


81
2017-08-05 14:59



Depuis novembre 2013, une demande de fonctionnalité non officielle a été ouverte avec GitHub pour leur demander d'ajouter une méthode très simple et intuitive pour synchroniser un fork local avec l'amont:

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

Note: Comme la demande de fonctionnalité n'est pas officielle, il est également conseillé de contacter support@github.com pour ajouter votre soutien à une fonctionnalité comme celle-ci à mettre en œuvre. La demande de fonctionnalité non officielle ci-dessus pourrait être utilisée comme preuve de la quantité d'intérêt pour ce qui est mis en œuvre.


39
2018-02-21 10:42



Avant-propos Votre fourchette est "l'origine" et le référentiel dont vous avez dérivé est "en amont".

Supposons que vous avez déjà cloné votre fork sur votre ordinateur avec une commande comme celle-ci:

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

Si cela est indiqué, vous devez continuer dans cet ordre:

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

    git remote add upstream git@github.com:original_author/project_name.git
    
  2. Récupère les commits (et les branches) du "en amont":

    git fetch upstream
    
  3. Passez à la branche "master" de votre fork ("origine"):

    git checkout master
    
  4. Stash les changements de votre branche "maître":

    git stash
    
  5. Fusionner les changements de la branche "maître" de "l'amont" dans votre branche "maîtresse" de votre "origine":

    git merge upstream/master
    
  6. Résolvez les conflits de fusion le cas échéant et validez votre fusion

    git commit -am "Merged from upstream"
    
  7. Poussez les changements à votre fourchette

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

    git stash pop
    
  9. Vous avez terminé! Toutes nos félicitations!

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


29
2018-03-16 12:24



À la date de cette réponse, GitHub n'a pas (ou dois-je dire plus?) cette fonctionnalité dans l'interface Web. Vous pouvez cependant demander support@github.com pour ajouter votre vote pour cela.

En attendant, l'utilisateur de GitHub bardiharborow a créé un outil pour faire exactement cela: https://upriver.github.io/

La source est ici: https://github.com/upriver/upriver.github.io


21
2017-09-14 14:22



Si, comme moi, vous ne jamais rien faire directement pour maîtriser, que vous devriez vraiment, vous pouvez faire ce qui suit.

À partir du clone local de votre fourche, créez votre télécommande en amont. Vous avez seulement besoin de le faire une fois:

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

Ensuite, chaque fois que vous voulez rattraper la branche maîtresse du référentiel amont, vous devez:

git checkout master
git pull upstream master

En supposant que vous n'avez jamais rien fait sur maître, vous devriez déjà avoir terminé. Vous pouvez maintenant pousser votre maître local vers votre fourche GitHub distante. Vous pouvez également rebaser votre branche de développement sur votre maître local maintenant à jour.

Ainsi, après la configuration initiale en amont et la vérification principale, tout ce que vous devez faire est d'exécuter la commande suivante pour synchroniser votre maître avec l'amont: git tirez maître en amont.


21
2018-01-03 16:59



Si vous utilisez GitHub pour Windows, ils disposent maintenant d'une fonctionnalité en un clic pour mettre à jour les fourches:

  1. Sélectionnez le référentiel dans l'interface utilisateur.
  2. Cliquez sur le bouton "Mettre à jour de l'utilisateur / branche" en haut.

12
2018-03-31 21:45



Suivez les étapes ci-dessous. Je les ai essayés et ça m'a aidé.

Commander à votre succursale

Syntaxe: git branche yourDevelopmentBranch
Exemple: git checkout master

Tirez la branche du référentiel source pour obtenir le dernier code

Syntaxe: git pull https://github.com/tastejs/awesome-app-ideas maîtriser
Exemple: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git NOM DE LA FILIALE


8
2018-01-15 12:31



En fait, il est possible de créer une branche dans votre fork à partir de toute validation de l'amont dans le navigateur:

  • Ouvrir https://github.com/<repo>/commits/<hash>, où repo est ta fourchette, et hacher est le hash complet de commit que vous pouvez trouver dans l'interface web en amont. Par exemple, je peux ouvrir https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990, qui pointe vers linux  master au moment de l'écriture.
  • Cliquez sur le bouton "Tree: ....".
  • Entrez le nom de la nouvelle branche et appuyez sur Entrer

Enter image description here

Vous pouvez ensuite récupérer cette branche dans votre clone local, et vous n'aurez plus à renvoyer toutes ces données vers GitHub lorsque vous appuierez sur les modifications au-dessus de ce commit. Ou utilisez l'interface web pour changer quelque chose dans cette branche.

Comment cela fonctionne (c'est une conjecture, je ne sais pas comment exactement GitHub le fait): les fourchettes partagent le stockage et l'utilisation des objets espaces de noms séparer les références des utilisateurs. Ainsi, vous pouvez accéder à tous les commits à travers votre fourche, même s'ils n'existaient pas au moment du forking.


8
2018-01-18 06:41