Przedmowa (11)

1. Wprowadzenie (17)

• Podstawy (17)
• Narodziny Gita (18)
• Poprzednicy (20)
• Na osi czasu (21)
• Cóż to za nazwa? (22)

2. Instalowanie Gita (23)

• Zastosowanie binarnych dystrybucji Linuksa (23)
  
  • Dystrybucje Debian lub Ubuntu (23)
  • Inne dystrybucje binarne (24)
• Uzyskanie wydania źródłowego (25)
• Budowanie i instalowanie (26)
• Instalowanie Gita w systemie Windows (27)
  
  • Instalowanie pakietu Git w systemie Cygwin (28)
  • Instalowanie wolno stojącej wersji Gita (msysGit) (29)

3. Na dobry początek (31)

• Polecenie git (31)
• Szybkie wprowadzenie do użytkowania Gita (33)
  
  • Tworzenie archiwum początkowego (33)
  • Dodawanie pliku do Twojego archiwum (34)
  • Konfigurowanie autora zatwierdzenia (35)
  • Wykonanie kolejnego zatwierdzenia (36)
  • Przeglądanie Twoich zatwierdzeń (36)
  • Przeglądanie różnic w zatwierdzeniach (37)
  • Usuwanie i przemianowywanie plików w Twoim archiwum (38)
  • Tworzenie kopii Twojego archiwum (39)
• Pliki konfiguracyjne (39)
  
  • Konfigurowanie synonimu (41)
• Zasięganie języka (42)

4. Podstawowe koncepcje Gita (43)

• Pojęcia podstawowe (43)
• Archiwa (43)
  
  • Typy obiektów Gita (44)
  • Indeks (45)
  • Nazwy adresowane treścią (46)
  • Git nadzoruje treść (46)
  • Nazwy ścieżek a treść (47)
  • Pliki pakowane (48)
• Obrazy magazynu obiektów (49)
• Koncepcje Gita uwidocznione w działaniu (51)
  
  • Zawartość katalogu .git (51)
  • Obiekty, haszowania i bloby (52)
  • Pliki i drzewa (53)
  • Uwaga o zastosowaniu w Gicie algorytmu SHA1 (54)
  • Hierarchie drzewiaste (55)
  • Zatwierdzenia (56)
  • Metki (57)

5. Zarządzanie plikami a indeks (59)

• Wszystko kręci się wokół indeksu (59)
• Klasyfikacje plików w Gicie (60)
• Użycie polecenia git add (62)
• Kilka uwag o stosowaniu polecenia git commit (64)
  
  • Użycie polecenia git commit --all (64)
  • Zapisywanie komunikatów dziennika zatwierdzeń (65)
• Użycie polecenia git rm (65)
• Użycie polecenia git mv (67)
• Uwaga o śledzeniu przemianowań (68)
• Plik .gitignore (69)
• Szczegółowy przegląd modelu obiektowego i plików Gita (71)

6. Zatwierdzenia (77)

• Niepodzielne zbiory zmian (78)
• Identyfikowanie zatwierdzeń (79)
  
  • Bezwzględne nazwy zatwierdzeń (79)
  • Refy i symrefy (80)
  • Względne nazwy zatwierdzeń (81)
• Historia zatwierdzeń (83)
  
  • Przeglądanie starych zatwierdzeń (83)
  • Grafy zatwierdzeń (85)
  • Przedziały zatwierdzeń (89)
• Znajdowanie zatwierdzeń (93)
  
  • Użycie polecenia git bisect (93)
  • Użycie polecenia git blame (97)
  • Użycie kilofa (98)

7. Odgałęzienia (99)

• Powody stosowania odgałęzień (99)
• Nazwy odgałęzień (100)
  
  • Co używać, a czego nie używać w nazwach odgałęzień (101)
• Zastosowanie odgałęzień (101)
• Tworzenie odgałęzień (103)
• Sporządzanie wykazów nazw odgałęzień (104)
• Przeglądanie odgałęzień (104)
• Wyciąganie odgałęzień (106)
  
  • Elementarny przykład wyciągania odgałęzienia (107)
  • Wyciąganie w wypadku niezatwierdzonych zmian (107)
  • Łączenie zmian w nowe odgałęzienie (109)
  • Tworzenie i wyciąganie nowego odgałęzienia (111)
  • Wyosobnione odgałęzienia HEAD (111)
• Usuwanie odgałęzień (112)

8. Różnice (115)

• Postaci polecenia git diff (116)
• Prosty przykład polecenia git diff (120)
• Polecenie git diff i przedziały zatwierdzeń (122)
• Polecenie git diff z ograniczeniem ścieżki (125)
• Porównanie wyprowadzania różnic w systemach Subversion i Git (126)

9. Łączenia (129)

• Przykłady łączeń (129)
  
  • Przygotowanie do łączenia (130)
  • Łączenie dwóch odgałęzień (130)
  • Konflikt w trakcie łączenia (132)
• Postępowanie z konfliktami łączenia (135)
  
  • Lokalizowanie konfliktowych plików (136)
  • Badanie konfliktów (136)
  • W jaki sposób Git śledzi konflikty (140)
  • Zakończenie rozwiązywania konfliktu (142)
  • Zaniechanie lub wznowienie łączenia (143)
• Strategie łączenia (144)
  
  • Łączenia zdegenerowane (146)
  • Łączenia zwykłe (147)
  • Łączenia specjalne (149)
  • Stosowanie strategii łączenia (149)
  • Sterowniki łączenia (151)
• Jak Git rozpatruje łączenia (151)
  
  • Łączenia i model obiektowy Gita (151)
  • Łączenia zgniatane (152)
  • Czemu nie łączyć po prostu każdej zmiany po kolei? (153)

10. Zmienianie zatwierdzeń (155)

• Uwaga dotycząca zmieniania historii (157)
• Użycie polecenia git reset (158)
• Użycie polecenia git cherry-pick (164)
• Użycie polecenia git revert (166)
• Polecenia reset, revert i checkout (167)
• Zmiana zatwierdzenia szczytowego (168)
• Przebazowanie zatwierdzeń (170)
  
  • Użycie polecenia git rebase -i (172)
  • Operacja rebase a łączenie (176)

11. Skrytka stash i rejestr odniesień reflog (181)

• Skrytka (181)
• Rejestr odniesień (189)

12. Archiwa zdalne (193)

• Koncepcje archiwum (194)
  
  • Archiwa czyste i rozwojowe (194)
  • Klony archiwów (195)
  • Piloty (196)
  • Odgałęzienia nadzorujące (197)
• Odwoływanie się do innych archiwów (198)
  
  • Odwołania do archiwów zdalnych (198)
  • Refspec - specyfikator odniesienia (200)
• Przykład użycia zdalnych archiwów (202)
  
  • Tworzenie archiwum wzorcowego (203)
  • Uczyń swój własny początek zdalnym (204)
  • Prowadzenie prac we własnym archiwum (206)
  • Wypychanie zmian (206)
  • Dodawanie nowego wykonawcy (207)
  • Pobieranie uaktualnień archiwum (209)
• Cykl rozwoju zdalnego archiwum w ujęciu rysunkowym (214)
  
  • Klonowanie archiwum (214)
  • Historie alternatywne (215)
  • Niespieszne wypychanie (216)
  • Pobieranie alternatywnej historii (217)
  • Łączenie historii (218)
  • Konflikty łączenia (218)
  • Wypychanie połączonej historii (219)
• Konfigurowanie zdalne (219)
  
  • Użycie polecenia git remote (220)
  • Użycie polecenia git config (221)
  • Obróbka ręczna (222)
• Działanie na odgałęzieniach nadzorowania (222)
  
  • Tworzenie gałęzi nadzorowania (222)
  • Przed i za (225)
• Dodawanie i usuwanie odgałęzień zdalnych (226)
• Archiwa czyste i polecenie git push (227)

13. Zarządzanie archiwum (229)

• Słowo o serwerach (229)
• Publikowanie archiwów (230)
  
  • Archiwa z kontrolowanym dostępem (230)
  • Archiwa z anonimowym dostępem do czytania (231)
  • Archiwa z anonimowym dostępem do pisania (235)
  • Publikowanie archiwum na koncie GitHub (235)
• Wskazówka dotycząca publikowania archiwum (236)
• Struktura archiwum (237)
  
  • Struktura archiwum dzielonego (237)
  • Struktura archiwum rozproszonego (238)
  • Przykłady struktur archiwów (239)
• Jak żyć w warunkach rozproszenia (241)
  
  • Zmienianie historii upublicznionej (241)
  • Rozdzielność kroków zatwierdzeń i publikowania (242)
  • Ani jednej historii prawdziwej (242)
• Znaj swoje miejsce (243)
  
  • Przepływy w górę i w dół (244)
  • Role pielęgnatora i budowniczego (244)
  • Współpraca między pielęgnatorem a budowniczym (245)
  • Dualność ról (246)
• Praca z wieloma archiwami (247)
  
  • Twoja własna przestrzeń robocza (247)
  • Gdzie rozpocząć swoje archiwum (248)
  • Przekształcenie w inne archiwum w górze (249)
  • Używanie wielu górnych archiwów (250)
  • Rozwidlanie projektów (252)

14. Łaty (255)

• Dlaczego używamy łat? (256)
• Generowanie łat (257)
  
  • Łaty i sortowanie topologiczne (264)
• Pocztowe ekspediowanie łat (264)
• Stosowanie łat (267)
• Złe łaty (273)
• Łatanie a łączenie (273)

15. Doczepki (275)

• Instalowanie doczepek (277)
  
  • Doczepki przykładowe (277)
  • Utworzenie pierwszej doczepki (278)
• Dostępne doczepki (280)
  
  • Doczepki powiązane z zatwierdzeniami (280)
  • Doczepki powiązane z łatami (281)
  • Doczepki powiązane z wypychaniem (282)
  • Inne doczepki do lokalnego archiwum (283)

16. Zestawianie projektów (285)

• Stare rozwiązanie: wyciągi częściowe (286)
• Rozwiązanie oczywiste: zaimportuj kod do swojego projektu (287)
  
  • Importowanie podprojektów przez kopiowanie (289)
  • Importowanie podprojektów poleceniem git pull -s subtree (289)
  • Kierowanie swoich zmian w górę (293)
• Rozwiązanie zautomatyzowane: wyciąganie podprojektów z użyciem odpowiednich skryptów (293)
• Rozwiązanie rodzime: gitlinki i git submodule (295)
  
  • Odsyłacze gitlinks (295)
  • Polecenie git submodule (297)

17. Najlepsze praktyki dotyczące podmodułów (301)

• Polecenia podmodułowe (301)
• Dlaczego podmoduły? (302)
• Przygotowywanie podmodułów (303)
• Dlaczego tylko do czytania? (304)
• Dlaczego nie tylko do czytania? (304)
• Sprawdzanie haszowań zatwierdzeń podmodułów (305)
• Ponowne wykorzystanie pełnomocnictw (305)
• Przypadki użycia (306)
• Wielopoziomowe zagnieżdżanie archiwów (307)
• Podmoduły na horyzoncie (307)

18. Zastosowanie Gita do archiwów systemu Subversion (309)

• Przykład: płytki klon jednego odgałęzienia (309)
  
  • Pora na wykonywanie zmian w Gicie (312)
  • Pobranie przed zatwierdzeniem (313)
  • Zatwierdzanie za pomocą git svn rebase (314)
• Wypychanie, ciągnięcie, rozgałęzianie i łączenie za pomocą git svn (315)
  
  • Utrzymywanie prostoty identyfikatorów zatwierdzeń (316)
  • Klonowanie wszystkich gałęzi (317)
  • Dzielenie Twojego archiwum (319)
  • Ponowne włączanie do Subversion (320)
• Inne uwagi o pracy z systemem Subversion (321)
  
  • Cecha svn:ignore a plik .gitignore (321)
  • Rekonstruowanie pamięci podręcznej git-svn (322)

19. Działania zaawansowane (323)

• Użycie polecenia git filter-branch (323)
  
  • Przykłady użycia polecenia git filter-branch (325)
  • Pułapki filter-branch (330)
• Jak pokochałem polecenie git rev-list (330)
  
  • Wyciąganie według daty (331)
  • Odzyskiwanie starej wersji pliku (333)
• Interaktywne wystawianie kawałków (335)
• Rekonstruowanie utraconego zatwierdzenia (345)
  
  • Polecenie git fsck (345)
  • Ponowne przyłączenie utraconego zatwierdzenia (349)

20. Rady, chwyty i sposoby (351)

• Interaktywne przebazowanie z zabrudzonym katalogiem roboczym (351)
• Usuwanie zbędnych plików edytora (352)
• Łączenie nieużytków (352)
• Podział archiwum (354)
• Sposoby rekonstruowania zatwierdzeń (355)
• Rady dotyczące konwersji Subversion (356)
  
  • Ogólne zalecenia (356)
  • Usuwanie trzonu po zaimportowaniu SVN (356)
  • Usuwanie identyfikatorów zatwierdzeń SVN (357)
• Manipulowanie odgałęzieniami pochodzącymi z dwu archiwów (357)
• Odzyskiwanie z przebazowania w górze (358)
• Tworzenie własnych poleceń w Gicie (359)
• Szybki przegląd zmian (360)
• Czyszczenie (361)
• Użycie polecenia git-grep do przeszukiwania archiwum (361)
• Aktualizowanie i usuwanie refów (363)
• Postępowanie za przemieszczonymi plikami (364)
• Zachowaj ten plik, lecz go nie nadzoruj (365)
• Byłeś tu już wcześniej? (366)

21. Git i GitHub (367)

• Archiwum kodu powszechnie dostępnego (367)
• Tworzenie archiwum w GitHubie (369)
• Kodowanie społeczne na otwartych źródłach (372)
• Obserwatorzy (373)
• Kanał informacyjny (373)
• Rozwidlenia (374)
• Przygotowywanie zamówień ciągnięcia (376)
• Obsługiwanie zamówień ciągnięcia (377)
• Powiadomienia (379)
• Odnajdywanie użytkowników, projektów i kodu (382)
• Wikisy (383)
• Strony GitHuba (Git do witryn) (384)
• Edytor kodu wprost ze strony (386)
• Most do systemu Subversion (388)
• Metki automatycznie zamieniane na pliki archiwalne (389)
• Organizacje (390)
• Interfejs REST API (390)
• Kodowanie społeczne oparte na źródłach zamkniętych (391)
• Docelowe czerpanie z otwartych źródeł (392)
• Modele kodowania (393)
• GitHub jako inicjatywa gospodarcza (395)
• GitHub - podsumowanie (396)

Skorowidz (397)

• Tytuł: Kontrola wersji z systemem Git. Narzędzia i techniki programistów. Wydanie II
• Autor: Jon Loeliger, Matthew McCullough
• Tytuł oryginału: Version Control with Git: Powerful tools and techniques for collaborative software development, 2nd edition
• Tłumaczenie: Zdzisław Płoski
• ISBN: 978-83-246-8179-2, 9788324681792
• Data wydania: 2014-02-17
• Format: Ebook
• Identyfikator pozycji: koweg2
• Wydawca: Helion