Como alterar o autor e o nome do committer e o e-mail de vários commits no Git?

Eu estava escrevendo um script simples no computador da escola e fazendo as alterações no Git (em um repository que estava no meu pendrive, clonado do meu computador em casa). Depois de vários commits, percebi que estava cometendo coisas como o usuário root.

Existe alguma maneira de alterar o autor desses commits para o meu nome?

Alterar o autor (ou committer) exigiria rewrite todo o histórico. Se você está bem com isso e acha que vale a pena, então você deve dar uma olhada no git filter-branch . A página man inclui vários exemplos para você começar. Note também que você pode usar variables ​​de ambiente para mudar o nome do autor, committer, datas, etc. – veja a seção “Environment Variables” da página man do git .

Especificamente, você pode corrigir todos os nomes de autores e e-mails errados para todas as ramificações e tags com este comando (fonte: ajuda do 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 

Usando o Rebase Interativo

Você poderia fazer

 git rebase -i -p  

Em seguida, marque todos os seus commits ruins como “edit” no arquivo de rebase. Se você também quiser alterar seu primeiro commit, terá que adicioná-lo manualmente como primeira linha no arquivo de rebase (siga o formato das outras linhas). Então, quando o git pede para você alterar cada commit, faça

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

editar ou apenas fechar o editor que é aberto e, em seguida,

 git rebase --continue 

para continuar o rebase.

Você pode pular abrindo o editor aqui adicionando --no-edit para que o comando seja:

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

Commit único

Como alguns dos comentadores notaram, se você quiser apenas alterar o commit mais recente, o comando rebase não é necessário. Apenas faça

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

Isso mudará o autor para o nome especificado, mas o committer será configurado para o usuário configurado em git config user.name e git config user.email . Se você quiser definir o committer como algo que você especificar, isso definirá o autor e o committer:

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

Nota sobre os Commits de mesclagem

Houve uma pequena falha na minha resposta original. Se houver alguma consolidação de mesclagem entre o HEAD atual e seu , o git rebase os estabilizará (e, a propósito, se você usar os pedidos pull do GitHub, haverá uma tonelada de mesclagem comete em sua história). Isso muitas vezes pode levar a um histórico muito diferente (como alterações duplicadas podem ser “rebased out”), e no pior dos casos, pode levar a git rebase pedindo para resolver conflitos de mesclagem difíceis (que provavelmente já foram resolvidos nos commits de mesclagem) ). A solução é usar o sinalizador -p para git rebase , que preservará a estrutura de mesclagem do seu histórico. A manpage para git rebase avisa que o uso de -p e -i pode levar a problemas, mas na seção BUGS ele diz “Editar commits e reformular suas mensagens de commit deve funcionar bem”.

Eu adicionei -p ao comando acima. Para o caso em que você está apenas alterando o commit mais recente, isso não é um problema.

Você também pode fazer:

 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 

Note, se você estiver usando este comando no prompt de comando do Windows, então você precisa usar " vez 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 

Um forro, mas tenha cuidado se você tiver um repository multiusuário – isto irá mudar todos os commits para ter o mesmo (novo) autor 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 

Com quebras de linha na string (que é possível no 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 

Isso acontece quando você não tem um $ HOME / .gitconfig inicializado. Você pode consertar isso como:

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

testado com git version 1.7.5.4

Para um único commit:

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

(extraído da resposta de asmeurer)

No caso em que apenas os poucos commits inferiores têm autores ruins, você pode fazer isso tudo dentro do git rebase -i usando o comando exec e o --amend commit, como segue:

 git rebase -i HEAD~6 # as required 

que apresenta a lista editável de commits:

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

Em seguida, adicione exec ... --author="..." linhas depois de todas as linhas com maus autores:

 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 

salvar e sair do editor (para executar).

Esta solução pode ser mais longa para digitar do que outras, mas é altamente controlável – eu sei exatamente o que ela confirma.

Obrigado a @asmeurer pela inspiração.

O Github tem uma boa solução , que é o seguinte script de 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" ' 

Como mencionado, a reescrita da história é perigosa e destruirá os repositorys de outras pessoas.

Mas se você realmente quer fazer isso e você está em um ambiente bash (não há problema no Linux, no Windows, você pode usar o git bash, que é fornecido com a instalação do git), use 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' 

Para acelerar as coisas, você pode especificar um intervalo de revisões que deseja rewrite:

 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 

Ao assumir um commit não mesclado de outro autor, há uma maneira fácil de lidar com isso.

git commit --amend --reset-author

Esta é uma versão mais elaborada da versão do @ Brian:

Para alterar o autor e committer, você pode fazer isso (com quebras de linha na string que é possível no 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 

Você pode receber um desses erros:

  1. O diretório temporário já existe
  2. Refs começando com refs / original já existe
    (isso significa que outra ramificação de filtro foi executada anteriormente no repository e a referência de ramificação original é feita em refs / original )

Se você quiser forçar a execução apesar desses erros, adicione o sinalizador --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 

Uma pequena explicação da opção -- --all pode ser necessária: Faz o filtro funcionar em todas as revisões em todas as referências (o que inclui todas as ramificações). Isso significa, por exemplo, que as tags também são reescritas e visíveis nas ramificações reescritas.

Um “erro” comum é usar o HEAD , o que significa filtrar todas as revisões apenas no ramo atual . E, então, nenhuma tag (ou outras refs) existiria na ramificação reescrita.

Você pode usar esse alias para fazer:

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

ou nos últimos 10 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 " 

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

Espero que seja útil.

  1. execute git rebase -i
  2. marque todos os commits que você deseja alterar com edit (ou e )
  3. loop os seguintes dois comandos até que você tenha processado todos os commits:

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

Isso manterá todas as outras informações de confirmação (incluindo as datas). A opção --reuse-message=HEAD impede que o editor de mensagens seja --reuse-message=HEAD .

Eu uso o seguinte para rewrite o autor para um repository inteiro, incluindo tags e todas as ramificações:

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

Em seguida, conforme descrito na página MAN da ramificação do filtro , remova todos os refs originais cujo backup tenha sido feito por filter-branch (isso é destrutivo, faça o backup primeiro):

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

Eu adaptei esta solução que funciona através da ingestão de um simples author-conv-file (formato é o mesmo que um para git-cvsimport ). Ele funciona alterando todos os usuários conforme definido no author-conv-file em todas as filiais.

Usamos isso em conjunto com o cvs2git para migrar nosso repository do cvs para o git.

Exemplo author-conv-file

 john=John Doe  jill=Jill Doe  

O roteiro:

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

Eu encontrei o caminho das versões apresentadas para agressivo, especialmente se você cometer patches de outros desenvolvedores, isso essencialmente roubará seu código.

A versão abaixo funciona em todas as filiais e altera o autor e o emissor separadamente para evitar isso.

Muitos elogios para leif81 para a opção all.

 #!/bin/bash git filter-branch --env-filter ' if [ "$GIT_AUTHOR_NAME" = "" ]; then GIT_AUTHOR_NAME=""; GIT_AUTHOR_EMAIL=""; fi if [ "$GIT_COMMITTER_NAME" = "" ]; then GIT_COMMITTER_NAME=""; GIT_COMMITTER_EMAIL=""; fi ' -- --all 
  1. Altere o author name & email confirmação por Amend , em seguida, substitua 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. Outra maneira Rebasing :

     $ git rebase -i  # back to last good commit # Editor would open, replace 'pick' with 'edit' before the commit want to change author $ git commit --amend --author="author name " # change the author name & email # Save changes and exit the editor $ git rebase --continue # finish the rebase 

Devo salientar que, se o único problema é que o autor / email é diferente do seu habitual, isso não é um problema. A correção correta é criar um arquivo chamado .mailmap na base do diretório com linhas como

 Name you want  Name you don't want  

E a partir de então, comandos como o git shortlog considerarão esses dois nomes como iguais (a menos que você diga especificamente para eles não). Consulte http://schacon.github.com/git/git-shortlog.html para mais informações.

Isto tem a vantagem de todas as outras soluções aqui em que você não tem que rewrite o histórico, o que pode causar problemas se você tiver um upstream, e é sempre uma boa maneira de perder dados acidentalmente.

Claro, se você cometeu algo como você mesmo e realmente deveria ser outra pessoa, e você não se importa em rewrite a história neste momento, mudar o autor do commit é provavelmente uma boa idéia para fins de atribuição (nesse caso eu direciono você para o meu autor). outra resposta aqui).

Se você é o único usuário deste repository, você pode rewrite o histórico usando git filter-branch (como svick escreveu ) ou git fast-export / git fast-import mais o script de filtro (como descrito no artigo referenciado na resposta do docgnome ), ou rebase interativo. Mas qualquer um desses mudaria as revisões do primeiro commit alterado em diante; isso significa problema para qualquer pessoa que baseou suas alterações em sua ramificação antes da reescrita.

RECUPERAÇÃO

Se outros desenvolvedores não basearam seu trabalho na versão pré-reescrita, a solução mais simples seria re-clonar (clone novamente).

Alternativamente, eles podem tentar git rebase --pull , que git rebase --pull se não houvesse nenhuma mudança em seu repository, ou rebase sua ramificação em cima de commits reescritos (queremos evitar mesclar, já que isso iria reescreva comits para sempre). Tudo isso assumindo que eles não têm trabalho não comprometido; use git stash para guardar alterações de outra forma.

Se outros desenvolvedores usarem ramificações de resources, e / ou git pull --rebase não funcionar, por exemplo, porque upstream não está configurado, eles precisam fazer o rebase de seu trabalho em cima de commits pós-reescrita. Por exemplo, logo após a busca de novas mudanças ( git fetch ), para uma ramificação master baseada em / bifurcada a partir de origin/master , é necessário executar

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

Aqui origin/master@{1} é o estado de pré-reescrita (antes da busca), veja gevisões .


A solução alternativa seria usar refs / replace / mechanism, disponível no Git desde a versão 1.6.5. Nesta solução, você fornece substituições para confirmações com email incorreto; então qualquer um que busca ‘replace’ refs (algo como fetch = +refs/replace/*:refs/replace/* refspec no local apropriado em seu .git/config ) obteria substituições transparentemente, e aqueles que não buscassem esses refs veja commits antigos.

O procedimento é algo assim:

  1. Encontre todos os commits com email errado, por exemplo, usando

     $ git log --author=user@wrong.email --all 
  2. Para cada confirmação incorreta, crie uma confirmação de substituição e inclua-a no database de objects

     $ 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. Agora que você corrigiu commit no database de objects, você tem que dizer ao git para replace automaticamente e transparentemente o commit errado pelo comando corrigido usando o comando git replace :

     $ git replace   
  4. Finalmente, liste todas as substituições para verificar se este procedimento foi bem-sucedido

     $ git replace -l 

    e verifique se as substituições ocorrem

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

Você pode, naturalmente, automatizar este procedimento … bem, tudo exceto usando o git replace que não tem (ainda) o modo batch, então você teria que usar o shell loop para isso, ou replace “manualmente”.

NÃO TESTADO! YMMV.

Note que você pode encontrar alguns cantos ásperos ao usar refs/replace/ mechanism: ele é novo e ainda não foi muito bem testado .

Se os commits que você quer consertar forem os mais recentes, e apenas alguns deles, você pode usar uma combinação de git reset e git stash para voltar a confirmá-los depois de configurar o nome e o email corretos.

A sequência será algo assim (para 2 commits errados, sem alterações pendentes):

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

Se você estiver usando o Eclipse com o EGit, então há uma solução bastante fácil.
Suposição: você tem commits em uma ramificação local ‘local_master_user_x’ que não pode ser enviada para uma ramificação remota ‘master’ por causa do usuário inválido.

  1. Verifica a ramificação remota ‘master’
  2. Selecione os projetos / pastas / arquivos para os quais ‘local_master_user_x’ contém alterações
  3. Clique com o botão direito do mouse – Substitua por – Branch – ‘local_master_user_x’
  4. Confirme essas alterações novamente, desta vez como o usuário correto e na ramificação local ‘master’
  5. Empurrar para remoto ‘mestre’

Usando rebase interativo, você pode colocar um comando de alteração após cada commit que você deseja alterar. Por exemplo:

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

Note que o git armazena dois endereços de e-mail diferentes, um para o committer (a pessoa que cometeu a mudança) e outro para o autor (a pessoa que escreveu a alteração).

As informações do committer não são exibidas na maioria dos lugares, mas você pode vê-las com git log -1 --format=%cn,%ce (ou use show vez de log para especificar um commit específico).

Embora a alteração do autor do seu último commit seja tão simples quanto o git commit --amend --author "Author Name " , não existe uma única linha ou argumento para fazer o mesmo com as informações do committer.

A solução é (temporariamente ou não) alterar as informações do usuário e, em seguida, alterar o commit, que atualizará o committer para as informações atuais:

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

Nós tivemos um problema hoje, onde um caractere UTF8 em um nome de autor estava causando problemas no servidor de compilation, então tivemos que rewrite o histórico para corrigir isso. Os passos dados foram:

Etapa 1: altere seu nome de usuário no git para todos os commits futuros, de acordo com as instruções aqui: https://help.github.com/articles/setting-your-username-in-git/

Etapa 2: execute o seguinte 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 

Visão geral rápida: Faça o check-out do seu repository para um arquivo temporário, registre todas as ramificações remotas, execute o script que irá rewrite o histórico, faça um push forçado do novo estado e diga a todos os seus colegas para fazer um rebase para obter as alterações.

Nós tivemos problemas em rodar isso no OS X porque de alguma forma bagunçou os finais de linha nas mensagens de commit, então nós tivemos que re-executá-lo em uma máquina Linux depois.

Seu problema é muito comum. Consulte ” Usando o Mailmap para corrigir a lista de autores no Git ”

Por uma questão de simplicidade, criei um script para facilitar o processo: git-changemail

Depois de colocar esse script em seu caminho, você pode emitir comandos como:

  • Alterar correspondências de autor no ramo atual

     $ git changemail -a old@email.com -n newname -m new@email.com 
  • Altere as correspondências de autor e committer em e . Passar -f para filiais de filtros para permitir a reconfiguração de backups

     $ git changemail -b old@email.com -n newname -m new@email.com -- -f <branch> <branch2> 
  • Mostrar usuários existentes no repo

     $ git changemail --show-both 

By the way, depois de fazer suas alterações, limpe o backup do ramo de filtro com: git-backup-clean

Se você é o único usuário deste repository ou não se importa em quebrar o repository para outros usuários, então sim. Se você empurrou esses commits e eles existem onde algum outro lugar pode acessá-los, então não, a menos que você não se importe em quebrar o repository de outras pessoas. O problema é que ao alterar esses commits você estará gerando novos SHAs, o que fará com que eles sejam tratados como commits diferentes. Quando alguém tenta puxar esses commits alterados, a história é diferente e kaboom.

Esta página http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html descreve como fazer isso. (Eu não tentei isso tão YMMV)

Eu quero adicionar meu exemplo também. Eu quero criar um bash_function com determinado parâmetro.

isso funciona em mint-linux-17.3

 # $1 => email to change, $2 => new_name, $3 => new E-Mail function git_change_user_config_for_commit { # defaults WRONG_EMAIL=${1:-"you_wrong_mail@hello.world"} NEW_NAME=${2:-"your name"} NEW_EMAIL=${3:-"new_mail@hello.world"} git filter-branch -f --env-filter " if [ \$GIT_COMMITTER_EMAIL = '$WRONG_EMAIL' ]; then export GIT_COMMITTER_NAME='$NEW_NAME' export GIT_COMMITTER_EMAIL='$NEW_EMAIL' fi if [ \$GIT_AUTHOR_EMAIL = '$WRONG_EMAIL' ]; then export GIT_AUTHOR_NAME='$NEW_NAME' export GIT_AUTHOR_EMAIL='$NEW_EMAIL' fi " --tag-name-filter cat -- --branches --tags; } 
 git rebase -i YOUR_FIRTS_COMMIT_SHA^ while true; do git commit --amend --author="Name Surname " --no-edit && git rebase --continue; done 

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

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