git - Hoe update of synchroniseer ik een gevorkte repository op GitHub?

Ik heb een project geforked, verschillende fixes toegepast en een pull-verzoek gemaakt dat werd geaccepteerd. Een paar dagen later werd er nog een wijziging aangebracht door een andere bijdrager. Dus mijn fork bevat die wijziging niet.

Hoe krijg ik dat wisselgeld in mijn vork? Moet ik mijn fork verwijderen en opnieuw maken als ik verdere wijzigingen heb om bij te dragen? Of is er een update-knop?

Antwoord 1, autoriteit 100%

In uw lokale kloon van uw gevorkte repository kunt u de originele GitHub-repository als een “remote” toevoegen. (“Afstandsbedieningen” zijn als bijnamen voor de URL’s van repositories – originis er bijvoorbeeld een.) Dan kun je alle branches ophalen uit die upstream-repository en je werk rebasen om verder te werken aan de upstream versie. In termen van commando’s die eruit kunnen zien als:

# 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
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

Als je de geschiedenis van je master branch niet wilt herschrijven, (bijvoorbeeld omdat andere mensen het misschien hebben gekloond), dan moet je het laatste commando vervangen door git merge upstream/master. Voor het maken van verdere pull-verzoeken die zo schoon mogelijk zijn, is het waarschijnlijk beter om te rebasen.

Als je je branch opnieuw hebt gebasseerd op upstream/master, moet je de push mogelijk forceren om het naar je eigen gevorkte repository op GitHub te pushen. Dat zou je doen met:

git push -f origin master

U hoeft alleen de -fde eerste keer nadat u opnieuw hebt bereikt.

2, Autoriteit 17%

Vanaf mei 2014 is het mogelijk om een vork rechtstreeks van GitHub bij te werken. Dit werkt nog steeds vanaf september 2017, maar het zal leiden tot een vuile beginsituatie.

Open je vork op Github.
Klik op Pull-aanvragen .
Klik op Nieuwe pull-aanvraag . Standaard vergelijkt GitHub het origineel met uw vork, en er zou niets moeten zijn om te vergelijken als u geen wijzigingen aanbrengt.
Klik op De basis schakelen Als u die link ziet. Anders, handmatig de Basisvork instellen DRUP NAAR UW VORKEN EN DE HOOFDVORK NAAR DE UITSTREKKING. Nu zal Github uw vork vergelijken met het origineel en u moet de nieuwste wijzigingen zien.
Pull-aanvraag maken en wijs een voorspelbare naam toe aan uw pull-aanvraag (bijvoorbeeld Update from original).
Scroll naar beneden naar Merge Pull-aanvraag , maar klik nog niet op iets.

Nu heb je drie opties, maar elk zal ertoe leiden tot een minder dan-schone beginsituatie.

De standaardinstelling zal een lelijke samenvoeging commit maken.
Als u op de vervolgkeuzelijst klikt en "Squash and Merge" kiest, worden alle tussenliggende commits in één ingepakt. Dit is meestal iets dat je niet wilt.
Als u op Rebase en samenvoegt , worden alle commits "met" u gemaakt, de originele PRS zal linken naar uw PR en GITHUB wordt weergegeven This branch is X commits ahead, Y commits behind <original fork>.

Dus ja, je kunt je repo upstream upstream houden met behulp van de GitHub web-UI, maar dit zal je commit-geschiedenis bezoedelen. Blijf in plaats daarvan bij de opdrachtregel- het is gemakkelijk.

Antwoord 3, autoriteit 11%

Hier is het officiële document van GitHub over Een vork synchroniseren:

Een vork synchroniseren

De installatie

Voordat u kunt synchroniseren, moet u een afstandsbediening toevoegen die naar de upstream-repository verwijst. Je hebt dit misschien gedaan toen je oorspronkelijk forkte.

Tip: Door uw fork te synchroniseren, wordt alleen uw lokale kopie van de repository bijgewerkt; het werkt je repository op GitHub niet bij.
$ 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)
Synchroniseren

Er zijn twee stappen nodig om je repository te synchroniseren met de upstream: eerst moet je ophalen van de remote, daarna moet je de gewenste branch mergen in je lokale branch.

Ophalen

Het ophalen van de externe repository zal zijn branches en hun respectievelijke commits binnenbrengen. Deze worden opgeslagen in uw lokale repository onder speciale filialen.
$ 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
We hebben nu de master branch van de upstream opgeslagen in een lokale branch, 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
Samenvoegen

Nu we de upstream-repository hebben opgehaald, willen we de wijzigingen samenvoegen met onze lokale branch. Dit zal die vertakking synchroniseren met de stroomopwaartse, zonder onze lokale wijzigingen te verliezen.
$ 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
Als je lokale branch geen unieke commits had, zal git in plaats daarvan een "fast-forward" uitvoeren:
$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
Tip: als je je repository op GitHub wilt bijwerken, volg dan de instructies hier

Antwoord 4, autoriteit 3%

Veel antwoorden zorgen ervoor dat je fork één commit vooruitvan de bovenliggende repository wordt verplaatst. Dit antwoord vat de stappen samen die hierzijn gevonden en die verplaats je vork naar dezelfde commit als de ouder.

Verander de map in uw lokale repository.
- Schakel over naar master branch als je geen git checkout master
Voeg de ouder toe als een externe repository, git remote add upstream <repo-location>
Probleem git fetch upstream
Probleem git rebase upstream/master
- In dit stadium controleer je welke commits wat zullen worden samengevoegd door git status
Probleem git push origin master

Voor meer informatie over deze commando's, zie step 3.

Antwoord 5

Als je, net als ik, nooit iets rechtstreeks vastlegt om te masteren, wat eigenlijk wel zou moeten, kun je het volgende doen.

Maak vanuit de lokale kloon van je vork je upstream-afstandsbediening. U hoeft dat maar één keer te doen:

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

Als je dan de upstream repository master branch wilt inhalen, moet je:

git checkout master
git pull upstream master

Ervan uitgaande dat je zelf nooit iets op master hebt gepleegd, zou je al klaar moeten zijn. Nu kunt u uw lokale master naar uw oorspronkelijke GitHub-vork op afstand pushen. Je zou ook je ontwikkelingsbranch kunnen rebasen op je nu up-to-date lokale master.

Na de initiële upstream-configuratie en master checkout, hoef je alleen maar het volgende commando uit te voeren om je master met upstream te synchroniseren: git pull upstream master.

Antwoord 6

Voorwoord:je fork is de "oorsprong" en de repository waaruit je hebt geforkt is de "upstream".

Laten we aannemen dat je je fork al naar je computer hebt gekloond met een commando als dit:

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

Als dat wordt gegeven, moet u in deze volgorde verder gaan:

Voeg de "upstream" toe aan uw gekloonde repository ("oorsprong"):

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

Haal de commits (en branches) op uit de "upstream":
```
git fetch upstream
```
Schakel over naar de "master" branch van je fork ("origin"):
```
git checkout master
```
Stash de wijzigingen van je "master" branch:
```
git stash
```
Samenvoeg de wijzigingen van de "master" branch van de "upstream" in de "master" branch van uw "origin":
```
git merge upstream/master
```
Los eventuele samenvoegconflicten op en leg je samenvoeging vast
```
git commit -am "Merged from upstream"
```
Duw de wijzigingen naar je vork
```
git push
```
Haal uw opgeslagen wijzigingen terug (indien aanwezig)
```
git stash pop
```
Je bent klaar! Gefeliciteerd!

GitHub biedt ook instructies voor dit onderwerp: Een vork synchroniseren

Antwoord 7

Sinds november 2013 is er een onofficiële functieaanvraag geopend met GitHub om hen te vragen om een zeer eenvoudige en intuïtieve methode toe te voegen om een lokale vork in synchronisatie te houden met stroomopwaarts:

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

OPMERKING: Aangezien het feature-aanvraag niet officieel is, is het ook aan te raden om contact op te nemen met [email protected]om uw ondersteuning voor een te implementeren functie toe te voegen. Het onofficiële aanvraag hierboven kan worden gebruikt als bewijs van het bedrag van de belangstelling voor geïmplementeerd.

8

Vanaf de datum van dit antwoord, Github heeft het niet (of zal ik niet langer zeggen? ) deze functie in de webinterface. U kunt echter [email protected]vragen om uw stem voor te voegen.

In de tussentijd heeft GitHub-gebruiker Bardiharborow een hulpmiddel gemaakt om dit te doen:
https://upriver.github.io/

Bron is hier: https://github.com/upriver/upriR.github.io

9

Als u GitHub voor Windows of Mac gebruikt, hebben ze nu een functie met één klik om vorken bij te werken:

Selecteer de repository in de UI.
Klik op "Update van gebruiker / filiaal" knop de bovenkant.

10

Er is een manier om het te doen van de webapp van Github.

Laten we door het volgende voorbeeld gaan.

Open de repo die u wilt bijwerken.

Men kan de waarschuwing zien

Deze tak is 157 commits achter GoogleCloudplatform: Master.

Rechts zijn er twee knoppen Pull requesten Compare. Druk op Compare.

Omdat er waarschijnlijk niets te vergelijken is, drukt u op switching the base

Er verschijnt een lijst met alle wijzigingen en men kan een pull-aanvraag maken door op de knop Create pull request

te drukken

Geef het een titel, laten we zeggen "Repo bijwerken"

En maak het pull-verzoek.

Zodra het verzoek is gemaakt, scrolt u naar beneden en drukt u op Merge pull request.

Bevestig de samenvoeging en dat is alles!

Antwoord 11

Ik update mijn gevorkte repo's met deze ene regel:

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

Gebruik dit als u geen ander extern eindpunt aan uw project wilt toevoegen, zoals andere oplossingen hier hebben gepost.

Antwoord 12

Volg de onderstaande stappen. Ik heb ze geprobeerd en het heeft me geholpen.

Afrekenen naar uw filiaal

Syntaxis:git branch yourDevelopmentBranch
Voorbeeld:git checkout master

Trek de bronbronvertakking om de nieuwste code te verkrijgen

Syntaxis:git pull https://github.com/tastejs /awesome-app-ideasmeester
Voorbeeld:git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.gitBRANCH_NAME

Antwoord 13

Als aanvulling op dit antwoord was ik op zoek naar een manier om alle remote branches van mijn gekloonde repo (oorsprong) van upstreambranches in één keer bij te werken. Dit is hoe ik het deed.

Dit veronderstelt dat je al een upstreamremote hebt geconfigureerd die naar de source repository wijst (waar oorsprongvandaan kwam) en deze hebt gesynchroniseerd met git fetch upstream.

Voer vervolgens uit:

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

Het eerste deel van dit commando geeft een lijst van alle heads in de upstreamremote repo en verwijdert de SHA-1 gevolgd door refs/heads/branch name prefix.

Vervolgens pusht het voor elk van deze branches de lokale kopie van de upstreamremote tracking branch (refs/remotes/upstream/<branch>aan de lokale kant) rechtstreeks naar de remote branch op origin(refs/heads/<branch>op remote side).

Elk van deze branch sync commando's kan om een van de volgende twee redenen mislukken: of de upstreambranch is herschreven, of je hebt commits op die branch naar je fork gepusht. In het eerste geval dat je niets hebt vastgelegd in de branch op je fork, is het veilig om krachtig te pushen (Voeg de -fswitch toe; dwz git push -fin de opdracht hierboven). In het andere geval is dit normaal, omdat je fork-branch is gedivergeerd en je niet kunt verwachten dat het sync-commando werkt totdat je commits weer zijn samengevoegd in upstream.

Antwoord 14

GitHub heeft nu een functie geïntroduceerd om een fork met één klik op de knop te synchroniseren.

Ga naar uw vork, klik op Fetch upstreamen klik vervolgens op Fetch and mergeom direct te synchroniseren uw vork met zijn ouder Repo.

U kunt ook op de Compare-knop om de wijzigingen te vergelijken voor het samenvoegen.

Referentie : Github's Tweet

15

De "Trek"-app is een automatische set-up-en-vergeten oplossing. Het synchroniseert de standaardtak van uw vork met de upstream-repository.

Bezoek de URL, klik op de knop Groene "Installeren" en selecteer de repositories waar u automatische synchronisatie wilt inschakelen.

Het filiaal wordt eenmaal per uur per uur bijgewerkt op GitHub, op uw lokale machine die u nodig hebt om de hoofdtak te trekken om ervoor te zorgen dat uw lokale kopie synchroon is.

16

Als u uw stroomopwaarts instelt. Neem contact op met git remote -v, dan is dit voldoende.

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

17

Wanneer u uw gevorkte repository hebt gekloneerd, gaat u naar het directorypad waar uw kloon zich bevindt en de paar regels in uw 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

En daar ben je klaar om te gaan. Alle bijgewerkte wijzigingen in de hoofdrepository worden naar uw fork-repository gepusht.

Het "fetch"-commando is onmisbaar om up-to-date te blijven in een project: alleen wanneer u een "git fetch" uitvoert, wordt u geïnformeerd over de wijzigingen die uw collega's naar de externe server hebben doorgevoerd.

Je kunt hiernog steeds bezoeken voor verdere vragen

Antwoord 18

Android Studio heeft nu geleerd om te werken met GitHub fork-repository's (je hoeft niet eens "upstream" remote repository toe te voegen via console-opdracht).

Open menu VCS→ Git

En let op de twee laatste pop-upmenu-items:

Rebase mijn GitHub-vork
Pulverzoek maken

Probeer ze. Ik gebruik de eerste om mijn lokale repository te synchroniseren. Hoe dan ook, de branches van de bovenliggende externe repository ("upstream") zijn toegankelijk in Android Studio nadat je op "Rebase my GitHub fork" hebt geklikt, en je kunt er gemakkelijk mee werken.

(Ik gebruik Android Studio 3.0 met plug-ins voor "Git-integratie" en "GitHub".)

Antwoord 19

Dat hangt af van de grootte van je repository en hoe je het hebt geforkt.

Als het een vrij grote repository is, wilde je het misschien op een speciale manier beheren (bijv. drop-geschiedenis). In principe kun je verschillen tussen huidige en upstream-versies krijgen, ze committen en vervolgens cherry pick-up terug om het onder de knie te krijgen.

Probeer het lezen van deze . Het beschrijft hoe om te gaan groot Git repositories en hoe ze stroomopwaarts met de nieuwste wijzigingen.

20

Ik zou graag op voeg toe aan @ krlmlr is antwoord .

In eerste instantie, de gevorkte repository heeft een branch genaamd: master. Als u werkt aan een nieuwe functie of een moeilijke situatie, zou u over het algemeen een nieuwe tak featureen maak de wijzigingen.

Als u wilt dat de gevorkte repository te worden gesynchroniseerd met de ouder repository, kunt u het opzetten van een configuratiebestand (pull.yml) voor de pull app (in de functie tak ), zoals deze:

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

Dit houdt de mastertak van de gevorkte repo up-to-date met de ouder repo. Het houdt de featuretak van de gevorkte repo op de hoogte via de mastertak van de gevorkte repo door het samenvoegen van hetzelfde. Dit veronderstelt dat de featurebranch is de standaardvertakking waarin het configuratiebestand bevat.

Hier zijn twee mergemethodsin het spel, één is hardresetdie helpt bij het forceren van synchronisatiewijzigingen in de master-tak van de gevorkte repo met de ouder repo en de andere methode is merge. Deze methode wordt gebruikt om door jou aangebrachte wijzigingen in de featurebranch samen te voegen en wijzigingen die zijn aangebracht als gevolg van geforceerde synchronisatie in de masterbranch. In het geval van een samenvoegconflict, kun je met de pull-app de volgende actie kiezen tijdens het pull-verzoek.

Je kunt lezen over basis- en geavanceerde configuraties en verschillende mergemethodshier.

Ik gebruik deze configuratie momenteel in mijn gevorkte repo hierom er zeker van te zijn dat een verbetering aangevraagd hierblijft op de hoogte.

Antwoord 21

Ervan uitgaande dat uw fork https://github.com/me/foobaris en de originele repository https://github.com/someone/foobar

Bezoek https://github.com/me /foobar/compare/master...iemand:master
Als je de groene tekst Able to mergeziet, druk dan op Create pull request
Scroll op de volgende pagina naar de onderkant van de pagina en klik op Optrekverzoek samenvoegenen Samenvoeging bevestigen.

Antwoord 22

Er zijn twee belangrijke dingen om een gevorkte repository altijd voor altijd te updaten.

1. Maak de branchesvan de forkmaster en breng daar wijzigingen aan.

Dus wanneer uw Pull Requestis geaccepteerd, kunt u de branch veilig verwijderen, aangezien uw bijgedragen code dan live zal zijn in uw master van uw gevorkte repository wanneer u deze bijwerkt met de upstream. Hierdoor zal je master altijd in schone staat zijn om een nieuwe branch te maken om nog een wijziging aan te brengen.

2. Maak een geplande taakvoor de vorkmaster om automatisch te updaten.

Dit kan gedaan worden met cron. Hier is een voorbeeldcode als je het in linux doet.

$ crontab -e

zet deze code in het crontab fileom de taak op uurbasis uit te voeren.

0 * * * * sh ~/cron.sh

maak vervolgens het cron.sh-scriptbestand en een git-interactiemet ssh-agenten/of verwachtenzoals hieronder

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="[email protected]:<username>/$REPOSITORY.git"   
[email protected]:<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`

Controleer uw gevorkte repository. Van tijd tot tijd wordt deze melding altijd weergegeven:

Deze branch is zelfs met <upstream>:master.

Antwoord 23

Gebruik deze commando's (in het gelukkige geval)

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

Antwoord 24

rm -rf oldrepository
git clone ...

Er zijn misschien subtielere opties, maar het is de enige manier waarop ik er zeker van kan zijn dat mijn lokale repository hetzelfde is als stroomopwaarts.

Antwoord 25

Probeer dit, klik op "Upstream ophalen" om uw gevorkte repo te synchroniseren met de upstream-master.

Antwoord 26

Als u GitHub Desktop gebruikt, kunt u dit gemakkelijk doen in slechts 6 stappen (eigenlijk slechts 5).

Zodra u Github Desktop opent en uw repository kiest,

Ga naar het tabblad Geschiedenis
Klik op de zoekbalk. Het toont u alle beschikbare vestigingen (inclusief
stroomopwaartse vertakkingen van bovenliggende repository)
Selecteer de respectieve upstream-tak (het zal upstream/master zijn om master te synchroniseren)
tak)
(OPTIONEEL) Het zal je alle commits in de upstream branch laten zien. U kunt klikken op
elke commit om de wijzigingen te zien.
Klik op Samenvoegen in master/ branch-name, gebaseerd op je actieve branch.
Wacht tot GitHub Desktop de magie doet.

Bekijk de GIF hieronder als voorbeeld:

Antwoord 27

Verwijder je externe ontwikkelaar van de github-pagina

pas dan deze commando's toe:

1) git branch -D dev
2) git fetch upstream
3) git checkout master
4) git fetch upstream && git fetch upstream --prune && git rebase upstream/master && git push -f origin master
5) git checkout -b dev
6) git push origin dev
7) git fetch upstream && git fetch upstream --prune && git rebase upstream/dev && 8) git push -f origin dev

Antwoord 28

Als je je GitHub-forks up-to-date wilt houden met de respectieve upstreams, bestaat er ook specifiek dit probotprogramma voor GitHub: https://probot.github.io/apps/pull/die het werk doet.
Je zou installatie in je account moeten toestaan en het zal je vorken up-to-date houden.

Antwoord 29

Hoe update je je gevorkte repo op je lokale computer?

Controleer eerst uw afstandsbediening/master

git remote -v

Je moet origin en upstream hebben. Bijvoorbeeld:

origin  https://github.com/your___name/kredis.git (fetch)
origin  https://github.com/your___name/kredis.git (push)
upstream    https://github.com/rails/kredis.git (fetch)
upstream    https://github.com/rails/kredis.git (push)

Ga daarna naar hoofdmenu:

git checkout main

en samenvoegen van upstream naar main:

git merge upstream/main

Hoe update of synchroniseer ik een gevorkte repository op GitHub?

Antwoord 1, autoriteit 100%

2, Autoriteit 17%

Antwoord 3, autoriteit 11%

Een vork synchroniseren

De installatie

Synchroniseren

Ophalen

Samenvoegen