Rebase komutu için Gıt belgelerine oldukça kısa

--preserve-merges
    Instead of ignoring merges, try to recreate them.

This uses the --interactive machinery internally, but combining it
with the --interactive option explicitly is generally not a good idea
unless you know what you are doing (see BUGS below).

Aslında --koru-birleştirir kullandığınızda oluyor? Nasıl varsayılan davranış (bu bayrak olmadan) farklılık gösteriyor mu? "Birleştirme, vb.. . yeniden ne demek

Geçici bir cevap. Deftere neler olduğunu en azından bir fikir vermesi için.

Normal bir git rebase gibi ---birleştirir korumak ile git ilk müdahale yapılan bir listesini tanımlar bu kısmı grafik işlemek, ve sonra yerine koymak bu başka bir parça üstüne tamamlar. Farklılıkları --tekrar için seçilir işleyen ve bu dinleme işleri nasıl işliyor birleştirme için birleştirir korumak endişe.

Normal arasındaki temel farklar hakkında daha açık olmak ve birleştirme-koruma rebase:

• Birleştirme-koruma rebase tekrar normal ise (bazı) oyuncular birleştirme, rebase tamamen taahhüt birleştirme yok sayar için istekli.
• Tamamlar tekrar birleştirmek için istekli çünkü, birleştirme-koruma rebase ne tanımlamak için vardırdemektiryeniden bir taahhüt birleştirme, ve bazı ekstra kırışıklıklar ile başa çıkmak
  • En ilginç kısmı, kavramsal olarak, belki de tamamlama yeni birleştirme ebeveynler ne olması gerektiği tespit edilir.
  • Birleştirme de açıkça belli kontrol gerektiren haller yeniden işleyen (normal rebase bu konuda endişelenmenize gerek yok oysa. "git checkout <istenen ilk üst>"),
• Birleştirme-koruma rebase tekrar için iptalleri sığ bir set olarak görüyor:
  • Özellikle, yalnızca işlemlerini en son bu yana yapılan temel birleştirme yeniden değerlendirir(s) -- yanien sonzaman, iki dal normal rebase tekrar yaparsa geri ise -- ayrıldıilkzaman bu iki kol ayrıldı.
  • Geçici ve belirsiz olması, bu sonuçta "zaten" "bir birleştirme işlemek. içine de dahil edilmiş" eski tamamlar oynatırken ekran için bir anlamı olduğuna inanıyorum

İlk ben korumak-birleştirir ve daha sonra bazı örnekler olacak". --"yeterince tam olarak tarif etmeye çalışacağız Tabii eğer daha yararlı görünüyorsa örnekleri ile başlatın.

Algoritma"". Kısacası

Eğer gerçekten yabani ot olsun, gıt kaynak indirin ve dosyayı incelemek istediğini "eğer". git-rebase--interactive.sh (Rebase Gıt C çekirdek parçası değil, daha ziyade bash ile yazılmış. Ve perde arkasında, kod paylaşır "interaktif rebase".)

Ama burada bunun özü olduğunu düşündüğüm taslak çizeceğim. Şeylerin sayısını düşünmek azaltmak için, birkaç özgürlükler almış. (örn bilmiyorum denemek çekimi ile 0 doğruluğu kesin sırayla hangi hesaplamaları, ve Yoksay biraz daha az merkezi-görünen konular, örneğin sana ne oldu böyle işliyor zaten cherry-picked arasında dalları).

İlk olarak, non-birleştirme-koruyarak bir rebase oldukça basit olduğunu unutmayın. Daha fazla veya daha az

Find all commits on B but not on A ("git log A..B")
Reset B to A ("git reset --hard A") 
Replay all those commits onto B one at a time in order.

Rebase --koru-birleştirir nispeten karmaşıktır. Burada çok önemli şeyler kaybetmeden bunu yapmak mümkün olmadığım kadar basit

Find the commits to replay:
  First find the merge-base(s) of A and B (i.e. the most recent common ancestor(s))
    This (these) merge base(s) will serve as a root/boundary for the rebase.
    In particular, we'll take its (their) descendants and replay them on top of new parents
  Now we can define C, the set of commits to replay. In particular, it's those commits:
    1) reachable from B but not A (as in a normal rebase), and ALSO
    2) descendants of the merge base(s)
  If we ignore cherry-picks and other cleverness preserve-merges does, it's more or less:
    git log A..B --not $(git merge-base --all A B)
Replay the commits:
  Create a branch B_new, on which to replay our commits.
  Switch to B_new (i.e. "git checkout B_new")
  Proceeding parents-before-children (--topo-order), replay each commit c in C on top of B_new:
    If it's a non-merge commit, cherry-pick as usual (i.e. "git cherry-pick c")
    Otherwise it's a merge commit, and we'll construct an "equivalent" merge commit c':
      To create a merge commit, its parents must exist and we must know what they are.
      So first, figure out which parents to use for c', by reference to the parents of c:
        For each parent p_i in parents_of(c):
          If p_i is one of the merge bases mentioned above:
            # p_i is one of the "boundary commits" that we no longer want to use as parents
            For the new commit's ith parent (p_i'), use the HEAD of B_new.
          Else if p_i is one of the commits being rewritten (i.e. if p_i is in R):
            # Note: Because we're moving parents-before-children, a rewritten version
            # of p_i must already exist. So reuse it:
            For the new commit's ith parent (p_i'), use the rewritten version of p_i.
          Otherwise:
            # p_i is one of the commits that's *not* slated for rewrite. So don't rewrite it
            For the new commit's ith parent (p_i'), use p_i, i.e. the old commit's ith parent.
      Second, actually create the new commit c':
        Go to p_1'. (i.e. "git checkout p_1'", p_1' being the "first parent" we want for our new commit)
        Merge in the other parent(s):
          For a typical two-parent merge, it's just "git merge p_2'".
          For an octopus merge, it's "git merge p_2' p_3' p_4' ...".
        Switch (i.e. "git reset") B_new to the current commit (i.e. HEAD), if it's not already there
  Change the label B to apply to this new branch, rather than the old one. (i.e. "git reset --hard B")

Rebase bir "C" argümanı çok benzer olmalıdır. üzerine ... B BAŞINI oynatma taahhüt başlatmak yerine, C başında çalma yerine işlemek başlayın. (Ve kullanmak yerine B_new. C_new)

Örnek 1

Örneğin, grafik işlemek

  B---C <-- master
 /                     
A-------D------E----m----H <-- topic
         \         /
          F-------G

m ailesi ile tamamlama birleştirme E ve G. bir

Ana üst (C) bir normal kullanarak,-birleştirme-koruma olmayan bir konu hakkında (H) rebased etsek rebase. (Örneğin,ödeme konusu; rebase usta.) Bu durumda, git seçersiniz aşağıdaki tekrar eder:

• D seç
• E seç
• F seç
• G seç
• H seç

ve sonra: grafik tamamlama güncelleme

  B---C <-- master
 /     \                
A       D'---E'---F'---G'---H' <-- topic

(D' D, vb.) tekrarlanmış eşdeğerdir

Birleştirme unutmayın m tekrar seçili değil taahhüt.

Eğer biz ... -birleştirir korumak C üstünde H rebase yerine yaptıysa (örneğin, ödeme konusu; rebase --koru-usta birleştirir.) Bu yeni durumda, git seçersiniz aşağıdaki tekrar eder:

• D seç
• E seç
• F (D üzerine', 'konu' şube)
• G seç (F üzerine', 'konu' şube)
• pick şube '' konu . konu Birleştirme
• H seç

Şimdi molduseçilen tekrar için. Ayrıca birleştirme unutmayın E anne ve G birleştirme önce eklenmesi için seçtiği tamamlama m.

Burada elde edilen tamamlama grafik:

 B---C <-- master
/     \                
A      D'-----E'----m'----H' <-- topic
        \          / 
         F'-------G'

Yine, D' D. cherry-picked (yani yeniden) bir versiyonu', Her vb. E Aynı ana tekrarlanmış olmamıştır tamamlama. Her iki E ve F (m ebeveynleri birleştirme) E olarak yaratılan' ve' m ailesi olarak hizmet etmek'. F

Örnek 2

Normal rebase ile aksine, birleştirme-koruma rebase birden fazla oluşturabilirsiniz akıntıya karşı kafa çocuklar.

Örneğin, göz önünde bulundurun:

  B---C <-- master
 /                     
A-------D------E---m----H <-- topic
 \                 |
  ------- F-----G--/ 

Eğer H (konu) C (ana) üst rebase, daha sonra tamamlar rebase için seçilmiş

• D seç
• E seç
• F seç
• G seç
• m seç
• H seç

Ve sonuç böyle

  B---C  <-- master
 /    | \                
A     |  D'----E'---m'----H' <-- topic
       \            |
         F'----G'---/

Örnek 3

Yukarıdaki örneklerde, her iki birleştirme vardır tekrarlanmış olup iki ebeveyn işleyen ve işlemeye, yerine orijinal birleştirme tamamlama orijinal anne. Ancak, diğer rebases bir tekrarlanmış taahhüt zaten içinde olan ebeveynler ile sona erebilir birleştirme birleştirme önce grafik işlemek.

Örneğin, göz önünde bulundurun:

  B--C---D <-- master
 /    \                
A---E--m------F <-- topic

Eğer master (birleştirir korunması) üzerine konu biz rebase, daha sonra tekrar olacağını taahhüt eder

• birleştirme m tamamlama seç
• F seç

Taahhüt yazılmış grafik gibi görünecektir:

                     B--C--D <-- master
                    /       \             
                   A-----E---m'--F'; <-- topic

Burada da tekrar birleştirme m' önceden var olan grafik taahhüt anne alır,taahhüt yani (usta BAŞI) D ve E (orijinal ebeveynlerden biri m tamamlama birleştirme).

Örnek 4

Birleştirme-koruma rebase belirli karışır "" durumlarda. boş tamamlama En azından bu git bazı eski sürümleri sadece gerçek (örneğin 1.7.8.)

Bu grafik tamamlama:

                   A--------B-----C-----m2---D <-- master
                    \        \         /
                      E--- F--\--G----/
                            \  \
                             ---m1--H <--topic

Hem m1 hem de m2 olarak kaydetme not B ve F. tüm değişiklikler dahil olmalıdır

Eğer "git koru-birleştirir" D (ana) üzerine H rebase (konu), sonra aşağıdaki tamamlar tekrar seçilen:. --yapmaya çalışırsak ..

• m1 seç
• H seç

Not değişiklikleri (B, F) Birleşik m1 gerektiğini çoktan dahil D. (Bu değişiklikler gerektiğini çoktan dahil m2, çünkü m2 birleştirir birlikte çocukların B ve F). bu Nedenle, kavramsal olarak, yeniden m1 üstünde D muhtemelen de bir no-op veya oluşturmak boş bir taahhüt olması (yani bir yerde diff arasında ardışık revizyonlar boş).

Bunun yerine, ancak, gıt bir hata alabilirsiniz D. üstüne m1 tekrar denemesi reddedebilir bunun gibi

error: Commit 90caf85 is a merge but no -m option was given.
fatal: cherry-pick failed

Bir git bir bayrak geçirmek için unutmuş gibi görünüyor, ama temel sorun git sevmedikleri boş oluşturmayı taahhüt eder.