Czy w .gitconfig mogę określić wielu użytkowników dla siebie?

Na mojej ~/.gitconfigliście podam mój osobisty adres e-mail [user], ponieważ właśnie tego chcę używać do repozytoriów Github.

Ale ostatnio zacząłem używać git również do pracy. Repozytorium git mojej firmy pozwala mi na zatwierdzenie, ale kiedy wysyła ogłoszenia o nowych zestawach zmian, mówi, że pochodzą one od Anonimowego, ponieważ nie rozpoznaje adresu e-mail w moim .gitconfig- przynajmniej taka jest moja teoria.

Czy można podać wiele [user]definicji w .gitconfig? A może jest jakiś inny sposób na zastąpienie wartości domyślnej .gitconfigokreślonego katalogu? W moim przypadku sprawdzam cały kod pracy ~/worksrc/- czy istnieje sposób na określenie .gitconfigtylko dla tego katalogu (i jego podkatalogów)?

Możesz skonfigurować indywidualne repozytorium, aby używało określonego użytkownika / adresu e-mail, który zastępuje konfigurację globalną. Z katalogu głównego repozytorium uruchom

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

podczas gdy domyślny użytkownik / e-mail jest skonfigurowany w twoim ~ / .gitconfig

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

Od wersji 2.13 możliwe jest rozwiązanie tego problemu za pomocą nowo wprowadzonych Uwarunkowań warunkowych .

Przykład:

Globalna konfiguracja ~ / .gitconfig

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

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

Konfiguracja specyficzna dla pracy ~ / work / .gitconfig

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

Lub możesz dodać następujące informacje do .git/configpliku lokalnego

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

Jedno polecenie przełącza konta github

To rozwiązanie ma postać pojedynczego aliasu git. Po wykonaniu bieżący użytkownik projektu zostanie przyłączony do innego konta

Wygeneruj klucze 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'

Połącz je ze swoimi kontami GitHub / Bitbucket

1. skopiuj domyślny klucz publiczny pbcopy < ~/.ssh/id_rsa.pub
2. zaloguj się do konta GitHub
3. wklej klucz na add SSH keystronie github
4. skopiuj inny klucz publiczny pbcopy < ~/.ssh/id_rsa_pro.pub
5. powtórz i dostosuj kroki od 2 do 4 dla każdego innego konta

Krok 1. Automatyczne przełączanie klucza ssh.

Możemy skonfigurować sshwysyłanie użycia określonego klucza szyfrowania w zależności od host. Fajną rzeczą jest to, że możesz mieć kilka aliasów dla tego samegohostname .

Zobacz ten przykładowy ~/.ssh/configplik:

# 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

zdalna konfiguracja git

Możesz teraz używać tych aliasów w pilotach git, zmieniając git@github.comwedług git@github_pro.

Możesz zmienić istniejące piloty projektów (używając czegoś podobnego git remote set-url origin git@github_pro:foo/bar.git) lub dostosować je bezpośrednio podczas klonowania.

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

przy użyciu aliasu staje się:

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

Krok 2. Zmiana adresu e-mail git user.email

Ustawienia konfiguracji Git mogą być globalne lub dla jednego projektu. W naszym przypadku chcemy ustawienia dla każdego projektu. Bardzo łatwo to zmienić:

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

Choć jest to łatwe, trzeba długo czekać na to, kim jesteśmy programiści. Możemy do tego napisać bardzo prosty alias git.

Dodamy go do ~/.gitconfigpliku.

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

...

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

Następnie git setpromailwystarczy zmienić adres e-mail tylko dla tego projektu.

Krok 3. Jeden przełącznik poleceń, proszę ?!

Czy nie byłoby miło przejść z domyślnego konta na określone za pomocą pojedynczego polecenia bez parametrów? Jest to zdecydowanie możliwe. To polecenie będzie miało dwa kroki:

• zmień obecne piloty projektu na wybrane aliasy
• zmień bieżącą konfigurację projektu user.email

Mamy już jedno rozwiązanie dla drugiego kroku, ale pierwsze jest o wiele trudniejsze. Zmiana zdalnego hosta za pomocą jednego polecenia

Oto rozwiązanie w postaci innego polecenia aliasu git, które można dodać do ~/.gitconfig:

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

Umożliwia to zmianę wszystkich pilotów z jednego hosta na inny (alias). Zobacz przykład:

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

Połącz je wszystkie

Teraz musimy tylko połączyć dwa polecenia w jedno, jest to dość łatwe. Zobacz, jak integruję przełączanie hostów 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 do źródła - samouczek

Po otrzymaniu inspiracji z postu na blogu Orr Selli napisałem haczyk przed zatwierdzeniem (rezyduje w ~/.git/templates/hooks), który ustawiałby konkretne nazwy użytkowników i adresy e-mail na podstawie informacji zawartych w lokalnym repozytorium ./.git/config:

Musisz umieścić ścieżkę do katalogu szablonów w swoim ~/.gitconfig:

[init]
    templatedir = ~/.git/templates

Następnie każdy git initlub git cloneodbierze ten zaczep i zastosuje dane użytkownika podczas następnego git commit. Jeśli chcesz zastosować hak do już istniejących git initrepozytoriów, po prostu uruchom repozytorium w celu ponownego zainicjowania.

Oto hak, który wymyśliłem (nadal wymaga dopracowania - sugestie są mile widziane). Zapisz to jako

~/.git/templates/hooks/pre_commit

lub

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

i upewnij się, że jest wykonywalny: 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

EDYTOWAĆ:

Więc przepisałem hak jako hak i polecenie w Pythonie. Dodatkowo możliwe jest również wywołanie skryptu jako polecenia Git ( git passport). Możliwe jest również zdefiniowanie dowolnej liczby identyfikatorów w pliku configfile ( ~/.gitpassport), które można wybrać w monicie. Możesz znaleźć projekt na github.com: git-passport - Komenda Git i hak napisane w Pythonie do zarządzania wieloma kontami Git / tożsamościami użytkowników .

Jeśli nie chcesz mieć domyślnego adresu e-mail (adres e- mail prowadzi do użytkownika github ), możesz skonfigurować, że chcesz być pytany. Jak to zrobić, zależy od używanej wersji git, patrz poniżej.

(Zamierzoną) wadą jest to, że musisz skonfigurować swój adres e-mail (i swoje imię) raz dla każdego repozytorium. Nie możesz więc tego zapomnieć.

Wersja <2.7.0

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

w globalnej konfiguracji, ~/.gitconfigjak stwierdzono w komentarzu Dana Aloni w poście na blogu Orr Selli . Podczas próby wykonania pierwszego zatwierdzenia w repozytorium git kończy się niepowodzeniem z ładnym komunikatem:

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

Nazwa jest pobierana z konfiguracji globalnej, gdy adres e-mail jest ustawiany lokalnie (wiadomość nie jest idealnie dokładna).

2.7.0 ≤ Wersja <2.8.0

Zachowanie w wersjach <2.7.0 nie było zamierzone i naprawione w wersji 2.7.0. Nadal możesz użyć haka przed zatwierdzeniem, jak opisano w blogu Orr Selli . To rozwiązanie działa również w przypadku innych wersji, ale inne rozwiązania nie dotyczą tej wersji.

Wersja ≥ 2.8.0

Dan Aloni dodał opcję osiągnięcia tego zachowania (patrz informacje o wersji ). Używaj go z:

[user]
    useConfigOnly = true

Aby działało, nie możesz podać nazwy ani adresu e-mail w konfiguracji globalnej. Następnie przy pierwszym zatwierdzeniu pojawia się komunikat o błędzie

fatal: user.useConfigOnly set but no name given

Wiadomość nie jest więc bardzo pouczająca, ale ponieważ wyraźnie ustawiłeś tę opcję, powinieneś wiedzieć, co robić. W przeciwieństwie do rozwiązania w wersji <2.7.0, zawsze musisz ręcznie ustawić zarówno nazwę, jak i adres e-mail.

Z uwarunkowanymi obejmuje zawartym w Git 2.13 możliwe jest współistnienie wielu użytkowników / wiadomości e-mail na jednym komputerze przy niewielkiej pracy.

user.gitconfigma moje imię i nazwisko oraz adres e-mail. work-user.gitconfigma moje imię i nazwisko oraz adres e-mail. Oba pliki są w~ ścieżce.

Więc moje imię i nazwisko / adres e-mail mają zastosowanie domyślnie. W przypadku c:/work/reżimu stosowana jest nazwa mojej pracy / adres e-mail. W przypadku c:/work/github/reżimu stosowane jest moje imię i nazwisko / adres e-mail. Działa to po zastosowaniu ostatniego ustawienia.

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

gitdir rozróżnia małe i wielkie litery oraz gitdir/i wielkie litery.

"gitdir/i:github/"zastosuje warunkowe dołączanie do każdego katalogu ze githubswoją ścieżką.

Inną opcją gitpracy z wieloma nazwami / e-mailami jest aliasinggit i korzystanie z-c flagi do zastąpienia konfiguracji globalnej i specyficznej dla repozytorium.

Na przykład, definiując alias:

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

Aby zobaczyć, czy to działa, po prostu wpisz git config user.email:

$ git config user.email
name@example.com

Zamiast aliasu możesz również umieścić niestandardowy gitplik wykonywalny w swoim pliku $PATH.

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

Zaletą tej metody w stosunku do konkretnego repozytorium .git/configjest to, że ma ona zastosowanie do każdego gitrepozytorium, gdy gitaktywny jest program niestandardowy . W ten sposób możesz łatwo przełączać się między użytkownikami / nazwami bez modyfikowania dowolnej (współdzielonej) konfiguracji.

git aliasy (i sekcje w konfiguracjach git) na ratunek!

dodaj alias (z wiersza poleceń):

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

następnie ustaw na przykład

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

a w nowym lub sklonowanym repozytorium możesz uruchomić to polecenie:

git identity github

To rozwiązanie nie jest automatyczne, ale rozbraja użytkownika i pocztę e-mail w Twojej globalnej ~/.gitconfigkonfiguracji i user.useConfigOnlypowoduje, trueże git będzie przypominał o ustawieniu ich ręcznie w każdym nowym lub sklonowanym repozytorium.

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

Oto pełne kroki po przeczytaniu wielu odpowiedzi tutaj

Jak skonfigurować ustawienia wielu kluczy SSH dla różnych kont github

Możesz zacząć sprawdzać obecnie zapisane klucze

$ ssh-add -l

Jeśli zdecydujesz się wcześniej usunąć wszystkie klucze z pamięci podręcznej ( opcjonalnie, uważaj na to )

$ ssh-add -D

Następnie możesz utworzyć klucz ssh pub / priv powiązany z każdym adresem e-mail / kontem, którego chcesz / potrzebujesz użyć

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

Po wykonaniu tych poleceń zostaną utworzone następujące pliki

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

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

Upewnij się, że agent uwierzytelniania jest uruchomiony

$ eval `ssh-agent -s`

Dodaj wygenerowane klucze w następujący sposób (z folderu ~ / .ssh)

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Teraz możesz ponownie sprawdzić zapisane klucze

$ ssh-add -l

Teraz potrzebujesz dodać wygenerowane klucze publiczne do swoich kluczy dostępu do serwera github / bickbuket

Sklonuj każde repozytorium do różnych folderów

Przejdź do folderu, w którym będzie działać praca użytkownika , i wykonaj to

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

Aby zobaczyć, co to robi, sprawdź zawartość „.git / config”

Przejdź do folderu, w którym będzie pracować użytkownik pers , i wykonaj to

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

Aby zobaczyć, co to robi, sprawdź zawartość „.git / config”

Po tym wszystkim będziesz mógł zatwierdzić swój osobisty i służbowy kod, po prostu przełączając się między tymi dwoma folderami

Jeśli używasz Git Bash i chcesz wygenerować klucze ssh w systemie Windows, wykonaj następujące kroki:

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

Istnieje proste rozwiązanie, które wydaje się działać dobrze w celu uniknięcia błędów.

Po prostu usuń [user]sekcję z twojego ~/.gitconfig, co uniemożliwi ci dokonywanie jakichkolwiek zatwierdzeń bez ustawianiauser.name dla każdego repozytorium.

W swoim ~/.bashrcdodaj kilka prostych aliasów dla użytkownika i e-maila:

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'

Ta odpowiedź jest częściowo zainspirowana postem @Saucier, ale szukałem zautomatyzowanego sposobu ustawienia user.nameiuser.email na zasadzie repo, opartego na pilocie, który niż pakiet paszportowy git, który opracował . Również h / t do @John dla ustawienia useConfigOnly. Oto moje rozwiązanie:

.gitconfig zmiany:

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

hak po kasie, który należy zapisać na następującej ścieżce ~/.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

Używam różnych danych uwierzytelniających dla github i gitlab, ale te odniesienia w powyższym kodzie można zastąpić lub rozszerzyć dowolną usługą, z której korzystasz. Aby hak po wykonaniu transakcji automatycznie ustawiał nazwę użytkownika i adres e-mail lokalnie dla repozytorium po kasie, upewnij się, że nazwa usługi pojawia się w zdalnym adresie URL, dodaj ją do tablicy usług w post-checkoutskrypcie i utwórz dla niej sekcję Twój.gitconfig zawierający twoją nazwę użytkownika i adres e-mail dla tej usługi.

Jeśli żadna z nazw usług nie pojawi się w zdalnym adresie URL lub w repozytorium nie ma pilota, nazwa użytkownika i adres e-mail nie zostaną ustawione lokalnie. W takich przypadkach user.useConfigOnlyustawienie będzie działać, co nie pozwoli na dokonywanie zatwierdzeń, dopóki nazwa użytkownika i adres e-mail nie zostaną ustawione na poziomie repo, i poprosi użytkownika o skonfigurowanie tych informacji.

GIT_AUTHOR_EMAIL + lokalny .bashrc

.bashrc_local: nie śledź tego pliku, umieść go tylko na komputerze służbowym:

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

.bashrc: śledź ten plik, zrób to samo na komputerach roboczych i domowych:

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

Korzystam z https://github.com/technicalpickles/homesick do synchronizacji moich plików dot.

Gdyby tylko gitconfig zaakceptował zmienne środowiskowe: Rozszerzenie zmiennych powłoki w git config

Środowisko Windows

Dodatkowo można to zmienić Git Extensions --> Settings --> Global Settings, jeśli masz zainstalowany w swoich systemach.

gitextension-najnowsze-wydanie

Kliknij prawym przyciskiem myszy folder / katalog w środowisku Windows, aby uzyskać dostęp do tych ustawień.

Aktualizacja : Jak przełączać / utrzymywać wiele ustawień w wersji 2.49

Może to prosty hack, ale jest użyteczny. Po prostu wygeneruj 2 klucze ssh jak poniżej.

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

W ten sam sposób stwórz jeszcze jeden dla osobistego. Masz więc 2 klucze ssh, pracę i firmę. Skopiuj work.pub, work, personal.pub, personal do ~ / .ssh / Directory.

Następnie utwórz skrypt powłoki z następującymi wierszami i nadaj mu nazwę crev.sh (Company Reverse) o następującej treści.

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

W ten sam sposób utwórz jeszcze jeden o nazwie prev.sh (Personal Reverse) o następującej treści.

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

w ~ / .bashrc dodaj aliasy dla tych skryptów jak poniżej

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

Ilekroć chcesz skorzystać z towarzystwa, po prostu zrób crev, a jeśli chcesz skorzystać z osobistego, zrób prev :-p.

Dodaj te klucze ssh do swoich kont GitHub. Upewnij się, że nie wygenerowano wcześniej id_rsa, ponieważ te skrypty zastąpią id_rsa. Jeśli już wygenerowałeś id_rsa, użyj tego dla jednego z kont. Skopiuj je jako osobiste i pomiń generowanie kluczy osobistych.

Zrobiłem funkcję bash, która to obsługuje. Oto repozytorium Github .

Do wiadomości:

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

Po prostu dodaj to do ~ / .bash_profile, aby przełączać się między domyślnymi kluczami dla 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"

Możesz także użyć git commit --author "Your Name <your@email.com>"w momencie wykonywania zatwierdzenia w repozytorium, w którym chcesz zatwierdzić jako inny użytkownik.

Coś jak odpowiedź Roba W , ale dopuszczenie innego klucza ssh i działa ze starszymi wersjami git (które nie mają np. Konfiguracji core.sshCommand).

Plik utworzyłem ~/bin/git_poweruserz uprawnieniami do wykonywania w ścieżce:

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

Ilekroć chcę zatwierdzić lub przekazać coś jako „Użytkownik git_poweruserzaawansowany ”, używam zamiast git. Powinien działać na każdym katalogu i nie wymaga zmian .gitconfiglub .ssh/configprzynajmniej nie w moim.

Chociaż większość pytań w pewnym stopniu odpowiadała PO, po prostu musiałem przez to przejść i nawet bez googlingu byłem w stanie znaleźć najszybsze i najprostsze rozwiązanie. Oto proste kroki:

• skopiuj istniejący .gitconfgz drugiego repozytorium
• wklej do nowo dodanego repozytorium
• zmień wartości w .gitconfigpliku, takie jak nazwa, adres e-mail i nazwa użytkownika [user] name = John email = john@email.net username = john133
• dodaj nazwę pliku do .gitignorelisty, aby upewnić się, że nie zatwierdzasz .gitconfigpliku do repozytorium pracy