git-tfs – lek na prawie całe zło

Jak da się zauważyć – mam teraz na tapecie TFSa. I jeśli z całego tego zamieszania wyniknie choć jedna skonwertowana na gita osoba – z radości urządzę sobie kąpiel w kozim mleku i szampanie.

Kilkukrotnie już wspominałem, że życie z TFS wcale nie musi oznaczać życia bez Gita. Wręcz przeciwnie – życie z TFS powinno “implicitly” kojarzyć się z wykorzystaniem Gita w celu obejścia największej porażki TFSa, czyli komponentu zajmującego się kontrolą wersji.

Można to zrobić bardzo prosto. A co najlepsze – zwykły szary klepacz kodu nie potrzebuje do tego nawet zgody wszechmocnego team leadera, architekta, meneżera. Na zewnątrz nikt nawet nie musi się dowiedzieć, że u siebie lokalnie traktujemy TFS tylko jako zło konieczne a tak naprawdę pieścimy umysł Gitem i jego dobrami. Oczywiście nie zachęcam do takiego “sabotażu” – lepiej jest poinformować team o swoich zamiarach, może ktoś się przyłączy? Albo może ktoś będzie miał obiekcje (inne niż “bo nie!”)?

A jak to zrobić? Użyć genialnego, cudnego projektu git-tfs potrafiącego służyć za proxy pomiędzy Gitem a TFSem (kto by się tego domyślił z nazwy?).

Po kolei:

1. Ściągamy i instalujemy Gita

Stąd http://git-scm.com/, a raczej stąd http://code.google.com/p/msysgit/downloads/list?can=3. Pierwszy link.

Zaznaczamy dodanie ‘Open git bash here‘ do shell extensions.

Zaznaczamy ‘autocrlf = false‘ (jako że wszyscy programujemy na Windowsach).
Uwaga! Jeżeli projekt powstaje na kilku systemach operacyjnych (np. Windows i Mac) to zalecam poczytanie o core.autocrlf, na przykład tutaj, i wybranie opcji odpowiedniej do sytuacji.

Zaznaczamy dodanie Gita do PATH – ułatwi to pracę.

Polecam lekturę mojego posta Git – początek, tam trochę więcej info na temat tego co warto skonfigurować od razu po instalacji.

Ta informacja jest zawarta w podlinkowanym poście, ale powtórzę: warto doinstalować TortoiseGit. Czasami wygodniej z tego poziomu prześledzić historię, wykonać diff albo puścić commit.

2. Ściągamy git-tfs

Stąd https://github.com/git-tfs/git-tfs, a raczej stąd https://github.com/git-tfs/git-tfs/releases.

3. Rozpakowujemy git-tfs…

…i dodajemy ten katalog do PATH.

4. Tworzymy nowy folder dla nowego repozytorium…

…odpalamy konsolę (zwykły cmdline może być, ale bardzo polecam git bash – prawym na katalogu i ‘open git bash here’).

5. Ściągamy repo z TFS do Gita…

…komendą: git tfs clone https://<Host>/<ProjectCollection> $/<ProjectName>

6. Pozbywamy się bindingu z TFSem…

… najlepiej bez modyfikacji plików .sln czy .csproj. Czyli wyłączamy sieć (czy to kabel czy wifi), otwieramy sln i czekamy aż VS bardzo rozsądnie przejdzie w tryb offline. Po załadowaniu projektu wyłączamy VS, podłączamy sieć, otwieramy ponownie .sln… hurra, jesteśmy oderwani od TFSa bez żadnych zmian w projekcie!

7. Konfigurujemy pliki, które powinny być ignorowane przez Git…

… czyli wszystkie *.suo, *.cache, śmieci generowane przez Resharpera itd. O samym ignorowaniu więcej pisałem w poście Git a ignorowanie plików.

Przykładowa początkowa zawartość takiego pliku, która przyda się w każdym projekcie, wygląda tak:

#####################
# Visual Studio
#####################
*.user
*.suo
*.sln.cache
#####################
# Build
#####################
bin/
obj/
#####################
# Resharper
#####################
*.resharper
*\_ReSharper*
*_ReSharper*
#####################
# StyleCop
#####################
StyleCop.Cache

Pro-tip: jeśli faktycznie nie chcemy, aby ktokolwiek dowiedział się, że używamy Gita, to nie możemy oczywiście pchnąć pliku .gitignore do TFSa. Ale możemy zastosować super-sprytną sztuczkę którą minutę temu wymyśliłem i przetestowałem:). Do pliku .gitignore możemy dodać linijkę “.gitignore” i… plik ten spowoduje ignorowanie samego siebie, jednocześnie nadal wpływając na zachowanie Gita! Mirakulus!

8. Uczymy się Gita…

… aż pogrubiłem ten punkt. BARDZO zalecam wcześniejsze pobawienie się samym Gitem poza prawdziwym projektem, poczytanie dokumentacji etc. Co prawda nawet bez tego prawdopodobnie nic nie spieprzymy (tym bardziej że żadne zmiany nie zostaną wypchnięte do TFSa dopóki jawnie tego nie rozkażemy), ale mimo wszystko warto poznać Gita głębiej. Materiałów jest cała masa, kilka przydatnych linków podałem w poście Git – rozproszony system kontroli wersji.

9. Pracujemy…

…nie przejmując się exclusive lockami, niewygodnymi branchami, niedziałającym merge. Po prostu: cieszymy się wszystkim co wymieniłem w poście W czym Git jest lepszy od TFS? … i nie tylko.

10. Wypychamy zmiany do TFSa…

…komendą git tfs ct, czyli skrótem od git tfs checkintool. Otwiera to znane, standardowe TFSowe okienko do commitowania. Możemy tam sobie skojarzyć zmiany z taskami, edytować komentarz itd.

Przydatny przełącznik:  –build-default-comment. Powoduje ono przerzucenie commit messages z Gita do okienka TFSowego checkin-toola.

Ewentualnie robimy z tego shelve jeśli wola:

git tfs shelve A_SHELVESET_NAME

11. Radujemy się…

…siwiejemy wolniej, życie jest zajebistsze, ptaszki ćwierkają, słonko świeci etc. Praca znowu jest przyjemna.

Uwaga uwaga achtung achtung !!!

Wszystkie zmiany wysyłane do TFSa są łączone w jeden wielki commit! Jest to zachowanie “by design“.

Cytat z http://groups.google.com/group/git-tfs-dev/browse_thread/thread/c9b921286a746918:

“checkintool is just a convenient tool to make last minute review of your changes and is not supposed to select things to checkin”

Jednak pierwsze co ja zrobiłem to złamanie tej zasady: tak nie mogłem się doczekać eksperymentowania z git-tfs, że nie zagłębiałem się w szczegóły i puściłem checkin odznaczając niektóre pliki. Efektem było kilka chwil konfuzji, ponieważ git-tfs się pogubił i nie do końca wiedział co się dzieje, nie wykrywając po tej operacji, że zostało coś jeszcze do wypchnięcia. Pomogła komenda git tfs pull która naprawiła lokalny stan.

Jeśli jednak chcemy zachować wszystkie swoje commity i faktycznie mieć je odwzorowane 1:1 w TFSie zamiast tworzyć jeden duży commit (ja chcę) to rozwiązaniem jest komenda rcheckin: https://github.com/git-tfs/git-tfs/wiki/Rcheckin. Puszcza ona commit po commicie do TFS, zachowując komentarze z Gita. Ale uwaga: to z kolei nie wyświetla checkintool, więc trzeba podać id powiązanego taska w cmdline (albo potem linkować je ręcznie, co mi się już kilkukrotnie zdarzyło)!

Na koniec ciekawe linki:

http://elegantcode.com/2011/03/15/git-tfs-where-have-you-been-all-my-life/

http://lostechies.com/jimmybogard/2011/09/20/git-workflows-with-git-tfs/

A na jeszcze bardziej końcowy koniec: co prawda ten tutorial wystarczy do rozpoczęcia zabawy z git-tfs, ale niech każdy najpierw poeksperymentuje sobie lokalnie z Gitem. Można w nim sprawnie działać na ślepo, ale świadome korzystanie z bardziej zaawansowanych funkcjonalności daje o wiele większą frajdę.

Reklamacji nie przyjmuję, odpowiedzialności nie biorę! Poświadczam jedynie, że sam korzystam i jestem z tego powodu mega-zadowolony.

Aha, i jakby ktoś się jeszcze nie zorientował: audycja zawierała lokowania produktu.