Począwszy od maja 2014, możliwe jest zaktualizowanie forka bezpośrednio z GitHub. To nadal działa od września 2017, ale doprowadzi to do brudnej historii zmian.

Otwórz Widelec na Githubie.
1. Kliknij na Pull Requests.
2. Kliknij na New Pull Request. Domyślnie GitHub porównuje oryginał z Twoim forkiem i nie powinno być nic do porównania, jeśli nie wprowadziłeś żadnych zmian.
3. Click switching the base jeśli widzisz ten link. W przeciwnym razie ręcznie ustaw widelec bazowy w dół do widelca, a widelec główny w górę. Teraz GitHub porówna Twój fork z oryginałem i powinieneś zobaczyć wszystkie najnowsze zmiany.
4. Utwórz pull request i nadaj przewidywalną nazwę żądaniu pull (np. Update from original).
5. przewiń w dół do Merge pull request , ale nie klikaj jeszcze niczego.

Teraz masz trzy opcje, ale każda z nich prowadzi do historii zatwierdzeń mniej niż czysta.

1. domyślnie utworzy brzydki commit scalający.
2. Jeśli klikniesz na listę rozwijaną i wybierzesz "Squash and merge", wszystkie zmiany zostaną zmiażdżone w jeden. To jest najczęściej coś, czego nie chcesz.
3. Jeśli klikniesz Rebase i połączysz, wszystkie commity zostaną wykonane" z " Tobą, oryginalny PRs połączy się z Twoim PR, a GitHub wyświetli This branch is X commits ahead, Y commits behind <original fork>.

Więc tak, możesz zatrzymać repo zaktualizowano go przy użyciu interfejsu WWW GitHub, ale spowoduje to splamienie historii zmian. Zamiast tego trzymaj się linii poleceń - to proste.

Oto oficjalny dokument Githuba na temat synchronizacji widelca :

Synchronizacja widelca

The Setup

Zanim będzie można zsynchronizować, musisz dodać pilota, który wskazuje na repozytorium upstream. Mogłeś to zrobić, kiedy pierwotnie rozwidlałeś.

Wskazówka: Synchronizacja forka aktualizuje tylko lokalną kopię repozytorium; nie aktualizuje repozytorium na 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)

Synchronizacja

Istnieją dwa kroki wymagane do synchronizacji repozytorium z upstream: najpierw musisz pobrać ze zdalnego, a następnie scalić żądaną gałąź do lokalnej gałęzi.

Pobieranie

Pobieranie ze zdalnego repozytorium spowoduje dodanie gałęzi i odpowiednich commitów. Są one przechowywane w lokalnym repozytorium w oddziałach specjalnych.

$ 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

Mamy teraz główną gałąź upstream przechowywaną w lokalnej gałęzi, 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

Scalanie

Teraz, gdy pobraliśmy repozytorium upstream, chcemy scalić jego zmiany do naszej lokalnej gałęzi. Spowoduje to zsynchronizowanie tej gałęzi z upstream, bez utraty naszych lokalnych zmian.

$ 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

Jeśli Twoja lokalna gałąź nie miała żadnych unikalnych commitów, git wykona "przewijanie do przodu":

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

Wskazówka: Jeśli chcesz zaktualizować swoje repozytorium na Githubie, postępuj zgodnie z instrukcjami tutaj

Wiele odpowiedzi kończy się przesunięciem twojego forka o jeden commit przed macierzystego repozytorium. Ta odpowiedź podsumowuje kroki znalezione tutaj , które przeniosą Twój Fork do tego samego commita co rodzic .

1. Zmień katalog do lokalnego repozytorium.

   • przełącz się na gałąź master jeśli nie jesteś git checkout master

2. Dodaj rodzica jako zdalne repozytorium, git remote add upstream <repo-location>

3. Wydanie git fetch upstream

4. Problem git rebase upstream/master

   • na tym etapie sprawdzasz czy commity zostaną scalone wpisując git status

5. Wydanie git push origin master

Aby uzyskać więcej informacji na temat tych poleceń, zobacz Krok 3 .

Od listopada 2013 roku istnieje nieoficjalne żądanie funkcji otwarte przez GitHub, aby poprosić ich o dodanie bardzo prostej i intuicyjnej metody synchronizacji lokalnego forka z upstream:

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

Uwaga: Ponieważ żądanie funkcji jest nieoficjalne, zaleca się również skontaktować się z [email protected], aby dodać wsparcie dla funkcji takiej jak ta, która ma zostać zaimplementowana. Powyższe nieoficjalne żądanie funkcji może być wykorzystane jako dowód wysokości odsetek w tym jest realizowane.

Przedmowa: Twój fork to "origin", a repozytorium, z którego się rozwidlałeś, to "upstream".

Załóżmy, że sklonowałeś już swój fork do swojego komputera za pomocą polecenia takiego jak:

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

Jeśli to jest podane, musisz kontynuować w tej kolejności:

1. Dodaj "upstream" do sklonowanego repozytorium ("origin"):

   git remote add upstream [email protected]:original_author/project_name.git
   

2. Pobiera commity (i gałęzie) z "pod prąd": {]}

   git fetch upstream
   

3. Przełącz na gałąź "master" swojego widelca ("origin"):

   git checkout master
   

4. Ukryj zmiany swojej gałęzi "master":

   git stash
   

5. Scal zmiany z gałęzi "master" z "upstream" do gałęzi "master" z "origin":

   git merge upstream/master
   

6. Rozwiązuj konflikty scalające, jeśli istnieją i zatwierdź połączenie

   git commit -am "Merged from upstream"
   

7. Wciśnij zmiany do widelca

   git push
   

8. Get back your stashed changes (if any)

   git stash pop
   

9. Jesteś skończony! Gratulacje!

GitHub zawiera również instrukcje dla tego tematu: Synchronizacja widelca

Jeśli, tak jak ja, nigdy nie powierzasz niczego bezpośrednio mistrzowi , co naprawdę powinieneś, możesz wykonać następujące czynności.

Z lokalnego klonu twojego forka, utwórz swój zdalny upstream. Musisz to zrobić tylko raz:

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

Wtedy, gdy chcesz nadrobić zaległości z nadrzędną gałęzią repozytorium, musisz:

git checkout master
git pull upstream master

Tak więc po wstępnej konfiguracji upstream i master checkout, wystarczy uruchomić następujące polecenie, aby zsynchronizować swój master z upstream: git pull upstream master.

Od Daty tej odpowiedzi, GitHub nie ( Czy mam powiedzieć, że już nie?) Ta funkcja w interfejsie WWW. Możesz jednak poprosić [email protected] o dodanie swojego głosu na to.

W międzyczasie, użytkownik GitHub bardiharborow stworzył narzędzie do tego: https://upriver.github.io/

Źródło jest tutaj: https://github.com/upriver/upriver.github.io

Jeśli używasz GitHub dla Windows, teraz mają one funkcję aktualizacji forków jednym kliknięciem:

1. Wybierz repozytorium w interfejsie użytkownika.
2. Kliknij przycisk "Update from user / branch" u góry.

Wykonaj poniższe kroki. Próbowałem ich i to mi pomogło.

Checkout to your branch

Składnia: Git branch yourDevelopmentBranch
Przykład: Git checkOut master

Pull source repository branch for getting the latest code

Składnia: git pull https://github.com/tastejs/awesome-app-ideas master
Przykład: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

W rzeczywistości można utworzyć gałąź w forku z dowolnego commita w przeglądarce:

• Otwórz https://github.com/<repo>/commits/<hash>, gdzie repo jest Twoim forkiem, a hash jest pełnym Hashem commita, który możesz znaleźć w interfejsie sieciowym. Na przykład, mogę otworzyć https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , co wskazuje na linux master jako czas pisania.
• Kliknij na " drzewo:...."button.
• Typ nazwa nowego oddziału i naciśnij Enter

Możesz następnie pobrać tę gałąź do swojego lokalnego klona i nie będziesz musiał wysyłać wszystkich danych z powrotem do GitHub, gdy wciśniesz zmiany na górze tego commita. Lub użyj interfejsu WWW, aby zmienić coś w tej gałęzi.

Jak to działa (domyślam się, nie wiem jak to dokładnie robi GitHub): forki współdzielą object storage i używają przestrzeni nazw do oddzielania referencji użytkowników. Więc możesz uzyskaj dostęp do wszystkich commitów za pośrednictwem forka, nawet jeśli nie istniały do czasu rozwidlenia.

Aktualizuję moje rozwidlone repos z tą jedną linijką:

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

Użyj tego, jeśli nie chcesz dodawać innego zdalnego punktu końcowego do swojego projektu, jak inne rozwiązania opublikowane tutaj.

Jako uzupełnienie tej odpowiedzi, szukałem sposobu, aby zaktualizować wszystkie zdalne gałęzie mojego sklonowanego repo ( origin) z upstream gałęziami za jednym zamachem. Tak to zrobiłem.

Zakłada to, że skonfigurowano już upstreamzdalne wskazywanie repozytorium źródłowego (gdzie origin zostało rozwidlone) i zsynchronizowano je z git fetch upstream.

Następnie uruchom:

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

Pierwsza część tego polecenia zawiera listę wszystkich głowic w upstream remote repo i usuwa SHA-1, po którym następuje prefiks nazwy gałęzi refs/heads/.

Każda z tych komend synchronizacji gałęzi może się nie udać z jednego z dwóch powodów: albogałąź upstream została przepisana, albo wcisnąłeś commity tej gałęzi do swojego forka. W pierwszym przypadku jeśli nie przypisałeś nic do gałęzi na swoim widelcu, możesz bezpiecznie nacisnąć ją siłą (Dodaj przełącznik -f, tzn. git push -f w Komendzie powyżej). W drugim przypadku jest to normalne, ponieważ twoja gałąź fork się rozeszła i nie możesz oczekiwać, że komenda sync będzie działać, dopóki twoje commity nie zostaną połączone z powrotem do upstream .

Android Studio nauczyło się teraz pracować z repozytoriami GitHub fork (nie musisz nawet dodawać zdalnego repozytorium" upstream " za pomocą polecenia konsoli).

Otwórz menu VCS → Git

I zwróć uwagę na dwie ostatnie pozycje menu:

• Rebase my GitHub fork

• Utwórz Pull Request

Spróbuj. Używam pierwszego do synchronizacji lokalnego repozytorium. Anyway the branches from the zdalne repozytorium rodzica ("upstream") będzie dostępne w Android Studio po kliknięciu "Rebase my GitHub fork" i będziesz mógł z nimi łatwo pracować.

(używam Android Studio 3.0 z wtyczkami "Git integration" i "GitHub".)

Po sklonowaniu rozwidlonego repozytorium, przejdź do ścieżki katalogu, w którym znajduje się twój klon i kilku linii w Terminalu 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

Polecenie "fetch "jest niezbędne, aby być na bieżąco w projekcie: tylko podczas wykonywania" git fetch " będziesz informowany o zmianach, które twoi koledzy wypchnęli na zdalny serwer.

Ty można jeszcze odwiedzić tutaj dla dalszych zapytań

To zależy od rozmiaru repozytorium i sposobu jego rozwidlenia.

Jeśli jest to dość duże repozytorium, być może chciałeś nim zarządzać w specjalny sposób(np. historia upuszczania). Zasadniczo można uzyskać różnice między bieżącą i upstream wersje, zatwierdzić je, a następnie cherry pick z powrotem do master.

Spróbuj przeczytać Ten . Opisuje jak obsługiwać duże repozytoria Git i jak wysyłać je z najnowszymi zmianami.