Puis-je spécifier plusieurs utilisateurs pour moi-même.gitconfig?

depuis git 2.13 , il est possible de résoudre cela en utilisant nouvellement introduit inclut conditionnel .

un exemple:

Global configuration ~/.gitconfig

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

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

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

ou vous pouvez ajouter les informations suivantes dans votre fichier local .git/config 151930920"

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

après avoir reçu une certaine inspiration de le billet de blog D'Orr Sella j'ai écrit un crochet pré-commit (réside dans ~/.git/templates/hooks ) qui définirait les noms d'utilisateur et les adresses e-mail spécifiques basés sur l'information à l'intérieur de ./.git/config d'une repositoria locale :

vous devez placer le chemin vers le répertoire de modèle dans votre ~/.gitconfig :

[init]
    templatedir = ~/.git/templates

puis chaque git init ou git clone ramassera ce crochet et va appliquer les données de l'utilisateur lors de la prochaine git commit . Si vous voulez appliquer le crochet pour les repos déjà existants, il vous suffit de lancer un git init à l'intérieur de la repos afin de le réinitialiser.

voici le crochet que j'ai inventé (il a encore besoin de quelques polissage - les suggestions sont les bienvenues). Garde-le comme

~/.git/templates/hooks/pre_commit

ou

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

et assurez-vous qu'il est exécutable: 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

EDIT:

donc j'ai réécrit le crochet comme un crochet et commande en Python. De plus, il est possible d'appeler le script comme une commande Git ( git passport ), aussi. Il est également possible de définir un nombre arbitraire d'IDs à l'intérieur d'un fichier configfile ( ~/.gitpassport ) qui sont sélectionnables sur un prompt. Vous pouvez trouver le projet à github.com: git-passport - une commande Git et un crochet écrits en Python pour gérer plusieurs comptes Git / utilisateur les identités .

si vous ne voulez pas avoir d'adresse email par défaut ( adresse email liens vers un utilisateur github ), vous pouvez configurer que vous voulez être demandé. Comment vous pouvez faire cela dépend de la version de git que vous utilisez, voir ci-dessous.

(prévue) inconvénient est que vous devez configurer votre adresse e-mail et votre nom) une fois pour chaque dépôt. Donc, vous ne pouvez pas oublier de le faire.

Version < 2.7.0

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

dans votre configuration globale ~/.gitconfig , comme indiqué dans un commentaire par Dan Aloni dans Orr Sella du blog . En essayant de faire la première propagation dans un dépôt, git échoue avec le message de nice:

*** 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)')

Le nom est tiré de la global configuration lorsque l'adresse e-mail est définie localement (le message n'est pas parfaitement exact).

2.7.0 ≤ Version < 2.8.0

le comportement dans les versions < 2.7.0 n'était pas prévu et fixé à 2.7.0. Vous pouvez toujours utiliser un crochet pre-commit comme décrit dans le billet de blog D'Orr Sella . Cette solution fonctionne également pour d'autres versions, mais les autres solutions pas pour cette version.

Version ≥ 2.8.0

Dan Aloni a ajouté une option pour atteindre ce comportement (voir notes de mise à jour ). Utilisez - le avec:

[user]
    useConfigOnly = true

à faites en sorte que cela fonctionne vous ne pouvez pas donner un nom ou une adresse e-mail dans la configuration globale. Ensuite, à la première propagation, vous obtenez un message d'erreur

fatal: user.useConfigOnly set but no name given

le message n'est donc pas très instructif, mais puisque vous définissez explicitement l'option, vous devriez savoir quoi faire. Contrairement à la solution des versions < 2.7.0, vous devez toujours définir à la fois le nom et l'email manuellement.

Une commande github comptes switch

cette solution prend la forme d'un seul pseudonyme git. Une fois exécuté, l'utilisateur courant du projet sera attaché à un autre compte

générer des clés 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'

liez-les à vos comptes Github / Bitbucket

1. clé publique par défaut de copie pbcopy < ~/.ssh/id_rsa.pub
2. connectez - vous à votre compte GitHub
3. coller la clé dans la add SSH key GitHub page
4. copie autre clé publique pbcopy < ~/.ssh/id_rsa_pro.pub
5. répéter et adapter les étapes 2 à 4 pour chaque autre compte

Étape 1. Commutation automatique des clés ssh.

nous pouvons configurer ssh pour envoyer une utilisation d'une clé de cryptage spécifique selon le host . La bonne chose est que vous pouvez avoir plusieurs alias pour le même hostname .

voir cet exemple ~/.ssh/config fichier:

# 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

git remote configuration

vous pouvez maintenant utiliser ces alias dans les télécommandes git en remplaçant git@github.com par git@github_pro .

vous pouvez soit modifier vos télécommandes existantes (en utilisant quelque chose comme git remote origin set-url git@github_pro:foo/bar.git ) ou les adapter directement lors du clonage.

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

utilisant un alias, il devient:

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

Étape 2. Changement d'utilisateur git.e-mail

les paramètres de configuration Git peuvent être globaux ou par projet. Dans notre cas, nous voulons un cadre par projet. Il est très facile de changer:

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

bien que ce soit facile, cela prend beaucoup de temps pour les développeurs que nous sommes. On peut écrire un pseudonyme très simple pour ça.

nous allons l'ajouter au fichier ~/.gitconfig .

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

...

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

alors, tout ce que nous avons à faire est git setpromail pour avoir notre email changé pour ce projet seulement.

Étape 3. Un commutateur de commande s'il vous plaît?!

ne serait-il pas agréable de changer du compte par défaut à un compte spécifié avec une seule commande sans paramètre? C'est certainement possible. Cette commande comporte deux étapes:

• modifier le projet en cours télécommandes de la alias
• modifier le projet en cours de l'utilisateur.email config

Nous avons déjà une solution de commande pour la deuxième étape, mais le premier est beaucoup plus difficile. Une commande de changement d'hôte distant

Voici la solution sous la forme d'une autre commande git alias pour ajouter à votre ~/.gitconfig :

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

cela permet de changer tous les remotes d'un hôte à un autre (l'alias). Voir l'exemple:

$ > 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)

combinez-les tous

Nous avons maintenant de combiner les deux commandes en une seule, c'est assez facile. Voyez comment j'intègre aussi la commutation hôte bitbucket.

[alias]
  changeremotehost = !sh -c \"git remote -v | grep '.*fetch' | sed s/..fetch.// | sed s/// | 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\"

Lien Source -Tutoriel

Une autre option pour faire fonctionner git avec plusieurs noms / e-mails est d'alias git et d'utiliser le drapeau -c pour outrepasser la configuration globale et spécifique au dépôt.

par exemple, en définissant un alias:

alias git='/usr/bin/git -c user.name="Your name" -c user.email="name@example.com"'

pour voir si cela fonctionne, tapez simplement git config user.email :

$ git config user.email
name@example.com

au lieu d'un alias, vous pouvez aussi mettre un exécutable personnalisé git dans votre $PATH .

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

un avantage de cette méthode par rapport à une .git/config spécifique à un dépôt est qu'elle s'applique à chaque dépôt git lorsque le programme personnalisé git est actif. De cette façon, vous pouvez facilement basculer entre les utilisateurs/noms sans modifier aucune configuration (partagée).

Il y a une solution simple qui semble bien fonctionner pour éviter les erreurs.

il suffit de supprimer la section [user] de votre ~/.gitconfig , qui vous empêchera de faire des propagations sans définir user.name pour chaque dépôt.

dans votre ~/.bashrc , ajoutez quelques alias simples pour l'utilisateur et envoyez un e-mail:

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'

avec inclut dans Git 2.13, il est maintenant possible d'avoir plusieurs utilisateurs/e-mail coexistants sur une seule machine avec peu de travail.

user.gitconfig a mon nom personnel et e-mail. work-user.gitconfig a mon nom de travail et e-mail. Les deux fichiers sont au chemin ~ .

ainsi mon nom personnel/e-mail s'applique par défaut. Pour c:/work/ dir, mon nom de travail/email est appliqué. Pour c:/work/github/ dir, mon personnel nom/e-mail est appliquée. Cela fonctionne lorsque le dernier paramètre est appliqué.

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

gitdir est sensible à la casse et gitdir/i est insensible à la casse.

"gitdir/i:github/" appliquerait l'inclusion conditionnelle pour tout annuaire avec github dans son chemin.

git alias (et les articles dans git configs) à la rescousse!

ajouter un alias (à partir de la ligne de commande):

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

puis, régler, par exemple

git config --global user.github.name "your github username"
git config --global user.github.email your@github.email

et dans un repo nouveau ou cloné vous pouvez exécuter cette commande:

git identity github

cette solution n'est pas automatique, mais l'utilisateur et le courrier électronique unsetting dans votre ~/global.gitconfig forcerait Git à vous rappeler de les régler manuellement à chaque nouveau ou cloné repo.

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

cette réponse est en partie inspirée par le post de @Saucier, mais je cherchais une façon automatisée de régler user.name et user.email sur une base per repo, basée sur la télécommande, qui était un peu plus léger que le paquet git-passeport qu'il a développé. Aussi h / T à @John pour le cadre useConfigOnly. Voici ma solution:

.gitconfig changements:

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

post-paiement crochet qui doit être sauvegardé sur le chemin suivant: ~/.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=""
    local config=""
    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

j'utilise des justificatifs d'identité différents pour Github et gitlab, mais ces références dans le code ci-dessus pourraient être remplacées ou augmentées par n'importe quel service que vous utilisez. Pour que le crochet post-checkout définisse automatiquement le nom d'utilisateur et l'email localement pour une prise en compte après un checkout, assurez-vous que le nom de service apparaît dans l'url distante, ajoutez-le au tableau de services dans le script post-checkout et créez un section dans votre .gitconfig qui contient votre nom d'utilisateur et l'adresse électronique de ce service.

si aucun des noms de service n'apparaît dans l'url distante ou si le repo n'a pas de remote, le nom d'utilisateur et le courriel ne seront pas définis localement. Dans ces cas ,le paramètre user.useConfigOnly sera en jeu, ce qui ne vous permettra pas de faire des propagations tant que le nom d'utilisateur et l'email ne seront pas définis au niveau repo, et invitera l'utilisateur à configurer cette information.

GIT_AUTHOR_EMAIL + locaux .bashrc

.bashrc_local : ne pas suivre ce fichier, mettez-le seulement sur votre ordinateur de travail:

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

.bashrc : le suivi de ce dossier, de faire la même sur les deux le travail et la maison des ordinateurs:

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

j'utilise https://github.com/technicalpickles/homesick pour synchroniser mes fichiers.

si seulement gitconfig accepter les variables d'environnement: variable du Shell extension du dépôt git config

Environnement Windows

Additional ceci peut être modifié de Git Extensions --> Settings --> Global Settings , si vous l'avez installé dans vos systèmes.

git extensions-latest-release

faites un clic droit sur un dossier/répertoire dans L'environnement Windows pour accéder à ces paramètres.

mise à jour : Comment faire basculer/maintenir plusieurs paramètres dans la Version 2.49

peut-être que c'est un simple hack, mais c'est utile. Il suffit de générer 2 touches ssh comme ci-dessous.

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]-----+

de la même façon créer un de plus pour personnelle. Donc, vous avez 2 clés ssh, travail et compagnie. Copie de travail.pub, travail, personnel.pub, personnels de ~/.répertoire ssh / .

crée alors le script shell avec les lignes suivantes et le nomme comme crev.sh (entreprise inversée) avec le contenu suivant.

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

Même façon, créez-en un plus appelé prev.sh (Personnels à l'envers) avec le contenu suivant.

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

dans ~/.bashrc ajouter des alias pour les scripts comme ci-dessous

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

Quand jamais vous voulez l'utiliser, il suffit de faire crev, et si vous voulez utiliser les personnels ne prev :-p.

ajoutez ces clés ssh à vos comptes github. Assurez-vous que vous n'avez pas id_rsa généré de manière perverse, car ces scripts vont écraser id_rsa. Si vous ont déjà généré id_rsa, l'utiliser pour l'un de compte. Copie à caractère personnel et passez de génération de clés personnelles.

j'ai créé une fonction bash qui gère ça. voici le GitHub repo .

Pour l'enregistrement de:

# 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'

quelque chose comme réponse de Rob W , mais en permettant différent une clé SSH différente, et fonctionne avec des versions git plus anciennes (qui n'ont pas par exemple un noyau.sshcommand config).

j'ai créé le fichier ~/bin/git_poweruser , avec la permission exécutable, et dans le chemin:

#!/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" $@

chaque fois que je veux commettre ou pousser quelque chose comme "Power User", j'utilise git_poweruser au lieu de git . Il devrait fonctionner sur n'importe quel répertoire, et ne ne pas exiger de changement dans .gitconfig ou .ssh/config , du moins pas dans le mien.

voici ce que je viens de trouver après avoir suivi les étapes dans de nombreuses réponses ici

Comment configurer Plusieurs Clés SSH paramètres pour les différentes github compte

Vous pourriez commencer à vérifier vos clés $ ssh-add-l

si vous décidez de supprimer toutes les clés mises en cache avant ( optionnel, attentif à ce ) $ ssh-add-d

Then vous pouvez créer une clé SSH pub/priv liée à chaque email/compte que vous souhaitez/devez utiliser

$ 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"

après avoir exécuté ces commandes, vous aurez les fichiers suivants créés

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

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

assurez-vous agent d'authentification est en cours d'exécution

$ eval `ssh-agent -s`

ajouter les clés générées comme suit (à partir du~/.ssh dossier)

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Maintenant, vous pouvez vérifier vos clés à nouveau

$ ssh-add -l

maintenant vous devez ajouter les clés publiques générées à vos clés d'accès au serveur GitHub / bickbuket

Cloner chacune des repos à des dossiers différents

aller au dossier où l'utilisateur travailler sera utilisé et faire ce

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

Juste pour voir ce que cela fait, vérifier le contenu de l' ".git / config"

aller dans le dossier où l'utilisateur activehacker sera utilisé et le faire

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

Juste pour voir ce que cela fait, vérifier le contenu de l' ".git / config"

après tout cela, vous serez en mesure de communiquer votre code personnel et de travail par l'échange de dossiers

Si vous avez des problèmes faites le moi savoir mgg.isco@gmail.com

bien que la plupart des questions sorte de répondu à L'OP, j'ai juste eu à passer par ce moi-même et sans même googler j'ai été en mesure de trouver la solution la plus rapide et la plus simple. Voici des étapes simples:

• copier .gitconfg à partir de vos autres pensions
• coller dans votre repo nouvellement ajouté
• modifier les valeurs dans .gitconfig du fichier, telles que le nom, e-mail et nom d'utilisateur [user] name = John email = john@email.net username = john133
• ajouter nom du fichier dans la liste .gitignore , pour vous assurer que vous ne commettez pas le fichier .gitconfig dans votre rapport de travail