Ich habe kürzlich ein Projekt gegabelt und mehrere Korrekturen vorgenommen. Ich habe dann eine Pull-Anfrage erstellt, die dann akzeptiert wurde.

Einige Tage später wurde eine weitere Änderung von einem anderen Mitwirkenden vorgenommen. Meine Gabel enthält diese Änderung also nicht.

Wie kann ich dieses Wechselgeld in meine Gabel bekommen? Muss ich meine Gabel löschen und neu erstellen, wenn ich weitere Änderungen vornehmen muss? Oder gibt es eine Update-Schaltfläche?

In Ihrem lokalen Klon Ihres gegabelten Repositorys können Sie das ursprüngliche GitHub-Repository als "Remote" hinzufügen. ("Fernbedienungen" sind wie Spitznamen für die URLs von Repositorys - originbeispielsweise eine.) Anschließend können Sie alle Zweige aus diesem Upstream-Repository abrufen und Ihre Arbeit neu starten, um die Arbeit an der Upstream-Version fortzusetzen. 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 Hauptzweigs nicht neu schreiben möchten (z. B. weil andere ihn möglicherweise geklont haben), sollten Sie den letzten Befehl durch ersetzen git merge upstream/master. Um jedoch weitere Pull-Anforderungen zu stellen, die so sauber wie möglich sind, ist es wahrscheinlich besser, die Basis neu zu erstellen.

Wenn Sie Ihren Zweig neu aufgebaut haben, müssen upstream/masterSie möglicherweise den Push erzwingen, um ihn in Ihr eigenes gegabeltes Repository auf GitHub zu verschieben. Das würdest du machen mit:

git push -f origin master

Sie müssen -fdas erste Mal erst verwenden, nachdem Sie die Basis neu festgelegt haben.

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

1. Öffne deine Gabel auf GitHub.
2. Klicken Sie auf Pull Requests.
3. Klicken Sie auf New Pull Request. Standardmäßig vergleicht GitHub das Original mit Ihrer Gabel, und es sollte nichts zu vergleichen sein, wenn Sie keine Änderungen vorgenommen haben.
4. Klicken switching the baseSie auf, wenn Sie diesen Link sehen. Andernfalls stellen Sie den base forkDropdown manuell auf Ihre Gabel und den head forkauf den Upstream ein. Jetzt vergleicht GitHub Ihre Gabel mit dem Original und Sie sollten die neuesten Änderungen sehen.
5. Create pull requestund weisen Sie Ihrer Pull-Anfrage einen vorhersehbaren Namen zu (z Update from original. B. ).
6. Scrollen Sie nach unten Merge pull request, aber klicken Sie noch nicht auf etwas.

Jetzt haben Sie drei Optionen, aber jede führt zu einem weniger sauberen Commit-Verlauf.

1. Die Standardeinstellung erstellt ein hässliches Zusammenführungs-Commit.
2. Wenn Sie auf die Dropdown-Liste klicken und "Squash and Merge" wählen, werden alle dazwischen liegenden Commits zu einem zusammengefasst. Dies ist meistens etwas, was Sie nicht wollen.
3. Wenn Sie auf klicken Rebase and merge, werden alle Commits "mit" Ihnen gemacht, die ursprünglichen PRs werden mit Ihrer PR verknüpft und GitHub wird angezeigt This branch is X commits ahead, Y commits behind <original fork>.

Ja, Sie können Ihr Repo über die GitHub-Web-Benutzeroberfläche mit dem Upstream auf dem neuesten Stand halten. Dadurch wird jedoch Ihr Commit-Verlauf beeinträchtigt. Halten Sie sich stattdessen an die Befehlszeile - es ist einfach.

Hier ist das offizielle Dokument von GitHub zum Synchronisieren einer Gabel :

Eine Gabel synchronisieren

Die Einrichtung

Bevor Sie synchronisieren können, müssen Sie eine Fernbedienung hinzufügen, die auf das Upstream-Repository verweist. Möglicherweise haben Sie dies getan, als Sie ursprünglich gegabelt haben.

Tipp: Durch die Synchronisierung Ihrer Verzweigung wird nur Ihre lokale Kopie des Repositorys aktualisiert. Ihr Repository auf GitHub wird nicht aktualisiert.

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

Synchronisieren

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

Holen

Durch das Abrufen aus dem Remote-Repository werden die Zweige und die entsprechenden Commits eingebunden. 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 jetzt den Hauptzweig des Upstreams 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

Nachdem wir das Upstream-Repository abgerufen haben, möchten wir seine Änderungen in unserer lokalen Niederlassung zusammenführen. Dadurch wird dieser Zweig mit dem Upstream synchronisiert, ohne dass unsere lokalen Änderungen verloren gehen.

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

Viele Antworten führen dazu, dass Ihr Fork One Commit vor dem übergeordneten Repository verschoben wird. Diese Antwort fasst die hier gefundenen Schritte zusammen, mit denen Sie Ihre Gabel auf das gleiche Commit wie das übergeordnete Element verschieben .

1. Wechseln Sie in Ihr lokales Repository.

   • Wechseln Sie zum Hauptzweig, wenn Sie dies nicht tun git checkout master

2. Fügen Sie das übergeordnete Element als Remote-Repository hinzu. git remote add upstream <repo-location>

3. Problem git fetch upstream

4. Problem git rebase upstream/master

   • In diesem Stadium überprüfen Sie durch Eingabe, ob festgeschrieben wird, was zusammengeführt wird git status

5. Problem git push origin master

Weitere Informationen zu diesen Befehlen finden Sie in Schritt 3 .

Wenn Sie, wie ich, niemals etwas direkt dem Meister übertragen , was Sie wirklich sollten, können Sie Folgendes tun.

Erstellen Sie aus dem lokalen Klon Ihrer Gabel Ihre Upstream-Fernbedienung. Sie müssen das nur einmal tun:

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

Wann immer Sie den Upstream-Repository-Hauptzweig einholen möchten, müssen Sie:

git checkout master
git pull upstream master

Angenommen, Sie haben selbst nie etwas für den Meister getan, sollten Sie bereits fertig sein. Jetzt können Sie Ihren lokalen Master auf Ihre ursprüngliche Remote-GitHub-Gabel schieben. Sie können Ihren Entwicklungszweig auch auf Ihrem jetzt aktuellen lokalen Master neu aufbauen.

Nach dem anfänglichen Upstream-Setup und dem Master-Checkout müssen Sie nur den folgenden Befehl ausführen, um Ihren Master mit dem Upstream zu synchronisieren: git pull upstream master .

Vorwort: Ihre Gabel ist der "Ursprung" und das Repository, aus dem Sie gegabelt haben, ist der "Upstream".

Nehmen wir an, 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 dies angegeben ist, müssen Sie in dieser Reihenfolge fortfahren:

1. Fügen Sie den "Upstream" zu Ihrem geklonten Repository hinzu ("Ursprung"):

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

2. Holen Sie sich die Commits (und Zweige) aus dem "Upstream":

   git fetch upstream
   

3. Wechseln Sie zum "Master" -Zweig Ihrer Gabel ("Ursprung"):

   git checkout master
   

4. Verstecken Sie die Änderungen Ihres "Master" -Zweigs:

   git stash
   

5. Führen Sie die Änderungen aus dem "Master" -Zweig des "Upstream" in den "Master" -Zweig Ihres "Ursprungs" ein:

   git merge upstream/master
   

6. Lösen Sie etwaige Zusammenführungskonflikte und legen Sie Ihre Zusammenführung fest

   git commit -am "Merged from upstream"
   

7. Schieben Sie die Änderungen an Ihre Gabel

   git push
   

8. Holen Sie sich Ihre versteckten Änderungen zurück (falls vorhanden)

   git stash pop
   

9. Du bist fertig! Herzliche Glückwünsche!

GitHub bietet auch Anweisungen zu diesem Thema: Synchronisieren einer Gabel

Seit November 2013 gibt es eine inoffizielle Feature-Anfrage bei GitHub, in der sie gebeten werden, eine sehr einfache und intuitive Methode hinzuzufügen, um eine lokale Abzweigung mit dem Upstream synchron zu halten:

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

Hinweis: Da die Funktionsanforderung inoffiziell ist, ist es auch ratsam, Kontakt aufzunehmen support@github.com, um Ihre Unterstützung für eine zu implementierende Funktion wie diese hinzuzufügen. Die obige inoffizielle Merkmalsanforderung könnte als Beweis für das Ausmaß des Interesses an der Umsetzung verwendet werden.

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

In der Zwischenzeit hat der GitHub-Benutzer bardiharborow ein Tool dafür erstellt: https://upriver.github.io/

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

Wenn Sie GitHub für Windows oder Mac 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 oben auf die Schaltfläche "Von Benutzer / Zweig aktualisieren".

Tatsächlich ist es möglich, aus jedem Commit des Upstreams im Browser einen Zweig in Ihrem Fork zu erstellen:

• Öffnen Sie https://github.com/<repo>/commits/<hash>, wobei Repo Ihre Abzweigung ist und Hash der vollständige Commit- Hash ist, den Sie in der Upstream-Weboberfläche finden. Zum Beispiel kann ich https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 öffnen , was auf linux masterden Zeitpunkt des Schreibens hinweist .
• Klicken Sie auf die Schaltfläche "Baum: ....".
• Geben Sie den Namen des neuen Zweigs ein und drücken Sie Enter

Sie können diesen Zweig dann zu Ihrem lokalen Klon abrufen, und Sie müssen nicht alle Daten an GitHub zurücksenden, wenn Sie Änderungen zusätzlich zu diesem Commit übertragen. Oder verwenden Sie die Weboberfläche, um etwas in diesem Zweig zu ändern.

Wie es funktioniert (es ist eine Vermutung, ich weiß nicht genau, wie GitHub es macht): Gabeln teilen den Objektspeicher und verwenden Namespaces , um Benutzerreferenzen zu trennen. Sie können also über Ihre Gabel auf alle Commits zugreifen, auch wenn diese zum Zeitpunkt des Gabelns noch nicht vorhanden waren.

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

Kasse zu Ihrer Filiale

Syntax: git branch yourDevelopmentBranch
Beispiel: git checkout master

Ziehen Sie den Quell-Repository-Zweig, um den neuesten Code abzurufen

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

Ich aktualisiere meine gegabelten Repos mit dieser einen Zeile:

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

Verwenden Sie diese Option, wenn Sie Ihrem Projekt keinen weiteren Remote-Endpunkt hinzufügen möchten, wie andere hier veröffentlichte Lösungen.

Als Ergänzung zu dieser Antwort suchte ich nach einer Möglichkeit, alle entfernten Zweige meines geklonten Repos ( Ursprungs ) von vorgelagerten Zweigen auf einmal zu aktualisieren . So habe ich es gemacht.

Dies setzt voraus, dass Sie bereits eine Upstream- Fernbedienung konfiguriert haben, die auf das Quell-Repository zeigt (von dem der Ursprung stammt), und diese mit synchronisiert haben git fetch upstream.

Dann renne:

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

Der erste Teil dieses Befehls listet alle Köpfe im Upstream- Remote-Repo auf und entfernt den SHA-1, gefolgt vom refs/heads/Präfix des Zweignamens.

Anschließend wird für jeden dieser Zweige die lokale Kopie des vorgelagerten Fernverfolgungszweigs ( refs/remotes/upstream/<branch>auf der lokalen Seite) direkt an den entfernten Zweig am Ursprung ( refs/heads/<branch>auf der entfernten Seite) gesendet.

Jeder dieser Verzweigungssynchronisierungsbefehle kann aus einem von zwei Gründen fehlschlagen: Entweder wurde der Upstream- Zweig neu geschrieben, oder Sie haben Commits für diesen Zweig an Ihre Verzweigung gesendet. Im ersten Fall, in dem Sie dem Zweig Ihrer Gabel nichts zugewiesen haben, können Sie sicher kräftig drücken (Fügen Sie den Schalter -f hinzu , dh git push -fim obigen Befehl). Im anderen Fall ist dies normal, da Ihr Gabelzweig auseinander gegangen ist und Sie nicht erwarten können, dass der Synchronisierungsbefehl funktioniert, bis Ihre Commits wieder in den Upstream zusammengeführt wurden .

Die "Pull" App ist eine automatische Lösung zum Einrichten und Vergessen. Der Standardzweig Ihrer Gabel wird mit dem Upstream-Repository synchronisiert.

Besuchen Sie die URL, klicken Sie auf die grüne Schaltfläche "Installieren" und wählen Sie die Repositorys aus, in denen Sie die automatische Synchronisierung aktivieren möchten.

Der Zweig wird einmal pro Stunde direkt auf GitHub aktualisiert. Auf Ihrem lokalen Computer müssen Sie den Hauptzweig ziehen, um sicherzustellen, dass Ihre lokale Kopie synchron ist.

Android Studio hat jetzt gelernt, mit GitHub-Fork-Repositorys zu arbeiten (Sie müssen nicht einmal das "Upstream" -Remote-Repository per Konsolenbefehl hinzufügen).

Öffnen Sie das Menü VCS → Git

Beachten Sie auch die beiden letzten Popup-Menüpunkte:

• Rebase meine GitHub Gabel

• Pull-Anfrage erstellen

Versuch sie. Ich verwende das erste, um mein lokales Repository zu synchronisieren. Auf jeden Fall können Sie auf die Zweige des übergeordneten Remote-Repositorys ("Upstream") in Android Studio zugreifen, nachdem Sie auf "Rebase my GitHub fork" geklickt haben, und Sie können problemlos mit ihnen arbeiten.

(Ich verwende Android Studio 3.0 mit den Plugins "Git Integration" und "GitHub".)

Wenn Sie Ihr gegabeltes Repository geklont haben, wechseln Sie zu dem Verzeichnispfad, in dem sich Ihr Klon befindet, und zu den wenigen Zeilen in Ihrem Git Bash Terminal.

$ 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

Und los geht's. Alle aktualisierten Änderungen im Haupt-Repository werden in Ihr Fork-Repository übertragen.

Der Befehl "Abrufen" ist unverzichtbar, um in einem Projekt auf dem neuesten Stand zu bleiben: Nur wenn Sie einen "Git-Abruf" durchführen, werden Sie über die Änderungen informiert, die Ihre Kollegen auf den Remote-Server übertragen haben.

Sie können hier noch weitere Fragen stellen

Wenn Sie Ihren Upstream einstellen. Überprüfen Sie mit git remote -v, dann wird dies ausreichen.

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

Das hängt von der Größe Ihres Repositorys ab und davon, wie Sie es gegabelt haben.

Wenn es sich um ein ziemlich großes Repository handelt, möchten Sie es möglicherweise auf besondere Weise verwalten (z. B. Drop-Verlauf). Grundsätzlich können Sie Unterschiede zwischen aktuellen und vorgelagerten Versionen feststellen, diese festschreiben und dann zum Master zurückkehren.

Versuchen Sie, dieses zu lesen . Es wird beschrieben, wie große Git-Repositorys behandelt und mit den neuesten Änderungen vorgelagert werden.

Ich möchte die Antwort von @ krlmlr ergänzen .

Anfänglich hat das gegabelte Repository einen Zweig mit dem Namen : master. Wenn Sie an einer neuen Funktion oder einem Fix arbeiten, erstellen Sie im Allgemeinen einen neuen Zweig featureund nehmen die Änderungen vor.

Wenn Sie möchten, dass das gegabelte Repository mit dem übergeordneten Repository synchronisiert ist, können Sie eine Konfigurationsdatei ( pull.yml) für die Pull-App ( im Feature-Zweig ) wie folgt einrichten :

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

Dies hält den masterZweig des gegabelten Repos mit dem übergeordneten Repo auf dem neuesten Stand. Es hält den featureZweig des gegabelten Repos über den masterZweig des gegabelten Repos auf dem neuesten Stand, indem es zusammengeführt wird. Dies setzt voraus, dass der featureZweig der Standardzweig ist, der die Konfigurationsdatei enthält.

Hier sind zwei mergemethodsim Spiel, eine hardresethilft dabei, Synchronisierungsänderungen im masterZweig des gegabelten Repos mit dem übergeordneten Repo zu erzwingen, und die andere Methode ist merge. Diese Methode wird verwendet, um von Ihnen in der featureVerzweigung vorgenommene Änderungen und Änderungen, die aufgrund der erzwungenen Synchronisierung in der masterVerzweigung vorgenommen wurden, zusammenzuführen. Im Falle eines Zusammenführungskonflikts können Sie mit der Pull-App die nächste Vorgehensweise während der Pull-Anforderung auswählen.

Sie können über grundlegende und erweiterte Konfigurationen lesen und verschiedene mergemethods hier .

Ich verwende diese Konfiguration derzeit in meinem gegabelten Repo hier , um sicherzustellen, dass eine hier angeforderte Verbesserung auf dem neuesten Stand bleibt.

Es gibt zwei wichtige Dinge, um ein gegabeltes Repository immer für immer zu aktualisieren.

1. Erstellen Sie die Zweige vom Gabelmaster und nehmen Sie dort Änderungen vor .

Wenn Ihre Pull-Anfrage akzeptiert wird, können Sie den Zweig sicher löschen, da Ihr beigetragener Code dann in Ihrem Master Ihres gegabelten Repositorys gespeichert wird, wenn Sie ihn mit dem Upstream aktualisieren. Auf diese Weise befindet sich Ihr Master immer in einem sauberen Zustand, um einen neuen Zweig für eine weitere Änderung zu erstellen.

2. Erstellen Sie einen geplanten Job, damit der Gabelmaster die Aktualisierung automatisch durchführt .

Dies kann mit cron erfolgen . Hier ist ein Beispielcode, wenn Sie es unter Linux tun.

$ crontab -e

Setzen Sie diesen Code auf crontab file, um den Job stündlich auszuführen.

0 * * * * sh ~/cron.sh

Erstellen Sie dann die cron.shSkriptdatei und eine Git-Interaktion mit ssh-agent und / oder erwarten Sie wie folgt

#!/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`

Überprüfen Sie Ihr gegabeltes Repository. Von Zeit zu Zeit wird immer diese Benachrichtigung angezeigt:

Dieser Zweig ist gerade mit <upstream>: master .

Verwenden Sie diese Befehle (im Glück)

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