Git'teki birden çok taahhüdün yazarını ve değiştiren adını ve e-postasını nasıl değiştirebilirim?

Okul bilgisayarında basit bir senaryo yazıyordum ve Git'teki değişiklikleri (pendrive'ımdaki bir repoda, evdeki bilgisayarımdan klonlanmış) yapıyordum. Birkaç işlemden sonra kök kullanıcı olarak bir şeyler yaptığımı fark ettim.

Bu taahhütlerin yazarını benim adımla değiştirmenin bir yolu var mı?

Bu cevap kullanımları git-filter-branchiçin de docs şimdi bu uyarı vermek:

git filter-branch, hedeflenen tarih yeniden yazımının belirgin olmayan manglinglerini üretebilen (ve bu tür bir dipsiz performansa sahip olduğu için bu tür sorunları araştırmak için size çok az zaman bırakabilecek) çok sayıda tuzağa sahiptir. Bu güvenlik ve performans sorunları geriye dönük olarak uyumlu şekilde sabitlenemez ve bu nedenle kullanılması önerilmez. Lütfen git filter-repo gibi alternatif bir geçmiş filtreleme aracı kullanın . Git filtre dalını kullanmaya devam etmeniz gerekiyorsa, lütfen filtre dalının kara mayınları hakkında bilgi edinmek için lütfen GÜVENLİK (ve PERFORMANS ) bölümünü dikkatlice okuyun ve orada listelenen tehlikelerden mümkün olduğunca makul bir şekilde kaçının.

Yazarın (ya da değiştiricinin) değiştirilmesi, tüm tarihin yeniden yazılmasını gerektirir. Bu konuda iyiyseniz ve buna değer olduğunu düşünüyorsanız, git filter-branch'u kontrol etmelisiniz . Man sayfası, başlamanıza yardımcı olacak birkaç örnek içerir. Ayrıca, yazarın adını, değiştiricisini, tarihlerini vb. Değiştirmek için ortam değişkenlerini kullanabileceğinizi unutmayın - git man sayfasının "Ortam Değişkenleri" bölümüne bakın .

Özellikle, bu komutla tüm dallar ve etiketler için tüm yanlış yazar adlarını ve e-postalarını düzeltebilirsiniz (kaynak: GitHub help ):

#!/bin/sh

git filter-branch --env-filter '
OLD_EMAIL="your-old-email@example.com"
CORRECT_NAME="Your Correct Name"
CORRECT_EMAIL="your-correct-email@example.com"
if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
    export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
    export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

NOT: Bu cevap SHA1'leri değiştirir, bu yüzden daha önce itilmiş olan bir dalda kullanmaya dikkat edin. Yalnızca bir adın yazımını düzeltmek veya eski bir e-postayı güncellemek istiyorsanız git, bunu geçmişi yeniden yazmadan yapabilirsiniz .mailmap. Diğer cevabımı gör .

Etkileşimli Rebase Kullanımı

Yapabilirsin

git rebase -i -p <some HEAD before all of your bad commits>

Ardından, tüm kötü taahhütlerinizi rebase dosyasında "düzenle" olarak işaretleyin. İlk taahhüdünüzü de değiştirmek istiyorsanız, rebase dosyasında ilk satır olarak manuel olarak eklemeniz gerekir (diğer satırların biçimini izleyin). Sonra git, sizden her taahhütte değişiklik yapmanızı istediğinde,

 git commit --amend --author "New Author Name <email@address.com>" 

açılan düzenleyiciyi düzenleyin veya kapatın ve ardından

git rebase --continue

Rebase'e devam etmek.

--no-edit Komutun şu şekilde olması için editörü ekleyerek burada açmayı atlayabilirsiniz :

git commit --amend --author "New Author Name <email@address.com>" --no-edit && \
git rebase --continue

Tek İşlem

Bazı yorumcuların belirttiği gibi, sadece en son taahhüdü değiştirmek istiyorsanız, rebase komutu gerekli değildir. Sadece yap

 git commit --amend --author "New Author Name <email@address.com>"

Bu belirtilen isme yazar değişecek, ama committer yapılandırılmış kullanıcıya ayarlanacaktır git config user.nameve git config user.email. Committer'ı belirttiğiniz bir şeye ayarlamak istiyorsanız, bu hem yazarı hem de committer'ı ayarlar:

 git -c user.name="New Author Name" -c user.email=email@address.com commit --amend --reset-author

Birleştirme Taahhütleri Hakkında Not

Orijinal yanıtımda hafif bir kusur vardı. Akım HEADile sizin arasında birleştirme taahhütleri varsa <some HEAD before all your bad commits>, git rebasebunları düzleştirir (ve bu arada, GitHub çekme isteklerini kullanırsanız, geçmişinizde bir ton birleştirme taahhütleri olacaktır). Bu genellikle çok farklı bir geçmişe yol açabilir (yinelenen değişiklikler "yeniden temel alınabilir") ve en kötü durumda, git rebasebirleştirme işlemlerinde büyük olasılıkla çözülmüş olan zor birleştirme çakışmalarını çözmenizi isteyebilir. Çözüm, tarihinizin birleştirme yapısını koruyacak -pbayrağı kullanmaktır git rebase. Manpage, kullanımı ve sorunlara yol açabileceği git rebasekonusunda uyarır , ancak-p-iBUGS "Taahhütlerin düzenlenmesi ve taahhüt mesajlarının yeniden düzenlenmesi işe yaramalıdır."

-pYukarıdaki komuta ekledim . En son taahhüdü değiştirdiğiniz durumda, bu bir sorun değildir.

Ayrıca şunları da yapabilirsiniz:

git filter-branch --commit-filter '
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "$@";
        else
                git commit-tree "$@";
        fi' HEAD

Bu komutu Windows komut isteminde kullanıyorsanız, aşağıdakiler "yerine kullanmanız gerekir ':

git filter-branch --commit-filter "
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "$@";
        else
                git commit-tree "$@";
        fi" HEAD

Bir astar, ancak çok kullanıcılı bir deponuz varsa dikkatli olun - bu, tüm taahhütleri aynı (yeni) yazar ve komisyoncuya sahip olacak şekilde değiştirecektir .

git filter-branch -f --env-filter "GIT_AUTHOR_NAME='Newname'; GIT_AUTHOR_EMAIL='new@email'; GIT_COMMITTER_NAME='Newname'; GIT_COMMITTER_EMAIL='new@email';" HEAD

Dizedeki satır aralıklarıyla (bash'da mümkündür):

git filter-branch -f --env-filter "
    GIT_AUTHOR_NAME='Newname'
    GIT_AUTHOR_EMAIL='new@email'
    GIT_COMMITTER_NAME='Newname'
    GIT_COMMITTER_EMAIL='new@email'
  " HEAD

Başlatılmış bir $ HOME / .gitconfig dosyası olmadığında olur. Bunu şu şekilde düzeltebilirsiniz:

git config --global user.name "you name"
git config --global user.email you@domain.com
git commit --amend --reset-author

git sürüm 1.7.5.4 ile test edildi

Tek bir taahhüt için:

git commit --amend --author="Author Name <email@address.com>"

(hissedarın cevabından çıkarılmıştır)

Sadece en iyi birkaç komisyonun kötü yazarları olması durumunda, bunu komut ve taahhüt git rebase -ikullanarak aşağıdaki gibi yapabilirsiniz:exec--amend

git rebase -i HEAD~6 # as required

size düzenlenebilir taahhüt listesi sunar:

pick abcd Someone else's commit
pick defg my bad commit 1
pick 1234 my bad commit 2

Ardından exec ... --author="..."kötü yazarlı tüm satırlardan sonra satır ekleyin :

pick abcd Someone else's commit
pick defg my bad commit 1
exec git commit --amend --author="New Author Name <email@address.com>" -C HEAD
pick 1234 my bad commit 2
exec git commit --amend --author="New Author Name <email@address.com>" -C HEAD

kaydedin ve düzenleyiciden çıkın (çalıştırmak için).

Bu çözüm diğerlerinden daha uzun sürebilir, ancak oldukça kontrol edilebilir - Ne işe yaradığını tam olarak biliyorum.

İlham için @asmeurer'a teşekkürler.

Github, aşağıdaki kabuk betiği olan güzel bir çözüme sahiptir :

#!/bin/sh

git filter-branch --env-filter '

an="$GIT_AUTHOR_NAME"
am="$GIT_AUTHOR_EMAIL"
cn="$GIT_COMMITTER_NAME"
cm="$GIT_COMMITTER_EMAIL"

if [ "$GIT_COMMITTER_EMAIL" = "your@email.to.match" ]
then
    cn="Your New Committer Name"
    cm="Your New Committer Email"
fi
if [ "$GIT_AUTHOR_EMAIL" = "your@email.to.match" ]
then
    an="Your New Author Name"
    am="Your New Author Email"
fi

export GIT_AUTHOR_NAME="$an"
export GIT_AUTHOR_EMAIL="$am"
export GIT_COMMITTER_NAME="$cn"
export GIT_COMMITTER_EMAIL="$cm"
'

Belgeselde de belirtildiği gibi, yeniden yazma tarihi tehlikelidir ve diğer insanların depolarını kıracaktır.

Ancak bunu gerçekten yapmak istiyorsanız ve bir bash ortamındaysanız (Linux'ta sorun yok, Windows'ta, git kurulumu ile sağlanan git bash'ı kullanabilirsiniz) git filter-branch kullanın :

git filter-branch --env-filter '
  if [ $GIT_AUTHOR_EMAIL = bad@email ];
    then GIT_AUTHOR_EMAIL=correct@email;
  fi;
export GIT_AUTHOR_EMAIL'

İşleri hızlandırmak için, yeniden yazmak istediğiniz bir dizi düzeltme belirtebilirsiniz:

git filter-branch --env-filter '
  if [ $GIT_AUTHOR_EMAIL = bad@email ];
    then GIT_AUTHOR_EMAIL=correct@email;
  fi;
export GIT_AUTHOR_EMAIL' HEAD~20..HEAD

Başka bir yazardan birleştirilmemiş bir taahhüt devralırken, bunu ele almanın kolay bir yolu vardır.

git commit --amend --reset-author

Bunu bir takma ad olarak kullanabilirsiniz, böylece şunları yapabilirsiniz:

git change-commits GIT_AUTHOR_NAME "old name" "new name"

veya son 10 taahhüt için:

git change-commits GIT_AUTHOR_EMAIL "old@email.com" "new@email.com" HEAD~10..HEAD

~ / .Gitconfig dosyasına ekleyin:

[alias]
    change-commits = "!f() { VAR=$1; OLD=$2; NEW=$3; shift 3; git filter-branch --env-filter \"if [[ \\\"$`echo $VAR`\\\" = '$OLD' ]]; then export $VAR='$NEW'; fi\" $@; }; f "

Kaynak: https://github.com/brauliobo/gitconfig/blob/master/configs/.gitconfig

Umarım faydalıdır.

Bu @ Brian'ın versiyonunun daha ayrıntılı bir versiyonudur:

Yazarı ve değiştiriciyi değiştirmek için bunu yapabilirsiniz (dizede bash içinde mümkün olan satır izleri ile):

git filter-branch --env-filter '
    if [ "$GIT_COMMITTER_NAME" = "<Old name>" ];
    then
        GIT_COMMITTER_NAME="<New name>";
        GIT_COMMITTER_EMAIL="<New email>";
        GIT_AUTHOR_NAME="<New name>";
        GIT_AUTHOR_EMAIL="<New email>";
    fi' -- --all

Aşağıdaki hatalardan birini alabilirsiniz:

1. Geçici dizin zaten var
2. Refs / original ile başlayan referanslar zaten var
   (bu, daha önce depoda başka bir filtre dalının çalıştırıldığı ve daha sonra orijinal dal başvurusunun refs / original'da yedeklendiği anlamına gelir )

Bu hatalara rağmen çalıştırmayı zorlamak istiyorsanız, --forcebayrağı ekleyin :

git filter-branch --force --env-filter '
    if [ "$GIT_COMMITTER_NAME" = "<Old name>" ];
    then
        GIT_COMMITTER_NAME="<New name>";
        GIT_COMMITTER_EMAIL="<New email>";
        GIT_AUTHOR_NAME="<New name>";
        GIT_AUTHOR_EMAIL="<New email>";
    fi' -- --all

-- --allSeçeneğin küçük bir açıklaması gerekebilir: Filtre şubesinin tüm referanslardaki (tüm şubeleri içeren) tüm revizyonlar üzerinde çalışmasını sağlar . Bu, örneğin, etiketlerin de yeniden yazıldığı ve yeniden yazılan dallarda görülebileceği anlamına gelir.

Bunun yerine yaygın bir "hata" kullanmak HEAD, yalnızca geçerli daldaki tüm düzeltmeleri filtrelemek anlamına gelir . Ve sonra yeniden yazılan dalda hiçbir etiket (veya başka referanslar) mevcut olmaz.

Bir tek komut geçen N kaydedilmesini yazarını değiştirmek için:

git rebase -i HEAD~4 -x "git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit"

NOTLAR

• --no-editbayrak markaları emin git commit --amendekstra onay sormuyor
• kullandığınızda git rebase -i, yazarın değiştirileceği taahhütleri manuel olarak seçebilirsiniz,

düzenlediğiniz dosya şöyle görünür:

pick 897fe9e simplify code a little
exec git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit
pick abb60f9 add new feature
exec git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit
pick dc18f70 bugfix
exec git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit

Daha sonra, yazarı nerede değiştirmek istediğinizi görmek için bazı satırları değiştirebilirsiniz. Bu, otomasyon ve kontrol arasında güzel bir orta yol sağlar: çalışacak adımları görürsünüz ve kaydettiğinizde her şey bir kerede uygulanır.

1. Çalıştırmak git rebase -i <sha1 or ref of starting point>
2. değiştirmek istediğiniz tüm taahhütleri işaretleyin edit(veya e)

3. tüm işlemleri tamamlayana kadar aşağıdaki iki komutu tekrarlayın:

   git commit --amend --reuse-message=HEAD --author="New Author <new@author.email>" ; git rebase --continue

Bu, diğer tüm taahhüt bilgilerini (tarihler dahil) tutacaktır. Bu --reuse-message=HEADseçenek, mesaj düzenleyicinin başlatılmasını önler.

Etiketleri ve tüm dalları da dahil olmak üzere tüm bir depo için yazar yeniden yazmak için aşağıdakini kullanın:

git filter-branch --tag-name-filter cat --env-filter "
  export GIT_AUTHOR_NAME='New name';
  export GIT_AUTHOR_EMAIL='New email'
" -- --all

Ardından, filtre dalının MAN sayfasında açıklandığı gibi, tarafından yedeklenen tüm orijinal referansları kaldırın filter-branch(bu yıkıcı, önce yedekleme):

git for-each-ref --format="%(refname)" refs/original/ | \
xargs -n 1 git update-ref -d

Basit bir çözüm elde ederek çalışan bu çözümü uyarladım author-conv-file(format git-cvsimport için olanla aynıdır ). author-conv-fileTüm şubelerde tanımlanan tüm kullanıcıları değiştirerek çalışır .

Bunu cvs2gitdepomuzu cvs'den git'e taşımak için birlikte kullandık .

yani Örnek author-conv-file

john=John Doe <john.doe@hotmail.com>
jill=Jill Doe <jill.doe@hotmail.com>

Senaryo:

 #!/bin/bash

 export $authors_file=author-conv-file

 git filter-branch -f --env-filter '

 get_name () {
     grep "^$1=" "$authors_file" |
     sed "s/^.*=\(.*\) <.*>$/\1/"
 }

 get_email () {
     grep "^$1=" "$authors_file" |
     sed "s/^.*=.* <\(.*\)>$/\1/"
 }

 GIT_AUTHOR_NAME=$(get_name $GIT_COMMITTER_NAME) &&
     GIT_AUTHOR_EMAIL=$(get_email $GIT_COMMITTER_NAME) &&
     GIT_COMMITTER_NAME=$GIT_AUTHOR_NAME &&
     GIT_COMMITTER_EMAIL=$GIT_AUTHOR_EMAIL &&
     export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL &&
     export GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL
 ' -- --all

Tek sorun yazarın / e-postanın her zamankinden farklı olması durumunda, bunun bir sorun olmadığını belirtmeliyim. Doğru düzeltme, .mailmapdizinin altında çağrılan bir dosya oluşturmaktır.

Name you want <email you want> Name you don't want <email you don't want>

Ve o zamandan itibaren, gibi komutlar git shortlogbu iki ismi aynı olarak değerlendirecektir (özellikle onlara söylemediğiniz sürece). Daha fazla bilgi için http://schacon.github.com/git/git-shortlog.html adresine bakın .

Bu, diğer tüm çözümlerin avantajına sahiptir, çünkü geçmişi yeniden yazmak zorunda kalmazsınız, bu da bir yukarı akışınız varsa sorunlara neden olabilir ve yanlışlıkla veri kaybetmenin her zaman iyi bir yoludur.

Tabii ki, kendiniz gibi bir şey taahhüt ettiyseniz ve gerçekten başka biri olmalı ve bu noktada geçmişi yeniden yazmayı önemsemiyorsanız, taahhüt yazarını değiştirmek muhtemelen atıf amaçları için iyi bir fikirdir (bu durumda sizi burada başka cevap).

Sunulan sürümleri agresif bir şekilde buldum, özellikle diğer geliştiricilerin yamalarını yaparsanız, bu aslında kodlarını çalacaktır.

Aşağıdaki sürüm tüm dallarda çalışır ve bunu önlemek için yazar ve göndericiyi ayrı ayrı değiştirir.

Tüm seçenekler için leif81 için Kudos.

#!/bin/bash

git filter-branch --env-filter '
if [ "$GIT_AUTHOR_NAME" = "<old author>" ];
then
    GIT_AUTHOR_NAME="<new author>";
    GIT_AUTHOR_EMAIL="<youmail@somehost.ext>";
fi
if [ "$GIT_COMMITTER_NAME" = "<old committer>" ];
then
    GIT_COMMITTER_NAME="<new commiter>";
    GIT_COMMITTER_EMAIL="<youmail@somehost.ext>";
fi
' -- --all

1. Değişim taahhüt author name & emailtarafından Amenddaha sonra yerine old-commit with new-one:

   $ git checkout <commit-hash>                            # checkout to the commit need to modify  
   $ git commit --amend --author "name <author@email.com>" # change the author name and email
   
   $ git replace <old-commit-hash> <new-commit-hash>      # replace the old commit by new one
   $ git filter-branch -- --all                           # rewrite all futures commits based on the replacement                   
   
   $ git replace -d <old-commit-hash>     # remove the replacement for cleanliness 
   $ git push -f origin HEAD              # force push 
   

2. Başka bir yol Rebasing:

   $ git rebase -i <good-commit-hash>      # back to last good commit
   
   # Editor would open, replace 'pick' with 'edit' before the commit want to change author
   
   $ git commit --amend --author="author name <author@email.com>"  # change the author name & email
   
   # Save changes and exit the editor
   
   $ git rebase --continue                # finish the rebase
   

Bunu yapmanın en hızlı, en kolay yolu git rebase'in --exec argümanını kullanmaktır:

git rebase -i -p --exec 'git commit --amend --reset-author --no-edit'

Bu, şuna benzer bir yapılacaklar listesi oluşturur:

pick ef11092 Blah blah blah
exec git commit --amend --reset-author --no-edit
pick 52d6391 Blah bloh bloo
exec git commit --amend --reset-author --no-edit
pick 30ebbfe Blah bluh bleh
exec git commit --amend --reset-author --no-edit
...

ve bu otomatik olarak çalışacak, yüzlerce işiniz olduğunda işe yarayacak.

Bu deponun sadece kullanıcı iseniz, olabilir tarihi yeniden kullanarak git filter-branch(olarak svick yazdım ) veya git fast-export/ git fast-importartı filtre (başvurulan makalesinde anlatıldığı gibi komut docgnome cevap ) veya etkileşimli Rebase . Ancak bunlardan herhangi biri, revizyonları ilk değişikliğin ardından değiştirecek; bu, değişikliklerini kendi dalınıza yeniden yazmaya dayanan herkes için sorun demektir.

KURTARMA

Diğer geliştiriciler çalışmalarını yeniden yazma öncesi sürüme dayandırmamışlarsa, en basit çözüm yeniden klonlamak olacaktır (tekrar klonlamak).

Alternatif olarak, git rebase --pulldepolarında herhangi bir değişiklik olmasaydı hızlı ileri gidebilir veya dallarını yeniden yazılmış taahhütlerin üzerine yeniden bastırabilirler (yeniden yazma önizlemelerini sonsuza dek tutacağı için birleştirmeden kaçınmak istiyoruz). Bütün bunlar, işlerini taahhüt etmediklerini varsayarak; kullanımgit stashaksi takdirde değişiklikleri saklamak için .

Diğer geliştiricilerin özelliği dalları kullanın ve / veya varsa git pull --rebasememba kurulmamış çünkü örneğin çalışmıyor, onlar zorunda rebase sonrası yeniden yazma kaydedilmesini üstünde işlerini. Örneğin, yeni değişiklikler getirildikten hemen sonra ( git fetch), masterkaynağa dayalı / çatallı bir dal için origin/master,

$ git rebase --onto origin/master origin/master@{1} master

Burada origin/master@{1}yeniden yazma öncesi durum (getirmeden önce), bkz. Gitrevisions .

Alternatif çözüm, 1.6.5 sürümünden beri Git'te bulunan refs / replace / mekanizmasını kullanmak olacaktır . Bu çözümde, yanlış e-postaya sahip olan taahhütlerin yerine geçecek yedekleri sağlarsınız; Sonra getirir herkes ref (gibi bir şey 'yerine' fetch = +refs/replace/*:refs/replace/*uygun yerde refspec onların .git/config şeffaf alacağı değiştirmeler) ve eski kaydedilmesini görecekti bu ref getirme olmayanlar.

Prosedür şu şekilde gider:

1. Yanlış e-posta ile tüm taahhütleri bulun, örneğin

   $ git log --author=user@wrong.email --all
   

2. Her yanlış taahhüt için bir yedek taahhüt oluşturun ve bunu nesne veritabanına ekleyin

   $ git cat-file -p <ID of wrong commit> | 
     sed -e 's/user@wrong\.email/user@example.com/g' > tmp.txt
   $ git hash-object -t commit -w tmp.txt
   <ID of corrected commit>
   

3. Nesne veritabanındaki kesinliği düzelttiğinize göre, git git replacekomutunu komut kullanarak otomatik olarak ve şeffaf bir şekilde yanlış kesinliği değiştirmesini söylemelisiniz :

   $ git replace <ID of wrong commit> <ID of corrected commit>
   

4. Son olarak, bu prosedürün başarılı olup olmadığını kontrol etmek için tüm değiştirmeleri listeleyin

   $ git replace -l
   

   ve değişikliklerin olup olmadığını kontrol edin

   $ git log --author=user@wrong.email --all
   

Elbette bu prosedürü otomatikleştirebilirsiniz ... iyi, git replacehenüz toplu modu olmayan ( hariç) kullanımı hariç , bunun için kabuk döngüsünü kullanmanız veya "elle" değiştirmeniz gerekir.

TEST EDİLMEDİ! YMMV.

^{refs/replace/Mekanizmayı kullanırken bazı kaba köşelerle karşılaşabileceğinizi unutmayın : yeni ve henüz çok iyi test edilmemiştir} .

Düzeltmek istediğiniz taahhütler en sonuncuysa ve bunlardan sadece birkaçı ise , doğru adı ve e-postayı yapılandırdıktan sonra bir kombinasyonunu kullanabilir git resetve git stashbir taahhütte bulunabilirsiniz.

Dizi şu şekilde olacaktır (2 yanlış taahhüt için, bekleyen değişiklik yok):

git config user.name <good name>
git config user.email <good email>
git reset HEAD^
git stash
git reset HEAD^
git commit -a
git stash pop
git commit -a

Ecitse'yi EGit ile kullanıyorsanız, oldukça kolay bir çözüm var.
Varsayım: Yerel kullanıcı 'local_master_user_x' dalında, geçersiz kullanıcı nedeniyle uzak bir ana yöneticiye gönderilemeyen taahhütleriniz var.

1. Uzak daldaki 'master'a göz atın
2. 'Local_master_user_x' öğesinin değişiklik içerdiği projeleri / klasörleri / dosyaları seçin
3. Sağ tıklayın - Şununla değiştir - Şube - 'local_master_user_x'
4. Bu değişikliği tekrar doğru kullanıcı olarak ve yerel şubeye 'master' yapın
5. Uzaktan kumanda 'master'a aktar

Etkileşimli rebase'i kullanarak değiştirmek istediğiniz her bir taahhüdün ardından bir değişiklik komutu yerleştirebilirsiniz. Örneğin:

pick a07cb86 Project tile template with full details and styling
x git commit --amend --reset-author -Chead

Not o git depolar iki farklı e-posta adresleri için bir committer (değişiklik işleyen kişinin) ve başka bir yazar (değişim yazdı kişi).

Committer bilgileri çoğu yerde görüntülenmez, ancak bunu ile görebilirsiniz git log -1 --format=%cn,%ce(veya belirli bir taahhüdü belirtmek showyerine kullanın log).

Son taahhüdünüzün yazarını değiştirmek kadar basit git commit --amend --author "Author Name <email@example.com>" , komisyon bilgisine aynı şeyi yapan tek bir astar veya argüman yoktur.

Çözüm, kullanıcı bilgilerinizi değiştirmek (geçici olarak veya değil), ardından taahhütçeyi değiştirmek;

git config user.email my_other_email@example.com 
git commit --amend

Bugün bir yazar adındaki UTF8 karakterinin yapı sunucusunda soruna neden olduğu bir sorun yaşadık, bu yüzden bunu düzeltmek için geçmişi yeniden yazmak zorunda kaldık. Atılan adımlar:

Adım 1: Git'teki kullanıcı adınızı gelecekteki tüm taahhütler için aşağıdaki talimatlara göre değiştirin: https://help.github.com/articles/setting-your-username-in-git/

Adım 2: Aşağıdaki bash betiğini çalıştırın:

#!/bin/sh

REPO_URL=ssh://path/to/your.git
REPO_DIR=rewrite.tmp

# Clone the repository
git clone ${REPO_URL} ${REPO_DIR}

# Change to the cloned repository
cd ${REPO_DIR}

# Checkout all the remote branches as local tracking branches
git branch --list -r origin/* | cut -c10- | xargs -n1 git checkout

# Rewrite the history, use a system that will preseve the eol (or lack of in commit messages) - preferably Linux not OSX
git filter-branch --env-filter '
OLD_EMAIL="me@something.com"
CORRECT_NAME="New Me"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
fi
' --tag-name-filter cat -- --branches --tags

# Force push the rewritten branches + tags to the remote
git push -f

# Remove all knowledge that we did something
rm -rf ${REPO_DIR}

# Tell your colleagues to `git pull --rebase` on all their local remote tracking branches

Hızlı genel bakış: Deponuza geçici bir dosyaya bakın, tüm uzak dalları kontrol edin, geçmişi yeniden yazan komut dosyasını çalıştırın, yeni durumu zorla uygulayın ve tüm meslektaşlarınıza değişiklikleri almak için bir rebase çekme işlemi yapmasını söyleyin.

OS X'te bunu çalıştırmakta sorun yaşadık, çünkü işlem mesajlarında bir şekilde satır sonlarını berbat etti, bu yüzden daha sonra bir Linux makinesinde yeniden çalıştırmak zorunda kaldık.

Sorununuz gerçekten yaygın. Bkz. " Git'teki Yazarlar Listesini Düzeltmek için Posta Haritasını Kullanma "

Basitlik adına, süreci kolaylaştırmak için bir komut dosyası oluşturdum: git-changemail

Bu komut dosyasını yolunuza koyduktan sonra, aşağıdaki gibi komutlar verebilirsiniz:

• Geçerli daldaki yazar eşleşmelerini değiştirme

  $ git changemail -a old@email.com -n newname -m new@email.com
  

• <branch> ve <branch2> üzerindeki yazar ve değiştirici eşleşmelerini değiştirin. Geçiş -ffiltresi-dalına yedekleri yeniden izin vermek

  $ git changemail -b old@email.com -n newname -m new@email.com -- -f <branch> <branch2>
  

• Mevcut kullanıcıları depoda göster

  $ git changemail --show-both
  

Bu arada, değişikliklerinizi yaptıktan sonra filtre dalından yedeklemeyi şu yolla temizleyin: git-backup-clean

Bunu deneyin. Yukarıda belirtilenle aynı, ancak etkileşimli olarak yapılacaktır.

bash <(curl -s  https://raw.githubusercontent.com/majdarbash/git-author-change-script/master/run.sh)

Referans: https://github.com/majdarbash/git-author-change-script

Örneğimi de eklemek istiyorum. Verilen parametre ile bir bash_function oluşturmak istiyorum .

Bu nane-linux-17.3 çalışır

# $1 => email to change, $2 => new_name, $3 => new E-Mail

function git_change_user_config_for_commit {

 # defaults
 WRONG_EMAIL=${1:-"you_wrong_mail@hello.world"}
 NEW_NAME=${2:-"your name"}
 NEW_EMAIL=${3:-"new_mail@hello.world"}

 git filter-branch -f --env-filter "
  if [ \$GIT_COMMITTER_EMAIL = '$WRONG_EMAIL' ]; then
    export GIT_COMMITTER_NAME='$NEW_NAME'
    export GIT_COMMITTER_EMAIL='$NEW_EMAIL'
  fi
  if [ \$GIT_AUTHOR_EMAIL = '$WRONG_EMAIL' ]; then
    export GIT_AUTHOR_NAME='$NEW_NAME'
    export GIT_AUTHOR_EMAIL='$NEW_EMAIL'
  fi
 " --tag-name-filter cat -- --branches --tags;
}

Bu repo'nun tek kullanıcısıysanız veya muhtemelen diğer kullanıcılar için repoyu kırmakla ilgilenmiyorsanız, evet. Bu taahhütleri ittiyseniz ve başkalarının erişebileceği başka bir yerde mevcutlarsa, başkalarının depolarını kırmakla ilgilenmiyorsanız hayır. Sorun, bu taahhütleri değiştirerek farklı taahhütler olarak muamele görmelerine neden olacak yeni SHA'lar oluşturacaksınız. Bu değişen taahhütleri başka biri çekmeye çalıştığında, tarih farklı ve kaboom.

Bu sayfa http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html bunun nasıl yapılacağını açıklar. (Bunu denemedim bu yüzden YMMV)