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


755

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

Pero, recientemente, también comencé a usar git para el trabajo. El repositorio git de mi empresa me permite comprometerme, pero cuando envía anuncios de nuevos conjuntos de cambios, dice que son de Anonymous 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 [user]definiciones en .gitconfig? ¿O hay alguna otra forma de anular el valor predeterminado .gitconfigpara un determinado directorio? En mi caso, reviso todo el código de trabajo ~/worksrc/, ¿hay alguna manera de especificar un .gitconfigsolo para ese directorio (y sus subdirectorios)?



1
Me sorprende que el servidor de su empresa haga eso, tendría que CAMBIAR el tono de su compromiso para que eso funcione. Si se compromete con un pago local, ¿qué nombre de usuario ve?
Alex Brown

1
@Alex: Olvidé la parte importante, podría ser fácilmente un nombre en la notificación por correo electrónico, sin cambiar realmente nada en la confirmación.
Cascabel

1
Puede usar un git-hook para automatizar este trabajo recurrente: github.com/DrVanScott/git-clone-init
Henning

1
Acepte esta respuesta: stackoverflow.com/a/43654115/482899 . Es la mejor solución desde git 2.13.
northtree

Respuestas:


1017

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

git config user.name "Your Name Here"
git config user.email your@email.com

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 your@email.com

83
puedes ver los efectos de estas configuraciones en el .git/configarchivo
Abizern

21
Puede editar manualmente esos archivos de configuración con git config --edity git config --global --edit. Y en caso de que se haya perdido el comentario de Abizern , se encuentra el archivo de configuración de un repositorio <repo-root>/.git/config.
Rory O'Kane

13
También debe deshabilitar GIT_AUTHOR_EMAIL y GIT_COMMITTER_EMAIL (y * _NAME) ya que anularán la configuración local
ACyclic

66
¿Hay alguna manera de hacer esto para todos los repositorios en una carpeta determinada, en lugar de para repositorios individuales? Vea mi pregunta aquí: stackoverflow.com/questions/21307793/…
scubbo

66
Consulte esta respuesta a continuación para obtener una solución más actualizada Git 2.13lanzada hoy.
tejasbubane

491

Desde git 2.13 , es posible resolver esto usando las inclusiones condicionales recién introducidas .

Un ejemplo:

Configuración global ~ / .gitconfig

[user]
    name = John Doe
    email = john@doe.tld

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig

Trabajo específico config ~ / work / .gitconfig

[user]
    email = john.doe@company.tld

48
Esta es la mejor respuesta ahora que se ha lanzado git 2.13.
tejasbubane

1
¿Funcionaría esta solución para todos los subdirectorios dentro del especificado en la declaración de inclusión, suponiendo que no tengan sus propios archivos .gitconfig? Creo que sí, pero hasta ahora las pruebas no han confirmado esto.
Gary

2
@ Gary Sí, según mi experiencia y los documentos: “Si el patrón termina con /, ** se agregará automáticamente. Por ejemplo, el patrón foo / se convierte en foo / **. En otras palabras, coincide con "foo" y todo lo que hay dentro, recursivamente. ”,“; incluir para todos los repositorios dentro de $ HOME / to / group [includeIf "gitdir: ~ / to / group /"] ”
Tomáš Janoušek

66
El gitdir debe incluir el último '/'.
Chris Yim

55
Puede comprobar que funciona de forma recursiva ejecutándose git config --listen diferentes directorios. En subdirectorios de ~/work/que contienen un repositorio git, el includeIfefecto surte efecto. Tenga en cuenta que en subdirectorios ~/work/que no contienen un repositorio git, includeIfno se ejecuta.
NZD

105

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

[user]  
    name = Your Name
    email = your.email@gmail.com

27
... que es la forma manual de hacer lo que los comandos recomendados por @discomurray hacen por usted.
user456584

1
¿Es posible agregar varias líneas de esto por control remoto?
Abel Callejo

56

Un interruptor de cuentas de github de comando

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

Generar claves ssh

ssh-keygen -t rsa -C "rinquin.arnaud@gmail.com" -f '/Users/arnaudrinquin/.ssh/id_rsa'

[...]

ssh-keygen -t rsa -C "arnaud.rinquin@wopata.com" -f '/Users/arnaudrinquin/.ssh/id_rsa_pro'

Vincúlelos a sus cuentas de GitHub / Bitbucket

  1. copiar clave pública predeterminada pbcopy < ~/.ssh/id_rsa.pub
  2. inicie sesión en su cuenta de GitHub
  3. pegue la clave en la add SSH keypágina de github
  4. copiar otra clave pública pbcopy < ~/.ssh/id_rsa_pro.pub
  5. repita y adapte los pasos 2 a 4 para cualquier otra cuenta

Paso 1. Cambio automático de clave ssh.

Podemos configurar sshpara enviar un uso de una clave de cifrado específica según el host. Lo bueno es que puedes tener varios alias para el mismo hostname.

Ver este ~/.ssh/configarchivo de ejemplo :

# 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 de git

Ahora puede usar estos alias en los controles remotos git cambiando git@github.compor git@github_pro.

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

git clone git@github.com:ArnaudRinquin/atom-zentabs.git

usando alias, se convierte en:

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

Paso 2. Cambiar git user.email

La configuración de Git puede ser global o por proyecto. En nuestro caso, queremos una configuración por proyecto. Es muy fácil cambiarlo:

git config user.email 'arnaud.rinquin@wopata.com'

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

Lo vamos a agregar al ~/.gitconfigarchivo.

[user]
    name = Arnaud Rinquin
    email = rinquin.arnaud@gmail.com

...

[alias]
    setpromail = "config user.email 'arnaud.rinquin@wopata.com'"

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

Paso 3. ¿Un interruptor de comando por favor?

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

  • cambiar los controles remotos del proyecto actual a los alias elegidos
  • cambiar la configuración actual de user.email del proyecto

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

Aquí viene la solución en forma de otro comando git alias para agregar a su ~/.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). Mira el ejemplo:

$ > git remote -v
origin  git@github.com:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin  git@github.com: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)

Combinarlos todos

Ahora solo tenemos que combinar los dos comandos en uno, esto es bastante fácil. Vea cómo también integro la conmutación de host 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 'arnaud.rinquin@wopata.com'"
  gopro = !sh -c \"git changeremotehost github.com github_pro && git changeremotehost bitbucket.com bitbucket_pro && git setpromail\"

Enlace de origen - Tutorial


Esto es genial, gracias. Trabajo con un montón de repositorios por correo electrónico, por lo que mi setpromailalias hace un config --globalcambio (y tengo otros alias establecidos para configurar diferentes direcciones de correo electrónico). ¡Funciona!
michel-slm

1
Para esas 2 cuentas diferentes, ¿cómo puedo firmar con diferentes claves gpg? Tengo 2x gpg keys para 2x github cuentas y me gustaría firmar de manera diferente. "git config --global user.signingkey xxxx"
hakkican

Esta respuesta es asombrosa. Casi no lo leí porque pensé que había encontrado qué de la otra respuesta. Definitivamente merece más votos a favor. PD. Es incluso mejor cuando se combina con useConfigOnly = truela otra respuesta.
steinybot

No es IdentifyFile, es IdenfityFile.
Christian

40

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

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

[init]
    templatedir = ~/.git/templates

A continuación, cada git inito git clonerecogerá ese gancho y será de aplicación a los datos de usuario durante la siguiente git commit. Si desea aplicar el gancho a repos ya existentes, simplemente ejecute un git initdentro 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 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

#!/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). También es posible definir un número arbitrario de ID dentro de un archivo de configuración ( ~/.gitpassport) que se pueden seleccionar en una solicitud. Puede encontrar el proyecto en github.com: git-passport: un comando y gancho de Git escrito en Python para administrar múltiples cuentas de Git / identidades de usuario .


1
Esto funciona perfectamente. Sin embargo, funcionó mejor para mí al hacer esto un gancho posterior al pago (en lugar de post-commit). Mis sugerencias para mejorar esta respuesta son, mencionar que: 1. el fragmento debe guardarse como ~ / .git / templates / hooks / post-checkout y recibir permiso chmod +x post-checkout, 2. los git_remotesvalores son la parte inicial del nombre de host completo, por ejemplo git@github.com, 3. los local_idvalores deben ser editados por el usuario a sus respectivos nombres y direcciones de correo electrónico.
Shantanu Kumar

@ShantanuKumar Gracias por tu comentario. Ajusté la respuesta como me propusiste. Tal vez volveré a escribir el script en Python pronto.
Saucier

Se agregó soporte para expresiones regulares y para repositorios sin control remoto. Para una fácil descarga, todos se fusionaron aquí . Regexps para distinguir identidades para diferentes proyectos en el mismo servicio. Y es compatible con repositorios remoteless, por ejemplo, con una identidad predeterminada si tiene git initnuevos proyectos desde un IDE como eclipse(que no puede manejar desencadenantes de precompromiso interactivos)
cfi

25

Si no desea tener una dirección de correo electrónico predeterminada ( enlaces de direcciones de correo electrónico a un usuario de github ), puede configurar que desee que se le pregunte. Cómo puedes hacer eso depende de la versión de git que uses, ver más abajo.

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 ~/.gitconfigcomo se indica en un comentario de Dan Aloni en la publicación del blog de Orr Sella . Al intentar hacer la primera confirmación en un repositorio, git falla con el bonito mensaje:

*** Please tell me who you are.

Run

  git config --global user.email "you@example.com"
  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 configura localmente (el mensaje no es perfectamente preciso).

2.7.0 ≤ Versión <2.8.0

El comportamiento en las versiones <2.7.0 no fue intencionado y se solucionó con 2.7.0. Todavía puede usar un enlace previo a la confirmación como se describe en la publicación del blog de Orr Sella . Esta solución también funciona para otras versiones, pero las otras soluciones no son para esta versión.

Versión ≥ 2.8.0

Dan Aloni agregó una opción para lograr ese comportamiento (ver notas de la versión ). Úselo 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 configura 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.


Utilizo este método durante unos meses, funcionó muy bien. Tengo varias direcciones de correo electrónico (personal, laboral) y no quiero tener una "predeterminada" configurada en gitconfig global. Con un valor especial "(ninguno)" git me pedirá que proporcione una dirección válida cada vez que haga girar un nuevo repositorio, en lugar de adivinar una basada en el nombre de usuario y el nombre de host (lo cual es molesto y necesito --enmendarlo). Sin embargo, recientemente con la versión actualizada de Git (2.7.0, tal vez antes), descubrí que el valor especial "(ninguno)" ya no provoca errores fatales. En su lugar, solo usará "John Doe <(none)>" como está ...
Zhuoyun Wei

@wzyboy: Oh, tienes razón. Solía git bisectencontrar que commit 19ce497c ... introdujo este comportamiento. Sin embargo, independientemente de la versión (2.5 - 2.7) puedo usar email =(sin argumento) en la configuración y muestra el mismo comportamiento que email = "(none)"en versiones anteriores. ¿Puedes confirmar esto? Si es así, editaré mi respuesta. Soy escéptico ya que parece tan obvio y no lo usé antes.
Juan

Lo intenté email =en 2.7.0, Git todavía adivina la dirección de correo electrónico basada en el nombre de usuario y el nombre de host. Ahora uso el pre-commitenfoque en el blog de Sella. También notifiqué al Dan Aloni a quien se le ocurrió la "(none)"idea en la publicación de Sella y archivó un parche para implementarlo formalmente como una característica: permalink.gmane.org/gmane.comp.version-control.git/285301
Zhuoyun Wei

3
desde git-2.8: La variable de configuración "user.useConfigOnly" se puede usar para obligar al usuario a configurar siempre user.email & user.name github.com/git/git/blob/master/Documentation/RelNotes/2.8.0. txt
rofrol

@rofrol Gracias por la información. Actualicé mi respuesta en consecuencia.
John

24

Con las condiciones condicionales incluidas en Git 2.13, ahora es posible tener múltiples usuarios / correos electrónicos coexistiendo en una máquina con poco trabajo.

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

Entonces 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 cuando 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

gitdires sensible a gitdir/imayúsculas y minúsculas.

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


Si bien su respuesta es apreciada y buena, Tomáš Janoušek dio la misma 20 días antes que usted. Por favor considere eliminar esta respuesta.
Hedge

55
@Hedge Sí, voté por su respuesta, pero me tomó un tiempo configurar en Windows y ahí fue donde gitdir/ime ayudó (que su respuesta no menciona).
FELIZ el

La forma particular en que @hIpPy implementó esto se aplicó directamente a mi caso de uso y lo hizo mucho más fácil de seguir que la respuesta de Tomás. Voté a ambos.
Isaac Adams

18

Otra opción para gittrabajar con múltiples nombres / correos electrónicos es alias gity usar el -cindicador 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="name@example.com"'

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

$ git config user.email
name@example.com

En lugar de un alias, también puedes poner un gitejecutable personalizado dentro de tu $PATH.

#!/bin/sh
/usr/bin/git -c user.name="Your name" -c user.email="name@example.com" "$@"

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


14

alias git (y secciones en configuraciones git) al rescate!

agregue un alias (desde la línea de comando):

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 your@github.email

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

git identity github

Esta solución no es automática, pero el usuario desarmado y el correo electrónico en su mundial ~/.gitconfigy el establecimiento user.useConfigOnlyde trueforzaría git para recordarle que debe configurar manualmente en cada repo nuevo o clonado.

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

1
Me gusta tu solucion; sin embargo, cuando desarmado mi global solo se compromete con el nombre de host de mi computadora en lugar de tener git, recuérdame configurarlo en cualquier repositorio dado :(
ENG618

12

Aquí están los pasos completos después de leer muchas respuestas aquí.

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

Es posible que desee comenzar a verificar sus claves guardadas actualmente

$ ssh-add -l

Si decide eliminar todas las claves almacenadas en caché antes ( opcional, tenga cuidado al respecto )

$ ssh-add -D

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

$ cd ~/.ssh
$ ssh-keygen -t rsa -C "work@company.com" <-- save it as "id_rsa_work"
$ ssh-keygen -t rsa -C "pers@email.com" <-- save it as "id_rsa_pers"

Después de ejecutar estos comandos, tendrá 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 puede verificar sus claves guardadas nuevamente

$ ssh-add -l

Ahora debe agregar las claves públicas generadas a las claves de acceso de su servidor github / bickbuket

Clone cada uno de los repositorios en diferentes carpetas

Vaya a la carpeta donde trabajará el usuario y ejecute esto

$ git config user.name "Working Hard"
$ git config user.email "work@company.com" 

Solo para ver qué hace esto, verifique el contenido de ".git / config"

Vaya a la carpeta donde trabajará el usuario pers y ejecute esto

$ git config user.name "Personal Account"
$ git config user.email "pers@email.com" 

Solo para ver qué hace esto, verifique el contenido de ".git / config"

Después de todo esto, podrá confirmar su código personal y de trabajo simplemente cambiando entre esas dos carpetas

En caso de que esté utilizando Git Bash y necesite generar claves ssh en Windows, siga estos pasos:

https://support.automaticsync.com/hc/en-us/articles/202357115-Generating-an-SSH-Key-on-Windows


9

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

Simplemente elimine la [user]sección de su ~/.gitconfig, lo que le impedirá realizar confirmaciones sin configurar user.namepara 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 me@gmail.com'
alias gwork='git config user.name "My Name";git config user.email me@work.job'

No es gran causa que va a duplicar la configuración de cada repositorio git
cambunctious

9

Esta respuesta está parcialmente inspirada en la publicación de @Saucier, pero estaba buscando una forma automática de configurar user.nameyuser.email según el repositorio, basada en el control remoto, que fuera un poco más liviana que el paquete de pasaporte git que desarrolló . También h / t a @John para la configuración useConfigOnly. Aquí está mi solución:

.gitconfig cambios:

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

gancho posterior al pago 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 enlace posterior al pago establezca automáticamente el nombre de usuario y el correo electrónico localmente para un repositorio después de un pago, asegúrese de que el nombre del servicio aparezca en la URL remota, agréguelo a la matriz de servicios en el post-checkoutscript y cree una sección para él en su .gitconfigque 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 el repositorio no tiene un control remoto, el nombre de usuario y el correo electrónico no se establecerán localmente. En estos casos, la user.useConfigOnlyconfiguración estará en juego, lo que no le permitirá realizar confirmaciones hasta que el nombre de usuario y el correo electrónico se establezcan en el nivel de repositorio, y le solicitará al usuario que configure esa información.


1
Gran solución No te olvides chmod 755del guión de gancho. De lo contrario, se copiará pero nunca se ejecutará.
onekiloparsec

5

GIT_AUTHOR_EMAIL + local .bashrc

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

export GIT_AUTHOR_EMAIL='me@work.com'
export GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"

.bashrc: rastrea este archivo, hazlo igual en las computadoras del trabajo y del hogar:

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 variables de shell en git config


5

Entorno de Windows

Adicional esto se puede modificar 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. ingrese la descripción de la imagen aquí

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


¿Cómo se dirige esto a múltiples usuarios, en lugar de solo editarlos?

@D_N Actualizado con una nueva captura de pantalla con opciones para cambiar la configuración.
Abhijeet

Abra la carpeta de repositorio local y seleccione git-config del menú de navegación, luego haga clic en la pestaña de repositorio local, el contenido se aplicará a $ local_repo_path / .git / config como respuesta anterior.
maxwu

3

Tal vez es un simple truco, pero es útil. Simplemente genere 2 claves ssh como a continuación.

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 GowthamSai@Gowtham-MacBook-Air.local
The key's randomart image is:
+---[RSA 4096]----+
|. .oEo+=o+.      |
|.o o+o.o=        |
|o o o.o. +       |
| =.+ .  =        |
|= *+.   S.       |
|o*.++o .         |
|=.oo.+.          |
| +. +.           |
|.o=+.            |
+----[SHA256]-----+

Del mismo modo crea uno más para lo personal. Entonces, tienes 2 claves ssh, trabajo y compañía. Copie work.pub, work, personal.pub, personal en ~ / .ssh / Directory.

Luego cree un script de shell con las siguientes líneas y asígnele el nombre crev.sh (Company Reverse) con el siguiente contenido.

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

Del mismo modo, 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 agrega alias para esos scripts como a continuación

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

Siempre que quiera usar compañía, solo haga crev, y si quiere usar personal, haga prev :-p.

Agregue esas claves ssh a sus cuentas de GitHub. Asegúrese de que no haya generado id_rsa anteriormente, porque esos scripts sobrescribirán id_rsa. Si ya ha generado id_rsa, úselo para una de las cuentas. Cópielos como personales y omita la generación de claves personales.


1

Hice una función bash que maneja eso. Aquí está el repositorio 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'

1

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"

1

También puede usarlo git commit --author "Your Name <your@email.com>"en el momento de realizar una confirmación en un repositorio donde desea comprometerse como un usuario diferente.


0

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

Creé el archivo ~/bin/git_poweruser, con permiso ejecutable, y en la RUTA:

#!/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="power@user.email" $@

Cada vez que quiero comprometer o empujar algo como "Usuario avanzado", lo uso en git_poweruserlugar de git. Debería funcionar en cualquier directorio, y no requiere cambios en , .gitconfigo .ssh/configal menos no en el mío.


0

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

  • copia existente .gitconfgde su otro repositorio
  • pegar en su repositorio recién agregado
  • cambiar valores en el .gitconfigarchivo, como nombre, correo electrónico y nombre de usuario [user] name = John email = john@email.net username = john133
  • agregue el nombre de archivo a la .gitignorelista, para asegurarse de no comprometer el .gitconfigarchivo en su repositorio de trabajo
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.