Jak zaktualizować rozgałęzione repozytorium GitHub?

niedawno разветвил projekt i zastosował kilka poprawek. Następnie stworzyłem wniosek, który następnie został przyjęty.

przez kilka dni inna zmiana została wykonana przez inną osobę. Tak, że moja wtyczka nie zawiera tej zmiany.

Jak mogę uzyskać to zmiana w moją wtyczkę? Czy należy usunąć i ponownie utworzyć wtyczkę, kiedy mam dodatkowe zmiany? Lub jest przycisk aktualizacji?


w lokalnym klonu swojego раздвоенного repozytorium można dodać oryginalny repozytorium GitHub jako "zdalnego". ("Remotes" - to pseudonimy dla adresów repozytoriów -origin - jeden, na przykład. Następnie można uzyskać wszystkie gałęzie z tego nadrzędnego repozytorium i przenieść swoją pracę, aby kontynuować pracę nad wyższej wersji. Z punktu widzenia zespołów, które mogą wyglądać tak:

# 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

jeśli nie chcesz przepisywać historię swojej głównej gałęzi (na przykład dlatego, że inni ludzie, być może, sklonowany), to musisz wymienić ostatnią komendę na git merge upstream/master. Jednak do tworzenia zaawansowanych zapytań na rozciąganie, które są najbardziej czyste, chyba lepiej przenieść.


jeśli перебазировали swój oddział na upstream/master może trzeba wymusić nacisnąć, aby skłonić go do własnego разветвленному repozytorium na GitHub. Można by zrobili to:

git push -f origin master

trzeba tylko użyć -f po raz pierwszy po ponownym uruchomieniu.


od maja 2014 roku, można zaktualizować wtyczkę bezpośrednio z GitHub. To nadal działa według stanu na wrzesień 2017, ale to doprowadzi do brudnej historii commits.

  1. otwórz wtyczkę na GitHub.
  2. nacisnąć przycisk Wnioski.
  3. nacisnąć przycisk Nowy Pull-Wniosek. Domyślnie GitHub będzie porównywać oryginał z twojej widelcem, i nie powinno być nic, aby porównać, jeśli nie zrobili nic zmiana.
  4. klik przełączanie bazy jeśli widzisz ten link. W przeciwnym razie należy ręcznie zainstalować podstawowa wtyczka przejdź do wtyczki, i rozdział widelec w górę rzeki. Teraz GitHub będzie porównywać wtyczkę z oryginałem, a zobaczysz wszystkie najnowsze zmiany. enter image description here
  5. utwórz pull-wniosek i przypisz przewidywalne nazwa państwa życzenie pull (np.Update from original).
  6. zwój do zapytanie fuzja ale na razie nic nie naciskaj.

teraz masz trzy opcje, ale każdy z nich prowadzić do mniej niż czystej historii zatwierdzenia.

  1. domyślnie tworzy brzydkie blokada korespondencji seryjnej.
  2. jeśli trafisz na listę rozwijaną i wybierz "squash i fuzji", wszystkie tymczasowe zmiany zostaną zgniecione w jeden. Najczęściej tego nie chcesz.
  3. wybierz przenieść i połączyć wszystkie zmiany będą wykonane "z" wami, oryginalny PRs będzie powoływać się na swój PR, GitHub i wyświetli This branch is X commits ahead, Y commits behind <original fork>.

tak, możesz aktualizować swoje REPO z pomocą wschodzącego przepływu za pomocą interfejsu www GitHub, ale to запятнает swoją historię zatwierdzenia. Trzymaj się wiersz polecenia zamiast tego-to po prostu.


oto oficjalny dokument GitHub na synchronizacja wtyczki:

synchronizacja wtyczki

Ustawienia

zanim będzie można synchronizować, trzeba dodać pilot, który wskazuje na serwerze repozytorium. Być może zrobili to, gdy początkowo раздвоились.

Wskazówka: synchronizacja wtyczki aktualizuje tylko w lokalnej kopii 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 z repozytorium wznoszącym: najpierw trzeba wyjąć z zdalnego, a następnie należy połączyć odpowiednią gałąź w lokalną gałąź.

Fetching

pobieranie z repozytorium zdalnego doprowadzi do jego oddziałów i ich odpowiednim коммитам. Są one przechowywane w lokalnym repozytorium w specjalnych gałęziach.

$ 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

teraz mamy główna gałąź w górę rzeki są przechowywane 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

korespondencja seryjna

teraz, kiedy otrzymaliśmy serwerze repozytorium, chcemy połączyć jego zmiany w naszą lokalną gałąź. To doprowadzi do synchronizacji tej gałęzi z wydmuchem górą, nie tracąc 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 lokalnej gałęzi nie było unikalnych commits, git zamiast tego wykonuje "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, aby uaktualnić swój repozytorium na GitHub, postępuj zgodnie z instrukcjami wyświetlanymi tutaj


wiele odpowiedzi, w końcu przenoszenie wtyczki jeden commit przed nadrzędnego repozytorium. Ta odpowiedź streszcza znalezione kroki tutajprzesuń wtyczkę na tej samej utrwalenie, że i nadrzędny.

  1. zmień katalog na lokalnym repozytorium.

    • przełącz na master branch, jeśli nie git checkout master
  2. dodaj rodzica jako repozytorium zdalnego, git remote add upstream <repo-location>

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

    • na tym etapie sprawdzić, co rejestruje to, że będą one połączone, wpisując git status
  5. pytanie git push origin master

więcej informacji na temat tych poleceń można znaleźć W sekcji Krok 3:.


Od listopada 2013 roku był nieoficjalny żądanie funkcji otwarty z GitHub, aby poprosić ich, aby dodać bardzo prosty i intuicyjny sposób, aby zachować lokalną wtyczkę do synchronizacji z upstream:

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

Uwaga: ponieważ żądanie funkcji jest nieoficjalny, również należy skontaktować się z [email protected] aby dodać obsługę takiej funkcji, która będzie zrealizowana. Nieoficjalne żądanie może zostać wykorzystane jako dowód z kwoty odsetek na to odbywa.


wstęp: widelec-to "pochodzenie" i repozytoriów rozwidlony na "w górę".

załóżmy, że sklonowano już swoją wtyczkę na swój komputer za pomocą tego polecenia:

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

jeśli jest to podane, to trzeba kontynuować w tej kolejności:

  1. dodaj "upstream" w swój sklonowany repozytorium ("origin"):

    git remote add upstream [email protected]:original_author/project_name.git
    
  2. próbka commits (i gałęzie) od "upstream":

    git fetch upstream
    
  3. przełącz na gałąź "master" twojej wtyczki ("origin"):

    git checkout master
    
  4. Stash zmiany swojej gałęzi master":

    git stash
    
  5. połącz zmiany z gałęzi "master ""w górę rzeki " w swoją gałąź" master "swojego " pochodzenia":

    git merge upstream/master
    
  6. rozwiązywać konflikty korespondencji seryjnej, jeśli w ogóle, i zablokować fuzja

    git commit -am "Merged from upstream"
    
  7. kliknij zmian na wtyczkę

    git push
    
  8. odzyskaj swoje ukryte zmiany (jeśli są)

    git stash pop
    
  9. brawo! Gratulacje!

GitHub zapewnia również instrukcje na ten temat: synchronizacja wtyczki


Jeśli, jak ja, pan nigdy nic nie powierzaj bezpośrednio mistrza, który naprawdę trzeba, można wykonać następujące czynności.

z lokalnego klon twojej wtyczki stwórz swój nadrzędny pilot zdalnego sterowania. Musisz zrobić to tylko raz:

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

następnie, gdy chcesz dogonić główną gałąź przełożonego repozytorium, trzeba:

git checkout master
git pull upstream master

zakładając, że nigdy nic nie zarobili na kreatorze siebie, trzeba być już wykonane. Teraz możesz kliknąć twój lokalny mistrz na swoje źródło, zdalny na GitHub fork. Można również przenieść swoją gałąź rozwoju na swoim nowym lokalnym kreatorze.

w ten sposób, po początkowej instalacji w górę rzeki i Master checkout, wszystko, co musisz zrobić, to uruchomić następujące polecenie, aby zsynchronizować swojego mistrza z upstream:git ciągnąć w górę rzeki master.


w dniu tej odpowiedzi GitHub nie ma (lub więcej mi nie mówić?) ta funkcja w interfejsie www. Można jednak zapytać [email protected] aby dodać swój głos za to.

w tym samym czasie, na GitHub bardiharborow użytkownik stworzył narzędzie, aby zrobić dokładnie to: https://upriver.github.io/

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


Jeśli korzystasz z GitHub dla Windows, to teraz mają funkcja jednego kliknięcia do aktualizacji wtyczek:

  1. wybierz repozytorium w interfejsie użytkownika.
  2. Kliknij przycisk" Aktualizuj od użytkownika/oddziału " u góry.

wykonaj następujące kroki. Próbowałem i mi to pomogło.

zamówienie na swój oddział

składnia: git oddział yourDevelopmentBranch
przykład: git checkout master

Pull source repository branch aby uzyskać ostatniego kodu

składnia: git pull https://github.com/tastejs/awesome-app-ideas mistrz!--10-->przykład: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME


faktycznie, można utworzyć wątek w swojej wtyczce z dowolnego ustalania wschodzącego potoku w przeglądarce:

  • otwórz https://github.com/<repo>/commits/<hash>, gdzie REPO to twoja wtyczka, i hash pełna hash commit, który można znaleźć w interfejsie www w górę. Na przykład, mogę otworzyć https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990, co wskazuje na linux master w chwili pisania tego artykułu.
  • kliknij drzewo. :..." przycisk.
  • wpisz nazwę nowej gałęzi i kliknij Enter

Enter image description here

następnie można uzyskać tę gałąź w swój lokalny klon, i nie będzie musiał zwrócić wszystkie te dane w GitHub, po kliknięciu zmiany na tej zatwierdzenia. Lub użyć interfejsu www, aby zmienić coś w tym wątku.

jak to działa (to przypuszczenie, nie wiem dokładnie, jak GitHub to robi): forks share object przechowywanie i korzystanie z przestrzeni nazw do podziału łącza użytkowników. W ten sposób można uzyskać dostęp do wszystkich коммитам przez swoją wtyczkę, nawet jeśli one nie istniały w momencie rozgałęzienia.


Ja uaktualniam swoje rozgałęzione repozytorium w jednym wierszu:

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

użyj tego, jeśli nie chcesz dodawać inne zdalnego punktu końcowego w swój projekt, jak i inne rozwiązania zamieszczone tutaj.


w dodatku do tego odpowiedzi szukałem sposób zaktualizować wszystkie usunięte gałęzie mojego klona REPO (pochodzenia od w górę gałęzie za jednym razem. Oto jak to zrobiłem.

załóżmy, że masz już skonfigurowane w górę zdalne wskazanie oryginalny repozytorium (gdzie pochodzenia był разветвлен) i synchronizowane z git fetch upstream.

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 polecenie wyświetla wszystkie głowy w w górę zdalne REPO i usuwa SHA-1, a następnie refs/heads/ oddziału prefiks nazwy.

następnie dla każdej z tych gałęzi, on pcha lokalną kopię w górę pilot zdalnego śledzenia gałęzi (refs/remotes/upstream/<branch> na lokalnej stronie) bezpośrednio w zdalną gałąź na pochodzenia (refs/heads/<branch> na zdalnej stronie).

każda z tych drużyn synchronizacji gałęzi może zakończyć się niepowodzeniem z jednego z dwóch powodów: albo w górę wątek zostały nadpisane lub naciśnięciu zatwierdzenia na tym wątku na swoją wtyczkę. W pierwszym przypadku, gdy nic nie zrobili z gałęzią na swojej wtyczki, można z siłą nacisnąć (dodaj - f przełącznik; czyli git push -f polecenia powyżej). W innym przypadku to jest normalne, tak jak twoja gałąź wtyczki rozeszła, i nie można oczekiwać, że zespół synchronizacji będzie działać, dopóki twoje zmiany nie zostaną połączone z powrotem do w górę.


Android Studio teraz nauczyłam się pracować w repozytoriach GitHub fork (nie trzeba nawet dodawać zdalnego repozytorium "w górę rzeki" konsoli poleceniem).

otwórz menu VCSGit

i zwrócić uwagę na dwa ostatnie miejsca w menu podręcznym:

  • Перебазируйте moją wtyczkę GitHub

  • Utwórz Zapytanie Pull

spróbuj je. Używam pierwszy, aby zsynchronizować mój lokalne repozytorium. W każdym razie gałęzie z nadrzędnego zdalnego repozytorium ("upstream") będą dostępne w Android Studio po naciśnięciu przycisku "Rebase my GitHub fork", i można łatwo pracować z nimi.

(używam Android Studio 3.0 z pluginami" git integration "i" GitHub".)

Enter image description here


kiedy sklonowano swój rozgałęzioną repozytorium, kliknij w ścieżkę do katalogu, gdzie znajduje się twój klon, i kilka linijek 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

i jesteś dobry, aby przejść. Wszystkie zaktualizowane zmiany w głównym repozytorium zostaną umieszczone w repozytorium fork.

zespół" fetch "jest niezbędna do tego, aby być na bieżąco z projektu: tylko podczas wykonywania "git fetch" będziesz informowany o zmianach, które twoi koledzy zachęcali do zdalnego serwer.

można jeszcze odwiedzić tutaj dla dalszych żądań


To zależy od wielkości twojego repozytorium i tego, jak go rozgałęziający.

Jeśli jest to dość duży repozytorium, może chcieli by zarządzać nim w sposób szczególny (np. historia upadku). W zasadzie może pojawić się różnice między obecnym i propagacji wersjami, zablokować je, a następnie cherry pick z powrotem do master.

spróbuj przeczytać ten. Opisano w nim sposób przetwarzać duże repozytorium Git i jak je przetwarzać z ostatnimi zmianami.