Kısa süre önce bir projeyi çatalladım ve birkaç düzeltme uyguladım. Daha sonra kabul edilen bir çekme isteği oluşturdum.

Birkaç gün sonra başka bir katılımcı tarafından başka bir değişiklik yapıldı. Yani çatalım bu değişikliği içermiyor.

Bu değişikliği çatalıma nasıl alabilirim? Katkıda bulunacak başka değişikliklerim olduğunda çatalımı silmeli ve yeniden oluşturmam gerekir mi? Yoksa bir güncelleme düğmesi var mı?

Çatallı deponuzun yerel klonuna, orijinal GitHub deposunu "uzak" olarak ekleyebilirsiniz. ("Uzaktan kumandalar", depoların URL'lerinin takma adlarına benzer - originörneğin bir tanesidir.) Ardından, bu yukarı akış deposundan tüm dalları alabilir ve yukarı akış sürümü üzerinde çalışmaya devam etmek için çalışmanızı yeniden başlatabilirsiniz. Şuna benzeyen komutlar açısından:

# 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

Ana dalınızın geçmişini yeniden yazmak istemiyorsanız (örneğin, başkaları onu klonlamış olabilir), son komutu yerine koymalısınız git merge upstream/master. Ancak, olabildiğince temiz olan daha fazla çekme isteği yapmak için, muhtemelen yeniden temellendirmek daha iyidir.

Şubenizi yeniden oluşturduysanız, Push'u upstream/masterGitHub'daki kendi çatallı deponuza itmek için zorlamanız gerekebilir. Bunu şu şekilde yaparsınız:

git push -f origin master

Sadece -filk kez tamir edildikten sonra kullanmanız gerekir .

Mayıs 2014'ten itibaren, doğrudan GitHub'dan bir çatalı güncellemek mümkündür. Bu hala Eylül 2017 itibariyle çalışıyor, ancak kirli bir taahhüt tarihine yol açacak.

1. GitHub'da çatalını aç.
2. Tıklayın Pull Requests.
3. Tıklayın New Pull Request. Varsayılan olarak GitHub orijinali çatalınızla karşılaştırır ve herhangi bir değişiklik yapmadıysanız karşılaştırılacak hiçbir şey olmamalıdır.
4. Click switching the basebu bağlantıyı görürseniz. Aksi takdirde, base forkaçılır menüyü manuel olarak çatalınıza ve head forkyukarı akış yönünde ayarlayın. Şimdi GitHub çatalınızı orijinal ile karşılaştırır ve en son değişiklikleri görmeniz gerekir.
5. Create pull requestve çekme isteğinize tahmin edilebilir bir ad atayın (ör Update from original.).
6. Sayfasına ilerleyin Merge pull request, ancak henüz hiçbir şeyi tıklamayın.

Şimdi üç seçeneğiniz var, ancak her biri temiz olmayan bir taahhüt geçmişine yol açacak.

1. Varsayılan, çirkin bir birleştirme taahhüdü oluşturur.
2. Açılır menüyü tıklayıp "Squash and merge" seçeneğini seçerseniz, araya giren tüm taahhütler bir tanesine sıkıştırılır. Bu çoğu zaman istemediğiniz bir şeydir.
3. Tıklarsanız Rebase and merge, bütün kaydedilmesini, orijinal PR sizin PR bağlanacaktır "ile" yapılacaktır ve GitHub gösterecektir This branch is X commits ahead, Y commits behind <original fork>.

Yani evet, GitHub web kullanıcı arayüzünü kullanarak repo'yu akış yukarı ile güncel tutabilirsiniz, ancak bunu yapmak taahhüt geçmişinizi somutlaştıracaktır. Stick komut satırı yerine - bu kolay.

GitHub'ın çatal senkronizasyonu ile ilgili resmi belgesi :

Çatal senkronizasyonu

Kurulum

Senkronize edebilmeniz için, yukarı akış deposuna işaret eden bir uzaktan kumanda eklemeniz gerekir. Başlangıçta çatallandığınızda bunu yapmış olabilirsiniz.

İpucu: Çatalınızı senkronize etmek, yalnızca deponun yerel kopyasını günceller; GitHub'daki havuzunuzu güncellemez.

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

Senkronize ediliyor

Deponuzu yukarı akışla senkronize etmek için iki adım gerekir: önce uzaktan kumandadan getirmeniz, ardından istediğiniz dalı yerel şubenizle birleştirmeniz gerekir.

getiriliyor

Uzak depodan getirilmesi, şubelerini ve ilgili taahhütlerini getirecektir. Bunlar, yerel şubenizde özel şubeler altında saklanır.

$ 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

Şimdi yukarı akış ana dalını yerel bir dalda, yukarı akış / ana depoda sakladık

$ 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

birleştirme

Şimdi yukarı akış deposunu getirdik, değişikliklerini yerel şubemizle birleştirmek istiyoruz. Bu, şubemizi yerel değişikliklerimizi kaybetmeden yukarı akışla senkronize edecektir.

$ 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

Yerel şubenizde benzersiz bir taahhüt yoksa git yerine "hızlı ileri sarma" gerçekleştirir:

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

İpucu: GitHub'dan üzerinde depoyu güncellemek isterseniz talimatları burada

Birçok yanıt, çatalınızı ana depodan bir adım önde hareket ettirir . Bu cevap, burada bulunan ve çatalınızı ebeveyni ile aynı çalışmaya yönlendirecek adımları özetler .

1. Dizini yerel deponuzla değiştirin.

   • Değilseniz ana şubeye geçin git checkout master

2. Üst öğeyi uzak depo olarak ekleyin, git remote add upstream <repo-location>

3. Konu git fetch upstream

4. Konu git rebase upstream/master

   • Bu aşamada yazarak birleştirilecekleri taahhüt edip etmediğinizi kontrol edersiniz git status

5. Konu git push origin master

Bu komutlar hakkında daha fazla bilgi için 3. adıma bakın .

Önsöz: Çatalınız "başlangıç ​​noktası" ve çatallandığınız depo "yukarı akış" tır.

Diyelim ki zaten çatalınızı bilgisayarınıza böyle bir komutla klonladınız:

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

Bu verilirse, bu sırayla devam etmeniz gerekir:

1. "Akış yukarı" yı klonlanmış deponuza ("orijin") ekleyin:

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

2. Taahhütleri (ve dalları) "yukarı akıştan" getir:

   git fetch upstream
   

3. Çatalınızın "ana" koluna geçin ("başlangıç ​​noktası"):

   git checkout master
   

4. "Ana" dalınızın değişikliklerini saklayın:

   git stash
   

5. "Yukarı akış" ın "ana" dalından "başlangıç ​​noktanızın" ana "dalına yaptığınız değişiklikleri birleştirin:

   git merge upstream/master
   

6. Varsa birleştirme çakışmalarını çözme ve birleştirme işleminizi gerçekleştirme

   git commit -am "Merged from upstream"
   

7. Değişiklikleri çatalına it

   git push
   

8. Depolanan değişikliklerinizi geri alma (varsa)

   git stash pop
   

9. Sen bittin! Tebrikler!

GitHub ayrıca bu konu için talimatlar sağlar: Çatal senkronizasyonu

Benim gibi, hiçbir zaman doğrudan efendiye hiçbir şey taahhüt etmezseniz, gerçekten yapmanız gereken, aşağıdakileri yapabilirsiniz.

Çatalınızın yerel klonundan yukarı akış uzaktan kumandanızı oluşturun. Bunu sadece bir kez yapmanız gerekir:

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

Sonra, akış yukarı depo ana dalını yakalamak istediğinizde şunları yapmanız gerekir:

git checkout master
git pull upstream master

Asla kendiniz için hiçbir şey yapmadığınız varsayılarak, zaten yapılmalıdır. Artık yerel ustanızı menşe uzak GitHub çatalına itebilirsiniz. Ayrıca, güncel yerel master'ınızda geliştirme dalınızı yeniden temellendirebilirsiniz.

İlk yukarı akış kurulumu ve ana ödeme işleminden sonra, tek yapmanız gereken master'ınızı yukarı akışla senkronize etmek için aşağıdaki komutu çalıştırmaktır: git pull upstream master .

Kasım 2013'ten beri GitHub ile yerel bir çatalı yukarı akışla senkronize tutmak için çok basit ve sezgisel bir yöntem eklemelerini istemek için resmi olmayan bir özellik isteği var:

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

Not: Özellik isteği gayri resmi olduğundan, bunun support@github.comgibi bir özellik için desteğinizi eklemek üzere iletişime geçmeniz de önerilir . Yukarıdaki gayri resmi özellik talebi, uygulanmakta olan faiz miktarının kanıtı olarak kullanılabilir.

Bu yanıtın tarihi itibariyle, GitHub web arayüzünde bu özelliğe sahip değildir ( ya da artık söylemeyeceğim mi? ). Bununla birlikte, bunun support@github.comiçin oyunuzu eklemenizi isteyebilirsiniz .

Bu arada, GitHub kullanıcısı bardiharborow bunu yapmak için bir araç yarattı: https://upriver.github.io/

Kaynak burada: https://github.com/upriver/upriver.github.io

Windows veya Mac için GitHub kullanıyorsanız, şimdi çatalları güncellemek için tek tıklatma özelliğine sahipler:

1. Kullanıcı arayüzünde havuzu seçin.
2. Üstteki "Kullanıcıdan / şubeden güncelle" düğmesini tıklayın.

Aslında, tarayıcınızdaki yukarı akışın herhangi bir işleminden çatalınızda bir dal oluşturmak mümkündür:

• Açık https://github.com/<repo>/commits/<hash>, repo çatal ve karma tam akış web arayüzünde bulabileceğiniz tam karma vardır. Örneğin, yazma zamanı olarak işaret eden https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 açabilirim linux master.
• "Ağaç: ...." düğmesini tıklayın.
• Yeni dalın adını yazın ve Enter

Daha sonra bu dalı yerel klonunuza getirebilirsiniz ve düzenlemelerin üzerine düzenlemeler uyguladığınızda tüm bu verileri GitHub'a geri göndermek zorunda kalmazsınız. Veya bu daldaki bir şeyi değiştirmek için web arayüzünü kullanın.

Nasıl çalışır (tahminim, GitHub'ın tam olarak nasıl yaptığını bilmiyorum): çatallar nesne depolamasını paylaşır ve kullanıcıların referanslarını ayırmak için ad alanlarını kullanır. Böylece çatallara kadar mevcut olmasalar bile, tüm taahhütlere çatal yoluyla erişebilirsiniz.

Aşağıdaki adımları izleyin. Onları denedim ve bana yardımcı oldu.

Şubenize çıkış

Sözdizimi: git branch yourDevelopmentBranch
Örnek: git checkout master

En son kodu almak için kaynak veri havuzu dalını çekin

Sözdizimi: git pull https://github.com/tastejs/awesome-app-ideas master
Örnek: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

Çatallı depolarımı bu tek satırla güncelliyorum:

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

Burada yayınlanan diğer çözümler gibi projenize başka bir uzak uç nokta eklemek istemiyorsanız bunu kullanın.

Bu cevabın bir tamamlayıcısı olarak, klonlanmış reporumun ( kökeninin ) tüm uzak dallarını tek seferde yukarı akış dallarından güncellemenin bir yolunu arıyordum . Ben böyle yaptım.

Bu, daha önce kaynak veri havuzuna ( başlangıç noktasının çatallandığı) dönük bir yukarı akış uzaktan kumandası yapılandırdığınızı ve bunu senkronize ettiğinizi varsayar .git fetch upstream

O zaman koş:

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

Bu komutun ilk kısmı, yukarı akış uzak deposundaki tüm kafaları listeler ve SHA-1'i ve ardından refs/heads/şube adı önekini kaldırır .

Daha sonra bu dalların her biri için, yukarı akış uzaktan izleme dalının yerel kopyasını ( refs/remotes/upstream/<branch>yerel tarafta) doğrudan orijinli olarak uzak dalda ( refs/heads/<branch>uzak tarafta) iter .

Bu şube eşitleme komutlarından herhangi biri iki nedenden ötürü başarısız olabilir: yukarı akış dalı yeniden yazılmıştır veya söz konusu daldaki taahhütleri çatalınıza iletmişsinizdir. Çatalı üzerinde şubeye bir şey yapmadığınız ilk durumda, zorla itmek güvenlidir ( -f anahtarını ekleyin ; yani git push -fyukarıdaki komutta). Diğer durumda, çatal dalınız ayrıştığından bu normaldir ve taahhütleriniz tekrar yukarı akışa birleştirilene kadar senkronizasyon komutunun çalışmasını bekleyemezsiniz .

"Çekme" uygulaması otomatik çözüm kurulum ve unut olduğunu. Çatalınızın varsayılan dalını yukarı akış deposuyla senkronize eder.

URL'yi ziyaret edin, yeşil "Yükle" düğmesini tıklayın ve otomatik senkronizasyonu etkinleştirmek istediğiniz depoları seçin.

Şube saatte bir kez doğrudan GitHub'da güncellenir, yerel makinenizde yerel kopyanızın senkronize olduğundan emin olmak için ana dalı çekmeniz gerekir.

Android Studio artık GitHub çatal depolarıyla çalışmayı öğrendi (konsol komutuyla "yukarı akış" uzak depo eklemenize bile gerek yok).

VCS menüsünü aç → Git

Ve son iki açılır menü öğesine dikkat edin:

• GitHub çatalımı yeniden oluştur

• Çekme İsteği Oluştur

Onları dene. İlkini yerel veri havuzumu senkronize etmek için kullanıyorum. Yine de üst uzaktan depodaki ("yukarı akış") şubelere, "GitHub çatalımı yeniden oluştur" u tıkladıktan sonra Android Studio'dan erişilebilir ve onlarla kolayca çalışabilirsiniz.

(Android Studio 3.0'ı "Git entegrasyonu" ve "GitHub" eklentileri ile kullanıyorum.)

Çatallı deponuzu klonladığınızda, klonunuzun bulunduğu dizin yoluna ve Git Bash Terminalinizdeki birkaç satıra gidin.

$ 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

Ve işte gitmekte fayda var. Ana depodaki güncellenmiş tüm değişiklikler çatal deponuza aktarılacaktır.

"Getirme" komutu bir projede güncel kalmak için vazgeçilmezdir: yalnızca bir "git getirme" işlemi gerçekleştirirken iş arkadaşlarınızın uzak sunucuya aktardığı değişiklikler hakkında bilgilendirilirsiniz.

Daha fazla soru için burayı ziyaret edebilirsiniz.

Yukarı akışınızı ayarlarsanız. Kontrol edin git remote -v, o zaman bu yeterli olacaktır.

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

Bu, deponuzun büyüklüğüne ve onu nasıl çatalladığınıza bağlıdır.

Oldukça büyük bir havuzsa, bunu özel bir şekilde yönetmek isteyebilirsiniz (örn. Bırakma geçmişi). Temel olarak, mevcut ve yukarı akış sürümleri arasında farklar elde edebilir, bunları taahhüt edebilir ve daha sonra kiraz master'a geri dönebilirsiniz.

Okumayı deneyin bunu . Büyük Git depolarının nasıl ele alınacağını ve en son değişikliklerle nasıl yukarı akış gerçekleştirileceğini açıklar.

Ben üzerine eklemek istiyorum @ krlmlr en cevabı .

Başlangıçta, çatallı deposu bir dala seçti: master. Yeni bir özellik veya düzeltme üzerinde çalışıyorsanız, genellikle yeni bir dal oluşturur featureve değişiklikleri yaparsınız .

Çatallı deponun üst havuzla senkronize olmasını istiyorsanız pull.yml, Pull uygulaması ( özellik dalında ) için aşağıdaki gibi bir yapılandırma dosyası ( ) ayarlayabilirsiniz :

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

Bu master, çatallı repo şubesini ana repo ile güncel tutar . featureÇatallı repo masterşubesini çatallı repo şubesi aracılığıyla bir araya getirerek güncel tutar . Bu, featuredalın yapılandırma dosyasını içeren varsayılan dal olduğunu varsayar .

Burada ikisi mergemethodsoyuna dahil, biri çatallı repo dalında ana repo ile şube hardresetsenkronizasyon değişikliklerini zorlamaya yardımcı olan masterve diğer yöntemdir merge. Bu yöntem, featureşubede yaptığınız değişiklikleri ve şubedeki zorla eşitleme nedeniyle yapılan değişiklikleri birleştirmek için kullanılır master. Birleştirme çakışması durumunda, çekme uygulaması çekme isteği sırasında bir sonraki eylemi seçmenize izin verecektir.

Temel ve gelişmiş konfigürasyonlar ve çeşitli konfigürasyonları mergemethods burada okuyabilirsiniz .

Şu anda benim çatal repo bu yapılandırmayı kullanıyorum burada emin bir artırımı talep yapmak için buraya kalır güncellendi.

Çatallı bir deponun her zaman iyilik için güncellenmesi konusunda iki ana şey vardır.

1. Çatal ustasından dalları oluşturun ve orada değişiklikler yapın .

Bu nedenle, Çekme İsteğiniz kabul edildiğinde, şubeyi güvenli bir şekilde silebilirsiniz, çünkü katkıda bulunan kodunuz, yukarı akışla güncellediğinizde çatallı deponuzun ana verilerinizde yaşayacaktır. Bununla, efendiniz başka bir değişiklik yapmak için yeni bir şube oluşturmak için her zaman temiz durumda olacaktır.

2. Fork master'ın otomatik olarak güncellenmesi için zamanlanmış bir iş oluşturun .

Bu cron ile yapılabilir . Linux'ta yaparsanız örnek bir kod için.

$ crontab -e

crontab fileişi saatlik olarak yürütmek için bu kodu .

0 * * * * sh ~/cron.sh

Sonra oluşturmak cron.shkomut dosyası ve git etkileşimi ile ssh-agent ve / veya beklemek aşağıdaki gibi

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

Çatallı deponuzu kontrol edin. Zaman zaman bu bildirimi her zaman gösterecektir:

Bu dal bile ile <upstream>: usta .

Bu komutları kullanın (şanslı durumda)

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