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

Stavo scrivendo una semplice sceneggiatura nel computer della scuola e stavo commettendo le modifiche a Git (in un repository che era nel mio pendrive, 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 con il mio nome?

Questa risposta utilizza git-filter-branch, per la quale i documenti ora danno questo avviso:

git filter-branch ha una miriade di insidie ​​che possono produrre mangling non ovvi della riscrittura della storia prevista (e possono lasciarti con poco tempo per indagare su tali problemi poiché ha prestazioni così spaventose). Questi problemi di sicurezza e prestazioni non possono essere risolti in modo compatibile all'indietro e, come tale, non è raccomandato il suo utilizzo. Utilizzare uno strumento di filtro cronologico alternativo come git filter-repo . Se hai ancora bisogno di usare git filtro-ramo, leggi attentamente SICUREZZA (e PRESTAZIONI ) per conoscere le miniere di terra di filtro-ramo, quindi evita con cautela quanti più pericoli elencati lì ragionevolmente possibile.

Cambiare l'autore (o il committer) richiederebbe riscrivere tutta la storia. Se stai bene e pensi che ne valga la pena, allora dai un'occhiata a git filter-branch . La pagina man include diversi esempi per iniziare. Nota anche che puoi usare le variabili d'ambiente per cambiare il nome dell'autore, il committer, le date, ecc. - vedi la sezione "Variabili d'ambiente" della pagina man di git .

In particolare, puoi correggere tutti i nomi e le e-mail sbagliate dell'autore 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

NOTA: questa risposta modifica gli SHA1, quindi fai attenzione a usarlo su un ramo che è già stato premuto. Se vuoi solo correggere l'ortografia di un nome o aggiornare una vecchia e-mail, git ti consente di farlo senza riscrivere la cronologia usando .mailmap. Vedi la mia altra risposta .

Utilizzo di Interactive Rebase

Si potrebbe fare

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

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

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

modifica o chiudi semplicemente l'editor che si apre e poi fai

git rebase --continue

per continuare il rebase.

Potresti saltare l'apertura totale dell'editor qui aggiungendo in --no-edit modo che il comando sarà:

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

Impegno singolo

Come alcuni 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 <email@address.com>"

Ciò cambierà l'autore con il nome specificato, ma il committer verrà impostato come utente configurato in git config user.namee 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 Unisci commit

C'è stato un piccolo difetto nella mia risposta originale. Se ci sono dei commit di fusione tra la corrente HEADe la tua <some HEAD before all your bad commits>, git rebaseli appiattirai (e comunque, se usi le richieste pull di GitHub, ci saranno un sacco di commit di fusione nella tua cronologia). Questo può portare molto spesso a una storia molto diversa (poiché le modifiche duplicate possono essere "riequilibrate") e, nel peggiore dei casi, può portare a git rebasechiederti di risolvere conflitti di unione difficili (che probabilmente erano già stati risolti nelle commit di unione). La soluzione è utilizzare la -pbandiera a git rebase, che conserverà la struttura di unione della tua cronologia. La manpage per git rebaseavverte che l'utilizzo -pe -ipuò portare a problemi, ma nelBUGS sezione dice "La modifica dei commit e la riformulazione dei loro messaggi di commit dovrebbero funzionare correttamente."

Ho aggiunto -pal comando sopra. Nel caso in cui stai cambiando il commit più recente, questo non è un problema.

Puoi anche fare:

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

Nota, se si utilizza questo comando nel prompt dei comandi di Windows, è necessario utilizzare "invece di ':

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

Un aspetto, ma fai attenzione se hai un repository multiutente - questo cambierà tutti gli 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 le interruzioni di riga nella stringa (che è possibile 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 inizializzato $ HOME / .gitconfig. È possibile 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 <email@address.com>"

(estratto dalla risposta di asmeurer)

Nel caso in cui solo alcuni dei primi commit abbiano autori non validi, puoi farlo tutto all'interno git rebase -iusando il execcomando e il --amendcommit, come segue:

git rebase -i HEAD~6 # as required

che ti presenta un elenco modificabile di commit:

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

Quindi aggiungere le exec ... --author="..."righe dopo tutte le righe con autori non validi:

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

salva ed esci dall'editor (per eseguirlo).

Questa soluzione potrebbe essere più lunga da digitare rispetto ad alcune altre, ma è altamente controllabile: so esattamente cosa commette.

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 menzionato nel documento, la riscrittura della storia è pericolosa e spezzerà i repository di altre persone.

Ma se vuoi davvero farlo e ti trovi in ​​un ambiente bash (nessun problema in Linux, su Windows, puoi usare git bash, 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 una serie di revisioni che vuoi 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 unito da un altro autore, esiste un modo semplice per gestirlo.

git commit --amend --reset-author

Puoi usarlo come alias in modo da poter 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

Aggiungi a ~ / .gitconfig:

[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 sia utile

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

Per modificare l'autore e il committer, puoi farlo (con interruzioni di riga nella stringa che è possibile in bash):

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

È possibile che venga visualizzato uno di questi errori:

1. La directory temporanea esiste già
2. I riferimenti che iniziano con ref / originale esistono già
   (ciò significa che un altro filtro-ramo è stato precedentemente eseguito sul repository e il riferimento al ramo originale di cui è stato eseguito il backup su ref / originale )

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

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

-- --allPotrebbe essere necessaria una piccola spiegazione dell'opzione: fa funzionare il ramo del filtro su tutte le revisioni su tutti i riferimenti (che include tutti i rami). Ciò significa, ad esempio, che anche i tag vengono riscritti ed è visibile sui rami riscritti.

Un "errore" comune è HEADinvece quello di utilizzare , il che significa filtrare tutte le revisioni solo sul ramo corrente . E quindi non esisterebbero tag (o altri riferimenti) nel ramo riscritto.

Un singolo comando per modificare l'autore degli ultimi N commit:

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

APPUNTI

• la --no-editbandiera si assicura git commit --amendche non richieda una conferma aggiuntiva
• quando lo usi git rebase -i, puoi selezionare manualmente i commit dove cambiare l'autore,

il file modificato sarà simile al seguente:

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

È quindi possibile modificare alcune righe per vedere dove si desidera modificare l'autore. Questo ti offre una buona via di mezzo tra automazione e controllo: vedi i passaggi che verranno eseguiti e una volta salvato tutto verrà applicato in una sola volta.

1. correre git rebase -i <sha1 or ref of starting point>
2. contrassegnare tutti i commit con cui si desidera modificare edit(o e)

3. ripetere i due comandi seguenti fino a quando non sono stati elaborati tutti i commit:

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

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

Uso quanto segue per riscrivere l'autore per un intero repository, inclusi 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 del filtro-ramo , rimuovere tutti i riferimenti originali di cui è stato eseguito il backup filter-branch(questo è distruttivo, prima il backup):

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

Ho adattato questa soluzione che funziona inserendo un semplice author-conv-file(il formato è lo stesso di quello per git-cvsimport ). Funziona modificando tutti gli utenti come definito in author-conv-filetutti i rami.

Abbiamo usato questo insieme a cvs2gitper migrare il nostro repository da cvs a git.

cioè campione author-conv-file

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

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

Devo sottolineare che se l'unico problema è che l'autore / e-mail è diverso dal solito, questo non è un problema. La correzione corretta è quella di creare un file chiamato .mailmapalla base della directory con linee simili

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

E da quel momento in poi, i comandi simili git shortlogconsidereranno quei due nomi uguali (a meno che tu non gli dica espressamente 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, il 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 davvero essere qualcun altro, e non ti dispiace riscrivere la storia 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).

Ho trovato le versioni presentate troppo aggressive, specialmente se si commettono patch da altri sviluppatori, questo essenzialmente ruberà il loro codice.

La versione seguente funziona su tutti i rami e modifica l'autore e la comitter separatamente per evitarlo.

Complimenti a leif81 per l'opzione all.

#!/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. Cambia commit author name & emailcon Amend, quindi sostituendo 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. Un altro modo 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
   

Il modo più rapido e semplice per farlo è usare l'argomento --exec di git rebase:

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

Questo creerà una lista di cose da fare simile a questa:

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
...

e questo funzionerà tutto automaticamente, il che funziona quando hai centinaia di commit.

Se sei l'unico utente di questo repository, puoi riscrivere la cronologia usando git filter-branch(come svick ha scritto ) o git fast-export/ git fast-importpiù lo script di filtro (come descritto nell'articolo a cui si fa riferimento nella risposta del docgnome ) o il rebase interattivo . Ma uno di questi cambierebbe le revisioni dal primo commit in poi; questo significa problemi per chiunque abbia basato le proprie modifiche sulla pre-riscrittura del proprio ramo.

RECUPERO

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

In alternativa, possono provare git rebase --pull, il che farebbe avanzare rapidamente se non ci fossero cambiamenti nel loro repository, o rifare il loro ramo in cima ai commit riscritti (vogliamo evitare l'unione, poiché manterrebbe i commit pre-riscrittura per sempre). Tutto questo supponendo che non abbiano commesso un lavoro; usogit stash per nascondere le modifiche altrimenti.

Se altri sviluppatori usano questi rami, e / o git pull --rebasenon funziona per esempio perché a monte non è configurato, devono rebase il loro lavoro sulla parte superiore del post-commit di riscrittura. Ad esempio, subito dopo aver recuperato nuove modifiche ( git fetch), per un masterramo basato su / biforcato origin/master, è necessario eseguire

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

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

Una soluzione alternativa sarebbe quella di utilizzare refs / replace / meccanismo, disponibile in Git dalla versione 1.6.5. In questa soluzione fornite sostituzioni per commit che hanno email errate; quindi chiunque fetch = +refs/replace/*:refs/replace/*recuperi i ref di "sostituzione" (qualcosa come refspec nel loro posto appropriato .git/config) otterrebbe sostituzioni in modo trasparente, e quelli che non recuperano questi ref vedrebbero i vecchi commit.

La procedura è simile a questa:

1. Trova tutti i commit con email errate, ad esempio utilizzando

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

2. Per ogni commit errato, creare un commit sostitutivo e aggiungerlo al database degli oggetti

   $ 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. Ora che hai corretto il commit nel database degli oggetti, devi dire a git di sostituire automaticamente e in modo trasparente il commit errato con uno corretto usando il git replacecomando:

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

4. Infine, elenca tutte le sostituzioni per verificare se questa procedura ha avuto esito positivo

   $ git replace -l
   

   e verificare se si verificano sostituzioni

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

Ovviamente puoi automatizzare questa procedura ... beh, tutto tranne l'uso git replaceche non ha (ancora) la modalità batch, quindi dovresti usare il loop shell per quello, o sostituire "a mano".

NON TESTATO! YMMV.

^{Si noti che è possibile incontrare alcuni angoli irregolari quando si utilizza il refs/replace/meccanismo: è nuovo e non ancora ben testato} .

Se i commit che vuoi correggere sono gli ultimi, e solo un paio di essi, puoi usare una combinazione di git resete git stashtornare indietro per impegnarli nuovamente dopo aver configurato il nome e l'e-mail corretti.

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

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

Se si utilizza Eclipse con EGit, esiste una soluzione abbastanza semplice.
Presupposto: è stato eseguito il commit in una filiale locale 'local_master_user_x' che non può essere trasferita a una filiale remota 'master' a causa dell'utente non valido.

1. Verifica il ramo principale "master"
2. Seleziona i progetti / cartelle / file per i quali 'local_master_user_x' contiene le modifiche
3. Tasto destro del mouse - Sostituisci con - Branch - 'local_master_user_x'
4. Effettuare nuovamente il commit di queste modifiche, questa volta come utente corretto e nel ramo "master" locale
5. Spingere in remoto "master"

Utilizzando rebase interattivo, è possibile inserire un comando di modifica dopo ogni commit che si desidera 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 commesso la modifica) e un altro per l' autore (la persona che ha scritto la modifica).

Le informazioni sul committer non vengono visualizzate nella maggior parte dei luoghi, ma è possibile visualizzarle con git log -1 --format=%cn,%ce(o utilizzare showinvece di logspecificare un commit specifico).

Cambiare l'autore del tuo ultimo commit è semplice come git commit --amend --author "Author Name <email@example.com>" , non esiste una riga o argomento per fare lo stesso con le informazioni del committer.

La soluzione è quella di modificare (temporaneamente o meno) le informazioni dell'utente, quindi modificare il commit, che aggiornerà il committer con le 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 compilazione, quindi abbiamo dovuto riscrivere la cronologia per correggere questo. I passi fatti sono stati:

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

Passaggio 2: eseguire il seguente script 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 spinta forzata del nuovo stato e dirà a tutti i tuoi colleghi di fare 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 linea nei messaggi di commit, quindi in seguito abbiamo dovuto eseguirlo nuovamente su una macchina Linux.

Il tuo problema è molto comune Vedere " Uso di Mailmap per correggere l'elenco degli autori in Git "

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

Dopo aver inserito quello script nel tuo percorso, puoi eseguire comandi come:

• Modifica le corrispondenze dell'autore nel ramo corrente

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

• Cambia le corrispondenze di autore e committer su <branch> e <branch2>. Passa -fal ramo filtro 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 repository

  $ git changemail --show-both
  

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

Prova questo. Farà lo stesso di cui sopra, ma interattivamente.

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

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

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

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;
}

Se sei l'unico utente di questo repository o non ti interessa possibilmente interrompere il repository per altri utenti, quindi sì. Se hai spinto questi commit ed esistono dove altrove possono accedervi, allora no, a meno che non ti interessi a interrompere i repository di altre persone. Il problema è che cambiando questi commit genererai nuovi SHA che li faranno trattare come commit diversi. Quando qualcun altro tenta di attirare questi impegni modificati, la storia è diversa e kaboom.

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