Come modificare il nome dell’autore e del committente e l’e-mail di più commit in Git?

Stavo scrivendo una semplice sceneggiatura nel computer della scuola e ho commesso le modifiche a Git (in un repository che era nella mia chiavetta, clonato dal mio computer a casa). Dopo diversi commit mi sono reso conto che stavo commettendo cose come utente root.

C’è un modo per cambiare l’autore di questi commit al mio nome?

Cambiare l’autore (o il committer) richiederebbe riscrivere tutta la cronologia. Se stai bene con quello e pensi che ne valga la pena, allora dovresti dare un’occhiata a git filter-branch . La pagina man include diversi esempi per iniziare. Si noti inoltre che è ansible utilizzare le variabili di ambiente per modificare il nome dell’autore, il committer, le date e così via. Vedere la sezione “Variabili d’ambiente” della pagina man di git .

Nello specifico, puoi correggere tutti i nomi di autori e le email sbagliati per tutti i rami e tag con questo comando (fonte: Guida di GitHub ):

#!/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 

Utilizzo di Rebase interattivo

Potresti farlo

 git rebase -i -p  

Quindi contrassegna tutti i tuoi cattivi commit come “modifica” nel file di rebase. Se si desidera modificare anche il primo commit, è necessario aggiungerlo manualmente come prima riga nel file di rebase (seguire il formato delle altre righe). Quindi, quando git ti chiede di modificare ogni commit, fallo

  git commit --amend --author "New Author Name " 

modificare o semplicemente chiudere l’editor che si apre, e poi fare

 git rebase --continue 

per continuare il rebase.

Puoi saltare completamente l’editor qui aggiungendo --no-edit modo che il comando sia:

 git commit --amend --author "New Author Name " --no-edit && \ git rebase --continue 

Single Commit

Come alcuni dei commentatori hanno notato, se si desidera solo modificare il commit più recente, il comando rebase non è necessario. Basta fare

  git commit --amend --author "New Author Name " 

Ciò cambierà l’autore nel nome specificato, ma il committer verrà impostato sul tuo utente configurato in git config user.name e git config user.email . Se vuoi impostare il committer su qualcosa che specifichi, questo imposterà sia l’autore che il committer:

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

Nota su Merge Commits

C’era un leggero difetto nella mia risposta originale. Se ci sono commit di merge tra l’ HEAD corrente e il tuo , git rebase li appiattirà (e comunque, se usi le richieste di pull GitHub, ci sarà un tonnellata di fusioni commette nella tua storia). Questo può molto spesso portare a una storia molto diversa (poiché le modifiche duplicate possono essere “ridefinite”), e nel peggiore dei casi, può portare a git rebase che ti chiede di risolvere i conflitti di fusione difficili (che erano probabilmente già risolti nell’unione di commit) ). La soluzione è usare il flag -p per git rebase , che preserverà la struttura di fusione della cronologia. La manpage di git rebase avverte che l’uso di -p e -i può portare a problemi, ma nella sezione BUGS si dice “La modifica dei commit e la riformulazione dei messaggi di commit dovrebbero funzionare correttamente”.

Ho aggiunto -p al comando precedente. Per il caso in cui stai solo cambiando il commit più recente, questo non è un problema.

Puoi anche fare:

 git filter-branch --commit-filter ' if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_AUTHOR_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_EMAIL=""; git commit-tree "$@"; else git commit-tree "$@"; fi' HEAD 

Nota, se stai usando questo comando nel prompt dei comandi di Windows, allora devi usare " invece di ' :

 git filter-branch --commit-filter " if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_AUTHOR_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_EMAIL=""; git commit-tree "$@"; else git commit-tree "$@"; fi" HEAD 

Un solo liner, ma fai attenzione se hai un repository multi-utente – questo cambierà tutti i commit per avere lo stesso (nuovo) autore e committer.

 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 

Con interruzioni di riga nella stringa (che è ansible in bash):

 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 

Succede quando non hai un $ HOME / .gitconfig inizializzato. Puoi risolvere questo problema come:

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

testato con git versione 1.7.5.4

Per un singolo commit:

 git commit --amend --author="Author Name " 

(estratto dalla risposta di asmeurer)

Nel caso in cui solo i più --amend commit abbiano un cattivo autore, puoi farlo all’interno di git rebase -i usando il comando exec e il comando --amend , come segue:

 git rebase -i HEAD~6 # as required 

che ti presenta con l’elenco modificabile di commit:

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

Quindi aggiungi exec ... --author="..." linee dopo tutte le linee con autori cattivi:

 pick abcd Someone else's commit pick defg my bad commit 1 exec git commit --amend --author="New Author Name " -C HEAD pick 1234 my bad commit 2 exec git commit --amend --author="New Author Name " -C HEAD 

salva ed esci dall’editor (per eseguire).

Questa soluzione potrebbe essere più lunga da scrivere rispetto ad altri, ma è altamente controllabile – so esattamente cosa impegna.

Grazie a @asmeurer per l’ispirazione.

Github ha una bella soluzione , che è il seguente script di shell:

 #!/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" ' 

Come accennato, la cronologia della riscrittura è pericolosa e distruggerà i repository di altre persone.

Ma se vuoi davvero farlo e sei in un ambiente bash (nessun problema in Linux, su Windows, puoi usare git bash, che è fornito con l’installazione di git), usa git filter-branch :

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

Per velocizzare le cose, puoi specificare un intervallo di revisioni che desideri riscrivere:

 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 

Quando si assume un commit non diviso da un altro autore, c’è un modo semplice per gestirlo.

git commit --amend --reset-author

Questa è una versione più elaborata della versione di @ Brian:

Per cambiare l’autore e il committer, puoi farlo (con interruzioni di riga nella stringa che è ansible in bash):

 git filter-branch --env-filter ' if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi' -- --all 

Potresti ricevere uno di questi errori:

  1. La directory temporanea esiste già
  2. Refs che iniziano con refs / originale esiste già
    (questo significa che un altro filtro-ramo è stato eseguito in precedenza sul repository e il riferimento della succursale originale è stato eseguito il backup su refs / originale )

Se vuoi forzare la corsa nonostante questi errori, aggiungi il flag --force :

 git filter-branch --force --env-filter ' if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi' -- --all 

Una piccola spiegazione dell’opzione -- --all potrebbe essere necessaria: Fa funzionare il filtro-ramo su tutte le revisioni su tutti i refs (che include tutti i rami). Ciò significa, ad esempio, che anche i tag vengono riscritti ed è visibile sui rami riscritti.

Un “errore” comune è utilizzare HEAD , che significa filtrare tutte le revisioni solo sul ramo corrente . E quindi nessun tag (o altri riferimenti) esisterebbe nel ramo riscritto.

Puoi usare questo alias in modo che tu possa fare:

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

o per gli ultimi 10 commit:

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

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 " 

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

Spero che sia utile

  1. eseguire git rebase -i
  2. segna tutti i commit che vuoi cambiare con edit (o e )
  3. loop i seguenti due comandi finché non hai elaborato tutti i commit:

    git commit --amend --reuse-message=HEAD --author="New Author " ; git rebase --continue

Ciò manterrà tutte le altre informazioni di commit (comprese le date). L’ --reuse-message=HEAD impedisce l’avvio dell’editor di messaggi.

Io uso il seguente per riscrivere l’autore per un intero repository, compresi i tag e tutti i rami:

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

Quindi, come descritto nella pagina MAN di filter-branch , rimuovi tutti i ref originali di cui è stato eseguito il filter-branch (questo è distruttivo, il backup prima):

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

Ho adattato questa soluzione che funziona inserendo un semplice file author-conv-file (il formato è lo stesso di git-cvsimport ). Funziona cambiando tutti gli utenti come definito nel author-conv-file attraverso tutte le filiali.

Lo abbiamo usato insieme a cvs2git per migrare il nostro repository da cvs a git.

vale a dire author-conv-file

 john=John Doe  jill=Jill Doe  

Il copione:

  #!/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 

Ho trovato le versioni presentate come aggressive, specialmente se commetti patch di altri sviluppatori, questo essenzialmente ruberà il loro codice.

La versione seguente funziona su tutti i rami e cambia separatamente autore e committer per impedirlo.

Complimenti a leif81 per l’opzione all.

 #!/bin/bash git filter-branch --env-filter ' if [ "$GIT_AUTHOR_NAME" = "" ]; then GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; fi ' -- --all 
  1. Modifica il author name & email commit da Amend , quindi sostituisci old-commit with new-one :

     $ git checkout  # checkout to the commit need to modify $ git commit --amend --author "name " # change the author name and email $ git replace   # replace the old commit by new one $ git filter-branch -- --all # rewrite all futures commits based on the replacement $ git replace -d  # remove the replacement for cleanliness $ git push -f origin HEAD # force push 
  2. Un altro modo di Rebasing :

     $ git rebase -i  # 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 " # change the author name & email # Save changes and exit the editor $ git rebase --continue # finish the rebase 

Vorrei sottolineare che se l’unico problema è che l’autore / email è diverso dal solito, questo non è un problema. La correzione corretta è creare un file chiamato .mailmap alla base della directory con linee simili

 Name you want  Name you don't want  

E da quel momento in poi, comandi come git shortlog considereranno quei due nomi uguali (a meno che non specifichi loro di non farlo). Vedi http://schacon.github.com/git/git-shortlog.html per ulteriori informazioni.

Questo ha il vantaggio di tutte le altre soluzioni qui in quanto non è necessario riscrivere la cronologia, che può causare problemi se si dispone di un upstream, ed è sempre un buon modo per perdere accidentalmente i dati.

Certo, se hai commesso qualcosa come te stesso e dovrebbe essere davvero qualcun altro, e non ti importa di riscrivere la cronologia a questo punto, cambiare l’autore del commit è probabilmente una buona idea per scopi di attribuzione (nel qual caso ti indirizzo al mio altra risposta qui).

Se sei l’unico utente di questo repository, puoi riscrivere la cronologia usando git filter-branch (come svick scritto ), oppure git fast-export / git fast-import più script di filtro (come descritto nell’articolo a cui si fa riferimento in docgnome answer ), o rebase interattivo. Ma uno di questi cambierebbe le revisioni dal primo cambio di impegno in poi; questo significa problemi per chiunque abbia basato le sue modifiche sulla pre-riscrittura del tuo ramo.

RECUPERO

Se altri sviluppatori non hanno basato il loro lavoro sulla versione di pre-riscrittura, la soluzione più semplice sarebbe quella di ri-clonare (clone di nuovo).

In alternativa, possono provare git rebase --pull , che farebbe avanzare rapidamente se non ci fossero cambiamenti nel loro repository, o rebase il loro ramo sopra a commit re-scritti (vogliamo evitare l’unione, poiché manterrebbe riscrivi i comizi per sempre). Tutto ciò presupponendo che essi non abbiano svolto attività lavorativa; usa git stash per hide le modifiche altrimenti.

Se altri sviluppatori utilizzano i rami delle funzionalità e / o git pull --rebase non funziona, ad esempio perché upstream non è impostato, devono rebase il loro lavoro in cima ai commit post-riscrittura. Ad esempio, subito dopo aver recuperato le nuove modifiche ( git fetch ), per un ramo master basato su / forked da origin/master , è necessario eseguire

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

Qui origin/master@{1} è stato di pre-riscrittura (prima del recupero), vedere gitrevisions .


La soluzione alternativa sarebbe quella di usare refs / replace / mechanism, disponibile in Git dalla versione 1.6.5. In questa soluzione fornisci sostituzioni per commit che hanno email errate; quindi chiunque recuperi i ‘ref’ di sostituzione (qualcosa come fetch = +refs/replace/*:refs/replace/* refspec in un posto appropriato nel proprio .git/config ) otterrebbe le sostituzioni in modo trasparente, e quelli che non recuperano quei refs vedere i vecchi commit.

La procedura è simile a questa:

  1. Trova tutti i commit con e-mail errate, ad esempio utilizzando

     $ git log --author=user@wrong.email --all 
  2. Per ogni commit errato, creare un commit sostitutivo e aggiungerlo al database dell’object

     $ git cat-file -p  | sed -e 's/user@wrong\.email/user@example.com/g' > tmp.txt $ git hash-object -t commit -w tmp.txt  
  3. Ora che hai corretto il commit nel database degli oggetti, devi dire a git di sostituire automaticamente e in modo trasparente il commit sbagliato con quello corretto usando il comando git replace :

     $ git replace   
  4. Infine, elencare tutte le sostituzioni per verificare se questa procedura è riuscita

     $ git replace -l 

    e controllare se le sostituzioni avvengono

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

Ovviamente puoi automatizzare questa procedura … beh, tutto eccetto usare git replace che non ha (ancora) la modalità batch, quindi dovresti usare il ciclo di shell per quello, o sostituire “a mano”.

NON TESTATO! YMMV.

Nota che potresti riscontrare delle spigolosità quando usi refs/replace/ meccanismo: è nuovo e non ancora molto ben testato .

Se i commit che vuoi correggere sono gli ultimi, e solo un paio di questi, puoi usare una combinazione di git reset e git stash per tornare indietro e git stash nuovamente dopo aver configurato il nome e l’email corretti.

La sequenza sarà simile a questa (per 2 commit errati, senza modifiche in sospeso):

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

Se usi Eclipse con EGit, allora c’è una soluzione abbastanza semplice.
Presupposto: hai eseguito il commit in un ramo locale ‘local_master_user_x’ che non può essere trasferito a un “master” di ramo remoto a causa dell’utente non valido.

  1. Controlla il “master” del ramo remoto
  2. Seleziona i progetti / cartelle / file per i quali “local_master_user_x” contiene le modifiche
  3. Fai clic con il tasto destro del mouse – Sostituisci con – Branch – ‘local_master_user_x’
  4. Applica nuovamente queste modifiche, questa volta come utente corretto e nel “master” del ramo locale
  5. Premi su “master” remoto

Usando il rebase interattivo, puoi inserire un comando di modifica dopo ogni commit che vuoi modificare. Per esempio:

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

Nota che git memorizza due diversi indirizzi e-mail, uno per il committer (la persona che ha effettuato il cambiamento) e un altro per l’ autore (la persona che ha scritto la modifica).

Le informazioni del committer non vengono visualizzate nella maggior parte delle posizioni, ma è ansible visualizzarle con git log -1 --format=%cn,%ce (oppure utilizzare show anziché log per specificare un commit particolare).

Mentre cambiare l’autore del tuo ultimo commit è semplice come git commit --amend --author "Author Name " , non esiste un solo liner o argomento per fare lo stesso con le informazioni del committer.

La soluzione è di (temporaneamente o meno) modificare le informazioni dell’utente, quindi modificare il commit, che aggiornerà il committer alle informazioni correnti:

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

Oggi abbiamo riscontrato un problema in cui un carattere UTF8 nel nome di un autore stava causando problemi sul server di generazione, quindi abbiamo dovuto riscrivere la cronologia per correggere questo problema. I passi compiuti sono stati:

Passaggio 1: modifica il tuo nome utente in git per tutti i futuri commit, come da istruzioni qui: https://help.github.com/articles/setting-your-username-in-git/

Passaggio 2: eseguire il seguente script di bash:

 #!/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 

Panoramica rapida: controlla il tuo repository in un file temporaneo, controlla tutti i rami remoti, esegui lo script che riscriverà la cronologia, eseguirà una forzatura del nuovo stato e dirà a tutti i tuoi colleghi di eseguire un pull di rebase per ottenere le modifiche.

Abbiamo avuto problemi con l’esecuzione di questo su OS X perché in qualche modo ha incasinato le terminazioni di riga nei messaggi di commit, quindi abbiamo dovuto ri-eseguirlo su una macchina Linux in seguito.

Il tuo problema è molto comune Vedi ” Uso di Mailmap per correggere l’elenco di autori in Git ”

Per semplicità, ho creato uno script per facilitare il processo: git-changemail

Dopo aver messo quello script sul tuo percorso, puoi impartire comandi come:

  • Modifica le corrispondenze dell’autore sul ramo corrente

     $ git changemail -a old@email.com -n newname -m new@email.com 
  • Modifica le corrispondenze di autore e committer su e . Passa -f per filtrare-ramo per consentire la riscrittura dei backup

     $ git changemail -b old@email.com -n newname -m new@email.com -- -f <branch> <branch2> 
  • Mostra utenti esistenti su repo

     $ git changemail --show-both 

A proposito, dopo aver apportato le modifiche, pulire il backup dal ramo filtro con: git-backup-clean

Se sei l’unico utente di questo repo o non ti preoccupi di interrompere il repository per altri utenti, allora si. Se hai spinto questi commit e loro esistono dove da qualche altra parte possono accedervi, allora no, a meno che non ti preoccupi di rompere i repository di altre persone. Il problema è cambiando questi commit che genererai nuovi SHA che li faranno trattare come commit diversi. Quando qualcun altro prova a inserire questi cambiamenti commessi, la storia è diversa e kaboom.

Questa pagina http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html descrive come farlo. (Non ho provato questo così YMMV)

Voglio aggiungere anche il mio esempio. Voglio creare una bash_function con un determinato parametro.

questo funziona in mint-linux-17.3

 # $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; } 
 git rebase -i YOUR_FIRTS_COMMIT_SHA^ while true; do git commit --amend --author="Name Surname " --no-edit && git rebase --continue; done 

Press ^C # after the rebase is done (the loop will keep updating last commit)

Prova questo. It will do the same as above mentioned, but interactively.

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

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

This isn’t an answer to your question, but rather a script you can use to avoid this in the future. It utilizes global hooks available since Git version 2.9 to check your email configuration based on the directory your in:

 #!/bin/sh PWD=`pwd` if [[ $PWD == *"Ippon"* ]] # 1) then EMAIL=$(git config user.email) if [[ $EMAIL == *"Work"* ]] # 2) then echo ""; else echo "Email not configured to your Work email in the Work directory."; git config user.email "youremail@youremail.com" echo "Git email configuration has now been changed to \"$(git config user$ echo "\nPlease run your command again..." echo '' exit 1 fi; elif [[ $PWD == *"Personal"* ]] then EMAIL=$(git config user.email) if [[ $EMAIL == "youremail@youremail.com" ]] then echo ""; else echo "Email is not configured to your personal account in the Personal di$ git config user.email "youremail@youremail.com" echo "Git email configuration has now been changed to \"$(git config user$ echo "\nPlease run your command again..." echo '' exit 1; fi; fi; 

It checks your current working directory, then verifies your git is configured to the correct email. If not, it changes it automatically. See the full details here .