Posso specificare più utenti per me stesso in .gitconfig?

Nel mio ~/.gitconfig, elenco il mio indirizzo e-mail personale sotto [user], poiché è quello che voglio usare per i repository Github.

Ma recentemente ho iniziato a usare git anche per lavoro. Il repository git della mia azienda mi consente di impegnarmi, ma quando invia annunci di nuovi changeset, dice che provengono da Anonimo perché non riconosce l'indirizzo e-mail nel mio .gitconfig- almeno, questa è la mia teoria.

È possibile specificare più [user]definizioni in .gitconfig? Oppure esiste un altro modo per sovrascrivere il valore predefinito .gitconfigper una determinata directory? Nel mio caso, controllo tutto il codice di lavoro in ~/worksrc/- c'è un modo per specificare un .gitconfigper solo quella directory (e le sue sottodirectory)?

È possibile configurare un singolo repository per utilizzare un utente / indirizzo e-mail specifico che sovrascrive la configurazione globale. Dalla radice del repository, eseguire

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

mentre l'utente / e-mail predefinito è configurato in ~ / .gitconfig

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

Da git 2.13 , è possibile risolverlo usando inclusioni condizionali di recente introduzione .

Un esempio:

Config globale ~ / .gitconfig

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

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

Configura specifica del lavoro ~ / work / .gitconfig

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

Oppure puoi aggiungere le seguenti informazioni nel tuo .git/configfile locale

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

Un comando cambia account github

Questa soluzione prende la forma di un singolo alias git. Una volta eseguito, l'utente del progetto corrente verrà collegato a un altro account

Genera chiavi 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'

Collegali ai tuoi account GitHub / Bitbucket

1. copia la chiave pubblica predefinita pbcopy < ~/.ssh/id_rsa.pub
2. accedi al tuo account GitHub
3. incolla la chiave in add SSH key pagina di github
4. copia altra chiave pubblica pbcopy < ~/.ssh/id_rsa_pro.pub
5. ripetere e adattare i passaggi da 2 a 4 per ogni altro account

Passaggio 1. Commutazione automatica dei tasti ssh.

Siamo in grado di configurare sshper inviare un uso una chiave di crittografia specifica a seconda del host. La cosa bella è che puoi avere diversi alias per lo stessohostname .

Vedi questo ~/.ssh/configfile di esempio :

# 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

configurazione remota git

Ora puoi usare questi alias nei telecomandi git cambiando git@github.comper git@github_pro.

Puoi modificare i telecomandi dei tuoi progetti esistenti (usando qualcosa di simile git remote set-url origin git@github_pro:foo/bar.git) o adattarli direttamente durante la clonazione.

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

usando alias, diventa:

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

Passaggio 2. Modifica di git user.email

Le impostazioni di configurazione di Git possono essere globali o per progetto. Nel nostro caso, vogliamo impostazioni per progetto. È molto facile cambiarlo:

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

Anche se questo è facile, ci vuole tempo per gli sviluppatori che siamo. Per questo possiamo scrivere un alias git molto semplice.

Lo aggiungeremo al ~/.gitconfigfile.

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

...

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

Quindi, tutto ciò che dobbiamo fare è git setpromail cambiare la nostra e-mail solo per questo progetto.

Passaggio 3. Un interruttore di comando per favore ?!

Non sarebbe bello passare dall'account predefinito a uno specificato con un singolo comando senza parametri? Questo è sicuramente possibile. Questo comando prevede due passaggi:

• cambia i telecomandi del progetto corrente con gli alias scelti
• cambia la configurazione user.email del progetto corrente

Abbiamo già una soluzione a un comando per il secondo passaggio, ma il primo è molto più difficile. Un comando cambia l'host remoto

Ecco la soluzione sotto forma di un altro comando git alias da aggiungere al tuo ~/.gitconfig:

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

Ciò consente di cambiare tutti i telecomandi da un host a un altro (l'alias). Vedi l'esempio:

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

Uniscili tutti

Non ci resta che combinare i due comandi in uno solo, questo è abbastanza semplice. Guarda come integra anche la commutazione 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\"

Link sorgente - Tutorial

Dopo aver preso ispirazione dal post sul blog di Orr Sella, ho scritto un hook pre-commit (risiede in ~/.git/templates/hooks) che avrebbe impostato nomi utente e indirizzi e-mail specifici in base alle informazioni all'interno di un repository locale ./.git/config:

Devi inserire il percorso della directory del modello nel tuo ~/.gitconfig:

[init]
    templatedir = ~/.git/templates

Quindi ciascuno git inito git cloneprenderà quel gancio e applicherà i dati dell'utente durante il prossimo git commit. Se si desidera applicare l'hook a repository già esistenti, eseguire semplicemente agit init repository repository interno per reinizializzarlo.

Ecco il gancio che mi è venuto in mente (ha ancora bisogno di qualche lucidatura - i suggerimenti sono ben accetti). Salvalo come

~/.git/templates/hooks/pre_commit

o

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

e assicurati che sia eseguibile: 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

MODIFICARE:

Quindi ho riscritto l'hook come hook e comando in Python. Inoltre è possibile chiamare lo script anche come comando Git ( git passport). Inoltre è possibile definire un numero arbitrario di ID all'interno di un configfile ( ~/.gitpassport) che sono selezionabili su un prompt. Puoi trovare il progetto su github.com: git-passport - Un comando Git e un hook scritto in Python per gestire più account Git / identità utente .

Se non si desidera avere un indirizzo e-mail predefinito ( l'indirizzo e-mail si collega a un utente github ), è possibile configurare la richiesta. Come puoi farlo dipende dalla versione di git che usi, vedi sotto.

Lo svantaggio (previsto) è che devi configurare il tuo indirizzo e-mail (e il tuo nome) una volta per ogni repository. Quindi, non puoi dimenticare di farlo.

Versione <2.7.0

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

nella tua configurazione globale ~/.gitconfigcome dichiarato in un commento di Dan Aloni nel post del blog di Orr Sella . Quando si tenta di eseguire il primo commit in un repository, git non riesce con il bel messaggio:

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

Il nome viene preso dalla configurazione globale quando l'indirizzo e-mail è impostato localmente (il messaggio non è perfettamente accurato).

2.7.0 ≤ Versione <2.8.0

Il comportamento nelle versioni <2.7.0 non era previsto e risolto con 2.7.0. Puoi ancora usare un hook pre-commit come descritto nel post del blog di Orr Sella . Questa soluzione funziona anche per altre versioni, ma le altre soluzioni non per questa versione.

Versione ≥ 2.8.0

Dan Aloni ha aggiunto un'opzione per raggiungere quel comportamento (vedi note di rilascio ). Usalo con:

[user]
    useConfigOnly = true

Per farlo funzionare potresti non dare un nome o un indirizzo e-mail nella configurazione globale. Quindi, al primo commit, viene visualizzato un messaggio di errore

fatal: user.useConfigOnly set but no name given

Quindi il messaggio non è molto istruttivo, ma poiché imposti l'opzione in modo esplicito, dovresti sapere cosa fare. Contrariamente alla soluzione delle versioni <2.7.0, devi sempre impostare manualmente sia il nome che l'e-mail.

Con le inclusioni condizionali in Git 2.13, ora è possibile far coesistere più utenti / e-mail su una macchina con poco lavoro.

user.gitconfigha il mio nome personale ed e-mail. work-user.gitconfigha il mio nome di lavoro ed e-mail. Entrambi i file sono sul ~percorso.

Quindi il mio nome / email personale si applica per impostazione predefinita. Per c:/work/dir, viene applicato il mio nome / email di lavoro. Per c:/work/github/dir, viene applicato il mio nome / email personale. Funziona quando viene applicata l'ultima impostazione.

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

gitdirdistingue tra maiuscole e minuscole e distingue tra maiuscole e gitdir/iminuscole.

"gitdir/i:github/"applicherebbe l'inclusione condizionale per qualsiasi directory con githubnel suo percorso.

Un'altra opzione per gitlavorare con più nomi / e-mail è l'aliasing gite l'utilizzo di-c flag per sovrascrivere la configurazione globale e specifica del repository.

Ad esempio, definendo un alias:

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

Per vedere se funziona, digita semplicemente git config user.email:

$ git config user.email
name@example.com

Invece di un alias, puoi anche inserire un giteseguibile personalizzato nel tuo $PATH.

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

Un vantaggio di questi metodi rispetto a un repository specifico .git/configè che si applica a tutti i gitrepository quando il gitprogramma personalizzato è attivo. In questo modo, è possibile passare facilmente tra utenti / nomi senza modificare alcuna configurazione (condivisa).

git alias (e sezioni in git configs) in soccorso!

aggiungi un alias (dalla riga di comando):

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

quindi, impostare, ad esempio

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

e in un repository nuovo o clonato è possibile eseguire questo comando:

git identity github

Questa soluzione non è automatica, ma disinserire l'utente e l'e-mail nel tuo globale ~/.gitconfige impostando user.useConfigOnlysu trueforzerebbe git a ricordarti di impostarli manualmente in ogni repository nuovo o clonato.

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

Ecco i passaggi completi dopo aver letto molte risposte qui

Come configurare le impostazioni di più chiavi SSH per diversi account github

Potresti voler iniziare a controllare le chiavi attualmente salvate

$ ssh-add -l

Se si decide di eliminare prima tutte le chiavi memorizzate nella cache ( facoltativo, fare attenzione a questo )

$ ssh-add -D

Quindi è possibile creare una chiave pub / priv ssh collegata a ciascuna e-mail / account che si desidera / è necessario utilizzare

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

Dopo aver eseguito questi comandi, verranno creati i seguenti file

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

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

Assicurarsi che l'agente di autenticazione sia in esecuzione

$ eval `ssh-agent -s`

Aggiungi le chiavi generate come segue (dalla cartella ~ / .ssh)

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Ora puoi controllare di nuovo le tue chiavi salvate

$ ssh-add -l

Ora hai bisogno aggiungere le chiavi pubbliche generate al tuo github / bickbuket server di Acces Keys

Clonare ciascuno dei repository in cartelle diverse

Vai alla cartella in cui lavorerà l'utente ed eseguilo

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

Solo per vedere cosa fa controllare il contenuto di ".git / config"

Vai alla cartella in cui lavorerà l'utente pers ed eseguilo

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

Solo per vedere cosa fa controllare il contenuto di ".git / config"

Dopo tutto questo sarai in grado di impegnare il tuo codice personale e di lavoro semplicemente passando da quelle due cartelle

Nel caso in cui si stia utilizzando Git Bash e sia necessario generare chiavi ssh in Windows, attenersi alla seguente procedura:

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

C'è una soluzione semplice che sembra funzionare bene per evitare errori.

Basta rimuovere la [user]sezione dal tuo ~/.gitconfig, che ti impedirà di effettuare qualsiasi commit senza impostazioneuser.name per ciascun repository.

Nel tuo ~/.bashrc, aggiungi alcuni semplici alias per l'utente e l'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'

Questa risposta è parzialmente ispirata al post di @Saucier, ma stavo cercando un modo automatizzato di impostare user.namee user.emailsu base per repo, basato sul telecomando, che fosse un po 'più leggero del pacchetto git-passport che ha sviluppato . Anche h / t a @John per l'impostazione useConfigOnly. Ecco la mia soluzione:

.gitconfig i cambiamenti:

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

hook post-checkout che deve essere salvato nel seguente percorso ~/.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

Uso diverse credenziali per github e gitlab, ma quei riferimenti nel codice sopra potrebbero essere sostituiti o aumentati con qualsiasi servizio che usi. Per fare in modo che l'hook post-checkout imposti automaticamente il nome utente e l'e-mail localmente per un repository dopo un checkout, assicurarsi che il nome del servizio sia visualizzato nell'URL remoto, aggiungerlo all'array dei servizi nello post-checkoutscript e creare una sezione per esso in il tuo .gitconfigche contiene il tuo nome utente ed e-mail per quel servizio.

Se nessuno dei nomi dei servizi appare nell'URL remoto o il repository non ha un telecomando, il nome utente e l'e-mail non verranno impostati localmente. In questi casi user.useConfigOnlysarà attiva l' impostazione che non ti consentirà di eseguire commit fino a quando il nome utente e l'e-mail non saranno impostati a livello di repository e richiederà all'utente di configurare tali informazioni.

GIT_AUTHOR_EMAIL + locale .bashrc

.bashrc_local: non tracciare questo file, inseriscilo solo sul tuo computer di lavoro:

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

.bashrc: traccia questo file, rendilo lo stesso su entrambi i computer di lavoro e domestici:

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

Sto usando https://github.com/technicalpickles/homesick per sincronizzare i miei dotfile.

Se solo gitconfig accetterebbe le variabili di ambiente: Espansione delle variabili della shell in git config

Ambiente Windows

Ulteriore questo può essere modificato da Git Extensions --> Settings --> Global Settings , se lo hai installato nei tuoi sistemi.

gitextensions-ultima-release

Fare clic con il tasto destro su una cartella / directory in Ambiente Windows per accedere a queste impostazioni.

Aggiornamento : come cambiare / mantenere più impostazioni nella versione 2.49

Forse è un semplice trucco, ma è utile. Basta generare 2 chiavi ssh come di seguito.

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

Allo stesso modo creane uno in più per il personale. Quindi, hai 2 chiavi ssh, lavoro e compagnia. Copia work.pub, work, personal.pub, personal in ~ / .ssh / Directory.

Quindi creare uno script di shell con le seguenti righe e denominarlo come crev.sh (Company Reverse) con il seguente contenuto.

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

Allo stesso modo, creane uno chiamato prev.sh (Personal Reverse) con il seguente contenuto.

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

in ~ / .bashrc aggiungi gli alias per quegli script come di seguito

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

Ogni volta che vuoi usare compagnia, fai semplicemente crev, e se vuoi usare personale fai prev :-p.

Aggiungi quelle chiavi ssh ai tuoi account GitHub. Assicurati di non aver generato id_rsa in precedenza, perché quegli script sovrascriveranno id_rsa. Se hai già generato id_rsa, utilizzalo per uno degli account. Copiarli come personali e saltare la generazione di chiavi personali.

Ho fatto una funzione bash che lo gestisce. Ecco il repository Github .

Per la cronaca:

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

Basta aggiungere questo al tuo ~ / .bash_profile per passare tra le chiavi predefinite per 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"

È inoltre possibile utilizzare git commit --author "Your Name <your@email.com>"al momento di eseguire un commit in un repository in cui si desidera eseguire il commit come utente diverso.

Qualcosa come la risposta di Rob W , ma che consente una diversa chiave ssh diversa e funziona con le versioni precedenti di git (che non hanno ad esempio una configurazione core.sshCommand).

Ho creato il file ~/bin/git_poweruser, con permesso eseguibile, e nel PERCORSO:

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

Ogni volta che voglio impegnare o spingere qualcosa come "Power User", uso git_poweruserinvece di git. Dovrebbe funzionare su qualsiasi directory e non richiede modifiche in .gitconfigo .ssh/config, almeno non nella mia.

Sebbene la maggior parte delle domande abbia risposto all'OP, ho dovuto solo affrontare questo da solo e senza nemmeno cercare su Google sono stato in grado di trovare la soluzione più rapida e semplice. Ecco alcuni semplici passaggi:

• copia esistente .gitconfgdall'altro repository
• incollare nel repository appena aggiunto
• cambia i valori nel .gitconfigfile, come nome, email e nome utente [user] name = John email = john@email.net username = john133
• aggiungi il nome file .gitignoreall'elenco, per assicurarti di non eseguire .gitconfigil commit del file nel tuo repository di lavoro