Sadece git'te aşamalı değişiklikler saklamak mümkün mü?

Sadece sahnelediğim değişiklikleri saklamamın bir yolu var mı? Sorun yaşadığım senaryo, belirli bir zamanda birkaç hata üzerinde çalıştığımda ve birkaç değişmemiş değişiklik olduğunda. Kodları onaylanıncaya kadar bu dosyaları tek tek hazırlayabilmek, .patch dosyalarımı oluşturmak ve saklamak istiyorum. Bu şekilde, onaylandığında tüm (geçerli) oturumumu saklayabilir, bu hatayı açıp kodu itebilirim.

Buna yanlış mı gidiyorum? Git'in sürecimi basitleştirmek için başka şekillerde nasıl çalışabileceğini yanlış mı anlıyorum?

Evet, ÇİFT STASH ile mümkün

1. İhtiyacınız olan tüm dosyalarınızı saklayın.
2. Koş git stash --keep-index. Bu komut TÜM değişikliklerinizle birlikte bir stash oluşturacak ( aşamalı ve etiketsiz ), ancak aşamalı değişiklikleri çalışma dizininizde bırakacaktır (hala durum aşamasındadır).
3. Çalıştırmak git stash push -m "good stash"
4. Artık reklam "good stash"gelmiştir SADECE dosyaları düzenledi .

Şimdi stash'tan önce işaretlenmemiş dosyalara ihtiyacınız varsa, ilk stash'ı ( ile oluşturulmuş olan--keep-index ) uygulayın ve şimdi stash yaptığınız dosyaları kaldırabilirsiniz "good stash".

Zevk almak

En son git ile --patchseçeneği kullanabilirsiniz

git stash push --patch  

git stash save --patch   # for older git versions

Ve git sizden dosyalarınızdaki her değişikliği saklamak isteyip istemediğinizi soracaktır.
Sadece cevap veriyorsun yveyan

ÇİFT STASH
için UPD Takma Adı :

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

Şimdi dosyalarınızı aşamalı olarak çalıştırabilirsiniz git stash-staged.
Sonuç olarak , hazırladığınız dosyalar saklanır .

Aşamalı dosyaları saklamak istemiyorsanız ve bunları saklamak istiyorsanız. Ardından başka bir takma ad ekleyebilir ve çalıştırabilirsiniz 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"'

Sadece şu anda sahnelenen şeyleri saklayan ve diğer her şeyi bırakan bir senaryo hazırladım. Çok fazla ilgisiz değişiklik yapmaya başladığımda bu harika. Sadece istenen taahhüd ile ilgili olmayan şeyleri hazırlayın ve saklayın.

(Başlangıç ​​noktası için Bartłomiej'e teşekkürler)

#!/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 Hemen eklemek -- $(git diff --staged --name-only)için git için <pathspec>parametre

İşte basit bir astar:

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

Ve bir mesaj eklemek için:

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

V2.17.1 ve v2.21.0.windows.1 üzerinde test edilmiştir

Sınırlamalar:

• Hazırlanmış dosya yoksa, bunun her şeyi saklayacağını lütfen unutmayın.
• Ayrıca, yalnızca kısmen aşamalı bir dosyanız varsa (diğer bir deyişle, yalnızca bazı değiştirilen satırlar, diğer bazı değiştirilen satırlar değilken hazırlanır), tüm dosya saklanır (sabit olmayan satırlar dahil).

Aynı şeyi başarmak için ...

1. Yalnızca üzerinde çalışmak istediğiniz dosyaları hazırlayın.
2. git commit -m 'temp'
3. git add .
4. git stash
5. git reset HEAD~1

Boom. İstemediğiniz dosyalar saklanır. İstediğiniz dosyaların hepsi sizin için hazır.

Bu senaryoda, her sorun için yeni dallar oluşturmayı tercih ediyorum. Bir önek temp / kullanıyorum, bu şubeleri daha sonra silebileceğimi biliyorum.

git checkout -b temp/bug1

Hata1'i düzelten ve teslim eden dosyaları hazırlayın.

git checkout -b temp/bug2

Daha sonra kirazları gerektiği gibi ilgili dallardan alabilir ve bir çekme talebi gönderebilirsiniz.

Neden belirli bir hata için değişikliği yapmıyorsunuz ve bu taahhüt ve selefinden bir yama oluşturmuyorsunuz?

# 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

Ardından, uygun yamaları oluşturmak için şunu kullanın git format-patch:

git format-patch HEAD^^

Bu iki dosya oluşturur: 0001-fix-bug-123.patchve0002-fix-bug-321.patch

Veya her hata için ayrı dallar oluşturabilirsiniz, böylece hata düzeltmelerini tek tek birleştirebilir veya yeniden çözebilir, hatta çalışmazlarsa silebilirsiniz.

git stash --keep-index iyi bir çözümdür ... ancak Git 2.23'te (3. Çeyrek 2019) düzeltilen kaldırılan yollarda düzgün çalışmadıysa

Bakınız Thomas Gummerer ( ) tarafından b932f6a (16 Tem 2019 ) . ^{(Göre Birleştirilmiş - Junio Cı Hamano - içinde f8aee85 tamamlama 2019 25 Tem)}tgummerer
gitster

stash: ile kaldırılan dosyaların işlenmesi düzeltildi --keep-index

git stash push --keep-index dizinde eklenmiş olan tüm değişiklikleri hem dizinde hem de diskte tutması gerekir.

Şu anda bir dosya dizinden kaldırıldığında bu doğru davranmıyor.
Diskte silinmiş tutmak yerine ** - keep-index şu anda dosyayı geri yükler. **

Bu davranışı git checkout, dizin ve çalışma ağacına sadakatle geri yükleyebilen yer paylaşımsız modda ' ' kullanarak düzeltin .
Bu aynı zamanda kodu basitleştirir.

İzlenmeyen dosya dizinde silinmiş bir dosyayla aynı ada sahipse, izlenmeyen dosyaların üzerine yazılacağını unutmayın.

Git'te yalnızca dizini (aşamalı değişiklikler) saklamak olması gerekenden daha zordur. @ Joe'nun iyi çalışmasına cevap buldum ve küçük bir varyasyonunu bu takma ada dönüştürdüm:

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"

Hem aşamalı hem de değişmemiş değişiklikleri geçici bir depoya iterek aşamalı değişiklikleri yalnız bırakır. Ardından, aşamalı değişiklikleri saklamak istediğimiz zulası olan zulasına iter. Takma ada iletilen bağımsız değişkenler, --message "whatever"bu stash komutuna eklenecektir. Son olarak, orijinal durumu geri yüklemek ve geçici saklamayı kaldırmak için geçici saklayıcı açılır ve son olarak saklanan değişiklikleri bir ters yama uygulaması aracılığıyla çalışma dizininden "kaldırır".

Sadece saklanmayan değişimleri (takma ad stash-working) saklama zıt problemi için bu cevaba bakınız .

Aynı anda birkaç böcek üzerinde çalışmak kesinlikle gerekli mi? "Aynı anda" demek istediğim "dosyaların aynı anda birden çok hata için düzenlenmesi." Çünkü buna kesinlikle ihtiyacınız olmadığı sürece, ortamınızdaki her seferinde sadece bir hata üzerinde çalışacağım. Bu şekilde karmaşık şubeleri / aşamaları yönetmekten çok daha kolay bulduğum yerel şubeleri ve rebase'i kullanabilirsiniz.

Diyelim ki usta B işinde. Şimdi hata # 1 üzerinde çalışın.

git checkout -b bug1

Şimdi şube hata 1'de. Bazı değişiklikler yapın, taahhüt edin, kod incelemesini bekleyin. Bu yereldir, bu yüzden kimseyi etkilemezsiniz ve git diffs'den bir yama yapmak yeterince kolay olmalıdır.

A-B < master
   \
    C < bug1

Şimdi bug2 üzerinde çalışıyorsunuz. İle master yapmaya geri dön git checkout master. Yeni bir dal yap git checkout -b bug2. Değişiklik yapın, taahhüt edin, kod incelemesini bekleyin.

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

İncelemeyi beklerken başkasının E & F'yi ustalıkla taahhüt ettiğini varsayalım.

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

Kodunuz onaylandığında, aşağıdaki adımlarla ustalaşmak için kodu yeniden oluşturabilirsiniz:

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

Bu aşağıdakilerle sonuçlanacaktır:

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

Ardından, yerel bug1 dalınızı itebilir, silebilir ve yola çıkabilirsiniz. Çalışma alanınızdaki her seferinde bir hata, ancak yerel dalları kullanarak deponuz birden çok hatayı işleyebilir. Ve bu karmaşık bir sahne / stash dansı önler.

Yorumlarda ctote'nin sorusuna cevap verin:

Her hata için saklamaya geri dönebilir ve bir seferde yalnızca bir hata ile çalışabilirsiniz. En azından sahneleme sorununu kurtarır. Ama bunu denedikten sonra, kişisel olarak zahmetli buluyorum. Zımbalar git günlük grafiğinde biraz dağınıktır. Ve daha da önemlisi, bir şeyi mahvederseniz, geri dönemezsiniz. Kirli bir çalışma dizininiz varsa ve bir zulayı açarsanız, o pop'u "geri alamazsınız". Mevcut taahhütleri bertaraf etmek çok daha zordur.

Yani git rebase -i.

Bir dalı diğerine yeniden adlandırdığınızda, etkileşimli olarak yapabilirsiniz (-i bayrağı). Bunu yaptığınızda, her taahhütte ne yapmak istediğinizi seçme seçeneğiniz vardır. Pro Git, HTML biçiminde de çevrimiçi olan ve yeniden bastırma ve ezme konusunda güzel bir bölüme sahip harika bir kitap:

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

Kolaylık sağlamak için örneklerini aynen çalacağım. Aşağıdaki işlem geçmişine sahip olduğunuzu varsayın ve bug1'i master'a yeniden oluşturmak ve ezmek istediğinizi varsayalım:

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

İşte yazarken görecekleriniz 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.
#

Bir dalın tüm taahhütlerini tek bir taahhütte ezmek için, ilk taahhüdü "pick" olarak saklayın ve sonraki tüm "pick" girişlerini "squash" veya basitçe "s" ile değiştirin. İşlem mesajını da değiştirme fırsatı elde edersiniz.

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

Yani evet, ezmek biraz acı verici, ama yine de ağır miktarda saklamak için tavsiye ederim.

Mike Monkiewicz cevabı hakkındaki yorumlarınızdan daha basit bir model kullanmanızı öneririz: Düzenli geliştirme dalları kullanın, ancak ana dalınızda tek bir taahhüt almak için birleştirme işleminin kabak seçeneğini kullanın:

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

Bu prosedürün avantajı, normal git iş akışını kullanabilmenizdir.

TL; DR ;git stash-staged

Bir takma ad oluşturduktan sonra:

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

İşte git difflistesini döndürür --stageddosyaları --name-only
Ve sonra bu listeyi geçmesi pathspeciçin git stashcommad.

Gönderen 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.

Yanlışlıkla yapılan bir değişikliği, özellikle birden fazla dosyanın silinmesini önlemek için aşağıdakileri yapın:

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

başka bir deyişle, bok saklamak ve tamamen saklamak ile atmak.

Git 2.17.1 sürümünde test edildi