password - git login

¿Puedo especificar varios usuarios para mí en.gitconfig?

Question

En mi ~/.gitconfig , enumero mi dirección de correo electrónico personal en [user] , ya que eso es lo que quiero usar para los repositorios de Github.

Pero, recientemente he comenzado a usar git para el trabajo, también. El repositorio git de mi compañía me permite comprometerme, pero cuando envía anuncios de nuevos conjuntos de cambios, dice que son de Anónimo porque no reconoce la dirección de correo electrónico en mi .gitconfig ; al menos, esa es mi teoría.

¿Es posible especificar múltiples definiciones de [user] en .gitconfig ? ¿O hay alguna otra forma de anular el .gitconfig predeterminado para un directorio determinado? En mi caso, ~/worksrc/ todo el código de trabajo en ~/worksrc/ - ¿hay alguna forma de especificar un .gitconfig solo para ese directorio (y sus subdirectorios)?

Answer 1

Algo así como la respuesta de Rob W , pero permitiendo una clave ssh diferente, y funciona con versiones anteriores de git (que no tienen, por ejemplo, una configuración core.sshCommand).

~/bin/git_poweruser el archivo ~/bin/git_poweruser , con permiso ejecutable, y en el PATH:

#!/bin/bash
TMPDIR=$(mktemp -d)
trap ''rm -rf "$TMPDIR"'' EXIT
cat > $TMPDIR/ssh << ''EOF''
#!/bin/bash
ssh -i $HOME/.ssh/poweruserprivatekey $@
EOF
chmod +x $TMPDIR/ssh
export GIT_SSH=$TMPDIR/ssh
git -c user.name="Power User name" -c user.email="[email protected]" $@

Cuando quiero cometer o empujar algo como "Usuario avanzado", uso git_poweruser lugar de git . Debería funcionar en cualquier directorio y no requiere cambios en .gitconfig o .ssh/config , al menos no en el mío.

Answer 2

Aquí está lo que acabo de encontrar después de seguir los pasos de muchas respuestas aquí.

Cómo configurar múltiples configuraciones de claves SSH para diferentes cuentas de github

Es posible que desee comenzar a verificar las claves guardadas actualmente $ ssh-add -l

Si decide eliminar todas las claves almacenadas en caché antes ( opcional, tenga cuidado con esto ) $ ssh-add -D

Luego, puede crear una clave ssh pub / priv vinculada a cada correo electrónico / cuenta que desee o necesite usar

$ cd ~/.ssh
$ ssh-keygen -t rsa -C "[email protected]" <-- save it as "id_rsa_work"
$ ssh-keygen -t rsa -C "[email protected]" <-- save it as "id_rsa_pers"

Después de ejecutar estos comandos tendrás los siguientes archivos creados

~/.ssh/id_rsa_work
~/.ssh/id_rsa_work.pub
~/.ssh/id_rsa_pers
~/.ssh/id_rsa_pers.pub

Asegúrese de que el agente de autenticación se está ejecutando

$ eval `ssh-agent -s`

Agregue las claves generadas de la siguiente manera (desde la carpeta ~ / .ssh)

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Ahora puedes revisar tus llaves guardadas de nuevo

$ ssh-add -l

Ahora necesita agregar las claves públicas generadas a su servidor github / bickbuket Acces Keys

Clona cada uno de los repos en carpetas diferentes.

Vaya a la carpeta donde se usará el trabajo del usuario y haga esto

$ git config user.name "Working Hard"
$ git config user.email "[email protected]"

Solo para ver de qué se trata, verifique el contenido de ".git / config"

Vaya a la carpeta donde se utilizará el usuario activehacker y haga esto

$ git config user.name "Personal Account"
$ git config user.email "[email protected]"

Solo para ver de qué se trata, verifique el contenido de ".git / config"

Después de todo esto, podrá enviar su código personal y de trabajo mediante el cambio de carpetas.

Si tiene algún problema, hágamelo saber [email protected]

Answer 3

Aunque la mayoría de las preguntas respondieron al OP, solo tuve que pasar por esto y sin siquiera buscar en Google pude encontrar la solución más rápida y sencilla. Aquí hay pasos simples:

• copia el .gitconfg existente de tu otro repositorio
• pega en tu nuevo repositorio agregado
• cambie los valores en el archivo .gitconfig , como nombre, correo electrónico y nombre de [user] name = John email = [email protected] username = john133
• agregue el nombre del archivo a la lista de .gitignore , para asegurarse de no cometer el archivo .gitconfig en su repositorio de trabajo

Answer 4

Con las inclusión condicionales en Git 2.13, ahora es posible que varios usuarios / correo electrónico coexistan en una máquina con poco trabajo.

user.gitconfig tiene mi nombre personal y correo electrónico. work-user.gitconfig tiene mi nombre de trabajo y correo electrónico. Ambos archivos están en ~ ruta.

Así que mi nombre personal / correo electrónico se aplica por defecto. Para c:/work/ dir, se aplica mi nombre de trabajo / correo electrónico. Para c:/work/github/ dir, se aplica mi nombre personal / correo electrónico. Esto funciona a medida que se aplica la última configuración.

# ~/.gitconfig
[include]
path = user.gitconfig
[includeIf "gitdir/i:c:/work/"]
path = work-user.gitconfig
[includeIf "gitdir/i:c:/work/github/"]
path = user.gitconfig

gitdir entre mayúsculas y minúsculas y gitdir/i distingue entre mayúsculas y minúsculas.

"gitdir/i:github/" aplicaría la inclusión condicional para cualquier directorio con github en su ruta.

Answer 5

Desde git 2.13 , es posible resolver esto utilizando los incluidos condicionales recientemente introducidos.

Un ejemplo:

Configuración global ~ / .gitconfig

[user]
name = John Doe
email = [email protected]
[includeIf "gitdir:~/work/"]
path = ~/work/.gitconfig

Configuración específica de trabajo ~ / trabajo / .gitconfig

[user]
email = [email protected]

Answer 6

Después de inspirarme en la publicación del blog de Orr Sella, escribí un enlace de confirmación previa (reside en ~/.git/templates/hooks ) que establecería nombres de usuario específicos y direcciones de correo electrónico basadas en la información dentro de un repositorio local ./.git/config :

~/.gitconfig colocar la ruta al directorio de plantillas en su ~/.gitconfig :

[init]
templatedir = ~/.git/templates

Luego, cada git init o git clone recogerá ese gancho y aplicará los datos del usuario durante la próxima git commit . Si desea aplicar el enlace a los repositorios existentes, simplemente ejecute git init dentro del repositorio para reinicializarlo.

Aquí está el gancho que se me ocurrió (todavía necesita un poco de pulido - las sugerencias son bienvenidas). Guárdalo ya sea como

~/.git/templates/hooks/pre_commit

o

~/.git/templates/hooks/post-checkout

y asegúrese de que sea ejecutable: chmod +x ./post-checkout || chmod +x ./pre_commit chmod +x ./post-checkout || chmod +x ./pre_commit

#!/usr/bin/env bash
# -------- USER CONFIG
# Patterns to match a repo''s "remote.origin.url" - beginning portion of the hostname
git_remotes[0]="Github"
git_remotes[1]="Gitlab"
# Adjust names and e-mail addresses
local_id_0[0]="my_name_0"
local_id_0[1]="my_email_0"
local_id_1[0]="my_name_1"
local_id_1[1]="my_email_1"
local_fallback_id[0]="${local_id_0[0]}"
local_fallback_id[1]="${local_id_0[1]}"
# -------- FUNCTIONS
setIdentity()
{
local current_id local_id
current_id[0]="$(git config --get --local user.name)"
current_id[1]="$(git config --get --local user.email)"
local_id=("$@")
if [[ "${current_id[0]}" == "${local_id[0]}" &&
"${current_id[1]}" == "${local_id[1]}" ]]; then
printf " Local identity is:/n"
printf "» User: %s/n» Mail: %s/n/n" "${current_id[@]}"
else
printf "» User: %s/n» Mail: %s/n/n" "${local_id[@]}"
git config --local user.name "${local_id[0]}"
git config --local user.email "${local_id[1]}"
fi
return 0
}
# -------- IMPLEMENTATION
current_remote_url="$(git config --get --local remote.origin.url)"
if [[ "$current_remote_url" ]]; then
for service in "${git_remotes[@]}"; do
# Disable case sensitivity for regex matching
shopt -s nocasematch
if [[ "$current_remote_url" =~ $service ]]; then
case "$service" in
"${git_remotes[0]}" )
printf "/n»» An Intermission/n» %s repository found." "${git_remotes[0]}"
setIdentity "${local_id_0[@]}"
exit 0
;;
"${git_remotes[1]}" )
printf "/n»» An Intermission/n» %s repository found." "${git_remotes[1]}"
setIdentity "${local_id_1[@]}"
exit 0
;;
* )
printf "/n» pre-commit hook: unknown error/n» Quitting./n"
exit 1
;;
esac
fi
done
else
printf "/n»» An Intermission/n» No remote repository set. Using local fallback identity:/n"
printf "» User: %s/n» Mail: %s/n/n" "${local_fallback_id[@]}"
# Get the user''s attention for a second
sleep 1
git config --local user.name "${local_fallback_id[0]}"
git config --local user.email "${local_fallback_id[1]}"
fi
exit 0

EDITAR:

Así que reescribí el gancho como un gancho y comando en Python. Además, también es posible llamar al script como un comando Git ( git passport Git). También es posible definir un número arbitrario de ID dentro de un archivo de configuración ( ~/.gitpassport ) que se pueden seleccionar en un aviso. Puede encontrar el proyecto en github.com: git-passport - Un comando de Git y un enlace escrito en Python para administrar varias cuentas de Git / identidades de usuario .

Answer 7

Esta respuesta está parcialmente inspirada en la publicación de @Saucier, pero estaba buscando una forma automatizada de configurar user.name y user.email por repo, basada en el control remoto, que era un poco más ligero que el git -Paquete de pasaporte que desarrolló. También h / t a @John para la configuración useConfigOnly. Aquí está mi solución:

.gitconfig cambia:

[github]
name = <github username>
email = <github email>
[gitlab]
name = <gitlab username>
email = <gitlab email>
[init]
templatedir = ~/.git-templates
[user]
useConfigOnly = true

hook posterior a la comprobación que debe guardarse en la siguiente ruta: ~/.git-templates/hooks/post-checkout :

#!/usr/bin/env bash
# make regex matching below case insensitive
shopt -s nocasematch
# values in the services array should have a corresponding section in
# .gitconfig where the ''name'' and ''email'' for that service are specified
remote_url="$( git config --get --local remote.origin.url )"
services=(
''github''
''gitlab''
)
set_local_user_config() {
local service="${1}"
local config="${2}"
local service_config="$( git config --get ${service}.${config} )"
local local_config="$( git config --get --local user.${config} )"
if [[ "${local_config}" != "${service_config}" ]]; then
git config --local "user.${config}" "${service_config}"
echo "repo ''user.${config}'' has been set to ''${service_config}''"
fi
}
# if remote_url doesn''t contain the any of the values in the services
# array the user name and email will remain unset and the
# user.useConfigOnly = true setting in .gitconfig will prompt for those
# credentials and prevent commits until they are defined
for s in "${services[@]}"; do
if [[ "${remote_url}" =~ "${s}" ]]; then
set_local_user_config "${s}" ''name''
set_local_user_config "${s}" ''email''
break
fi
done

Utilizo diferentes credenciales para github y gitlab, pero esas referencias en el código anterior podrían reemplazarse o aumentarse con cualquier servicio que use. Para que el enganche posterior a la comprobación establezca automáticamente el nombre de usuario y el correo electrónico localmente para un repositorio después de una comprobación, asegúrese de que el nombre del servicio aparezca en la URL remota, agréguelo a la matriz de servicios en el script post-checkout y cree una sección para ello en su .gitconfig que contiene su nombre de usuario y correo electrónico para ese servicio.

Si ninguno de los nombres de servicio aparece en la URL remota o si el repositorio no tiene un remoto, el nombre de usuario y el correo electrónico no se configurarán localmente. En estos casos, la configuración de user.useConfigOnly estará en juego, lo que no le permitirá realizar confirmaciones hasta que el nombre de usuario y el correo electrónico estén configurados en el nivel de recompra, y le pedirá al usuario que configure esa información.

Answer 8

Hay una solución simple que parece funcionar bien para evitar errores.

Simplemente elimine la sección [user] de su ~/.gitconfig , lo que le impedirá realizar confirmaciones sin configurar user.name para cada repositorio.

En su ~/.bashrc , agregue algunos alias simples para el usuario y el correo electrónico:

alias ggmail=''git config user.name "My Name";git config user.email [email protected]''
alias gwork=''git config user.name "My Name";git config user.email [email protected]''

Answer 9

Hice una función de bash que maneja eso. Aquí está el repo de Github .

Para el registro:

# Look for closest .gitconfig file in parent directories
# This file will be used as main .gitconfig file.
function __recursive_gitconfig_git {
gitconfig_file=$(__recursive_gitconfig_closest)
if [ "$gitconfig_file" != '''' ]; then
home="$(dirname $gitconfig_file)/"
HOME=$home /usr/bin/git "$@"
else
/usr/bin/git "$@"
fi
}
# Look for closest .gitconfig file in parents directories
function __recursive_gitconfig_closest {
slashes=${PWD//[^//]/}
directory="$PWD"
for (( n=${#slashes}; n>0; --n ))
do
test -e "$directory/.gitconfig" && echo "$directory/.gitconfig" && return
directory="$directory/.."
done
}
alias git=''__recursive_gitconfig_git''

Answer 10

O puede agregar la siguiente información en su archivo .git/config local

[user]
name = Your Name
email = [email protected]

Answer 11

Otra opción para hacer que git funcione con varios nombres / correos electrónicos es aliasing git y usar la -c para anular la configuración global y específica del repositorio.

Por ejemplo, al definir un alias:

alias git=''/usr/bin/git -c user.name="Your name" -c user.email="[email protected]"''

Para ver si funciona, simplemente escriba git config user.email :

$ git config user.email
[email protected]

En lugar de un alias, también puede poner un ejecutable git personalizado dentro de su $PATH .

#!/bin/sh
/usr/bin/git -c user.name="Your name" -c user.email="[email protected]" "$@"

Una ventaja de este método sobre un .git/config específico del repositorio es que se aplica a todos los repositorios git cuando el programa git personalizado está activo. De esta manera, puede cambiar fácilmente entre usuarios / nombres sin modificar ninguna configuración (compartida).

Answer 12

Puede configurar un repositorio individual para usar un usuario / dirección de correo electrónico específico que invalida la configuración global. Desde la raíz del repositorio, ejecute

git config user.name "Your Name Here"
git config user.email [email protected]

mientras que el usuario / correo electrónico predeterminado está configurado en su ~ / .gitconfig

git config --global user.name "Your Name Here"
git config --global user.email [email protected]

Answer 13

Puede que sea un simple hack, pero es útil. Solo genera 2 claves ssh como abajo.

Generating public/private rsa key pair.
Enter file in which to save the key (/Users/GowthamSai/.ssh/id_rsa): work
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in damsn.
Your public key has been saved in damsn.pub.
The key fingerprint is:
SHA256:CrsKDJWVVek5GTCqmq8/8RnwvAo1G6UOmQFbzddcoAY [email protected]
The key''s randomart image is:
+---[RSA 4096]----+
|. .oEo+=o+. |
|.o o+o.o= |
|o o o.o. + |
| =.+ . = |
|= *+. S. |
|o*.++o . |
|=.oo.+. |
| +. +. |
|.o=+. |
+----[SHA256]-----+

De la misma manera crea uno más para personal. Entonces, tienes 2 llaves ssh, trabajo y compañía. Copie work.pub, work, personal.pub, personal a ~ / .ssh / Directory.

Luego cree el script de shell con las siguientes líneas y asígnele el nombre crev.sh (Reversa de la compañía) con el siguiente contenido.

cp ~/.ssh/work ~/.ssh/id_rsa
cp ~/.ssh/work.pub ~/.ssh/id_rsa.pub

De la misma manera, cree uno más llamado prev.sh (Personal Reverse) con el siguiente contenido.

cp ~/.ssh/personal ~/.ssh/id_rsa
cp ~/.ssh/personal.pub ~/.ssh/id_rsa.pub

en ~ / .bashrc agregue alias para los scripts como abajo

alias crev="sh ~/.ssh/crev.sh"
alias prev="sh ~/.ssh/prev.sh"
source ~/.bashrc

Cuando quieras usar compañía, solo haz crev, y si quieres usar personal do prev :-p.

Agregue esas claves ssh a sus cuentas de github. Asegúrese de que no haya generado id_rsa con anterioridad, ya que esos scripts sobrescribirán id_rsa. Si ya ha generado id_rsa, úselo para una de las cuentas. Cópialos como personales y omitiendo generación de claves personales.

Answer 14

Si no desea tener una dirección de correo electrónico predeterminada ( enlaces de dirección de correo electrónico a un usuario de github ), puede configurar que desea que se le pregunte. La forma en que puede hacerlo depende de la versión de git que utilice, consulte a continuación.

El inconveniente (previsto) es que debe configurar su dirección de correo electrónico (y su nombre) una vez para cada repositorio. Entonces, no puedes olvidarte de hacerlo.

Versión <2.7.0

[user]
name = Your name
email = "(none)"

en su configuración global ~/.gitconfig como se indica en un comentario de Dan Aloni en la publicación del blog de Orr Sella . Cuando se intenta realizar la primera confirmación en un repositorio, git falla con el mensaje agradable:

*** Please tell me who you are.
Run
git config --global user.email "[email protected]"
git config --global user.name "Your Name"
to set your account''s default identity.
Omit --global to set the identity only in this repository.
fatal: unable to auto-detect email address (got ''(none)'')

El nombre se toma de la configuración global cuando la dirección de correo electrónico se establece localmente (el mensaje no es perfectamente exacto).

2.7.0 ≤ Versión <2.8.0

El comportamiento en las versiones <2.7.0 no fue pensado y corregido con 2.7.0. Aún puedes usar un gancho de pre-confirmación como se describe en la publicación del blog de Orr Sella . Esta solución funciona también para otras versiones, pero las otras soluciones no para esta versión.

Versión ≥ 2.8.0

Dan Aloni agregó una opción para lograr ese comportamiento (ver las notas de la versión ). Úsalo con:

[user]
useConfigOnly = true

Para que funcione, no puede dar un nombre o dirección de correo electrónico en la configuración global. Luego, en la primera confirmación, aparece un mensaje de error.

fatal: user.useConfigOnly set but no name given

Por lo tanto, el mensaje no es muy instructivo, pero como establece la opción explícitamente, debe saber qué hacer. A diferencia de la solución de las versiones <2.7.0, siempre debe configurar el nombre y el correo electrónico manualmente.

Answer 15

Simplemente agregue esto a su ~ / .bash_profile para cambiar entre las teclas predeterminadas para github.com

# Git SSH keys swap alias work_git="ssh-add -D && ssh-add -K ~/.ssh/id_rsa_work" alias personal_git="ssh-add -D && ssh-add -K ~/.ssh/id_rsa"

Answer 16

git alias (y secciones en configuraciones git) para el rescate!

agregar un alias (desde la línea de comandos):

git config --global alias.identity ''! git config user.name $(git config user.$1.name); git config user.email $(git config user.$1.email); :''

luego, establecer, por ejemplo

git config --global user.github.name "your github username"
git config --global user.github.email [email protected]

y en un repositorio nuevo o clonado puede ejecutar este comando:

git identity github

Esta solución no es automática, pero si desactiva el usuario y el correo electrónico en su ~ / .gitconfig global, forzará a git a recordarle que los configure manualmente en cada repositorio nuevo o clonado.

git config --global --unset user.name
git config --global --unset user.email

Answer 17

GIT_AUTHOR_EMAIL + local .bashrc

.bashrc_local : no .bashrc_local este archivo, solo póngalo en su computadora de trabajo:

export GIT_AUTHOR_EMAIL=''[email protected]''
export GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"

.bashrc : haga un seguimiento de este archivo, hágalo igual en las computadoras tanto de trabajo como domésticas:

F="$HOME/.bashrc_local"
if [ -r "$F" ]; then
. "$F"
fi

Estoy usando https://github.com/technicalpickles/homesick para sincronizar mis archivos de puntos.

Si solo gitconfig aceptara variables de entorno: expansión de variable de shell en git config

Answer 18

Entorno de Windows

Adicional, esto puede modificarse desde Git Extensions --> Settings --> Global Settings , si lo tiene instalado en sus sistemas.

gitextensions-latest-release

Haga clic derecho en una carpeta / directorio en el entorno de Windows para acceder a esta configuración.

Actualización : Cómo cambiar / mantener configuraciones múltiples en la versión 2.49

Answer 19

Un comando de cambio de cuentas github

Esta solución toma la forma de un solo alias de git. Una vez ejecutado, el usuario del proyecto actual se adjuntará a otra cuenta

Generar claves ssh

ssh-keygen -t rsa -C "[email protected]" -f ''/Users/arnaudrinquin/.ssh/id_rsa''
[...]
ssh-keygen -t rsa -C "[email protected]" -f ''/Users/arnaudrinquin/.ssh/id_rsa_pro''

Vincúlelos a sus cuentas de GitHub / Bitbucket

1. copiar la clave pública predeterminada pbcopy < ~/.ssh/id_rsa.pub
2. Inicia sesión en tu cuenta de GitHub.
3. pegar la clave en la página de github add SSH key
4. copiar otra clave pública pbcopy < ~/.ssh/id_rsa_pro.pub
5. repite y adapta los pasos 2 a 4 para cualquier otra cuenta

Paso 1. Cambio automático de la tecla ssh.

Podemos configurar ssh para enviar un uso de una clave de cifrado específica en función del host . Lo bueno es que puedes tener varios alias para el mismo hostname .

Vea este ejemplo ~/.ssh/config file:

# Default GitHub
Host github.com
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa
# Professional github alias
Host github_pro
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_pro

configuración remota git

Ahora puede usar estos alias en los controles remotos de git cambiando [email protected] por git@github_pro .

Puede cambiar los controles remotos de sus proyectos existentes (utilizando algo como git remote origin set-url git@github_pro:foo/bar.git ) o adaptarlos directamente al git remote origin set-url git@github_pro:foo/bar.git .

git clone [email protected]:ArnaudRinquin/atom-zentabs.git

usando alias, se convierte en:

git clone git@github_pro:ArnaudRinquin/atom-zentabs.git

Paso 2. Cambiando el usuario de git.

Los ajustes de configuración de Git pueden ser globales o por proyecto. En nuestro caso, queremos una configuración por proyecto. Es muy fácil cambiarlo:

git config user.email ''[email protected]''

Si bien esto es fácil, lleva mucho tiempo para los desarrolladores que somos. Podemos escribir un alias git muy simple para eso.

Vamos a agregarlo al archivo ~/.gitconfig .

[user]
name = Arnaud Rinquin
email = [email protected]
...
[alias]
setpromail = "config user.email ''[email protected]''"

Entonces, todo lo que tenemos que hacer es git setpromail para que nuestro correo electrónico sea cambiado solo para este proyecto.

Paso 3. Un interruptor de comando por favor?

¿No sería bueno cambiar de una cuenta predeterminada a una especificada con un solo comando sin parámetros? Esto es definitivamente posible. Este comando tendrá dos pasos:

• cambiar los remotos del proyecto actual a los alias elegidos
• cambiar usuario actual del proyecto. configuración de correo

Ya tenemos una solución de comando para el segundo paso, pero la primera es mucho más difícil. Un comando de cambio de host remoto

Aquí viene la solución en la forma de otro comando de git alias para agregar a tu ~/.gitconfig :

[alias]
changeremotehost = !sh -c /"git remote -v | grep ''$1.*fetch'' | sed s/..fetch.// | sed s/$1/$2/ | xargs git remote set-url/"

Esto permite cambiar todos los controles remotos de un host a otro (el alias). Vea el ejemplo:

$ > git remote -v
origin [email protected]:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin [email protected]:ArnaudRinquin/arnaudrinquin.github.io.git (push)
$ > git changeremotehost github.com github_pro
$ > git remote -v
origin git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (push)

Combínalos todos

Ahora solo tenemos que combinar los dos comandos en uno, esto es bastante fácil. Vea cómo también integro el cambio de host de bitbucket.

[alias]
changeremotehost = !sh -c /"git remote -v | grep ''$1.*fetch'' | sed s/..fetch.// | sed s/$1/$2/ | xargs git remote set-url/"
setpromail = "config user.email ''[email protected]''"
gopro = !sh -c /"git changeremotehost github.com github_pro && git changeremotehost bitbucket.com bitbucket_pro && git setpromail/"

Fuente de enlace -Tutorial