ส่งออกที่ซ่อนไปยังคอมพิวเตอร์เครื่องอื่น

ฉันต้องการวิธีการส่งออกการเปลี่ยนแปลงที่ถูกซ่อนไปยังคอมพิวเตอร์เครื่องอื่น

ใน Computer1 ฉันทำ

$ git stash save feature

ฉันกำลังพยายามนำแพตช์สะสมไปยังไฟล์แล้วนำเข้าไฟล์ไปยังคอมพิวเตอร์เครื่องอื่น

$ git stash show -p > patch

คำสั่งนี้ให้แฟ้มที่ฉันสามารถย้ายไปยังคอมพิวเตอร์เครื่องอื่นที่ repo นี้ถูกโคลน แต่คำถามคือวิธีการนำเข้ามันเป็นที่ซ่อนอีกครั้ง

ขอบคุณ

คุณสามารถใช้ไฟล์ปะแก้ (โดยไม่ยอมรับการเปลี่ยนแปลง) เพียงแค่เรียกใช้

git apply patchfile

จากนั้นคุณสามารถสร้างที่เก็บใหม่จากไดเรกทอรีการทำงานปัจจุบัน:

git stash

หรือคุณสามารถสร้างสาขาจากที่เก็บของคุณ (บนคอมพิวเตอร์ 1) โดยใช้

git stash branch stashed_changes_branch

กระทำการเปลี่ยนแปลงของคุณ:

git commit -a

จากนั้นเพิ่มเป็นรีโมตบนคอมพิวเตอร์ 2:

git remote add pc1 user@computer1:/path/to/repo

ตอนนี้คุณสามารถดึงข้อมูลระยะไกลโดยใช้

git fetch pc1

ตอนนี้คุณสามารถอิมพอร์ตคอมมิตในแบบที่คุณต้องการ; ใช้git cherry-pick , git rebaseหรืออะไรก็ได้ที่คุณชอบ ... ถ้าคุณต้องการให้มันดูเหมือนว่าคุณเพิ่งใช้git stash ; คุณสามารถใช้git cherry-pick - no-commit

หากคุณไม่มีการเชื่อมต่อโดยตรงระหว่าง computer1 และ computer2; คุณสามารถใช้รีโมต (เช่น GitHub หรืออะไรที่คล้ายกัน):

git push origin stashed_changes_branch

และในคอมพิวเตอร์ 2:

git fetch

อีกวิธีหนึ่งคุณสามารถส่งออกการแคชภายในเครื่องทั้งหมดไปยังผู้รวบรวมอื่นได้ดังนี้

• git pull ทั้งในไดเรกทอรี git เก่าและใหม่ของคุณเพื่อให้แน่ใจว่าทั้งสองมีการเปลี่ยนแปลงล่าสุด
• คัดลอกโฟลเดอร์. git จากไดเรกทอรี git เก่าไปยังที่เก็บใหม่

วิธีการส่งออก Stash ใน SourceTree:

1. สร้างสาขาใหม่ "StashTransfer" จากสาขาที่คุณจะใช้ Stash ของคุณ

2. ใช้ที่ซ่อนของคุณกับมันและทำการกระทำ

3. คลิกที่คอมมิชชันของคุณและทำการปะจากนั้นนำไฟล์แพตช์ไปด้วย

4. ไปที่ที่เก็บอื่นเลือกสาขาหลักเดียวกับที่คุณเพิ่งใช้ใน 1)

5. Actions / Apply Patch เลือกโหมด: แก้ไขไฟล์สำเนาการทำงานกด Apply Apply ตอนนี้คุณมีการแก้ไขที่ไม่ได้รับการแก้ไขจากแพทช์ในสภาพแวดล้อมการทำงานปัจจุบันของคุณ

6. สร้าง Stash ใหม่สำหรับ repo ปัจจุบัน

คุณสามารถสร้างที่ซ่อนเป็นไฟล์ปะแก้จากเครื่องหนึ่งจากนั้นสามารถแชร์ไฟล์แพตช์นั้นกับเครื่องอื่น

การสร้างสะสมเป็นแพทช์

$ git stash show "stash@{0}" -p > changes.patch

“ stash @ {0}” คือการอ้างอิงของ stash.It จะสร้างไฟล์แพตช์ที่มี stash ล่าสุด หากคุณต้องการคำสั่งเดียวให้ใช้คำสั่งต่าง ๆ$ git stash listเพื่อดูรายการสถานะของคุณและเลือกรายการที่คุณต้องการแก้ไข

การใช้โปรแกรมแก้ไข

ตอนนี้โอนที่สะสมไปยังเครื่องอื่นและวางลงในโฟลเดอร์รากของโครงการของคุณ จากนั้นเรียกใช้คำสั่งนี้

$ git apply changes.patch

หากมีข้อผิดพลาดและคุณต้องการย้อนกลับการเปลี่ยนแปลง

$ git apply changes.patch --reverse

ตัวเลือกอื่นคือไปrsyncยัง.gitโฟลเดอร์จากคอมพิวเตอร์เครื่องหนึ่งไปยังคอมพิวเตอร์เครื่องอื่น rsyncประมวลผลเฉพาะการเปลี่ยนแปลงไฟล์ (เร็วกว่าสำเนา)

ข้อเสียอย่างหนึ่งของวิธีนี้คือการกำหนดค่าจะถูกเขียนทับซึ่งอาจไม่ต้องการหากคุณใช้การตั้งค่า. git ที่แตกต่างกันระหว่างเครื่องสองเครื่อง แต่คุณสามารถเอาชนะนี้โดยไม่รวมไฟล์ที่มีตัวเลือกในการ--excludersync

โดยรวมแล้วฉันคิดว่าวิธีแก้ปัญหา Git ดั้งเดิมนั้นสะอาดกว่า แต่การrsyncแฮ็คนี้อาจดีสำหรับบางคนที่อาจคุ้นเคยกับ rsync มากกว่า git

คำสั่งเริ่มต้นจากโพสต์ต้นฉบับ:

git stash show -p stash@{x} > patch_file

ไม่ทำงานสำหรับฉัน (ด้วยเหตุผลบางอย่างมันสร้างไฟล์แพตช์ที่ใช้ไม่ได้) แต่ฉันต้อง:

git stash apply stash@{x}
git commit

สำหรับที่เก็บข้อมูลแต่ละอันฉันต้องการถ่ายโอน จากนั้นฉันวาง repo 'parent' ไว้ในไฟล์: /// การเข้าถึง repo 'child' และทำสิ่งต่อไปนี้สำหรับการสแตชแต่ละครั้ง

git fetch file:///path_to_parent_git && git cherry-pick commit_sha
git reset --soft HEAD^
git stash save my_new_stash_on_child

มันซับซ้อนกว่านี้ แต่ก็เป็นกลอุบายของฉัน

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

สำนักงาน

git commit -m "-stash-"

ครัว

git reset --soft HEAD~1

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

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

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

จากรากของ repo ดั้งเดิม:

1. รับรายการการอ้างอิงที่ซ่อน
2. แท็กการอ้างอิงที่เก็บของคุณเพื่อให้คุณสามารถดึงข้อมูลเหล่านั้นด้วยการเรียก git (ชื่อแท็กไม่ได้เป็น mater เปลี่ยนไปหากมีข้อขัดแย้งฉันใช้stash_+ หมายเลข (s) ในการอ้างอิงการเก็บข้อมูลเชิงตรรกะ)
3. แปลงการอ้างอิงแบบลอจิคัลเป็น sha1 hashes ในลำดับย้อนกลับ - เราจะใช้ในภายหลัง
4. บันทึกเส้นทาง repo นั้น - ไว้ใช้ในภายหลัง

refs=$(git stash list|cut -d: -f1)
for ref in $refs; do tag stash_${ref//[^0-9]} $ref; done
refs=$(git rev-parse $refs|tac)
oldpath=$PWD

หมายเหตุ: สิ่งนี้ต้องใช้ bash หรือเชลล์ที่เข้ากันได้ (ksh, zsh ควรทำ ... ) คุณสามารถเพิ่มตัวแปรได้เช่นกันstash_$((i++))ถ้าเชลล์ไม่รองรับ${param//pattern}

ตอนนี้อยู่ใน repo ใหม่สำหรับแต่ละอ้างอิง:

1. ดึงการอ้างอิงจาก repo เก่า (เราไม่จำเป็นต้องใช้ชื่อแท็กเพราะเราติดแท็กพวกเขาเราสามารถดึงพวกเขาด้วย git fetch)
2. นำเข้าสะสมจากการอ้างอิงอีกครั้งโดยใช้หัวเรื่องของการอ้างอิงนั้นเป็นข้อความที่ซ่อน

for ref in $refs; do git fetch $oldpath $ref; git stash store -m "$(git show -s --pretty=%s $ref)" $ref; done