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

J'écrivais un script simple dans l'ordinateur de l'école et j'engageais les modifications dans Git (dans un dépôt qui était dans ma clé USB, cloné depuis mon ordinateur à la maison). Après plusieurs validations, j'ai réalisé que je validais des choses en tant qu'utilisateur root.

Existe-t-il un moyen de changer l'auteur de ces commits en mon nom?

Cette réponse utilise git-filter-branch, pour laquelle les documents donnent maintenant cet avertissement:

git filter-branch a une pléthore d'embûches qui peuvent produire des déformations non évidentes de la réécriture de l'histoire prévue (et peuvent vous laisser peu de temps pour enquêter sur de tels problèmes car il a une telle performance abyssale). Ces problèmes de sécurité et de performances ne peuvent pas être résolus de manière rétrocompatible et en tant que tels, son utilisation n'est pas recommandée. Veuillez utiliser un autre outil de filtrage d'historique tel que git filter-repo . Si vous devez encore utiliser git filter-branch, veuillez lire attentivement la SÉCURITÉ (et les PERFORMANCES ) pour en savoir plus sur les mines terrestres de filter-branch, puis éviter avec autant de vigilance que possible les dangers énumérés dans la liste.

Changer l'auteur (ou le 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, du committer, des dates, etc. - voir la section "Variables d'environnement" de la page de manuel git .

Plus précisément, vous pouvez corriger tous les mauvais noms d'auteur et e-mails pour toutes les branches et balises avec cette commande (source: aide 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

REMARQUE: cette réponse modifie les SHA1, alors faites attention à l'utiliser sur une branche qui a déjà été poussée. Si vous souhaitez uniquement corriger l'orthographe d'un nom ou mettre à jour un ancien e-mail, git vous permet de le faire sans réécrire l'historique à l'aide de .mailmap. Voir mon autre réponse .

Utilisation d'Interactive Rebase

Vous pourriez faire

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

Ensuite, marquez tous vos mauvais commits comme "modifier" dans le fichier de rebase. Si vous souhaitez également modifier votre premier commit, vous devez l'ajouter manuellement comme première ligne dans le fichier de rebase (suivez le format des autres lignes). Ensuite, quand git vous demande de modifier chaque commit, faites

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

modifier ou simplement fermer l'éditeur qui s'ouvre, puis faites

git rebase --continue

pour continuer le rebase.

Vous pouvez ignorer l'ouverture de l'éditeur 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

Validation unique

Comme certains commentateurs l'ont noté, si vous souhaitez simplement modifier le commit le plus récent, la commande rebase n'est pas nécessaire. Fais juste

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

Cela changera l'auteur en nom spécifié, mais le committer sera défini sur votre utilisateur configuré dans git config user.nameet 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 d'origine. S'il y a des validations de fusion entre l'actuel HEADet le vôtre <some HEAD before all your bad commits>, git rebaseles aplatiront (et au fait, si vous utilisez des requêtes Pull GitHub, il y aura une tonne de validations de fusion dans votre historique). Cela peut très souvent conduire à un historique très différent (car les modifications en double peuvent être "rebasées"), et dans le pire des cas, cela peut conduire à git rebasevous demander de résoudre des conflits de fusion difficiles (qui étaient probablement déjà résolus dans les validations de fusion). La solution consiste à utiliser l' -pindicateur to git rebase, qui préservera la structure de fusion de votre historique. La page de manuel pour git rebaseavertit que l'utilisation de -pet -ipeut entraîner des problèmes, maisBUGS Dans la section, il est indiqué que «la modification des validations et la reformulation de leurs messages de validation devraient fonctionner correctement.

J'ai ajouté -pà la commande ci-dessus. Dans le cas où vous modifiez simplement la validation la plus récente, ce n'est pas un problème.

Vous pouvez également 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, vous devez utiliser à la "place 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

Un liner, mais soyez prudent si vous avez un référentiel multi-utilisateurs - cela changera toutes les validations pour avoir le même (nouveau) 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 des sauts de ligne dans la chaîne (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 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 seul commit:

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

(extrait de la réponse de l'asmeurer)

Dans le cas où seules les premières validations ont de mauvais auteurs, vous pouvez tout faire à l'intérieur en git rebase -iutilisant la execcommande et la --amendvalidation, 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 des 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 (pour exécuter).

Cette solution peut être plus longue à taper que certaines autres, mais elle est hautement contrôlable - je sais exactement ce qu'elle engage.

Merci à @asmeurer pour l'inspiration.

Github a une belle 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 l'a mentionné docgnome, la réécriture de l'historique est dangereuse et brisera les référentiels des autres.

Mais si vous voulez vraiment le faire 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

Lorsque vous reprenez un commit non fusionné d'un autre auteur, il existe un moyen simple de gérer cela.

git commit --amend --reset-author

Vous pouvez l'utiliser comme un alias afin de pouvoir faire:

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

Ajoutez à ~ / .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 "

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

J'espère que c'est utile.

Il s'agit d'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 qui est possible dans 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 pouvez obtenir 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 branche de filtre a été exécutée précédemment sur le référentiel et que la référence de branche d'origine est sauvegardée à refs / original )

Si vous souhaitez forcer l'exécution malgré ces erreurs, ajoutez l' --forceindicateur:

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' -- --alloption pourrait être nécessaire: elle fait fonctionner la branche de filtre sur toutes les révisions sur toutes les références (qui inclut toutes les branches). Cela signifie, par exemple, que les balises sont également réécrites et visibles sur les branches réécrites.

Une "erreur" courante consiste à utiliser à la HEADplace, ce qui signifie filtrer toutes les révisions uniquement sur la branche actuelle . Et puis aucune balise (ou autres références) n'existerait dans la branche réécrite.

Une seule commande pour changer l'auteur des N derniers commits:

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

REMARQUES

• le --no-editdrapeau s'assure que le git commit --amendne demande pas de confirmation supplémentaire
• lorsque vous utilisez git rebase -i, vous pouvez sélectionner manuellement les validations où changer l'auteur,

le fichier que vous éditez ressemblera à ceci:

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

Vous pouvez ensuite modifier certaines lignes pour voir où vous souhaitez modifier l'auteur. Cela vous donne un bon compromis entre l'automatisation et le contrôle: vous voyez les étapes qui se dérouleront, et une fois que vous aurez enregistré, tout sera appliqué en même temps.

1. courir git rebase -i <sha1 or ref of starting point>
2. marquez 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 <new@author.email>" ; git rebase --continue

Cela conservera toutes les autres informations de validation (y compris les dates). L' --reuse-message=HEADoption empêche l'éditeur de messages de se lancer.

J'utilise ce qui suit pour réécrire l'auteur pour un référentiel entier, y compris les balises 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

Ensuite, comme décrit dans la page MAN de filter-branch , supprimez toutes les références d'origine sauvegardées par filter-branch(c'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(le format est le même que pour git-cvsimport ). Il fonctionne en changeant tous les utilisateurs tels que définis dans author-conv-filetoutes les branches.

Nous l'avons utilisé conjointement avec cvs2gitpour migrer notre référentiel de cvs vers git.

c.-à-d. échantillon author-conv-file

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

Le scénario:

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

Je dois souligner que si le seul problème est que l'auteur / e-mail est différent de votre habituel, ce n'est pas un problème. La solution correcte consiste à 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à, des commandes comme git shortlogconsidéreront ces deux noms comme étant les mêmes (sauf si vous leur dites spécifiquement de ne pas le faire). Voir http://schacon.github.com/git/git-shortlog.html pour plus d'informations.

Cela a l'avantage de toutes les autres solutions ici en ce que vous n'avez pas à réécrire l'historique, ce qui peut causer des problèmes si vous avez un 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 à ce stade, changer l'auteur de la validation est probablement une bonne idée à des fins d'attribution (auquel cas je vous dirige vers mon autre réponse ici).

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

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

Félicitations à leif81 pour l'option tout.

#!/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. Modifiez la validation author name & emailpar Amend, puis remplacez 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. Une autre façon 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
   

La façon la plus rapide et la plus simple de le faire est d'utiliser l'argument --exec de git rebase:

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

Cela créera une liste de tâches qui ressemble à ceci:

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

et cela fonctionnera automatiquement, ce qui fonctionne lorsque vous avez des centaines de validations.

Si vous êtes le seul utilisateur de ce référentiel, vous pouvez réécrire l'historique en utilisant git filter-branch(comme écrit svick ), ou git fast-export/ ou un git fast-importscript de filtre (comme décrit dans l'article référencé dans la réponse docgnome ), ou un rebase interactif . Mais l'un ou l'autre modifierait les révisions à partir du premier commit modifié; cela signifie des problèmes pour quiconque a basé ses modifications sur la pré-réécriture de votre branche.

RÉCUPÉRATION

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

Alternativement, ils peuvent essayer git rebase --pull, qui avancerait rapidement s'il n'y avait aucun changement dans leur référentiel, ou rebaser leur branche au-dessus des validations réécrites (nous voulons éviter la fusion, car cela garderait les comits de pré-réécriture pour toujours). Tout cela en supposant qu'ils n'ont pas engagé de travail; utiliser git stashpour cacher les modifications autrement.

Si d'autres développeurs utilisent des branches de fonctionnalités et / ou git pull --rebasene fonctionnent pas, par exemple parce que l'amont n'est pas configuré, ils doivent rebaser leur travail en plus des validations post-réécriture. Par exemple, juste après avoir récupéré de nouveaux changements ( git fetch), pour une masterbranche basée sur / forked from origin/master, il faut exécuter

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

Voici l'état de origin/master@{1}pré-réécriture (avant l'extraction), voir gitrevisions .

Une autre solution serait d'utiliser refs / replace / mécanisme, disponible dans Git depuis la version 1.6.5. Dans cette solution, vous fournissez des remplacements pour les validations contenant un mauvais e-mail; alors quiconque récupère les références de remplacement (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 récupèrent pas ces références verraient les anciens commits.

La procédure ressemble à ceci:

1. Rechercher toutes les validations avec un mauvais e-mail, 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 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é la validation dans la base de données d'objets, vous devez dire à git de remplacer automatiquement et de manière transparente la mauvaise validation par une correction à l'aide de la git replacecommande:

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

4. Enfin, listez tous les remplaçants pour vérifier si cette procédure a réussi

   $ 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, tout sauf en utilisant git replacequi n'a pas (encore) le mode batch, vous devrez donc utiliser la boucle shell pour cela, ou remplacer "à la main".

PAS TESTÉ! YMMV.

^{Notez que vous pourriez rencontrer des coins difficiles lors de l'utilisation du refs/replace/mécanisme: il est nouveau et pas encore très bien testé} .

Si les validations que vous souhaitez corriger sont les dernières, et seulement quelques-unes, vous pouvez utiliser une combinaison de git resetet git stashrevenir en arrière et les valider à nouveau après avoir configuré le bon nom et l'adresse e-mail.

La séquence ressemblera à ceci (pour 2 commits incorrects, aucun changement 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, il existe une solution assez simple.
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. Commander la branche distante «maître»
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 à nouveau ces modifications, cette fois en tant qu'utilisateur correct et dans la branche locale «maître»
5. Pousser vers le «maître» distant

À l'aide de 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 e-mail différentes, une pour le committer (la personne qui a commis le changement) et une autre pour l' auteur (la personne qui a écrit le changement).

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

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

La solution consiste à (temporairement ou non) modifier vos informations utilisateur, puis à modifier le commit, ce qui mettra le commiteur à 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 prises étaient les suivantes:

Étape 1: Modifiez votre nom d'utilisateur dans git pour tous les futurs commits, 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: extrayez votre référentiel dans un fichier temporaire, extrayez toutes les branches distantes, exécutez le script qui réécrira l'historique, effectuez une poussée forcée du nouvel état et dites à tous vos collègues de faire un tirage de rebase pour obtenir les modifications.

Nous avons eu du mal à exécuter cela sur OS X, car cela a en quelque sorte gâché les fins 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 courant. 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 lancer des commandes comme:

• Modifier les correspondances d'auteur sur la branche actuelle

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

• Modifiez les correspondances d'auteur et de committer sur <branch> et <branch2>. Passer -fà filter-branch pour permettre 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 le référentiel

  $ git changemail --show-both
  

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

Essayez ceci. Il fera la même chose que mentionné ci-dessus, mais de manière 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

Je veux également ajouter mon exemple. Je veux créer une fonction bash 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 -- --branches --tags;
}

Si vous êtes le seul utilisateur de ce dépôt ou si vous ne vous souciez pas de le casser pour d'autres utilisateurs, alors oui. Si vous avez poussé ces validations et qu'elles existent là où un autre endroit peut y accéder, alors non, à moins que vous ne vous souciez pas de casser les repos des autres. Le problème est qu'en changeant ces validations, vous générerez de nouveaux SHA qui les traiteront comme des validations différentes. Quand quelqu'un d'autre essaie 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 procéder. (Je n'ai pas essayé ça alors YMMV)