ฉันเพิ่งแยกโครงการและใช้การแก้ไขหลายอย่าง ฉันสร้างคำขอดึงซึ่งเป็นที่ยอมรับแล้ว

ไม่กี่วันต่อมามีการเปลี่ยนแปลงอื่นโดยผู้มีส่วนร่วมอื่น ดังนั้นส้อมของฉันไม่มีการเปลี่ยนแปลงนั้น

ฉันจะเปลี่ยนสิ่งนั้นให้เป็นส้อมได้อย่างไร ฉันต้องลบและสร้างทางแยกใหม่อีกครั้งเมื่อฉันมีการเปลี่ยนแปลงเพิ่มเติมเพื่อร่วมให้ข้อมูลหรือไม่ หรือมีปุ่มอัปเดต

ในโคลนโลคัลของที่เก็บ forked ของคุณคุณสามารถเพิ่มที่เก็บ GitHub ดั้งเดิมเป็น "remote" ("รีโมต" เป็นเหมือนชื่อเล่นสำหรับ URL ของที่เก็บ - originเป็นชื่อเดียว) จากนั้นคุณสามารถดึงสาขาทั้งหมดจากที่เก็บอัปสตรีมนั้นและรีบูตงานของคุณเพื่อทำงานในเวอร์ชันอัปสตรีมต่อไป ในแง่ของคำสั่งที่อาจมีลักษณะดังนี้:

# 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

หากคุณไม่ต้องการที่จะเขียนประวัติศาสตร์ของสาขาต้นแบบของคุณ (ตัวอย่างเช่นเพราะคนอื่น ๆ อาจจะมีโคลนมัน) git merge upstream/masterแล้วคุณควรเปลี่ยนคำสั่งที่ผ่านมากับ อย่างไรก็ตามสำหรับการร้องขอการดึงเพิ่มเติมที่สะอาดเท่าที่จะเป็นไปได้

หากคุณรีบาวน์สาขาของคุณไปที่upstream/masterคุณอาจต้องบังคับให้มีการผลักดันเพื่อผลักดันมันไปยังพื้นที่เก็บข้อมูลที่แยกจากกันบน GitHub คุณทำเช่นนั้นกับ:

git push -f origin master

คุณจะต้องใช้-fในครั้งแรกหลังจากที่คุณได้รีบูต

เริ่มตั้งแต่พฤษภาคม 2014 เป็นไปได้ที่จะอัปเดตทางแยกโดยตรงจาก GitHub ยังคงใช้งานได้ในเดือนกันยายน 2017 แต่มันจะนำไปสู่ประวัติศาสตร์การกระทำที่สกปรก

1. เปิดส้อมของคุณบน GitHub
2. Pull Requestsคลิกที่
3. คลิกที่ New Pull Requestคลิกที่โดยค่าเริ่มต้น GitHub จะเปรียบเทียบต้นฉบับกับทางแยกของคุณและไม่ควรมีอะไรให้เปรียบเทียบหากคุณไม่ได้ทำการเปลี่ยนแปลงใด ๆ
4. คลิกswitching the baseถ้าคุณเห็นลิงค์นั้น มิฉะนั้นตั้งค่าbase forkแบบเลื่อนลงเพื่อส้อมของคุณด้วยตนเองและhead forkไปที่ต้นน้ำ ตอนนี้ GitHub จะเปรียบเทียบส้อมของคุณกับต้นฉบับและคุณควรเห็นการเปลี่ยนแปลงล่าสุดทั้งหมด
5. Create pull requestและกำหนดชื่อที่สามารถคาดเดาได้ให้กับคำขอดึงของคุณ (เช่นUpdate from original)
6. เลื่อนลงไปMerge pull requestแต่อย่าคลิกอะไรเลย

ตอนนี้คุณมีสามตัวเลือก แต่แต่ละตัวเลือกจะนำไปสู่ประวัติศาสตร์การส่งข้อมูลที่ไม่ถูกต้อง

1. ค่าเริ่มต้นจะสร้างการรวมที่น่าเกลียด
2. หากคุณคลิกเมนูแบบเลื่อนลงและเลือก "สควอชและผสาน" คอมมิชชันที่เข้ามาทั้งหมดจะถูกบีบเข้าเป็นหนึ่งเดียว นี่คือสิ่งที่คุณไม่ต้องการบ่อยที่สุด
3. หากคุณคลิกการRebase and mergeกระทำทั้งหมดจะถูกทำ "กับ" คุณ PRs ดั้งเดิมจะเชื่อมโยงไปยัง PR ของคุณและ GitHub จะแสดงThis branch is X commits ahead, Y commits behind <original fork>ขึ้น

ใช่คุณสามารถอัปเดต repo ของคุณด้วยอัปเดตอัปสตรีมโดยใช้ GitHub web UI แต่การทำเช่นนั้นจะทำให้ประวัติของคุณไม่เหมาะสม ติดกับบรรทัดคำสั่งแทน - ง่าย

นี่คือเอกสารอย่างเป็นทางการของ GitHub เกี่ยวกับการซิงค์ทางแยก :

กำลังซิงค์ส้อม

การตั้งค่า

ก่อนที่คุณจะสามารถซิงค์คุณต้องเพิ่มรีโมตที่ชี้ไปยังที่เก็บอัปสตรีม คุณอาจทำสิ่งนี้เมื่อคุณแยกทาง

เคล็ดลับ: การซิงค์ส้อมของคุณอัพเดตสำเนาโลคัลของที่เก็บเท่านั้น ไม่อัปเดตที่เก็บของคุณบน 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)

ซิงค์

มีสองขั้นตอนในการซิงค์ที่เก็บข้อมูลของคุณกับอัปสตรีม: ขั้นแรกคุณต้องดึงข้อมูลจากระยะไกลจากนั้นคุณจะต้องรวมสาขาที่ต้องการเข้ากับสาขาในพื้นที่ของคุณ

การดึงข้อมูล

การดึงข้อมูลจากพื้นที่เก็บข้อมูลระยะไกลจะนำมาซึ่งสาขาและการกระทำที่เกี่ยวข้อง เหล่านี้จะถูกเก็บไว้ในพื้นที่เก็บข้อมูลในพื้นที่ของคุณภายใต้สาขาพิเศษ

$ 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

ตอนนี้เรามีสาขาหลักของอัปสตรีมที่จัดเก็บในสาขาท้องถิ่นอัพสตรีม / มาสเตอร์

$ 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

การผสม

ตอนนี้เราได้เรียกที่เก็บข้อมูลต้นน้ำมาแล้วเราต้องการรวมการเปลี่ยนแปลงเข้ากับสาขาท้องถิ่นของเรา สิ่งนี้จะทำให้สาขานั้นซิงค์กับต้นน้ำโดยไม่สูญเสียการเปลี่ยนแปลงในท้องถิ่นของเรา

$ 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

หากสาขาในประเทศของคุณไม่มีข้อผูกพันใด ๆ git จะทำการ "ส่งต่ออย่างรวดเร็ว" แทน:

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

เคล็ดลับ: หากคุณต้องการอัปเดตที่เก็บของคุณบน GitHub ให้ทำตามคำแนะนำที่นี่

คำตอบมากมายจบลงที่การเคลื่อนย้าย fork ของคุณหนึ่งคำสั่งให้นำหน้าพื้นที่เก็บข้อมูลหลัก คำตอบนี้จะสรุปขั้นตอนที่พบที่นี่ซึ่งจะย้ายส้อมของคุณเพื่อเดียวกันกระทำการเป็นผู้ปกครอง

1. เปลี่ยนไดเรกทอรีเป็นที่เก็บในเครื่องของคุณ

   • สลับไปที่สาขาหลักหากคุณไม่ได้ git checkout master

2. เพิ่มพาเรนต์เป็นที่เก็บรีโมต git remote add upstream <repo-location>

3. ปัญหา git fetch upstream

4. ปัญหา git rebase upstream/master

   • ในขั้นตอนนี้คุณตรวจสอบว่ายอมรับสิ่งที่จะผสานโดยการพิมพ์ git status

5. ปัญหา git push origin master

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับคำสั่งเหล่านี้หมายถึงขั้นตอนที่ 3

คำนำ:ส้อมของคุณคือ "ต้นกำเนิด" และที่เก็บที่คุณแยกจากนั้นคือ "ต้นน้ำ"

สมมติว่าคุณโคลนของคุณกับคอมพิวเตอร์ด้วยคำสั่งเช่นนี้:

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

หากได้รับแล้วคุณจะต้องดำเนินการต่อในคำสั่งนี้:

1. เพิ่ม "upstream" ไปยังที่เก็บโคลนของคุณ ("origin"):

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

2. ดึงข้อมูลการกระทำ (และสาขา) จาก "upstream":

   git fetch upstream
   

3. สลับไปที่สาขา "มาสเตอร์" ของส้อมของคุณ ("ต้นกำเนิด"):

   git checkout master
   

4. ซ่อนการเปลี่ยนแปลงของสาขา "มาสเตอร์" ของคุณ:

   git stash
   

5. รวมการเปลี่ยนแปลงจากสาขา "ปรมาจารย์" ของ "ต้นน้ำ" ลงในสาขา "ปรมาจารย์" ของ "ต้นกำเนิด" ของคุณ:

   git merge upstream/master
   

6. แก้ไขข้อขัดแย้งการรวมหากมีและยืนยันการรวมของคุณ

   git commit -am "Merged from upstream"
   

7. ผลักดันการเปลี่ยนแปลงไปยังส้อมของคุณ

   git push
   

8. เรียกคืนการเปลี่ยนแปลงที่ถูกเก็บถาวรของคุณ (ถ้ามี)

   git stash pop
   

9. คุณทำเสร็จแล้ว! ขอแสดงความยินดี!

GitHub ยังมีคำแนะนำสำหรับหัวข้อนี้: การซิงค์ส้อม

ถ้าอย่างฉันคุณไม่เคยยอมทำอะไรกับอาจารย์โดยตรงซึ่งคุณควรทำจริงๆคุณสามารถทำสิ่งต่อไปนี้

จากโลคัลโลคัลของส้อมสร้างรีโมต upstream ของคุณ คุณจะต้องทำสิ่งนั้นครั้งเดียว:

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

จากนั้นเมื่อใดก็ตามที่คุณต้องการติดต่อกับสาขาหลักของที่เก็บข้อมูลต้นน้ำคุณจะต้อง:

git checkout master
git pull upstream master

สมมติว่าคุณไม่เคยทำสิ่งใดในการควบคุมตัวเองคุณควรจะทำไปแล้ว ตอนนี้คุณสามารถผลักดันต้นแบบท้องถิ่นของคุณไปยังส้อม GitHub ระยะไกลต้นทางของคุณ นอกจากนี้คุณยังสามารถลดสาขาการพัฒนาของคุณบนต้นแบบท้องถิ่นของคุณในปัจจุบัน

ที่ผ่านมาการตั้งค่าอัปสตรีมเริ่มต้นและการชำระเงินหลักทั้งหมดที่คุณต้องทำคือเรียกใช้คำสั่งต่อไปนี้เพื่อซิงค์ต้นแบบของคุณกับอัปสตรีม: ดึงคอมไพล์ต้นแบบต้นน้ำ

ตั้งแต่พฤศจิกายน 2013 มีการร้องขอคุณสมบัติไม่เป็นทางการเปิดกับ GitHub เพื่อขอให้พวกเขาเพิ่มวิธีที่ง่ายและใช้งานง่ายเพื่อให้ส้อมท้องถิ่นซิงค์กับต้นน้ำ:

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

หมายเหตุ: เนื่องจากคำขอคุณสมบัติไม่เป็นทางการจึงแนะนำให้ติดต่อsupport@github.comเพื่อเพิ่มการสนับสนุนของคุณสำหรับคุณสมบัติเช่นนี้ที่จะนำไปใช้ คำขอคุณลักษณะที่ไม่เป็นทางการด้านบนสามารถใช้เป็นหลักฐานของจำนวนดอกเบี้ยในการดำเนินการนี้

ณ วันที่คำตอบนี้ GitHub ไม่มีคุณสมบัตินี้ในเว็บอินเตอร์เฟส( หรือฉันจะบอกว่าไม่มีอีกแล้ว ) อย่างไรก็ตามคุณสามารถถามsupport@github.comเพิ่มคะแนนของคุณได้

ในระหว่างนี้ผู้ใช้ GitHub bardiharborow ได้สร้างเครื่องมือเพื่อทำสิ่งนี้: https://upriver.github.io/

แหล่งที่มาอยู่ที่นี่: https://github.com/upriver/upriver.github.io

หากคุณใช้ GitHub สำหรับ Windows หรือ Mac ตอนนี้พวกเขามีฟีเจอร์คลิกเดียวเพื่ออัพเดทส้อม:

1. เลือกที่เก็บใน UI
2. คลิกปุ่ม "อัปเดตจากผู้ใช้ / สาขา" ด้านบน

จริงๆแล้วมันเป็นไปได้ที่จะสร้างสาขาในทางแยกของคุณจากการกระทำใด ๆ ของ upstream ในเบราว์เซอร์:

• เปิดhttps://github.com/<repo>/commits/<hash>โดยที่repoเป็นทางแยกของคุณและแฮชเป็นแฮชการคอมมิชชันเต็มรูปแบบซึ่งคุณสามารถหาได้ในเว็บอินเตอร์เฟสต้นน้ำ ตัวอย่างเช่นฉันสามารถเปิดhttps://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990ซึ่งชี้ไปที่linux masterที่เวลาของการเขียน
• คลิกที่ปุ่ม "ต้นไม้: .... "
• พิมพ์ชื่อของสาขาใหม่แล้วกด Enter

จากนั้นคุณสามารถดึงสาขานั้นไปยังโคลนในพื้นที่ของคุณและคุณไม่จำเป็นต้องผลักดันข้อมูลทั้งหมดกลับไปที่ GitHub เมื่อคุณกดแก้ไขที่ด้านบนของคอมมิชชันนั้น หรือใช้เว็บอินเตอร์เฟสเพื่อเปลี่ยนบางอย่างในสาขานั้น

มันทำงานอย่างไร (เป็นการเดาฉันไม่รู้ว่า GitHub ทำหน้าที่อย่างไร): ส้อมแบ่งปันที่เก็บข้อมูลและใช้เนมสเปซเพื่อแยกการอ้างอิงของผู้ใช้ ดังนั้นคุณสามารถเข้าถึงการกระทำทั้งหมดผ่านทางส้อมของคุณแม้ว่าพวกเขาจะไม่ได้อยู่ในช่วงเวลาของการฟอร์ก

ทำตามขั้นตอนด้านล่าง ฉันลองพวกเขาและมันก็ช่วยฉัน

ชำระเงินที่สาขาของคุณ

ไวยากรณ์: git branch yourDevelopmentBranch
ตัวอย่าง: git checkout master

ดึงสาขาที่เก็บซอร์สเพื่อรับรหัสล่าสุด

ไวยากรณ์: git pull https://github.com/tastejs/awesome-app-ideasต้นแบบ
ตัวอย่าง: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRITCH_NAME

ฉันอัปเดต repos แยกของฉันด้วยหนึ่งบรรทัดนี้:

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

ใช้สิ่งนี้หากคุณไม่ต้องการเพิ่มจุดปลายทางระยะไกลอื่นในโครงการของคุณเช่นเดียวกับโซลูชันอื่น ๆ ที่โพสต์ที่นี่

ในฐานะที่เป็นส่วนเติมเต็มให้กับคำตอบนี้ฉันกำลังมองหาวิธีในการอัปเดตสาขาที่ห่างไกลทั้งหมดของ repo ที่โคลนของฉัน ( ต้นทาง ) จากสาขาต้นน้ำในครั้งเดียว นี่คือสิ่งที่ฉันทำ

นี้จะถือว่าคุณได้กำหนดค่าแล้วต้นน้ำชี้ระยะไกลที่พื้นที่เก็บข้อมูลแหล่งที่มา (ที่กำเนิดถูกคดเคี้ยวจาก) git fetch upstreamและมีการซิงค์กับ

จากนั้นเรียกใช้:

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

ส่วนแรกของคำสั่งนี้แสดงรายการหัวทั้งหมดในrepo ระยะไกลอัปสตรีมและลบ SHA-1 ตามด้วยrefs/heads/คำนำหน้าชื่อสาขา

แล้วสำหรับแต่ละสาขาเหล่านี้จะผลักดันให้สำเนาของต้นน้ำสาขาการติดตามระยะไกล ( refs/remotes/upstream/<branch>ในด้านท้องถิ่น) โดยตรงไปยังสาขาที่ห่างไกลบนต้นกำเนิด (refs/heads/<branch>ในด้านระยะไกล)

คำสั่งการซิงค์สาขาใด ๆ เหล่านี้อาจล้มเหลวด้วยเหตุผลข้อใดข้อหนึ่งจากสองข้อ: สาขาอัปสตรีมได้รับการเขียนใหม่หรือคุณได้ส่งการคอมมิชชันในสาขานั้นไปยังสาขาของคุณ ในกรณีแรกที่คุณไม่ได้ทำอะไรกับสาขาบนส้อมของคุณมันปลอดภัยที่จะผลักดันอย่างแรง (เพิ่มสวิตช์-f ; เช่นgit push -fในคำสั่งด้านบน) ในกรณีอื่นนี้เป็นเรื่องปกติเนื่องจากทางแยกของคุณแยกออกจากกันและคุณไม่สามารถคาดหวังว่าคำสั่ง sync จะทำงานได้จนกว่าคอมมิชชันของคุณจะถูกรวมกลับเข้าสู่อัปสตรีม

"ดึง" แอปเป็นอัตโนมัติวิธีการแก้ปัญหาการตั้งค่าและลืม มันจะซิงค์สาขาเริ่มต้นของทางแยกของคุณกับที่เก็บอัปสตรีม

ไปที่ URL คลิกปุ่ม "ติดตั้ง" สีเขียวและเลือกที่เก็บที่คุณต้องการเปิดใช้งานการซิงโครไนซ์อัตโนมัติ

สาขาจะได้รับการอัพเดทหนึ่งครั้งต่อชั่วโมงโดยตรงบน GitHub บนเครื่องของคุณคุณจะต้องดึงสาขาหลักเพื่อให้แน่ใจว่าสำเนาในเครื่องของคุณตรงกัน

ตอนนี้ Android Studio ได้เรียนรู้การทำงานกับที่เก็บส้อม GitHub (คุณไม่จำเป็นต้องเพิ่มที่เก็บระยะไกล "อัปสตรีม" ด้วยคำสั่งคอนโซล)

เปิดเมนูVCS → Git

และใส่ใจกับรายการเมนูป๊อปอัพสองรายการล่าสุด:

• รีบูตส้อม GitHub ของฉัน

• สร้างคำขอดึง

ลองพวกเขา ฉันใช้อันแรกเพื่อซิงโครไนซ์พื้นที่เก็บข้อมูลในเครื่องของฉัน อย่างไรก็ตามสาขาจากพื้นที่เก็บข้อมูลระยะไกลหลัก ("อัปสตรีม") จะสามารถเข้าถึงได้ใน Android Studio หลังจากที่คุณคลิก "Rebase my GitHub fork" และคุณจะสามารถใช้งานได้อย่างง่ายดาย

(ฉันใช้ Android Studio 3.0 กับปลั๊กอิน "Git Integration" และ "GitHub")

เมื่อคุณโคลนที่เก็บแบบแยกของคุณให้ไปที่เส้นทางไดเรกทอรีที่โคลนของคุณอยู่และไม่กี่บรรทัดในเทอร์มินัล 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

แล้วคุณก็ไปดี การเปลี่ยนแปลงที่อัปเดตทั้งหมดในที่เก็บหลักจะถูกส่งไปยังที่เก็บส้อมของคุณ

คำสั่ง "fetch" จะขาดไม่ได้สำหรับการอัพเดทล่าสุดในโครงการ: เฉพาะเมื่อดำเนินการ "git fetch" คุณจะได้รับแจ้งเกี่ยวกับการเปลี่ยนแปลงที่เพื่อนร่วมงานของคุณผลักไปยังเซิร์ฟเวอร์ระยะไกล

คุณยังสามารถเยี่ยมชมที่นี่เพื่อสอบถามเพิ่มเติม

หากคุณตั้งค่าอัปสตรีมของคุณ ตรวจสอบด้วยgit remote -vจากนั้นจะพอเพียง

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

ขึ้นอยู่กับขนาดของพื้นที่เก็บข้อมูลของคุณและวิธีแยกแยะมัน

หากเป็นพื้นที่เก็บข้อมูลขนาดใหญ่คุณอาจต้องการจัดการด้วยวิธีพิเศษ (เช่นประวัติหล่น) โดยทั่วไปคุณสามารถรับความแตกต่างระหว่างเวอร์ชันปัจจุบันและอัปสตรีมยอมรับกับเชอร์รี่แล้วเลือกกลับไปเป็นมาสเตอร์

ลองอ่านอันนี้สิสิ มันอธิบายวิธีจัดการกับที่เก็บ Git ขนาดใหญ่และวิธีอัปสตรีมกับการเปลี่ยนแปลงล่าสุด

ฉันต้องการเพิ่มคำตอบของ @ krlmlr คำตอบ

masterตอนแรกที่เก็บได้คดเคี้ยวสาขาหนึ่งชื่อ: หากคุณกำลังทำงานกับคุณสมบัติใหม่หรือการแก้ไขโดยทั่วไปคุณจะสร้างสาขาใหม่featureและทำการเปลี่ยนแปลง

หากคุณต้องการให้ที่เก็บข้อมูลที่มีการแยกสอดคล้องกับที่เก็บข้อมูลหลักคุณสามารถตั้งค่าไฟล์กำหนดค่า ( pull.yml) สำหรับแอปพลิเคชันดึงข้อมูล ( ในสาขาฟีเจอร์ ) ดังนี้:

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

สิ่งนี้จะทำให้masterสาขาของ repo ที่มีการแยกย่อยเป็นปัจจุบันด้วย parent repo มันเก็บfeatureสาขาของ repo ที่มีการแยกการปรับปรุงผ่านmasterสาขาของ repo ที่ forked โดยการรวมกัน นี่จะถือว่าfeatureสาขาเป็นสาขาเริ่มต้นซึ่งมีไฟล์กำหนดค่า

ที่นี่สองmergemethodsจะเข้าไปเล่นหนึ่งhardresetซึ่งจะช่วยให้การเปลี่ยนแปลงมีผลบังคับใช้ซิงค์ในmasterสาขาของ repo คดเคี้ยวกับ repo ผู้ปกครองและวิธีการอื่น ๆ mergeคือ วิธีนี้ใช้เพื่อรวมการเปลี่ยนแปลงที่คุณทำในfeatureสาขาและการเปลี่ยนแปลงที่ทำเนื่องจากการบังคับให้ซิงค์ในmasterสาขา ในกรณีที่มีการรวมความขัดแย้งแอพพลิเคชั่น pull จะอนุญาตให้คุณเลือกแนวทางการทำงานต่อไปในระหว่างการร้องขอ pull

คุณสามารถอ่านเกี่ยวกับการกำหนดค่าขั้นพื้นฐานและขั้นสูงและการต่างๆที่นี่mergemethods

ขณะนี้ฉันกำลังใช้การกำหนดค่านี้ใน repo แยกของฉันที่นี่เพื่อให้แน่ใจว่าการปรับปรุงที่ร้องขอในที่นี้ยังคงได้รับการปรับปรุง

มีสองสิ่งสำคัญในการรักษาพื้นที่เก็บข้อมูลที่มีการแยกการปรับปรุงให้ดีอยู่เสมอ

1. สร้างสาขาจากต้นแบบส้อมและจะเปลี่ยนแปลงมี

ดังนั้นเมื่อคำขอการยอมรับของคุณได้รับการยอมรับคุณสามารถลบสาขาได้อย่างปลอดภัยเนื่องจากรหัสที่คุณให้ไว้จะอยู่ในที่เก็บข้อมูลหลักของคุณเมื่อคุณอัปเดตด้วยอัปสตรีม โดยที่นี้อาจารย์ของคุณจะอยู่ในสภาพที่สะอาดเสมอเพื่อสร้างสาขาใหม่เพื่อทำการเปลี่ยนแปลงอื่น

2. สร้างงานที่กำหนดไว้สำหรับต้นแบบทางแยกเพื่อจะ update โดยอัตโนมัติ

ซึ่งสามารถทำได้ด้วยcron นี่คือตัวอย่างรหัสถ้าคุณทำมันใน linux

$ crontab -e

ใส่รหัสนี้บนcrontab fileเพื่อดำเนินงานเป็นรายชั่วโมง

0 * * * * sh ~/cron.sh

จากนั้นสร้างcron.shไฟล์สคริปต์และการโต้ตอบ gitกับssh-agentและ / หรือคาดหวังดังต่อไปนี้

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

ตรวจสอบพื้นที่เก็บข้อมูลที่แยกส่วนของคุณ เมื่อเวลาผ่านไปมันจะแสดงการแจ้งเตือนนี้:

สาขานี้เป็นแม้จะมี<upstream> : ต้นแบบ

ใช้คำสั่งเหล่านี้ (ในกรณีที่โชคดี)

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