การซ่อนการเปลี่ยนแปลงในคอมไพล์เท่านั้น - เป็นไปได้หรือไม่

มีวิธีที่ฉันสามารถซ่อนเพียงการเปลี่ยนแปลงของฉันจัดฉาก? สถานการณ์ที่ฉันมีปัญหาคือเมื่อฉันทำงานกับข้อบกพร่องหลายอย่างในเวลาที่กำหนดและมีการเปลี่ยนแปลงที่ไม่แน่นอนหลายอย่าง ฉันต้องการให้สามารถจัดวางไฟล์เหล่านี้ทีละรายการสร้างไฟล์. patch ของฉันและซ่อนไว้จนกว่ารหัสจะได้รับอนุมัติ ด้วยวิธีนี้เมื่อได้รับการอนุมัติฉันสามารถซ่อนเซสชันทั้งหมดของฉัน (ปัจจุบัน) ป๊อปอัปบั๊กนั้นแล้วกดรหัส

ฉันจะไปในทางที่ผิด? ฉันเข้าใจผิดว่า git สามารถทำงานในวิธีอื่นเพื่อทำให้กระบวนการของฉันง่ายขึ้นได้อย่างไร

ใช่เป็นไปได้ด้วยDOUBLE STASH

1. จัดวางไฟล์ทั้งหมดของคุณที่คุณต้องการซ่อน
2. git stash --keep-indexวิ่ง คำสั่งนี้จะสร้างที่เก็บของที่มีการเปลี่ยนแปลงทั้งหมดของคุณ ( staged และ unstaged ) แต่จะออกจากการเปลี่ยนแปลง staged ในไดเร็กทอรีการทำงานของคุณ (ยังอยู่ในสถานะ staged)
3. วิ่ง git stash push -m "good stash"
4. ตอนนี้คุณ"good stash"มีฉากไฟล์เท่านั้น

ตอนนี้หากคุณต้องการไฟล์ที่ไม่มีการจัดเรียงก่อนที่จะซ่อนเพียงแค่ใช้ที่ซ่อนแรก ( ไฟล์ที่สร้างด้วย--keep-index ) และตอนนี้คุณสามารถลบไฟล์ที่คุณซ่อนไว้"good stash"ได้

สนุก

ด้วยคอมไพล์ล่าสุดคุณสามารถใช้--patchตัวเลือก

git stash push --patch  

git stash save --patch   # for older git versions

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

UPD
Alias ​​สำหรับDouble Stash :

git config --global alias.stash-staged '!bash -c "git stash --keep-index; git stash push -m "staged" --keep-index; git stash pop stash@{1}"'

git stash-stagedตอนนี้คุณสามารถเวทีไฟล์ของคุณและเรียกใช้แล้ว
เป็นผลไฟล์ฉากของคุณจะถูกบันทึกลงในที่ซ่อน

หากคุณไม่ต้องการเก็บไฟล์ที่มีการจัดฉากไว้และต้องการย้ายไปไว้ในที่เก็บของ จากนั้นคุณสามารถเพิ่มชื่อแทนอื่นและเรียกใช้git move-staged:

git config --global alias.move-staged '!bash -c "git stash-staged;git commit -m "temp"; git stash; git reset --hard HEAD^; git stash pop"'

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

(ขอบคุณBartłomiejสำหรับจุดเริ่มต้น)

#!/bin/bash

#Stash everything temporarily.  Keep staged files, discard everything else after stashing.
git stash --keep-index

#Stash everything that remains (only the staged files should remain)  This is the stash we want to keep, so give it a name.
git stash save "$1"

#Apply the original stash to get us back to where we started.
git stash apply stash@{1}

#Create a temporary patch to reverse the originally staged changes and apply it
git stash show -p | git apply -R

#Delete the temporary stash
git stash drop stash@{1}

TL; DRเพียงเพิ่มพารามิเตอร์-- $(git diff --staged --name-only)git ของคุณ<pathspec>

นี่คือหนึ่งซับง่าย:

git stash -- $(git diff --staged --name-only)

และเพื่อเพิ่มข้อความง่ายๆ:

git stash push -m "My work in progress" -- $(git diff --staged --name-only)

ทดสอบกับv2.17.1และv2.21.0windows.1

ข้อ จำกัด :

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

เพื่อบรรลุสิ่งเดียวกัน ...

1. สเตจไฟล์ที่คุณต้องการทำงาน
2. git commit -m 'temp'
3. git add .
4. git stash
5. git reset HEAD~1

ความเจริญ ไฟล์ที่คุณไม่ต้องการถูกซ่อน ไฟล์ที่คุณต้องการพร้อมสำหรับคุณ

ในสถานการณ์นี้ฉันต้องการสร้างสาขาใหม่สำหรับแต่ละปัญหา ฉันใช้คำนำหน้า temp / ดังนั้นฉันรู้ว่าฉันสามารถลบสาขาเหล่านี้ได้ในภายหลัง

git checkout -b temp/bug1

สเตจไฟล์ที่แก้ไข bug1 และคอมมิต

git checkout -b temp/bug2

จากนั้นคุณสามารถเลือกรับเชอร์รี่จากสาขาตามที่ต้องการและส่งคำขอดึง

ทำไมคุณไม่ยอมรับการเปลี่ยนแปลงสำหรับข้อผิดพลาดบางอย่างและสร้างแพทช์จากการคอมมิทนั้นและบรรพบุรุษของมัน?

# hackhackhack, fix two unrelated bugs
git add -p                   # add hunks of first bug
git commit -m 'fix bug #123' # create commit #1
git add -p                   # add hunks of second bug
git commit -m 'fix bug #321' # create commit #2

จากนั้นในการสร้างแพตช์ที่เหมาะสมให้ใช้git format-patch:

git format-patch HEAD^^

สิ่งนี้จะสร้างสองไฟล์: 0001-fix-bug-123.patchและ0002-fix-bug-321.patch

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

git stash --keep-index เป็นทางออกที่ดี ... ยกเว้นว่าจะไม่ทำงานอย่างถูกต้องบนเส้นทางที่ถูกลบไปซึ่งได้รับการแก้ไขใน Git 2.23 (ไตรมาสที่ 3 ปี 2019)

ดูกระทำ b932f6a (16 กรกฎาคม 2019) โดยโทมัส Gummerer (tgummerer )
^{(รวมโดยJunio C Hamano - gitster-ในการกระทำ f8aee85 , 25 กรกฎาคม 2019)}

stash: แก้ไขการจัดการไฟล์ที่ถูกลบด้วย --keep-index

git stash push --keep-index ควรเก็บการเปลี่ยนแปลงทั้งหมดที่เพิ่มไว้ในดัชนีทั้งในดัชนีและบนดิสก์

ขณะนี้สิ่งนี้ไม่ทำงานอย่างถูกต้องเมื่อไฟล์ถูกลบออกจากดัชนี
แทนที่จะทำให้มันถูกลบบนดิสก์ ** - Keep-indexจะกู้คืนไฟล์ในปัจจุบัน **

แก้ไขพฤติกรรมนั้นโดยใช้ ' git checkout' ในโหมดไม่มีการซ้อนทับซึ่งสามารถกู้คืนดัชนีและแผนผังการทำงานได้อย่างสมบูรณ์
นอกจากนี้ยังลดความซับซ้อนของรหัส

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

การจัดทำดัชนี (การเปลี่ยนแปลงแบบฉาก) ใน Git นั้นยากกว่าที่ควรเป็น ฉันพบคำตอบของ Joe ที่ทำงานได้ดีและเปลี่ยนความแตกต่างเล็กน้อยให้เป็นนามแฝงนี้:

stash-index = "!f() { \
  git stash push --quiet --keep-index -m \"temp for stash-index\" && \
  git stash push \"$@\" && \
  git stash pop --quiet stash@{1} && \
  git stash show -p | git apply -R; }; f"

มันผลักดันการเปลี่ยนแปลงทั้งฉากและไม่มีฉากเป็นที่เก็บชั่วคราว จากนั้นจะผลักดันการเปลี่ยนแปลงที่มีการจัดฉากไว้ในที่เก็บซึ่งเป็นที่เก็บที่เราต้องการเก็บไว้ อาร์กิวเมนต์ส่งผ่านไปยังนามแฝงเช่น--message "whatever"จะถูกเพิ่มในคำสั่ง stash นี้ ในที่สุดมันจะปรากฏที่ซ่อนชั่วคราวเพื่อคืนค่าสถานะเดิมและลบที่เก็บชั่วคราวออกและจากนั้นในที่สุดก็ "ลบ" การเปลี่ยนแปลงที่เก็บไว้จากไดเรกทอรีการทำงานผ่านทางแอพพลิเคชั่นย้อนกลับ

สำหรับปัญหาตรงข้ามของการหยุดนิ่งเพียงแค่การเปลี่ยนแปลงที่ไม่ได้จัดทำ (นามแฝงstash-working) ดูคำตอบนี้

จำเป็นหรือไม่ที่จะต้องทำงานกับบั๊กหลายตัวในครั้งเดียว และโดย "พร้อมกัน" ฉันหมายถึง "การแก้ไขไฟล์สำหรับข้อบกพร่องหลายรายการในเวลาเดียวกัน" เพราะหากคุณไม่ต้องการสิ่งนั้นจริงๆฉันจะทำงานกับบั๊กเพียงครั้งเดียวในสภาพแวดล้อมของคุณ ด้วยวิธีนี้คุณสามารถใช้สาขาในท้องถิ่น & การคืนเงินซึ่งฉันพบได้ง่ายกว่าการจัดการที่ซับซ้อน / เวที

สมมติว่า master กำลังทำงาน B ตอนนี้ทำงานกับ bug # 1

git checkout -b bug1

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

A-B < master
   \
    C < bug1

ตอนนี้คุณกำลังทำงานกับ bug2 ไปกลับgit checkout masterไปต้นแบบที่มี สร้างสาขาใหม่git checkout -b bug2. ทำการเปลี่ยนแปลงคอมมิชชันรอการตรวจทานโค้ด

    D < bug2
   /
A-B < master
   \
    C < bug1

มาทำท่าว่าคนอื่นจะยอมรับ E&F กับนายขณะที่คุณรอการทบทวนอยู่

    D < bug2
   /
A-B-E-F < master
   \
    C < bug1

เมื่อรหัสของคุณได้รับการอนุมัติคุณสามารถรีบูตมันเป็นหลักได้ด้วยขั้นตอนต่อไปนี้:

git checkout bug1
git rebase master
git checkout master
git merge bug1

สิ่งนี้จะส่งผลให้:

    D < bug2
   /
A-B-E-F-C' < master, bug1

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

ตอบคำถามของ ctote ในความคิดเห็น:

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

git rebase -iดังนั้น

เมื่อคุณรีบูตสาขาหนึ่งไปยังสาขาอื่นคุณสามารถทำแบบโต้ตอบได้ (แฟล็ก -i) เมื่อคุณทำเช่นนี้คุณมีตัวเลือกในการเลือกสิ่งที่คุณต้องการจะทำกับแต่ละการกระทำ Pro Git เป็นหนังสือที่ยอดเยี่ยมซึ่งยังออนไลน์อยู่ในรูปแบบ HTML และมีส่วนที่ดีในการรีบูท & squashing:

http://git-scm.com/book/ch6-4.html

ฉันจะขโมยตัวอย่างคำต่อคำของพวกเขาเพื่อความสะดวก แกล้งทำเป็นว่าคุณมีประวัติการกระทำดังต่อไปนี้และคุณต้องการที่จะ rebase & squash bug1 ไปยังมาสเตอร์:

    F < bug2
   /
A-B-G-H < master
   \
    C-D-E < bug1

นี่คือสิ่งที่คุณจะเห็นเมื่อคุณพิมพ์ git rebase -i master bug1

pick f7f3f6d changed my name a bit
pick 310154e updated README formatting and added blame
pick a5f4a0d added cat-file
#
# Commands:
#  p, pick = use commit
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#

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

pick f7f3f6d changed my name a bit
s 310154e updated README formatting and added blame
s a5f4a0d added cat-file
#
# Commands:
#  p, pick = use commit
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit

ดังนั้นการบีบเป็นความเจ็บปวดเล็กน้อย แต่ฉันยังคงแนะนำให้ใช้อย่างหนัก

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

git checkout -b bug1    # create the development branch
* hack hack hack *      # do some work
git commit
* hack hack hack *
git commit
* hack hack hack *
git commit
* hack hack hack *
git commit
git checkout master     # go back to the master branch
git merge --squash bug1 # merge the work back
git commit              # commit the merge (don't forget
                        #    to change the default commit message)
git branch -D bug1      # remove the development branch

ข้อดีของโพรซีเดอร์นี้คือคุณสามารถใช้โฟลว์การทำงานของคอมไพล์ปกติ

TL; DR ;git stash-staged

หลังจากสร้างนามแฝง:

git config --global alias.stash-staged '!bash -c "git stash -- \$(git diff --staged --name-only)"'

ที่นี่git diffส่งคืนรายการ--stagedไฟล์--name-only
จากนั้นเราส่งรายการนี้pathspecเพื่อgit stashคอมม่า

จากman git stash:

git stash [--] [<pathspec>...]

<pathspec>...
   The new stash entry records the modified states only for the files
   that match the pathspec. The index entries and working tree
   files are then rolled back to the state in HEAD only for these
   files, too, leaving files that do not match the pathspec intact.

หากต้องการตัดการเปลี่ยนแปลงที่ไม่ตั้งใจโดยเฉพาะอย่างยิ่งการลบหลายไฟล์ให้ทำดังต่อไปนี้:

git add <stuff to keep> && git stash --keep-index && git stash drop

กล่าวอีกนัยหนึ่งคือเก็บอึแล้วโยนทิ้งไปพร้อม ๆ กัน

ทดสอบใน git เวอร์ชั่น 2.17.1