Saya baru-baru ini melakukan proyek dan menerapkan beberapa perbaikan. Saya kemudian membuat permintaan tarik yang kemudian diterima.

Beberapa hari kemudian perubahan lain dilakukan oleh kontributor lain. Jadi garpu saya tidak mengandung perubahan itu.

Bagaimana saya bisa memasukkan uang itu ke dalam garpu saya? Apakah saya perlu menghapus dan membuat ulang garpu ketika ada perubahan lebih lanjut untuk disumbangkan? Atau ada tombol pembaruan?

Di klon lokal repositori bercabang Anda, Anda bisa menambahkan repositori GitHub asli sebagai "remote". ("Remote" seperti nama panggilan untuk URL repositori - originmisalnya, adalah satu.) Kemudian Anda dapat mengambil semua cabang dari repositori hulu itu, dan menyusun kembali pekerjaan Anda untuk terus bekerja pada versi upstream. Dalam hal perintah yang mungkin terlihat seperti:

# 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

Jika Anda tidak ingin menulis ulang sejarah cabang master Anda, (misalnya karena orang lain mungkin telah mengkloningnya) maka Anda harus mengganti perintah terakhir dengan git merge upstream/master. Namun, untuk membuat permintaan tarik lebih lanjut yang sebersih mungkin, mungkin lebih baik untuk melakukan rebase.

Jika Anda telah mengubah kembali cabang upstream/masterAnda, Anda mungkin harus mendorongnya untuk mendorongnya ke repositori bercabang sendiri di GitHub. Anda akan melakukannya dengan:

git push -f origin master

Anda hanya perlu menggunakan -fyang pertama kali setelah rebased.

Mulai Mei 2014, dimungkinkan untuk memperbarui garpu langsung dari GitHub. Ini masih berfungsi sampai September 2017, TAPI itu akan menyebabkan sejarah komit yang kotor.

1. Buka garpu Anda di GitHub.
2. Klik pada Pull Requests.
3. Klik pada New Pull Request. Secara default, GitHub akan membandingkan yang asli dengan garpu Anda, dan seharusnya tidak ada yang bisa dibandingkan jika Anda tidak melakukan perubahan apa pun.
4. Klik switching the basejika Anda melihat tautan itu. Jika tidak, atur secara manual base forkdrop-down ke garpu Anda, dan head forkke hulu. Sekarang GitHub akan membandingkan garpu Anda dengan yang asli, dan Anda akan melihat semua perubahan terbaru.
5. Create pull requestdan menetapkan nama yang dapat diprediksi untuk permintaan tarik Anda (misalnya, Update from original).
6. Gulir ke bawah untuk Merge pull request, tetapi jangan mengklik apa pun.

Sekarang Anda memiliki tiga opsi, tetapi masing-masing akan menghasilkan riwayat komit yang kurang bersih.

1. Default akan membuat komit gabungan jelek.
2. Jika Anda mengklik dropdown dan memilih "Squash and merge", semua komit intervensi akan tergencet menjadi satu. Ini paling sering adalah sesuatu yang tidak Anda inginkan.
3. Jika Anda mengklik Rebase and merge, semua komit akan dibuat "dengan" Anda, PR asli akan ditautkan ke PR Anda, dan GitHub akan ditampilkan This branch is X commits ahead, Y commits behind <original fork>.

Jadi ya, Anda dapat menjaga repo Anda diperbarui dengan upstreamnya menggunakan GitHub web UI, tetapi melakukan hal itu akan menodai riwayat komit Anda. Tetaplah pada baris perintah sebagai gantinya - mudah.

Berikut adalah dokumen resmi GitHub tentang Menyinkronkan garpu :

Menyinkronkan garpu

Pengaturan

Sebelum Anda bisa menyinkronkan, Anda perlu menambahkan remote yang menunjuk ke repositori hulu. Anda mungkin telah melakukan ini ketika Anda awalnya bercabang.

Tip: Menyinkronkan garpu Anda hanya akan memperbarui salinan lokal repositori Anda; itu tidak memperbarui repositori Anda di 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)

Sinkronisasi

Ada dua langkah yang diperlukan untuk menyinkronkan repositori Anda dengan upstream: pertama Anda harus mengambil dari jarak jauh, kemudian Anda harus menggabungkan cabang yang diinginkan ke cabang lokal Anda.

Mengambil

Mengambil dari repositori jarak jauh akan membawa cabang dan komitmen masing-masing. Ini disimpan di repositori lokal Anda di bawah cabang khusus.

$ 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

Kami sekarang memiliki cabang master hulu yang disimpan di cabang lokal, hulu / 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

Penggabungan

Sekarang kami telah mengambil repositori hulu, kami ingin menggabungkan perubahannya ke cabang lokal kami. Ini akan membuat cabang itu sinkron dengan hulu, tanpa kehilangan perubahan lokal kami.

$ 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

Jika cabang lokal Anda tidak memiliki komitmen unik, git akan melakukan "fast-forward":

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

Tip: Jika Anda ingin memperbarui repositori di GitHub, ikuti instruksi di sini

Banyak jawaban yang akhirnya menggerakkan fork one Anda di depan repositori induk. Jawaban ini merangkum langkah-langkah yang ditemukan di sini yang akan memindahkan garpu Anda ke komit yang sama dengan orang tua .

1. Ubah direktori ke repositori lokal Anda.

   • Beralihlah ke cabang utama jika Anda tidak git checkout master

2. Tambahkan induk sebagai repositori jarak jauh, git remote add upstream <repo-location>

3. Isu git fetch upstream

4. Isu git rebase upstream/master

   • Pada tahap ini Anda memeriksa yang melakukan apa yang akan digabungkan dengan mengetik git status

5. Isu git push origin master

Untuk informasi lebih lanjut tentang perintah ini, lihat langkah 3 .

Jika, seperti saya, Anda tidak pernah melakukan sesuatu secara langsung untuk dikuasai , yang sebenarnya harus Anda lakukan, Anda dapat melakukan hal berikut.

Dari klon lokal garpu Anda, buat remote hulu Anda. Anda hanya perlu melakukannya sekali:

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

Maka setiap kali Anda ingin mengejar ketinggalan dengan cabang master repositori hulu Anda perlu:

git checkout master
git pull upstream master

Dengan asumsi Anda tidak pernah melakukan apa pun pada menguasai diri sendiri, Anda harus sudah melakukannya. Sekarang Anda dapat mendorong master lokal Anda ke garpu GitHub jauh asal Anda. Anda juga bisa rebase cabang pengembangan Anda pada master lokal Anda yang sekarang up-to-date.

Setelah pengaturan awal upstream dan checkout master, yang perlu Anda lakukan adalah menjalankan perintah berikut untuk menyinkronkan master Anda dengan upstream: git pull upstream master .

Kata Pengantar: Garpu Anda adalah "asal" dan repositori yang Anda gunakan adalah "upstream".

Mari kita asumsikan bahwa Anda sudah menggandakan garpu Anda ke komputer Anda dengan perintah seperti ini:

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

Jika itu diberikan maka Anda harus melanjutkan dalam urutan ini:

1. Tambahkan "hulu" ke repositori hasil kloning Anda ("asal"):

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

2. Ambil komit (dan cabang) dari "hulu":

   git fetch upstream
   

3. Beralih ke cabang "master" garpu Anda ("asal"):

   git checkout master
   

4. Simpan perubahan cabang "master" Anda:

   git stash
   

5. Gabungkan perubahan dari cabang "master" dari "hulu" ke cabang "master" dari "asal" Anda:

   git merge upstream/master
   

6. Selesaikan konflik penggabungan jika ada dan lakukan penggabungan Anda

   git commit -am "Merged from upstream"
   

7. Dorong perubahan ke garpu Anda

   git push
   

8. Dapatkan kembali perubahan simpanan Anda (jika ada)

   git stash pop
   

9. Kamu sudah selesai! Selamat!

GitHub juga menyediakan instruksi untuk topik ini: Menyinkronkan garpu

Sejak November 2013 telah ada permintaan fitur tidak resmi terbuka dengan GitHub untuk meminta mereka menambahkan metode yang sangat sederhana dan intuitif untuk menjaga garpu lokal tetap sinkron dengan upstream:

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

Catatan: Karena permintaan fitur tidak resmi, disarankan untuk menghubungi support@github.comuntuk menambahkan dukungan Anda agar fitur seperti ini diterapkan. Permintaan fitur tidak resmi di atas dapat digunakan sebagai bukti jumlah minat dalam penerapan ini.

Pada tanggal jawaban ini, GitHub belum ( atau harus saya katakan tidak lagi? ) Fitur ini di antarmuka web. Anda dapat, bagaimanapun, meminta support@github.comuntuk menambahkan suara Anda untuk itu.

Sementara itu, pengguna GitHub bardiharborow telah menciptakan alat untuk melakukan hal ini: https://upriver.github.io/

Sumber ada di sini: https://github.com/upriver/upriver.github.io

Jika Anda menggunakan GitHub untuk Windows atau Mac maka sekarang mereka memiliki fitur satu-klik untuk memperbarui garpu:

1. Pilih repositori di UI.
2. Klik tombol "Perbarui dari pengguna / cabang" di bagian atas.

Sebenarnya, dimungkinkan untuk membuat cabang di garpu Anda dari komit apa pun dari hulu di browser:

• Buka https://github.com/<repo>/commits/<hash>, di mana repo adalah garpu Anda, dan hash adalah hash penuh komit yang dapat Anda temukan di antarmuka web hulu. Sebagai contoh, saya dapat membuka https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , yang menunjuk pada linux mastersaat penulisan.
• Klik pada tombol "Tree: ....".
• Ketikkan nama cabang baru dan tekan Enter

Anda kemudian dapat mengambil cabang itu ke klon lokal Anda, dan Anda tidak perlu mendorong semua data itu kembali ke GitHub ketika Anda mendorong suntingan di atas komit itu. Atau gunakan antarmuka web untuk mengubah sesuatu di cabang itu.

Cara kerjanya (ini adalah dugaan, saya tidak tahu bagaimana tepatnya GitHub melakukannya): fork berbagi penyimpanan objek dan menggunakan ruang nama untuk memisahkan referensi pengguna. Jadi, Anda dapat mengakses semua komit melalui fork Anda, bahkan jika itu tidak ada pada saat forking.

Ikuti langkah-langkah di bawah ini. Saya mencobanya dan itu membantu saya.

Periksa ke cabang Anda

Sintaksis: git branch yourDevelopmentBranch
Contoh: master checkout git

Tarik cabang repositori sumber untuk mendapatkan kode terbaru

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

Saya memperbarui repositori bercabang saya dengan satu baris ini:

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

Gunakan ini jika Anda tidak ingin menambahkan titik akhir jarak jauh lain ke proyek Anda, seperti solusi lain yang diposting di sini.

Sebagai pelengkap jawaban ini, saya mencari cara untuk memperbarui semua cabang terpencil repo kloning saya ( asal ) dari cabang-cabang hulu dalam sekali jalan. Beginilah cara saya melakukannya.

Ini mengasumsikan Anda telah mengkonfigurasi remote remote upstream di repositori sumber (dari mana asal bercabang) dan telah disinkronkan dengan git fetch upstream.

Lalu lari:

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

Bagian pertama dari perintah ini mencantumkan semua kepala di repo jarak jauh hulu dan menghapus SHA-1 diikuti oleh refs/heads/awalan nama cabang.

Kemudian untuk masing-masing cabang ini, mendorong salinan lokal dari cabang pelacakan jarak jauh hulu ( refs/remotes/upstream/<branch>di sisi lokal) langsung ke cabang jauh di asal ( refs/heads/<branch>di sisi terpencil).

Salah satu dari perintah sinkronisasi cabang ini mungkin gagal karena salah satu dari dua alasan: cabang upstream telah ditulis ulang, atau Anda telah mendorong komit pada cabang itu ke fork Anda. Dalam kasus pertama di mana Anda belum melakukan sesuatu pada cabang pada garpu Anda, aman untuk mendorong dengan paksa (Tambahkan -f switch; yaitu git push -fdalam perintah di atas). Dalam kasus lain, ini normal karena cabang fork Anda telah menyimpang dan Anda tidak dapat mengharapkan perintah sinkronisasi berfungsi sampai komit Anda digabungkan kembali ke hulu .

Aplikasi "Tarik" adalah solusi pengaturan-dan-lupa otomatis. Ini akan menyinkronkan cabang default dari garpu Anda dengan repositori hulu.

Kunjungi URL, klik tombol hijau "Instal" dan pilih repositori tempat Anda ingin mengaktifkan sinkronisasi otomatis.

Cabang diperbarui sekali per jam langsung di GitHub, pada mesin lokal Anda, Anda perlu menarik cabang master untuk memastikan bahwa salinan lokal Anda sinkron.

Android Studio sekarang telah belajar untuk bekerja dengan repositori garpu GitHub (Anda bahkan tidak perlu menambahkan repositori jarak jauh "upstream" dengan perintah konsol).

Buka menu VCS → Git

Dan perhatikan dua item menu popup terakhir:

• Rebase garpu GitHub saya

• Buat Permintaan Tarik

Coba mereka. Saya menggunakan yang pertama untuk menyinkronkan repositori lokal saya. Pokoknya cabang-cabang dari repositori jarak jauh induk ("upstream") akan dapat diakses di Android Studio setelah Anda mengklik "Rebase my GitHub fork", dan Anda akan dapat mengoperasikannya dengan mudah.

(Saya menggunakan Android Studio 3.0 dengan plugin "Integrasi Git" dan "GitHub".)

Ketika Anda telah mengkloning repositori bercabang Anda, pergi ke jalur direktori di mana klon Anda berada dan beberapa baris di Terminal Git Bash Anda.

$ 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

Dan di sana Anda baik untuk pergi. Semua perubahan yang diperbarui di repositori utama akan dimasukkan ke repositori fork Anda.

Perintah "fetch" sangat diperlukan untuk tetap up-to-date dalam suatu proyek: hanya ketika melakukan "git fetch" Anda akan diberi tahu tentang perubahan yang didorong oleh kolega Anda ke server jarak jauh.

Anda masih dapat mengunjungi di sini untuk pertanyaan lebih lanjut

Jika Anda mengatur hulu Anda. Periksa dengan git remote -v, maka ini sudah cukup.

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

Itu tergantung pada ukuran repositori Anda dan bagaimana Anda melakukannya.

Jika itu adalah repositori yang cukup besar, Anda mungkin ingin mengelolanya dengan cara khusus (misalnya, jatuhkan riwayat). Pada dasarnya, Anda bisa mendapatkan perbedaan antara versi saat ini dan versi hulu, komit dan kemudian pilih kembali untuk dikuasai.

Coba baca yang ini . Ini menjelaskan cara menangani repositori Git besar dan bagaimana meng-upstreamnya dengan perubahan terbaru.

Saya ingin menambahkan jawaban @ krlmlr .

Awalnya, repositori bercabang memiliki satu cabang bernama: master. Jika Anda sedang mengerjakan fitur baru atau perbaikan, Anda biasanya akan membuat cabang baru featuredan melakukan perubahan.

Jika Anda ingin repositori bercabang untuk disinkronkan dengan repositori induk, Anda bisa mengatur file konfigurasi ( pull.yml) untuk aplikasi Tarik ( di cabang fitur ), seperti ini:

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

Ini membuat mastercabang repo bercabang up-to-date dengan repo induk. Itu membuat featurecabang repo bercabang diperbarui melalui mastercabang repo bercabang dengan menggabungkan yang sama. Ini mengasumsikan bahwa featurecabang adalah cabang default yang berisi file konfigurasi.

Di sini ada dua mergemethodsyang bermain, satu adalah hardresetyang membantu memaksa perubahan sinkronisasi di mastercabang repo bercabang dengan repo induk dan metode lainnya adalah merge. Metode ini digunakan untuk menggabungkan perubahan yang dilakukan oleh Anda di featurecabang dan perubahan yang dilakukan karena memaksa sinkronisasi di mastercabang. Jika terjadi konflik penggabungan, aplikasi tarik akan memungkinkan Anda untuk memilih tindakan selanjutnya selama permintaan tarik.

Anda dapat membaca tentang konfigurasi dasar dan lanjutan dan beragam di mergemethods sini .

Saat ini saya menggunakan konfigurasi ini di repo bercabang saya di sini untuk memastikan peningkatan yang diminta di sini tetap diperbarui.

Ada dua hal utama tentang menjaga repositori bercabang yang selalu diperbarui untuk selamanya.

1. Buat cabang dari master garpu dan lakukan perubahan di sana .

Jadi ketika Permintaan Tarik Anda diterima maka Anda dapat menghapus cabang dengan aman karena kode kontribusi Anda akan tinggal di master repositori bercabang Anda saat Anda memperbaruinya dengan hulu. Dengan ini master Anda akan selalu dalam kondisi bersih untuk membuat cabang baru untuk melakukan perubahan lain.

2. Buat pekerjaan yang dijadwalkan untuk master garpu untuk melakukan pembaruan secara otomatis .

Ini bisa dilakukan dengan cron . Ini adalah contoh kode jika Anda melakukannya di linux.

$ crontab -e

letakkan kode ini pada crontab fileuntuk menjalankan pekerjaan dalam basis per jam.

0 * * * * sh ~/cron.sh

kemudian buat cron.shfile skrip dan interaksi git dengan ssh-agent dan / atau harapkan seperti di bawah ini

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

Periksa repositori bercabang Anda. Dari waktu ke waktu akan selalu menampilkan pemberitahuan ini:

Cabang ini bahkan dengan <upstream>: master .

Gunakan perintah ini (dalam kasus beruntung)

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