Comment changer le nom de l’auteur et du committer et l’e-mail de plusieurs commits dans Git?

J’écrivais un script simple sur l’ordinateur de l’école, et j’engageais les modifications sur Git (dans un repo qui se trouvait dans ma clé USB, cloné depuis mon ordinateur à la maison). Après plusieurs commits, j’ai réalisé que je commettais des choses en tant qu’utilisateur root.

Est-il possible de changer l’auteur de ces commits à mon nom?

Changer l’auteur (ou committer) nécessiterait de réécrire toute l’histoire. Si vous êtes d’accord avec cela et pensez que cela en vaut la peine, alors vous devriez vérifier git filter-branch . La page de manuel comprend plusieurs exemples pour vous aider à démarrer. Notez également que vous pouvez utiliser des variables d’environnement pour changer le nom de l’auteur, le committer, les dates, etc. – voir la section “Variables d’environnement” de la page de manuel de git .

Plus précisément, vous pouvez corriger tous les noms d’auteurs et tous les emails erronés pour toutes les twigs et tous les tags avec cette commande (source: 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 -- --twigs --tags 

Utilisation de la firebase database interactive

Vous pourriez faire

 git rebase -i -p  

Ensuite, marquez tous vos mauvais commits comme “modifier” dans le fichier rebase. Si vous souhaitez également modifier votre premier commit, vous devez l’append manuellement en tant que première ligne dans le fichier de rebase (suivez le format des autres lignes). Alors, quand git vous demande de modifier chaque commit, faites

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

éditez ou fermez juste l’éditeur qui s’ouvre, puis faites

 git rebase --continue 

continuer la rebase.

Vous pouvez ignorer l’ouverture de l’éditeur en ajoutant --no-edit pour que la commande soit:

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

Engagement unique

Comme l’ont noté certains commentateurs, si vous souhaitez simplement modifier le dernier commit, la commande rebase n’est pas nécessaire. Juste faire

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

Cela changera l’auteur au nom spécifié, mais le committer sera défini sur votre utilisateur configuré dans git config user.name et git config user.email . Si vous souhaitez définir le Committer sur quelque chose que vous spécifiez, cela définira à la fois l’auteur et le committer:

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

Remarque sur les validations de fusion

Il y avait un léger défaut dans ma réponse initiale. S’il y a des validations de fusion entre le HEAD actuel et votre , alors git rebase les git rebase (et au fait, si vous utilisez des requêtes GitHub, il y aura une tonne de fusion commet dans votre histoire). Cela peut très souvent conduire à un historique très différent (car les modifications en double peuvent être “rebattées”), et dans le pire des cas, cela peut conduire à la résolution de conflits git rebase (probablement déjà résolus dans les git rebase fusion). ). La solution consiste à utiliser l’indicateur -p pour git rebase , ce qui préservera la structure de fusion de votre historique. La page de git rebase pour git rebase avertit que l’utilisation de -p et -i peut entraîner des problèmes, mais dans la section BUGS , elle indique que “l’édition de validations et la reformulation de leurs messages de validation devraient fonctionner correctement”.

J’ai ajouté -p à la commande ci-dessus. Pour le cas où vous ne faites que modifier le commit le plus récent, ce n’est pas un problème.

Vous pouvez aussi faire:

 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 

Notez que si vous utilisez cette commande dans l’invite de commande Windows, vous devez utiliser " au lieu de ' :

 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 

Une ligne, mais faites attention si vous avez un repository multi-utilisateurs – cela changera tous les engagements pour avoir le même (nouvel) auteur et 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 

Avec les sauts de ligne dans la chaîne (ce qui est possible dans 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 

Cela se produit lorsque vous n’avez pas initialisé $ HOME / .gitconfig. Vous pouvez résoudre ce problème comme suit:

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

testé avec la version 1.7.5.4 de git

Pour un engagement unique:

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

(extrait de la réponse de l’asmeur)

Dans le cas où seuls quelques-uns des principaux commits ont de mauvais auteurs, vous pouvez le faire à l’intérieur de git rebase -i à l’aide de la commande exec et de la commande --amend , comme suit:

 git rebase -i HEAD~6 # as required 

qui vous présente la liste modifiable des commits:

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

Ajoutez ensuite les lignes exec ... --author="..." après toutes les lignes avec des auteurs exec ... --author="..." :

 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 

Enregistrer et quitter l’éditeur (pour exécuter).

Cette solution peut être plus longue à dactylographier que d’autres, mais elle est hautement contrôlable – je sais exactement ce qu’elle commet.

Merci à @asmeurer pour l’inspiration.

Github a une bonne solution , qui est le script shell suivant:

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

Comme le mentionne docgnome, la réécriture de l’histoire est dangereuse et va casser les repositorys des autres.

Mais si vous voulez vraiment faire ça et que vous êtes dans un environnement bash (pas de problème sous Linux, sous Windows, vous pouvez utiliser git bash, fourni avec l’installation de git), utilisez 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' 

Pour accélérer les choses, vous pouvez spécifier une gamme de révisions que vous souhaitez réécrire:

 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 

Lors de la reprise d’un engagement non fusionné d’un autre auteur, il existe un moyen simple de gérer cela.

git commit --amend --reset-author

Ceci est une version plus élaborée de la version de @ Brian:

Pour changer l’auteur et le committer, vous pouvez le faire (avec des sauts de ligne dans la chaîne possible en 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 

Vous pourriez avoir l’une de ces erreurs:

  1. Le répertoire temporaire existe déjà
  2. Les références commençant par refs / original existent déjà
    (cela signifie qu’une autre twig de filtre a déjà été exécutée sur le référentiel et que la référence de twig d’origine est sauvegardée aux références / original )

Si vous souhaitez forcer l’exécution malgré ces erreurs, ajoutez le drapeau --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 

Une petite explication de l’option -- --all peut être nécessaire: elle fait fonctionner la twig de filtrage sur toutes les révisions de toutes les références (qui incluent toutes les twigs). Cela signifie, par exemple, que les étiquettes sont également réécrites et visibles sur les twigs réécrites.

Une “erreur” courante consiste à utiliser HEAD place, ce qui signifie filtrer toutes les révisions sur la twig en cours . Et puis, aucun tag (ou autre référence) n’existerait dans la twig réécrite.

Vous pouvez utiliser cet alias pour pouvoir:

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

ou pour les 10 derniers commits:

 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 " 

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

J’espère que c’est utile.

  1. lancez git rebase -i
  2. marquer tous les commits que vous souhaitez modifier avec edit (ou e )
  3. boucle les deux commandes suivantes jusqu’à ce que vous ayez traité toutes les validations:

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

Cela gardera toutes les autres informations de validation (y compris les dates). L’ --reuse-message=HEAD empêche le lancement de l’éditeur de messages.

J’utilise les éléments suivants pour réécrire l’auteur d’un référentiel complet, y compris les balises et toutes les twigs:

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

Ensuite, comme décrit dans la page MAN de filter-branch , supprimez toutes les références d’origine sauvegardées par filter-branch (ceci est destructif, sauvegardez d’abord):

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

J’ai adapté cette solution qui fonctionne en ingérant un simple author-conv-file format (le format est le même que pour git-cvsimport ). Cela fonctionne en changeant tous les utilisateurs tels que définis dans le author-conv-file dans toutes les twigs.

Nous avons utilisé ceci en conjonction avec cvs2git pour migrer notre référentiel de cvs vers git.

ie exemple de author-conv-file

 john=John Doe  jill=Jill Doe  

Le script:

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

J’ai trouvé les versions présentées agressives, surtout si vous validez des correctifs d’autres développeurs, cela volera essentiellement leur code.

La version ci-dessous fonctionne sur toutes les twigs et modifie séparément l’auteur et le comitter pour éviter cela.

Bravo à leif81 pour l’option tout.

 #!/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. Modifier le author name & email validation par Amend , puis remplacer l’ 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. Une autre manière:

     $ 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 

Je dois souligner que si le seul problème est que l’auteur / email est différent de votre habituel, ce n’est pas un problème. Le correctif correct consiste à créer un fichier appelé .mailmap à la base du répertoire avec des lignes comme

 Name you want  Name you don't want  

Et à partir de ce moment, les commandes comme git shortlog considéreront ces deux noms comme identiques (sauf si vous leur dites expressément de ne pas le faire). Voir http://schacon.github.com/git/git-shortlog.html pour plus d’informations.

Ceci a l’avantage de toutes les autres solutions ici dans la mesure où vous n’avez pas besoin de réécrire l’historique, ce qui peut poser problème si vous avez un stream amont, et c’est toujours un bon moyen de perdre accidentellement des données.

Bien sûr, si vous avez commis quelque chose comme vous-même et que cela devrait vraiment être quelqu’un d’autre et que cela ne vous dérange pas de réécrire l’histoire, changer l’auteur du commit est probablement une bonne idée. autre réponse ici).

Si vous êtes le seul utilisateur de ce repository, vous pouvez réécrire l’historique à l’ aide de git filter-branch (comme svick écrit ) ou de git fast-export / git fast-import plus le script de filtrage (comme décrit dans la référence docgnome ), ou rebase interactif. Mais l’une ou l’autre de ces modifications modifierait les révisions à partir des premiers engagements modifiés; Cela signifie des problèmes pour quiconque a basé ses changements sur la pré-réécriture de votre twig.

RÉCUPÉRATION

Si d’autres développeurs n’ont pas basé leur travail sur la version de pré-réécriture, la solution la plus simple serait de re-cloner (cloner à nouveau).

Sinon, ils peuvent essayer git rebase --pull , qui avance rapidement s’il n’y a pas de changement dans leur repository, ou rebaser leur twig par dessus les commits réécrits (nous voulons éviter la fusion, comme cela restrait pré-établi). réécrit les comits pour toujours). Tout cela en supposant qu’ils n’ont pas travaillé, utilisez git stash pour éviter les changements.

Si d’autres développeurs utilisent des twigs d’ git pull --rebase , et / ou si git pull --rebase ne fonctionne pas, par exemple parce que la configuration en amont n’est pas configurée, ils doivent rebaser leur travail en plus des validations post-réécriture. Par exemple, juste après avoir récupéré les nouvelles modifications ( git fetch ), pour une twig principale basée sur / forked from origin/master , il faut exécuter

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

Ici, origin/master@{1} est l’état de pré-réécriture (avant la récupération), voir gitrevisions .


Une autre solution serait d’utiliser refs / replace / mecanisme, disponible dans Git depuis la version 1.6.5. Dans cette solution, vous fournissez des remplacements pour les commits qui ont des e-mails incorrects; alors tous ceux qui chercheraient les références ‘replace’ (quelque chose comme fetch = +refs/replace/*:refs/replace/* refspec à la place appropriée dans leur .git/config ) obtiendraient des remplacements de manière transparente, et ceux qui ne voir les anciens commits.

La procédure va quelque chose comme ceci:

  1. Trouvez tous les commits avec des e-mails incorrects, par exemple en utilisant

     $ git log --author=user@wrong.email --all 
  2. Pour chaque commit incorrect, créez un commit de remplacement et ajoutez-le à la firebase database 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. Maintenant que vous avez corrigé les commits dans la firebase database d’objects, vous devez dire à git de remplacer automatiquement et de manière transparente les erreurs commises par les erreurs corrigées à l’aide de la commande git replace :

     $ git replace   
  4. Enfin, listez tous les remplacements pour vérifier si cette procédure a réussi.

     $ git replace -l 

    et vérifier si les remplacements ont lieu

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

Vous pouvez bien sûr automatiser cette procédure … eh bien, tous sauf en utilisant git replace qui n’a pas (encore) de mode batch, vous devrez donc utiliser la boucle shell pour cela, ou remplacer “à la main”.

PAS TESTÉ! YMMV.

Notez que vous pouvez rencontrer des difficultés lors de l’utilisation de refs/replace/ mecanel: c’est nouveau et pas encore très bien testé .

Si les commits que vous souhaitez corriger sont les derniers, et juste quelques-uns, vous pouvez utiliser une combinaison de git reset et de git stash pour revenir en arrière après les avoir configurés avec le nom et le courrier électronique appropriés.

La séquence sera quelque chose comme ça (pour 2 commits incorrects, pas de modifications en attente):

 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 

Si vous utilisez Eclipse avec EGit, il existe une solution assez simple.
Hypothèse: vous avez des commits dans une twig locale ‘local_master_user_x’ qui ne peuvent pas être transférés vers une twig distante ‘master’ à cause de l’utilisateur invalide.

  1. Commander la twig distante ‘master’
  2. Sélectionnez les projets / dossiers / fichiers pour lesquels ‘local_master_user_x’ contient des modifications
  3. Clic droit – Remplacer par – Branche – ‘local_master_user_x’
  4. Validez ces modifications à nouveau, cette fois-ci en tant qu’utilisateur correct et dans le «maître» de la twig locale
  5. Poussez à distance ‘maître’

En utilisant le rebase interactif, vous pouvez placer une commande de modification après chaque validation que vous souhaitez modifier. Par exemple:

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

Notez que git stocke deux adresses de messagerie différentes, une pour le committer (la personne qui a commis la modification) et une autre pour l’ auteur (la personne qui a écrit la modification).

Les informations sur le committer ne sont pas affichées dans la plupart des endroits, mais vous pouvez le voir avec git log -1 --format=%cn,%ce (ou utilisez show au lieu de log pour spécifier un commit particulier).

Bien que changer l’auteur de votre dernier commit soit aussi simple que git commit --amend --author "Author Name " , il n’y a pas de ligne ou d’argument pour faire la même chose avec les informations du committer.

La solution consiste à (temporairement ou non) modifier vos informations d’utilisateur, puis à modifier le commit, ce qui mettra le committer à jour avec vos informations actuelles:

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

Nous avons rencontré un problème aujourd’hui où un caractère UTF8 dans un nom d’auteur causait des problèmes sur le serveur de génération, nous avons donc dû réécrire l’historique pour corriger cela. Les mesures sockets étaient les suivantes:

Étape 1: Changez votre nom d’utilisateur en git pour tous les commits futurs, selon les instructions ici: https://help.github.com/articles/setting-your-username-in-git/

Étape 2: Exécutez le script bash suivant:

 #!/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 twigs as local tracking twigs 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 -- --twigs --tags # Force push the rewritten twigs + 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 twigs 

Aperçu rapide: vérifiez votre référentiel dans un fichier temporaire, vérifiez toutes les twigs distantes, exécutez le script qui réécrira l’historique, exécutez une poussée forcée du nouvel état, et demandez à tous vos collègues de procéder à une extraction de rebase pour obtenir les modifications.

Nous avons eu du mal à l’exécuter sous OS X car cela perturbait les terminaisons de ligne dans les messages de validation, nous avons donc dû le ré-exécuter sur une machine Linux par la suite.

Votre problème est vraiment commun. Voir ” Utiliser Mailmap pour corriger la liste des auteurs dans Git ”

Par souci de simplicité, j’ai créé un script pour faciliter le processus: git-changemail

Après avoir placé ce script sur votre chemin, vous pouvez lancer des commandes telles que:

  • Modifier les correspondances d’auteur sur la twig en cours

     $ git changemail -a old@email.com -n newname -m new@email.com 
  • Modifiez les correspondances auteur / committer sur et . Passez -f à la twig de filtrage pour autoriser la réécriture des sauvegardes

     $ git changemail -b old@email.com -n newname -m new@email.com -- -f <branch> <branch2> 
  • Afficher les utilisateurs existants sur repo

     $ git changemail --show-both 

Au fait, après avoir apporté vos modifications, nettoyez la sauvegarde de la twig de filtrage avec: git-backup-clean

Si vous êtes le seul utilisateur de ce repository ou que vous ne vous souciez peut-être pas de casser le repository pour les autres utilisateurs, alors oui. Si vous avez poussé ces commits et qu’ils existent là où quelque part peut y accéder, alors non, à moins que vous ne vous souciez pas de casser les repositorys des autres. Le problème est qu’en modifiant ces validations, vous générerez de nouveaux SHA qui les traiteront comme des commits différents. Quand quelqu’un d’autre tente de récupérer ces commits modifiés, l’histoire est différente et kaboom.

Cette page http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html décrit comment le faire. (Je n’ai pas essayé cela donc YMMV)

Je veux aussi append mon exemple. Je veux créer une fonction bash_function avec un paramètre donné.

cela fonctionne dans 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 -- --twigs --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)

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