Frage Wie aktualisiere ich ein gegabeltes GitHub-Repository?


Ich habe kürzlich ein Projekt gespalten und mehrere Fixes angewendet. Ich habe dann eine Pull-Anfrage erstellt, die dann akzeptiert wurde.

Einige Tage später wurde eine weitere Änderung von einem anderen Mitarbeiter vorgenommen. Also meine Gabel enthält diese Änderung nicht.

Wie kann ich diese Änderung in meine Gabel bekommen? Muss ich meinen Fork löschen und neu erstellen, wenn ich weitere Änderungen zum Beitragen habe? Oder gibt es eine Update-Schaltfläche?


2829
2017-08-30 13:53


Ursprung


Antworten:


In Ihrem lokalen Klon Ihres gegabelten Repositorys können Sie das ursprüngliche GitHub-Repository als "Remote" hinzufügen. ("Remotes" sind wie Spitznamen für die URLs von Repositories - origin ist zum Beispiel eins.) Dann können Sie alle Zweige aus diesem Upstream-Repository abrufen und Ihre Arbeit neu erstellen, um mit der Upstream-Version weiterarbeiten zu können. In Bezug auf Befehle, die wie folgt aussehen könnten:

# 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

Wenn Sie den Verlauf Ihres Master-Zweiges nicht neu schreiben wollen (zB weil andere Leute ihn geklont haben), sollten Sie den letzten Befehl durch ersetzen git merge upstream/master. Um jedoch weitere Pull-Anfragen zu erstellen, die so sauber wie möglich sind, ist es wahrscheinlich besser, Rebases durchzuführen.


Wenn Sie Ihren Zweig auf rebased haben upstream/master Möglicherweise müssen Sie den Push-Vorgang erzwingen, um ihn zu Ihrem eigenen gegabelten Repository auf GitHub zu verschieben. Du würdest das tun mit:

git push -f origin master

Sie müssen nur die verwenden -f das erste Mal, nachdem du dich umgestimmt hast.


3098
2017-08-30 14:01



Ab Mai 2014 ist es möglich, eine Gabel direkt von GitHub zu aktualisieren. Dies funktioniert immer noch ab September 2017, ABER es wird zu einer schmutzigen Commit-Geschichte führen.

  1. Öffne deine Gabel auf GitHub.
  2. Klicke auf Pull-Anfragen.
  3. Klicke auf Neue Pull-Anfrage. Standardmäßig vergleicht GitHub das Original mit Ihrem Fork. Wenn Sie keine Änderungen vorgenommen haben, sollte nichts zu vergleichen sein.
  4. Klicken die Basis wechseln wenn Sie diesen Link sehen. Andernfalls stellen Sie die Option manuell ein Basisgabel auf deine Gabel fallen lassen, und die Gabelkopf zum Upstream. Jetzt vergleicht GitHub Ihre Gabel mit dem Original und Sie sollten die letzten Änderungen sehen. enter image description here
  5. Erstellen Sie eine Pull-Anfrage und weisen Sie Ihrer Pull-Anfrage einen vorhersagbaren Namen zu (z. B. Update from original).
  6. Scrollen Sie nach unten Pull-Anfrage zusammenführen, aber noch nichts klicken.

Jetzt haben Sie drei Möglichkeiten, aber jede führt zu einem weniger als sauberen Commit-Verlauf.

  1. Der Standard erzeugt ein hässliches Merge-Commit.
  2. Wenn Sie auf das Drop-down-Menü klicken und "Squash and merge" auswählen, werden alle dazwischen liegenden Commits in einem zusammengefasst. Dies ist meistens etwas, das du nicht willst.
  3. Wenn Sie klicken Rebase und Zusammenführung, alle Commits werden "mit" dir gemacht, die ursprünglichen PRs werden mit deinem PR verlinkt, und GitHub wird angezeigt This branch is X commits ahead, Y commits behind <original fork>.

Sie können also Ihr Repo über die GitHub-Web-Benutzeroberfläche upstream-upstream halten, aber dies wird Ihren Commit-Verlauf belasten. Bleib bei die Befehlszeile stattdessen - es ist einfach.


642
2018-05-25 07:31



Hier ist das offizielle Dokument von GitHub Eine Gabel synchronisieren:

Eine Gabel synchronisieren

Die Einrichtung

Bevor Sie synchronisieren können, müssen Sie ein Remote hinzufügen, das auf das Upstream-Repository verweist. Vielleicht hast du das getan, als du ursprünglich gegabelt hast.

Tipp: Wenn Sie Ihre Verzweigung synchronisieren, wird nur Ihre lokale Kopie des Repositorys aktualisiert. Es aktualisiert Ihr Repository auf GitHub nicht.

$ 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)

Synchronisierung

Es sind zwei Schritte erforderlich, um Ihr Repository mit dem Upstream zu synchronisieren: Zuerst müssen Sie von der Remote abrufen, dann müssen Sie den gewünschten Zweig in Ihren lokalen Zweig zusammenführen.

Abrufen

Beim Abrufen aus dem Remote-Repository werden die Zweige und die entsprechenden Commits eingefügt. Diese werden in Ihrem lokalen Repository unter speziellen Zweigen gespeichert.

$ 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

Wir haben nun den Master-Zweig des Upstream in einem lokalen Zweig, Upstream / Master, gespeichert

$ 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

Zusammenführen

Jetzt, da wir das Upstream-Repository abgerufen haben, möchten wir seine Änderungen in unseren lokalen Zweig zusammenführen. Dadurch wird dieser Zweig mit dem Upstream synchronisiert, ohne unsere lokalen Änderungen zu verlieren.

$ 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

Wenn Ihre lokale Zweigstelle keine eindeutigen Commits hatte, führt Git stattdessen einen "Schnellvorlauf" durch:

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

Tipp: Wenn Sie Ihr Repository auf GitHub aktualisieren möchten, befolgen Sie die Anweisungen Hier


365
2017-10-21 23:04



Viele Antworten führen dazu, dass Sie Ihre Gabel bewegen eine Verpflichtung voraus des übergeordneten Repositorys. Diese Antwort fasst die gefundenen Schritte zusammen Hier welches wird Verschieben Sie Ihre Verzweigung zu demselben Commit wie das übergeordnete Element.

  1. Ändern Sie das Verzeichnis in Ihr lokales Repository.

    • Wechseln Sie zum Master-Zweig, wenn Sie nicht sind git checkout master
  2. Fügen Sie das übergeordnete Objekt als Remote-Repository hinzu. git remote add upstream <repo-location>

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

    • An dieser Stelle überprüfen Sie, ob das Commit durch die Eingabe erfolgt, was zusammengeführt wird git status
  5. Problem git push origin master

Weitere Informationen zu diesen Befehlen finden Sie unter Schritt 3.


81
2017-08-05 14:59



Seit November 2013 gibt es eine inoffizielle Feature-Anfrage, die mit GitHub geöffnet wurde, um sie zu bitten, eine sehr einfache und intuitive Methode hinzuzufügen, um einen lokalen Fork synchron mit dem Upstream zu halten:

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

Hinweis: Da die Feature-Anfrage inoffiziell ist, ist es auch ratsam, sich anzumelden support@github.com um die Unterstützung für ein Feature wie dieses zu implementieren. Die obige inoffizielle Merkmalsanforderung könnte als Beweis für die Höhe des Interesses an dieser Implementierung verwendet werden.


39
2018-02-21 10:42



Vorwort: Deine Gabel ist der "Ursprung" und das Repository, von dem du gegabst hast, ist das "Upstream".

Angenommen, Sie haben Ihre Gabel bereits mit einem Befehl wie diesem auf Ihren Computer geklont:

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

Wenn das gegeben ist, müssen Sie in dieser Reihenfolge fortfahren:

  1. Fügen Sie das "upstream" zu Ihrem geklonten Repository hinzu ("Herkunft"):

    git remote add upstream git@github.com:original_author/project_name.git
    
  2. Holen Sie die Commits (und Zweige) von der "Upstream":

    git fetch upstream
    
  3. Wechseln Sie zum Zweig "Master" Ihrer Verzweigung ("Herkunft"):

    git checkout master
    
  4. Verstecke die Änderungen deines "Master" Zweiges:

    git stash
    
  5. Fügen Sie die Änderungen aus dem "Master" Zweig des "Upstream" in Ihren "Master" Zweig Ihres "Ursprungs" ein:

    git merge upstream/master
    
  6. Beheben Sie gegebenenfalls Zusammenführungskonflikte und binden Sie Ihre Zusammenführung ein

    git commit -am "Merged from upstream"
    
  7. Drücke die Änderungen an deiner Gabel

    git push
    
  8. Erhalten Sie Ihre verdeckten Änderungen zurück (falls vorhanden)

    git stash pop
    
  9. Sie sind fertig! Herzliche Glückwünsche!

GitHub bietet auch Anweisungen für dieses Thema: Eine Gabel synchronisieren


29
2018-03-16 12:24



Zum Zeitpunkt dieser Antwort hat GitHub nicht (oder soll ich nicht mehr sagen?) diese Funktion in der Weboberfläche. Sie können jedoch fragen support@github.com um deine Stimme dafür hinzuzufügen.

In der Zwischenzeit hat GitHub user bardiharborow ein Tool erstellt, um genau dies zu tun: https://upriver.github.io/

Quelle ist hier: https://github.com/upriver/upriver.github.io


21
2017-09-14 14:22



Wenn, wie ich, du Begehe nie etwas direkt zu beherrschen, was Sie wirklich sollten, können Sie folgendes tun.

Erstellen Sie Ihre Upstream-Remote vom lokalen Klon Ihres Forks. Sie müssen das nur einmal tun:

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

Wenn Sie den Upstream-Repository-Master-Zweig aufholen möchten, müssen Sie Folgendes tun:

git checkout master
git pull upstream master

Vorausgesetzt, Sie haben nie etwas auf Meister selbst begangen, sollten Sie bereits fertig sein. Jetzt können Sie Ihren lokalen Master zu Ihrer entfernten Remote-GitHub-Gabel schieben. Sie könnten Ihren Entwicklungszweig auch auf Ihren aktuellen lokalen Master umbuchen.

Nach der anfänglichen Upstream-Installation und dem Master-Checkout müssen Sie lediglich den folgenden Befehl ausführen, um Ihren Master mit dem Upstream zu synchronisieren: git Pull Upstream Master.


21
2018-01-03 16:59



Wenn Sie GitHub für Windows verwenden, haben sie jetzt eine Ein-Klick-Funktion zum Aktualisieren von Gabeln:

  1. Wählen Sie das Repository in der Benutzeroberfläche aus.
  2. Klicken Sie auf "Aktualisieren von Benutzer / Zweig" -Taste oben.

12
2018-03-31 21:45



Befolgen Sie die folgenden Schritte. Ich habe sie ausprobiert und es hat mir geholfen.

Checkout zu Ihrer Filiale

Syntax: git Zweig yourDevelopmentBranch
Beispiel: Git Kasse Master

Ziehen Sie den Quellenrepository-Zweig, um den neuesten Code zu erhalten

Syntax: git ziehen https://github.com/tastejs/awesome-app-ideas Meister
Beispiel: git ziehen https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git ZWEIGNAME


8
2018-01-15 12:31



Tatsächlich ist es möglich, eine Verzweigung in Ihrem Fork zu erstellen, und zwar von jedem Commit des Upstream im Browser:

  • Öffnen https://github.com/<repo>/commits/<hash>, woher Repo ist deine Gabel und Hash ist der vollständige Hash des Commits, den Sie in der Upstream-Weboberfläche finden. Zum Beispiel kann ich öffnen https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990, die auf zeigt linux  master als Zeit des Schreibens.
  • Klicken Sie auf die Schaltfläche "Baum: ....".
  • Geben Sie den Namen der neuen Filiale ein und drücken Sie Eingeben

Enter image description here

Sie können dann diese Verzweigung zu Ihrem lokalen Klon abrufen, und Sie müssen nicht alle Daten zurück an GitHub senden, wenn Sie die Bearbeitungen über diese Festschreibung hinaus schieben. Oder verwenden Sie das Webinterface, um etwas in diesem Zweig zu ändern.

Wie es funktioniert (es ist eine Vermutung, ich weiß nicht, wie genau GitHub es macht): Gabeln teilen Objektspeicher und benutzen Namespaces um die Referenzen der Benutzer zu trennen. So können Sie auf alle Commits über Ihre Verzweigung zugreifen, auch wenn sie zum Zeitpunkt der Verzweigung nicht vorhanden waren.


8
2018-01-18 06:41