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

Od git 2.13, możliwe jest rozwiązanie tego problemu przy użyciu nowo wprowadzonego warunkowego includes .

Przykład:

Global config ~/.gitconfig

[user]
    name = John Doe
    email = [email protected]

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

Work specific config ~ / work/.gitconfig

[user]
    email = [email protected]

Lub możesz dodać następujące informacje w lokalnym pliku .git/config

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

Po zainspirowaniu się postem Orra Sella na blogu napisałem hak przed zatwierdzeniem (rezydujący w ~/.git/templates/hooks), który ustawiał konkretne nazwy użytkowników i adresy e-mail na podstawie informacji wewnątrz lokalnego repozytorium ./.git/config:

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

[init]
    templatedir = ~/.git/templates

Następnie każdy git init lub git clone odbierze ten hook i zastosuje dane użytkownika podczas następnego git commit. Jeśli chcesz zastosować hook do już exisiting następnie uruchom git init wewnątrz repo, aby go ponownie zainicjować.

Oto hak, który wymyśliłem (nadal wymaga polerowania - sugestie są mile widziane). Zapisz go 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

EDIT:

Więc przepisałem hook jako hook i polecenie w Pythonie. Dodatkowo możliwe jest również wywołanie skryptu jako polecenia Git (git passport). Możliwe jest również zdefiniowanie dowolnego liczba identyfikatorów wewnątrz pliku configfile (~/.gitpassport), które można wybrać w monicie. Projekt można znaleźć na stronie github.com: git-passport-polecenie Git i hook 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 łączy się z użytkownikiem github ), możesz skonfigurować, że chcesz zostać zapytany. Jak możesz to zrobić zależy od używanej wersji Gita, zobacz poniżej.

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

Wersja

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

W Twojej globalnej konfiguracji ~/.gitconfig zgodnie z komentarzem dana Aloni in Orr Sella ' s blog post . Podczas próby wykonania pierwszego commita w repozytorium, git nie powiedzie się z ładnym Komunikatem:

*** Please tell me who you are.

Run

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

to set your account's default identity.
Omit --global to set the identity only in this repository.

fatal: unable to auto-detect email address (got '(none)')

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

2.7.0 ≤ Wersja

Zachowanie w wersjach Orr Sella ' s blog post . To rozwiązanie działa również dla innych wersji, ale inne rozwiązania nie dla tej wersji.

Wersja ≥ 2.8.0

Dan Aloni dodał opcję, aby osiągnąć to zachowanie (zobacz uwagi do wydania). Użyj go z:

[user]
    useConfigOnly = true

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

fatal: user.useConfigOnly set but no name given

Więc wiadomość nie jest zbyt pouczająca, ale skoro Ustawiłeś tę opcję jawnie, powinieneś wiedzieć, co robić. W w przeciwieństwie do rozwiązania wersji

Jedno polecenie github accounts switch

To rozwiązanie przyjmuje postać pojedynczego aliasu git. Po wykonaniu, bieżący użytkownik projektu zostanie przypisany do innego konta

Generowanie kluczy ssh

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

[...]

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

Połącz je z kontami GitHub / Bitbucket

1. kopiowanie domyślnego klucza publicznego pbcopy < ~/.ssh/id_rsa.pub
2. Zaloguj się do konta GitHub
3. wklej klucz na stronie add SSH key 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

Punkt 1. Automatyczne przełączanie klawiszy ssh.

Możemy skonfigurować ssh, Aby wysłać użycie określonego klucza szyfrującego w zależności od host. Fajne jest to, że możesz mieć kilka aliasów dla tego samego hostname.

Zobacz przykład ~/.ssh/config plik:

# 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

Możesz teraz używać tych aliasów w git remotes zmieniając [email protected] by git@github_pro.

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

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

Używając aliasu, staje się:

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

Punkt 2. Zmiana użytkownika git.e-mail

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

git config user.email '[email protected]'

Choć jest to łatwe, to trwa długo dla jesteśmy deweloperami. Możemy do tego napisać bardzo prosty alias git.

Dodamy go do pliku ~/.gitconfig.

[user]
    name = Arnaud Rinquin
    email = [email protected]

...

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

Następnie, wszystko, co musimy zrobić, to git setpromail aby zmienić nasz e-mail tylko dla tego projektu.

Punkt 3. Jeden przełącznik?!

Czy nie byłoby miło przełączyć się z domyślnego konta na określone z jednym poleceniem bez parametru? Jest to zdecydowanie możliwe. Polecenie to będzie miało dwa kroki:

• Zmień aktualne projekty zdalne do wybranych aliasów
• Zmień bieżącego użytkownika projektu.email config

Mamy już rozwiązanie jednego polecenia dla drugiego kroku, ale pierwszy jest o wiele trudniejszy. Jedno polecenie remote host change

Oto rozwiązanie w postaci kolejnej komendy Git alias do dodania do twojego ~/.gitconfig:

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

Pozwala to na zmianę wszystkich pilotów z jednego hosta na drugi (alias). Zobacz przykład:

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

$ > git changeremotehost github.com github_pro

$ > git remote -v
origin  git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin  git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (push)

Połącz je wszystkie

Teraz musimy połączyć te dwie komendy w jedną, jest to dość proste. Zobacz, jak również 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 '[email protected]'"
  gopro = !sh -c \"git changeremotehost github.com github_pro && git changeremotehost bitbucket.com bitbucket_pro && git setpromail\"

Link Źródłowy-Tutorial

Inną opcją pozwalającą git pracować z wieloma nazwami / e-mailami jest aliasowanie git i użycie znacznika -c do nadpisania konfiguracji globalnej i repozytorium.

Na przykład, definiując alias:

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

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

$ git config user.email
[email protected]

Zamiast aliasu, możesz również umieścić Niestandardowy git plik wykonywalny w swoim $PATH.

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

Zaletą tej metody w stosunku do specyficznego dla repozytorium .git/config jest to, że ma ona zastosowanie do każde repozytorium git, Gdy program custom git jest aktywny. W ten sposób możesz łatwo przełączać się między użytkownikami / nazwami bez modyfikowania żadnej (współdzielonej) konfiguracji.

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

Po Prostu Usuń sekcję [user] ze swojego ~/.gitconfig, co uniemożliwi dokonywanie zmian bez ustawiania user.name dla każdego repozytorium.

W swoim ~/.bashrc dodaj kilka prostych aliasów dla użytkownika i e-mail:

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

With conditional includes W Git 2.13, możliwe jest teraz współistnienie wielu użytkowników/e-maili na jednej maszynie z niewielką ilością pracy.

user.gitconfig ma moje nazwisko i e-mail. work-user.gitconfig ma moje służbowe imię i e-mail. Oba pliki znajdują się na ścieżce ~.

Więc moje imię/adres e-mail ma zastosowanie domyślnie. Dla katalogu c:/work/ stosuje się nazwę/adres e-mail mojej pracy. Dla katalogu c:/work/github/ stosuje się moje imię / 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 na rozróżnia wielkość liter i {[7] } jest niewrażliwa na wielkość liter.

"gitdir/i:github/" zastosuje include warunkowy dla dowolnego katalogu z github w jego ścieżce.

Aliasy Git (i sekcje w GIT configs) na ratunek!

Dodaj alias (z linii 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 [email protected]

I w Nowym lub sklonowanym repo możesz uruchomić to polecenie:

git identity github

To rozwiązanie nie jest automatyczne, ale wyłącza użytkownika i e-mail w Twoim globalnym~/.gitconfig wymusiłby na git przypomnienie, aby ustawić je ręcznie w każdym nowym lub sklonowanym repo.

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

Ta odpowiedź jest częściowo zainspirowana postem @Saucier, ale szukałem zautomatyzowanego sposobu, aby ustawić user.name i user.email na zasadzie per repo, w oparciu o pilota, który był nieco bardziej lekki niż pakiet Git-passport, 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

Post-checkout hook który należy zapisać w 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 poświadczenia dla github i gitlab, ale te odniesienia w powyższym kodzie mogą zostać zastąpione lub rozszerzone o dowolną usługę, której używasz. Aby hook po kasie automatycznie ustawiał nazwę użytkownika i adres e-mail lokalnie dla repo po kasie upewnij się, że nazwa usługi pojawia się w zdalnym adresie url, dodaj ją do tablicy usług w skrypcie post-checkout i utwórz dla niej sekcję w .gitconfig, która zawiera nazwę użytkownika i adres e-mail dla tej usługi.

Jeśli żadna z usług nazwy pojawiają się w zdalnym url lub repo nie ma Zdalnego Nazwa użytkownika i e-mail nie będą ustawiane lokalnie. W takich przypadkach zostanie uruchomione ustawienie user.useConfigOnly, które nie pozwoli na dokonywanie zmian, 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 + lokalne .bashrc

.bashrc_local: nie śledź tego pliku, umieść go tylko na komputerze roboczym:

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

.bashrc: Śledź ten plik, spraw, aby był taki sam zarówno na komputerach roboczych, jak i domowych:

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

Używam https://github.com/technicalpickles/homesick aby zsynchronizować moje pliki dotfiles.

Gdyby tylko gitconfig akceptował zmienne środowiskowe: rozszerzenie zmiennej powłoki w git config

Środowisko Windows

Dodatkowe to może być zmodyfikowane z Git Extensions --> Settings --> Global Settings, jeśli masz go zainstalowany w swoich systemach.

Gitextensions-latest-release

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

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

Może i jest to prosty hack, ale jest przydatny. Wystarczy wygenerować 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 [email protected]
The key's randomart image is:
+---[RSA 4096]----+
|. .oEo+=o+.      |
|.o o+o.o=        |
|o o o.o. +       |
| =.+ .  =        |
|= *+.   S.       |
|o*.++o .         |
|=.oo.+.          |
| +. +.           |
|.o=+.            |
+----[SHA256]-----+

W ten sam sposób stwórz jeszcze jeden dla osobistego. Więc masz 2 klucze ssh, pracę i firmę. Kopia pracy.pub, praca, sprawy osobiste.pub, osobisty do ~/.Katalog ssh/.

Następnie Utwórz skrypt powłoki z następującymi liniami i nazwij go jako crev.sh (rewers firmy) 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, stwórz jeszcze jedną 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

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

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

Kiedy chcesz korzystać z firmy, po prostu zrób crev, a jeśli chcesz korzystać z osobistego do prev: - p.

Dodaj te klucze ssh do swoich kont github. Upewnij się, że nie masz wygenerowanego id_rsa, ponieważ te skrypty nadpiszą id_rsa. Jeśli wygenerowałeś już id_rsa, użyj go dla jednego z kont. Skopiuj je jako osobiste i pomiń generowanie kluczy osobistych.

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

Dla zapisu:

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

Coś w stylu Rob w ' s answer , ale zezwalając na inny klucz ssh, i działa ze starszymi wersjami Gita (które nie mają np. rdzenia.sshcommand config).

Utworzyłem plik ~/bin/git_poweruser z uprawnieniami wykonywalnymi i 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="[email protected]" $@

Kiedy chcę coś zatwierdzić lub wypchnąć jako "Power User", używam git_poweruser zamiast git. Powinien działać na każdym katalogu i nie wymaga zmian w .gitconfig lub .ssh/config, przynajmniej nie w moim.

Oto, co właśnie znalazłem po wykonaniu kroków w wielu odpowiedzi tutaj

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

Możesz zacząć sprawdzać aktualnie zapisane klucze $ ssh-add-l

Jeśli zdecydujesz się usunąć wszystkie buforowane klucze przed (opcjonalnie, uważaj na to ) $ ssh-add-d

Następnie możesz utworzyć klucz SSH pub/priv połączony z każdym e-mailem / kontem, które chcesz / potrzebujesz użycie

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

Po wykonaniu tego polecenia 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 Działa

$ eval `ssh-agent -s`

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

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Teraz możesz ponownie sprawdzić zapisane klucze

$ ssh-add -l

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

Klonowanie każdego z repozytoriów do różnych folderów

Przejdź do folderu gdzie user work będzie używany i zrobi to

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

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

Przejdź do folderu, w którym zostanie użyty użytkownik activehacker i zrób to

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

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

Po tym wszystkim będziesz mógł zatwierdzić swój osobisty i roboczy Kod przez przełącznik folderów

Jeśli masz jakieś problemy daj mi znać [email protected]

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

• skopiuj istniejące .gitconfg z innego repo
• wklej do nowo dodanego repo
• zmień wartości w pliku .gitconfig, takie jak nazwa, adres e-mail i nazwa użytkownika [user] name = John email = [email protected] username = john133
• Dodaj nazwę pliku do listy .gitignore, aby upewnić się, że nie zatwierdzisz .gitconfig Pliku do repo