Comment modifier le nom de l'auteur et du committeur et l'e-mail de multiple commits en Git?

À L'Aide De Rebase Interactif

Vous pourriez le faire

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

marquez alors toutes vos mauvaises propagations comme" edit " dans le fichier rebase. Si vous souhaitez également modifier votre première propagation, vous devez l'ajouter manuellement en première ligne dans le fichier rebase (suivre le format des autres lignes). Puis, quand git vous demande de modifier chaque commit, faites

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

éditer ou simplement fermer l'éditeur qui s'ouvre ,puis faire

git rebase --continue

pour continuer le rebase.

vous pourriez sauter l'ouverture de l'éditeur tout à fait ici en ajoutant --no-edit pour que la commande soit:

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

Commit Unique

comme certains commentateurs l'ont noté, si vous voulez simplement changer le plus récent commit, la commande rebase n'est pas nécessaire. Il suffit de faire

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

cela changera l'auteur au nom spécifié, mais le committer sera défini à votre utilisateur configuré dans git config user.name et git config user.email . Si vous voulez définir le committer à 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

Note sur la fusion commet

il y avait un petit défaut dans ma réponse originale. S'il y a une fusion de commits entre le courant HEAD et votre <some HEAD before all your bad commits> , alors git rebase va les aplatir (et d'ailleurs, si vous utilisez GitHub pull requests, il va y avoir une tonne de merge commits dans votre histoire). Cela peut très souvent conduire à une histoire très différente (car les modifications dupliquées peuvent être "rebasées"), et dans le pire des cas, cela peut conduire à git rebase vous demandant de résoudre les conflits de fusion difficiles (qui étaient probablement déjà résolus dans les propagations de fusion). La solution est d'utiliser le drapeau -p à git rebase , qui préservera la structure de fusion de votre histoire. La page de manuel pour git rebase avertit que l'utilisation de -p et -i peut conduire à des problèmes, mais dans la section BUGS il est dit" éditer commits et reformuler leurs messages de propagation devrait fonctionner correctement."

j'ai ajouté -p à la commande ci-dessus. Pour le cas où vous êtes en train de changer le plus récent engagement, ce n'est pas un problème.

vous pouvez aussi faire:

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

Remarque, si vous utilisez cette commande dans l'invite de commande Windows, alors vous devez utiliser " au lieu de ' :

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

une doublure, mais faites attention si vous avez un dépôt multi-utilisateurs - cela changera toutes s'engage à avoir le même (Nouveau) auteur et le même 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 des linebreaks dans la corde (ce qui est possible en 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 arrive quand vous n'avez pas de $HOME/.gitconfig initialisé. Vous pouvez corriger cela comme:

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

testé avec la version git 1.7.5.4

Pour un seul commit:

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

(extrait de la réponse d'asmeurer)

dans le cas où seulement les quelques premières commits ont de mauvais auteurs, vous pouvez faire tout cela à l'intérieur de git rebase -i en utilisant la commande exec et le --amend commit, comme suit:

git rebase -i HEAD~6 # as required

qui vous présente la liste éditable des commits:

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

puis Ajouter exec ... --author="..." lignes après toutes les lignes avec de mauvais auteurs:

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

enregistrer et quitter l'éditeur (à exécuter).

This solution peut être plus long à taper que certains autres, mais il est très contrôlable - je sais exactement ce qui engage qu'il frappe.

merci à @asmeurer pour l'inspiration.

GitHub a un nice solution , qui est l'écriture shell suivante:

#!/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 docgnome l'a mentionné, réécrire l'histoire est dangereux et brisera les dépôts d'autres personnes.

mais si vous voulez vraiment faire cela et que vous êtes dans un environnement bash (aucun problème sous Linux, sur Windows, vous pouvez utiliser git bash, qui est 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 plage de révisions que vous voulez 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

Lorsqu'on prend en charge un commit non fusionné d'un autre auteur, il y a un moyen facile de gérer cela.

git commit --amend --reset-author

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

pour changer l'auteur et le committer, vous pouvez le faire (avec linebreaks dans la chaîne qui est possible en 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

vous pourriez avoir une de ces erreurs:

1. l'annuaire temporaire existe déjà
2. Refs commençant par refs/original existe déjà
   
   (cela signifie qu'une autre branche de filtre a été exécutée précédemment sur le dépôt et que la référence de branche originale est sauvegardée à refs / original )

si vous voulez forcer la course malgré ces erreurs, ajoutez le --force drapeau:

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

une petite explication de l'option -- --all pourrait être nécessaire: Cela fait fonctionner la branche de filtre sur tous révisions sur tous réfs (qui inclut toutes les branches). Cela signifie, par exemple, que les tags sont également réécrits et sont visibles sur les branches réécrites.

une" erreur "courante consiste à utiliser HEAD à la place, ce qui signifie filtrer toutes les révisions sur la seule branche courante . Et alors aucune étiquette (ou autre réf) n'existerait dans la branche réécrite.

vous pouvez utiliser cet alias pour faire:

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

ou pour les 10 dernières s'engage:

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

Alias:

change-commits = "!f() { VAR=; OLD=; NEW=; 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

espère que c'est utile.

1. exécuter git rebase -i <sha1 or ref of starting point>
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 commits:

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

cette option conserve toutes les autres informations de propagation (y compris les dates). L'option --reuse-message=HEAD empêche le message Editeur du lancement.

j'utilise ce qui suit pour réécrire l'auteur pour un dépôt complet, y compris les tags et toutes les branches:

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

puis , comme décrit dans la page de manuel de la branche de filtre , supprimer tous les réfs originaux sauvegardés par filter-branch (ceci est destructif, sauvegarde en premier):

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 (le format est le même que celui pour git-cvsimport ). Il fonctionne en changeant tous les utilisateurs tels que définis dans le author-conv-file à travers toutes les branches.

nous l'avons utilisé en conjonction avec cvs2git pour migrer notre dépôt de cvs vers Git.

, C'est-à-dire L'échantillon author-conv-file

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

le script:

 #!/bin/bash

 export $authors_file=author-conv-file

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

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

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

 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é que les versions présentées sont agressives, surtout si vous propagez des correctifs d'autres développeurs, cela va essentiellement voler leur code.

la version ci-dessous fonctionne sur toutes les branches et change l'auteur et comitter séparément pour éviter cela.

félicitations à leif81 pour l'option 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. Changement de commettre author name & email par Amend , puis le remplacement de 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 Autre chemin 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
   

je tiens à souligner que si le seul problème est que l'auteur/e-mail est différente de l'habitude, ce n'est pas un problème. Le correctif est de créer un fichier appelé .mailmap à la base du répertoire avec des lignes comme

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

et à partir de là, les commandes comme git shortlog considéreront ces deux noms comme étant les mêmes (à moins que vous ne leur disiez expressément de ne pas le faire). Voir http://schacon.github.com/git/git-shortlog.html pour de plus amples informations.

cela a l'avantage de toutes les autres solutions ici en ce que vous n'avez pas à réécrire l'histoire, qui peut causer des problèmes si vous avez un amont, et 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 il devrait vraiment être quelqu'un d'autre, et vous n'avez pas d'objection à réécrire l'histoire à ce point, changer l'auteur du commit est probablement une bonne idée à des fins d'attribution (dans laquelle cas où je vous dirige vers mon autre réponse ici).

si vous êtes le seul utilisateur de ce dépôt, vous pouvez réécrire l'histoire en utilisant soit git filter-branch (comme svick a écrit ), ou git fast-export / git fast-import plus filter script (comme décrit dans l'article référencé dans docgnome answer ), ou interactive rebase . Mais l'un ou l'autre changerait les révisions à partir du premier commit modifié, cela signifie des problèmes pour quiconque a basé ses modifications sur votre pré-réécriture de branche.

récupération

si d'autres développeurs ne basaient pas leur travail sur une version pré-réécrite, la solution la plus simple serait de re-cloner (cloner à nouveau).

alternativement ils peuvent essayer git rebase --pull , qui serait rapide-en avant s'il n'y avait pas de changements dans leur dépôt, ou réécrire leur branche au-dessus des commits réécrits (nous voulons éviter la fusion, car cela garderait les comits pré-réécrits pour toujours). Tout cela en présumant qu'ils n'ont pas effectué de travail; utilisez git stash pour cacher les changements autrement.

si d'autres développeurs utilisent des branches de fonctionnalité, et/ou git pull --rebase ne fonctionne pas, par exemple parce que l'amont n'est pas mis en place, ils doivent rebase leur travail en plus de post-réécriture s'engage. Par exemple, juste après avoir récupéré de nouveaux changements ( git fetch ), pour une branche master basée sur / bifurquée de origin/master , il faut lancer

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

Ici origin/master@{1} est pré-réécriture d'état (avant de chercher), voir gitrevisions .

Autre solution serait d'utiliser des refs/remplacer/ , disponible dans Git depuis la version 1.6.5. Dans cette solution vous fournissez des remplacements pour les commits qui ont un email erroné; alors n'importe qui qui va chercher 'remplacez' des références (quelque chose comme fetch = +refs/replace/*:refs/replace/* refspec à l'endroit approprié dans leur .git/config ) obtiendrait des remplacements de manière transparente, et ceux qui ne vont pas chercher ces références verraient de vieilles commits.

la procédure va quelque chose comme ceci:

1. " trouver tous les commits avec le mauvais email, pour exemple d'utilisation de

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

2. pour chaque propagation erronée, créez une propagation de remplacement, et ajoutez-la à la base de données d'objets

   $ 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. maintenant que vous avez corrigé commit in object database, vous devez dire à git de remplacer automatiquement et de manière transparente wrong commit par corrected one en utilisant git replace commande:

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

4. enfin, énumérer tous les remplaçants pour vérifier si cette procédure a abouti

   $ git replace -l
   

   et vérifier si des 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) le mode batch, donc vous devriez utiliser la boucle shell pour cela, ou remplacer "à la main".

NON TESTÉ! YMMV.

^{notez que vous pourriez rencontrer des coins rugueux en utilisant le mécanisme refs/replace/ : il est nouveau, et pas encore très bien testé} .

si les propagations que vous voulez corriger sont les plus récentes, et juste quelques-unes d'entre elles, vous pouvez utiliser une combinaison de git reset et git stash pour revenir sur une propagation après avoir configuré le bon nom et l'email.

la séquence sera quelque chose comme ceci (pour 2 fausses propagations, pas de changements en attente):

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

si vous utilisez Eclipse avec EGit, alors il y a une solution assez facile.

Hypothèse: vous avez des commits dans une branche locale ' local_master_user_x 'qui ne peuvent pas être poussés vers une branche distante' master ' à cause de l'utilisateur invalide.

1. la Caisse de la distance de la branche "master"
2. sélectionnez les projets/dossiers / fichiers pour lesquels "local_master_user_x" contient des modifications
3. clic droit-remplacer avec-branche - 'local_master_user_x'
4. valider ces changements, de nouveau, cette fois en tant que l'utilisateur correct et dans les locaux de la branche "master"
5. Pousser à distance "maître",

en utilisant le rebase interactif, vous pouvez placer une commande amend après chaque propagation que vous voulez 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 e-mail différentes, une pour le committer (la personne qui a commis le changement) et une autre pour le auteur (la personne qui a écrit le changement).

les informations du 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 une propagation particulière).

alors que changer l'auteur de votre dernier commit est aussi simple que git commit --amend --author "Author Name <email@example.com>" , il n'y a pas de ligne ou d'argument pour faire la même chose avec les informations du committer.

la solution est de (Temporairement, ou non) changer vos informations utilisateur, puis modifier la propagation, qui mettra à jour le committer à vos informations actuelles:

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

nous avons connu un problème aujourd'hui où un caractère UTF8 dans un nom d'auteur causait des problèmes sur le serveur de construction, donc nous avons dû réécrire l'histoire pour corriger cela. Les mesures prises sont les suivantes:

Étape 1: Changez votre nom d'utilisateur en git pour toutes les futures propagations, 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 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

aperçu rapide: Vérifiez votre dépôt dans un fichier temp, vérifiez toutes les branches distantes, exécutez le script qui réécrira l'histoire, faites une poussée de force du nouvel état, et dites à tous vos collègues de faire une poussée de rebase pour obtenir les modifications.

nous avons eu du mal à exécuter ceci sur OS X parce que cela a d'une certaine manière foiré les fins de ligne dans les messages de propagation, donc nous avons dû le relancer sur une machine Linux après.

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 mis ce script sur votre chemin, vous pouvez émettre des commandes comme:

• Changer l'auteur couplages sur la branche courante

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

• Modifier les correspondances entre l'auteur et le committer sur et . Passer -f à filter-branch pour permettre des sauvegardes de réécriture

  $ 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
  

soit dit en passant, après avoir fait vos changements, nettoyez la sauvegarde de la branche filtre avec: git-backup-clean

si vous êtes le seul utilisateur de ce repo ou si vous ne vous souciez pas de casser le repo pour d'autres utilisateurs, alors oui. Si vous avez poussé ces commits et qu'ils existent là où d'autres peuvent y accéder, alors non, à moins que vous ne vous souciez pas de briser les repos des autres. Le problème est qu'en changeant ces propagations, vous générerez de nouvelles SHAs qui les feront traiter comme des propagations différentes. Lorsque quelqu'un tente de tirer dans ces changements s'engage, 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é cette sorte YMMV)

je veux ajouter mon Exemple. Je veux créer une bash_function avec un paramètre donné.

cela fonctionne à mint-linux-17.3

#  => email to change,  => new_name,  => 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 <email@example.com>" --no-edit && git rebase --continue; done

appuyez sur ^C # Après que le rebase est fait (la boucle va continuer à mettre à jour la dernière propagation)

essayez ceci. Il fera la même chose que ci-dessus, mais de façon interactive.

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

référence: https://github.com/majdarbash/git-author-change-script

Ce n'est pas la réponse à votre question, mais plutôt un script que vous pouvez utiliser pour éviter cela à l'avenir. Il utilise les crochets globaux disponibles depuis Git version 2.9 pour vérifier votre configuration de courrier électronique basé sur le répertoire de votre entrée:

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

il vérifie votre répertoire courant, puis vérifie que votre git est configuré à l'email correct. Si pas, il change automatiquement. Voir les détails complets ici .