he sc e ut ab De usg A
Projekte effizient und flexibel verwalten
Git
Versionskontrolle mit
O’Reilly
Jon Loeliger Deutsche Übersetzung von Kathrin Lichtenberg
00___Git_945-8.book Seite 308 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite I Donnerstag, 14. Januar 2010 2:25 14
Versionskontrolle mit Git
Jon Loeliger Deutsche Übersetzung von Kathrin Lichtenberg
Beijing · Cambridge · Farnham · Köln · Sebastopol · Taipei · Tokyo
00___Git_945-8.book Seite II Donnerstag, 14. Januar 2010 2:25 14
Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen. Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im Wesentlichen nach den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
Kommentare und Fragen können Sie gerne an uns richten: O’Reilly Verlag Balthasarstr. 81 50670 Köln Tel.: 0221/9731600 Fax: 0221/9731608 E-Mail:
[email protected]
Copyright der deutschen Ausgabe: © 2010 by O’Reilly Verlag GmbH & Co. KG
Die Originalausgabe erschien 2009 unter dem Titel Version Control with Git im Verlag O’Reilly Media, Inc.
Die Darstellung einer Langohrfledermaus im Zusammenhang mit dem Thema Git ist ein Warenzeichen von O’Reilly Media, Inc.
Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.
Lektorat: Susanne Gerbert, Köln Korrektorat: Eike Nitz, Köln Fachgutachten: Sven Riedel, München Satz: III-satz, Husby, www.drei-satz.de Umschlaggestaltung: Michael Oreal, Köln Produktion: Andrea Miß, Köln Belichtung, Druck und buchbinderische Verarbeitung: Druckerei Kösel, Krugzell; www.koeselbuch.de ISBN 978-3-89721-945-8 Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.
00___Git_945-8.book Seite III Donnerstag, 14. Januar 2010 2:25 14
Inhalt
1
2
3
4
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
VII
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hintergrund . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Geburt von Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Vorgeschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der weitere Verlauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Namen sind Schall und Rauch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 2 5 6 7
1
Git installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
Die Linux-Binärdistributionen benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Quellversion beschaffen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kompilieren und Installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Git unter Windows installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9 11 12 13
Erste Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
Die Git-Kommandozeile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kurze Einführung in die Benutzung von Git . . . . . . . . . . . . . . . . . . . . . . . . . . Konfigurationsdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19 21 28 31
Grundlegende Git-Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
Grundlegende Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Darstellungen des Objektspeichers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Git-Konzepte am Werk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33 38 41
| III
00___Git_945-8.book Seite IV Donnerstag, 14. Januar 2010 2:25 14
5
6
7
8
9
Dateiverwaltung und der Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Es geht um den Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dateiklassifikationen in Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git add benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einige Hinweise zur Benutzung von git commit . . . . . . . . . . . . . . . . . . . . . . . . git rm benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git mv benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein Hinweis zum Überwachen des Umbenennens . . . . . . . . . . . . . . . . . . . . . . Die Datei .gitignore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine ausführliche Darstellung des Objektmodells und der Dateien von Git . .
51 52 52 54 56 58 60 62 63 65
Commits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
Atomare Änderungsmengen (Changesets) . . . . . . . . . . . . . . . . . . . . . . . . . . . . Commits festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Commit-Verlauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Commits suchen (und finden) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72 73 78 90
Zweige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gründe für den Einsatz von Zweigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweignamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweige benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweige erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweignamen auflisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweige anschauen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweige auschecken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zweige löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
97 99 100 101 102 103 105 112
97
Diffs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
115
Formen des git diff-Befehls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein einfaches git diff-Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git diff und Commit-Bereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git diff mit Pfadbegrenzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie Subversion und Git Diffs ableiten – ein Vergleich . . . . . . . . . . . . . . . . . . .
116 120 124 126 128
Merges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
131
Merge-Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit Merge-Konflikten arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Merge-Strategien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie Git über Merges denkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
132 138 148 158
IV | Inhalt
00___Git_945-8.book Seite V Donnerstag, 14. Januar 2010 2:25 14
10 Commits verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
163
Vorsicht beim Verändern des Verlaufs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git reset benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git cherry-pick benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . git revert benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . reset, revert und checkout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das oberste Commit ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rebasing von Commits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
165 166 174 176 176 178 180
11 Entfernte Repositories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
193
Repository-Konzepte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Auf andere Repositories verweisen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein Beispiel mit entfernten Repositories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entfernte Repository-Operationen in Bildern . . . . . . . . . . . . . . . . . . . . . . . . . . Entfernte Zweige hinzufügen und löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . Remote-Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bare-Repositories und git push . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Repositories veröffentlichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
194 198 202 214 221 222 224 226
12 Repository-Verwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
233
Die Repository-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . In einer verteilten Entwicklung leben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wissen, wo Sie stehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mit mehreren Repositories arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
233 237 240 245
13 Patches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
253
Wozu Patches benutzen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Patches generieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Patches per E-Mail verschicken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Patches anwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schlechte Patches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Patching und Merging im Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
254 255 264 267 274 274
14 Hooks – Einstiegspunkte für die Automatisierung . . . . . . . . . . . . . . . . . . . . . . . . .
277
Hooks installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verfügbare Hooks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
279 282
15 Projekte kombinieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
289
Die alte Lösung: partielle Checkouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die offensichtliche Lösung: den Code in Ihr Projekt importieren . . . . . . . . . .
290 292
Inhalt
| V
00___Git_945-8.book Seite VI Donnerstag, 14. Januar 2010 2:25 14
Die automatisierte Lösung: Teilprojekte mit eigenen Skripten auschecken . . . Die native Lösung: Gitlinks und git submodule . . . . . . . . . . . . . . . . . . . . . . . .
299 301
16 Git mit Subversion-Repositories benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
309
Beispiel: ein einfacher Klon eines einzigen Zweigs . . . . . . . . . . . . . . . . . . . . . . Verschieben, Ziehen, Verzweigen und Zusammenführen mit git svn . . . . . . . Verschiedene Hinweise zum Arbeiten mit Subversion . . . . . . . . . . . . . . . . . . .
309 316 323
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
327
VI | Inhalt
00___Git_945-8.book Seite VII Donnerstag, 14. Januar 2010 2:25 14
Vorwort
Zielgruppe Eine gewisse Vertrautheit mit Revisionskontrollsystemen ist zwar von Vorteil, aber auch ein Leser, der noch kein solches System kennt, sollte in der Lage sein, genügend über grundlegende Git-Operationen zu lernen, um schon nach kurzer Zeit erfolgreich loszulegen. Erfahrenere Leser können einen Einblick in den inneren Aufbau von Git erlangen und auf diese Weise einige seiner leistungsfähigeren Techniken meistern. Die angepeilte Zielgruppe für dieses Buch sollte mit der Unix-Shell, wesentlichen ShellBefehlen und allgemeinen Programmierkonzepten vertraut sein.
Voraussetzungen Fast alle Beispiele und Erörterungen in diesem Buch gehen davon aus, dass der Leser ein Unix-artiges System mit einer Kommandozeilenschnittstelle besitzt. Der Autor hat diese Beispiele in Debian- und Ubuntu-Linux-Umgebungen entwickelt. Die Beispiele sollten auch in anderen Umgebungen funktionieren, etwa Mac OS X oder Solaris, allerdings muss der Leser in diesen Fällen leichte Abweichungen erwarten. Einige Beispiele erfordern root-Zugang auf den Maschinen, wenn Systemoperationen erforderlich sind. Natürlich müssen Sie sich in diesen Situationen der Verantwortung des root-Zugriffs bewusst sein.
Der Aufbau des Buches und Auslassungen Dieses Buch ist in Form einer fortschreitenden Folge von Themen gestaltet, die jeweils auf den zuvor eingeführten Konzepten aufbauen. Die ersten zehn Kapitel konzentrieren sich auf die Konzepte und Operationen, die ein Repository betreffen. Sie formen die Grundlage für die komplexeren Operationen an mehreren Repositories, die in den letzten sechs Kapiteln behandelt werden.
| VII
00___Git_945-8.book Seite VIII Donnerstag, 14. Januar 2010 2:25 14
Wenn Sie Git bereits installiert oder vielleicht sogar schon kurz benutzt haben, werden Sie die einführenden Informationen sowie die Erklärungen zur Installation nicht benötigen, die in den ersten beiden Kapiteln präsentiert werden, genausowenig wie den kurzen Überblick im dritten Kapitel. Die Konzepte, die in Kapitel 4 behandelt werden, sind wichtig für ein solides Verständnis des Git-Objektmodells. Sie bilden die Grundlage und bereiten den Leser für ein klareres Verständnis vieler komplexerer Git-Operationen vor. Kapitel 5 bis Kapitel 10 behandeln die verschiedenen Themen genauer. Kapitel 5 beschreibt den Index und die Dateiverwaltung. Kapitel 6 und Kapitel 10 diskutieren die Grundlagen des Bestätigens mit Commits und des Arbeitens mit ihnen, um eine beständige Entwicklungslinie zu bilden. In Kapitel 7 werden Zweige eingeführt, mit deren Hilfe sich unterschiedliche entwicklungslinien von einem lokalen Repository aus manipulieren lassen. Kapitel 8 erläutert, wie Git »Diffs« ableitet und präsentiert. Git bietet eine umfassende und leistungsfähige Fähigkeit, unterschiedliche Entwicklungszweige zusammenzufassen. Die Grundlagen des Zusammenführens von Zweigen in Merges und des Auflösens von Merge-Konflikten werden in Kapitel 9 behandelt. Ein wichtiger Einblick in das Git-Modell ist die Erkenntnis, dass das gesamte Zusammenführen in Merges durch Git im lokalen Repository im Kontext Ihres aktuellen Arbeitsverzeichnisses geschieht. Die Grundlagen des Benennens und Austauschens von Daten mit einem anderen, entfernten Repository werden in Kapitel 11 behandelt. Nachdem wir die Grundlagen des Merging gemeistert haben, wird demonstriert, dass das Arbeiten mit mehreren Repositories einfach eine Kombination aus einem Austauschschritt und einem Merge-Schritt ist. Der Austausch ist das neue Konzept, das in diesem Kapitel gezeigt wird, der MergeSchritt wurde in Kapitel 9 behandelt. Kapitel 12 bietet einen eher philosophischen und abstrakten Einblick in die RepositoryVerwaltung »im Ganzen«. Es bereitet außerdem einen Kontext für Kapitel 13 vor, in dem Patches behandelt werden, die zum Einsatz kommen, wenn ein direkter Austausch von Repository-Informationen mit den Git-eigenen Übertragungsprotokollen nicht möglich ist. Die verbleibenden drei Kapitel behandeln fortgeschrittene Themen: die Verwendung von Hooks zum Automatisieren von Schritten, das Kombinieren von Projekten und mehreren Repositories zu einem Superprojekt sowie die Zusammenarbeit mit Subversion-Repositories. Git entwickelt sich immer noch rasend schnell, weil es eine aktive Entwicklergemeinde gibt. Glauben Sie nicht, dass Git nicht ausgereift genug ist, um für die Entwicklung eingesetzt zu werden; dennoch werden laufend Verbesserungen an der Benutzungsschnittstelle und weitere Verfeinerungen veröffentlicht. Selbst während dieses Buch entstand, entwickelte Git sich weiter. Ich entschuldige mich, falls ich nicht ganz Schritt halten konnte.
VIII |
Vorwort
00___Git_945-8.book Seite IX Donnerstag, 14. Januar 2010 2:25 14
Den Befehl gitk behandle ich nicht so ausführlich, wie er es verdient hätte. Wenn Sie grafische Darstellungen des Verlaufs innerhalb eines Repository haben wollen, sollten Sie sich gitk anschauen. Es gibt noch weitere Werkzeuge zum Visualisieren von Verläufen, aber auch die werden hier nicht behandelt. Auch die sich rapide entwickelnde und anwachsende Gruppe der anderen Git-bezogenen Werkzeuge konnte ich nicht berücksichtigen. Nicht einmal alle Git-eigenen Werkzeuge und Optionen konnte ich in diesem Buch gründlich zeigen. Auch dafür meine Entschuldigung. Wahrscheinlich gibt es aber genügend Hinweise, Tipps und Anweisungen, um Sie, die Leser, anzuregen, Ihre eigenen Erkundungen einzuholen!
Konventionen in diesem Buch In diesem Buch gelten folgende typographische Konventionen: Kursivschrift Kennzeichnet neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateierweiterungen. Nichtproportionalschrift
Wird für Programmlistings sowie innerhalb von Absätzen zum Kennzeichnen von Programmelementen wie Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter verwendet. Nichtproportionalschrift fett
Zeigt Befehle oder anderen Text, der unverändert vom Benutzer eingegeben werden muss. Nichtproportionalschrift kursiv
Zeigt Text, der durch benutzereigene Werte oder Werte ersetzt werden soll, die sich aus dem Kontext ergeben. Dieses Icon kennzeichnet einen Tipp, einen Vorschlag, einen nützlichen Hinweis oder eine allgemeine Anmerkung.
Dieses Icon kennzeichnet eine Warnung oder einen Aufruf zur Vorsicht.
Darüber hinaus sollten Sie mit den grundlegenden Shell-Befehlen zum Manipulieren von Dateien und Verzeichnissen vertraut sein. Viele Beispiele enthalten solche Befehle zum Hinzufügen oder Entfernen von Verzeichnissen, Kopieren von Dateien oder Anlegen einfacher Dateien:
Konventionen in diesem Buch |
IX
00___Git_945-8.book Seite X Donnerstag, 14. Januar 2010 2:25 14
$ $ $ $ $ $
cp datei.txt kopie-von-datei.txt mkdir neuesverzeichnis rm datei rmdir verzeichnis echo "Testzeile" > datei echo "Noch eine Zeile" >> datei
Befehle, die mit root-Berechtigung ausgeführt werden müssen, erscheinen zusammen mit einer sudo-Operation: # Installieren des Git-Kernpakets $ sudo apt-get install git-core
Wie Sie Dateien bearbeiten oder Änderungen innerhalb Ihres Arbeitsverzeichnisses herbeiführen, ist ganz Ihnen überlassen. Sie sollten mit einem Texteditor vertraut sein. In diesem Buch deute ich das Verarbeiten einer Datei entweder durch einen direkten Kommentar oder durch einen Pseudobefehl an: # datei.c bearbeiten, um neuen Text zu erhalten $ edit index.html
Die Codebeispiele benutzen Dieses Buch soll Ihnen dabei helfen, Ihre Arbeit zu erledigen. Im Allgemeinen können Sie den Code aus diesem Buch in Ihren Programmen und Dokumentationen benutzen. Sie müssen uns nur dann um Erlaubnis fragen, wenn Sie einen wesentlichen Teil des Codes reproduzieren wollen. Ein Programm zu schreiben, das mehrere Codeschnippsel aus diesem Buch verwendet, erfordert z.B. keine gesonderte Erlaubnis. Das Verkaufen oder Vertreiben einer CD-ROM mit Beispielen aus O’Reilly-Büchern hingegen erfordert eine Erlaubnis. Das Beantworten einer Frage mithilfe dieses Buchs und eines zitierten Beispielcodes erfordert keine Erlaubnis. Das Aufnehmen einer größeren Menge Beispielcode aus diesem Buch in die Dokumentation Ihres Produkts aber erfordert eine Erlaubnis. Wir begrüßen es, wenn wir als Quelle genannt werden, verlangen es aber nicht. Eine Nennung enthält normalerweise den Titel, den Autor, den Verlag und die ISBN. Zum Beispiel: »Versionskontrolle mit Git von Jon Loeliger. Copyright 2010 Jon Loeliger, 9780-596-52012-0.« Falls Sie das Gefühl haben, dass Ihr Einsatz des Beispielcodes einer Erlaubnis bedarf oder Sie sich nicht sicher sind, dann schreiben Sie uns:
[email protected]
Danksagungen Ohne die Hilfe vieler Leute wäre diese Arbeit nicht entstanden. Ich möchte Avery Pennarun dafür danken, dass er wesentliches Material zu Kapitel 14, Kapitel 15 und Kapitel 16 beigesteuert hat. Er unterstützte mich auch bei Kapitel 4 und Kapitel 9. Ich weiß seine
X | Vorwort
00___Git_945-8.book Seite XI Donnerstag, 14. Januar 2010 2:25 14
Hilfe zu würdigen. Ich möchte öffentlich denjenigen danken, die sich die Zeit genommen haben, das Buch in den verschiedenen Stadien zu begutachten: Robert P. J. Day, Alan Hasty, Paul Jimenez, Barton Massey, Tom Rix, Jamey Sharp, Sarah Sharp, Larry Streepy, Andy Wilcox und Andy Wingo. Außerdem danke ich meiner Frau Rhonda und meinen Töchtern Brandi und Heather für ihre moralische Unterstützung, ihr sanftes Antreiben, den Pinot Noir und die gelegentlichen Grammatiktipps. Danke auch an Mylo, meinen Langhaardackel, der während der gesamten Schreibarbeit zusammengerollt auf meinem Schoß ausgeharrt hat. Einen besonderen Dank möchte ich an K. C. Dignan schicken, der genügend moralische Unterstützung und doppelseitiges Klebeband geliefert hat, um meinen Hintern so lange auf dem Stuhl zu halten, dass das Buch schließlich fertiggestellt werden konnte! Schließlich danke ich den Mitarbeitern bei O’Reilly und ganz besonders meinen Lektoren Andy Oram und Martin Streicher.
Danksagungen |
XI
00___Git_945-8.book Seite XII Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 1 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 1
KAPITEL 1
Einführung
Hintergrund Niemand, der bei einigermaßen klarem Verstand ist, startet ein Projekt heutzutage ohne Backup-Strategie. Da die Daten vergänglich sind und leicht verloren gehen können – sei es durch eine irrtümliche Codeänderung oder einen katastrophalen Festplatten-Crash –, tut man gut daran, ein lebendiges Archiv seiner gesamten Arbeit vorzuhalten. Bei Text- und Codeprojekten umfasst diese Backup-Strategie üblicherweise eine Versionskontrolle oder die Verfolgung und Verwaltung von Änderungen. Jeder Entwickler darf mehrere Änderungen pro Tag vornehmen. Die stetig anwachsende Sammlung dient gleichzeitig als Repository (Lager), Projektgeschichte, Kommunikationsmedium und Werkzeug zur Team- und Produktverwaltung. Angesichts ihrer zentralen Rolle funktioniert die Versionskontrolle am effektivsten, wenn sie auf die Arbeitsgewohnheiten und -ziele des Projektteams zugeschnitten ist. Ein Werkzeug, das unterschiedliche Versionen von Software oder anderen Inhalten verwaltet und überwacht, wird im Allgemeinen als Versionskontrollsystem (Version Control System; VCS), Source Code Manager (SCM), Revision Control System (RCS) oder mit anderen Kombinationen der Wörter »Revision«, »Version«, »Code«, »Content«, »Control«, »Management« und »System« bezeichnet. Auch wenn sich die Autoren und Benutzer der einzelnen Programme möglicherweise über esoterische Dinge streiten, dienen alle Systeme den gleichen Problemstellungen: der Entwicklung und Pflege eines Repository mit Inhalten, der Ermöglichung des Zugriffs auf historische Ausgaben der einzelnen Daten und der Aufzeichnung aller Änderungen in einem Log. In diesem Buch bezieht sich der Begriff Versionskontrollsystem ganz allgemein auf jede Form solcher Systeme. Dieses Buch behandelt Git, eine besonders leistungsstarke und flexible Versionskontrolle mit geringem Overhead, die gemeinschaftliche Entwicklung begünstigt. Git wurde von Linus Torvalds erfunden, um die Entwicklung des Linux-Kernels zu unterstützen. Mittlerweile hat es sich bei einer Vielzahl unterschiedlicher Projekte bewährt.
| 1
00___Git_945-8.book Seite 2 Donnerstag, 14. Januar 2010 2:25 14
Die Geburt von Git Existiert ein Missverhältnis zwischen einem Werkzeug und einem Projekt, stellen die Entwickler oft einfach ein neues Werkzeug her. Um genau zu sein, ist die Verlockung, sich neue Werkzeuge zu schaffen, in der Welt der Software meist unglaublich groß. Angesichts der vielen vorhandenen Versionskontrollsysteme sollte man allerdings nicht leichtfertig beschließen, ein weiteres herzustellen. Bei entsprechendem Bedarf, einer gewissen Einsicht und einer gehörigen Portion Motivation kann es sich jedoch als völlig richtig erweisen, ein neues Werkzeug aus dem Boden zu stampfen. Git, das von seinem Schöpfer auch liebevoll als »Information Manager from Hell« bezeichnet wird, ist ein solches Werkzeug. Die genauen Umstände und der exakte Zeitpunkt seiner Entstehung sind zwar im Zuge des politischen Gezänks innerhalb der Linux-Kernel-Community untergegangen, aber es besteht kein Zweifel daran, dass mit Git ein wohldurchdachtes Versionskontrollsystem geschaffen wurde, das in der Lage ist, die weltweit verteilte Entwicklung von Software in großem Maßstab zu unterstützen. Vor Git wurde bei der Entwicklung des Linux-Kernels das kommerzielle System BitKeeper benutzt, das komplizierte Operationen ermöglichte, die von den damaligen freien Versionskontrollsystemen wie RCS und CVS nicht geboten wurden. Als jedoch das Unternehmen, dem BitKeeper gehörte, im Frühjahr 2005 seine freie, d. h. kostenlose Version weiter einschränkte, fand die Linux-Gemeinschaft, dass BitKeeper keine praktikable Lösung mehr darstellte. Linus suchte nach Alternativen. Kommerzielle Lösungen meidend, untersuchte er die freien Softwarepakete, fand bei ihnen jedoch die gleichen Einschränkungen und Mängel, die bereits früher zu ihrer Ablehnung geführt hatten. Was stimmte nur nicht mit den vorhandenen Versionskontrollsystemen? Welche exotischen Funktionen oder Eigenschaften wollte Linus unbedingt haben, konnte sie aber nicht finden? Unterstützung der verteilten Entwicklung Die »verteilte Entwicklung« besitzt viele Facetten, und Linus wollte ein neues VCS haben, das die meisten von ihnen abdeckte. Es sollte sowohl parallele als auch unabhängige und gleichzeitige Entwicklung in privaten Repositories erlauben, ohne dass ständig eine Synchronisation mit einem zentralen Repository nötig wäre, die einen Entwicklungsengpass bilden könnte. Es müsste mehrere Entwickler an mehreren Orten zulassen, selbst wenn einige von ihnen zeitweise offline wären. Tausende von Entwicklern Es reicht nicht, nur ein verteiltes Entwicklungsmodell zu haben. Linus wusste, dass an jeder Linux-Version Tausende von Entwicklern mitarbeiteten, sodass jedes neue VCS mit einer großen Anzahl von Entwicklern zurechtkommen musste – ob sie nun an denselben oder an unterschiedlichen Teilen eines gemeinsamen Projekts arbeiteten. Und das neue VCS musste dazu in der Lage sein, ihre gesamte Arbeit zuverlässig zu integrieren.
2 |
Kapitel 1: Einführung
00___Git_945-8.book Seite 3 Donnerstag, 14. Januar 2010 2:25 14
Schnelle und effiziente Ausführung Linus wollte das neue VCS unbedingt schnell und effizient haben. Um die schiere Masse von Update-Operationen zu unterstützen, die allein am Linux-Kernel vorgenommen werden würden, müssten sowohl die einzelnen Update-Operationen als auch die Operationen zur Netzwerkübertragung sehr schnell sein. Um Platz und damit Übertragungszeit zu sparen, würden Komprimierungs- und »Delta«-Techniken benötigt werden. Der Einsatz eines verteilten Modells anstelle eines zentralisierten Modells würde sicherstellen, dass die tägliche Entwicklung nicht durch die Netzwerklatenz behindert wird. Integrität und Vertrauen bewahren Da es sich bei Git um ein verteiltes Revisionskontrollsystem handelt, ist es unerlässlich, die absolute Sicherheit zu haben, dass die Integrität der Daten gewahrt und nicht in irgendeiner Weise verletzt wird. Woher wissen Sie, dass die Daten beim Übergang von einem Entwickler oder einem Repository zum nächsten nicht verändert wurden? Und woher wissen Sie, dass die Daten in einem Git-Repository wirklich das sind, was sie zu sein vorgeben? Git benutzt eine gebräuchliche kryptographische Hash-Funktion namens Secure Hash Function (SHA1), um Objekte in seiner Datenbank zu benennen und zu identifizieren. Diese Funktion bietet vielleicht keinen absoluten Schutz, hat sich aber in der Praxis als solide genug erwiesen, um die Integrität und das Vertrauen für alle verteilten Repositories von Git zu sichern. Verantwortlichkeit erzwingen Einer der wesentlichen Aspekte bei einem Versionskontrollsystem besteht darin zu wissen, wer die Dateien geändert hat und weshalb dies geschehen ist (falls sich das überhaupt sagen lässt). Git erzwingt bei jedem Commit (Änderungsbestätigung), das eine Datei ändert, einen Protokolleintrag in einem Änderungslog. Welche Informationen in diesem Änderungslog gespeichert werden, hängt von den einzelnen Entwicklern, den Projektanforderungen, dem Management, den vereinbarten Konventionen usw. ab. Git sorgt dafür, dass Dateien, die der Versionskontrolle unterliegen, nicht mysteriöserweise geändert werden, da sich die Verantwortlichkeit für alle Änderungen nachverfolgen lässt. Unveränderbarkeit Gits Repository-Datenbank enthält Datenobjekte, die unveränderbar sind. Das bedeutet: Sobald sie erzeugt und in der Datenbank abgelegt wurden, können sie nicht mehr verändert werden. Man kann sie natürlich auf andere Weise neu anlegen, die Originaldaten lassen sich jedoch nicht folgenlos ändern. Das Design der GitDatenbank bewirkt, dass auch die gesamte History, die in der Versionskontrolldatenbank gespeichert ist, unveränderbar ist. Die Benutzung unveränderbarer Objekte bringt mehrere Vorteile mit sich, wie etwa die Möglichkeit, schnelle Vergleiche durchzuführen.
Die Geburt von Git | 3
00___Git_945-8.book Seite 4 Donnerstag, 14. Januar 2010 2:25 14
Atomare Transaktionen Bei atomaren Transaktionen werden unterschiedliche, aber verwandte Änderungen entweder zusammen oder gar nicht ausgeführt. Diese Eigenschaft sorgt dafür, dass die Versionskontrolldatenbank nicht in einem teilweise geänderten (und damit möglicherweise unzulässigen) Zustand hinterlassen wird, wenn ein Update oder Commit durchgeführt wird. Git implementiert atomare Transaktionen, indem es vollständige, diskrete Repository-Zustände aufzeichnet, die nicht in einzelne oder kleinere Zustandsänderungen unterteilt werden können. Unterstützung und Förderung der verzweigten Entwicklung Fast alle VCS können unterschiedliche Entwicklungsstammbäume innerhalb eines einzigen Projekts benennen. So könnte z.B. eine Folge von Codeänderungen mit »Entwicklung« bezeichnet werden, während eine andere »Test« heißt. Jedes Versionskontrollsystem ist außerdem in der Lage, eine einzelne Entwicklungslinie in mehrere Entwicklungslinien aufzuteilen und dann die verschiedenen Fäden wieder zu vereinigen oder zusammenzuführen. Genau wie die meisten VCS nennt Git eine Entwicklungslinie Zweig (engl. branch) und weist jedem Zweig einen Namen zu. Neben dem Verzweigen gibt es das Vereinigen. Linus wollte nicht nur das Verzweigen vereinfachen, um alternative Linien zu fördern, sondern auch das Vereinigen dieser Zweige sollte leicht vonstatten gehen. Da das Vereinigen von Zweigen in anderen Versionskontrollsystemen oft eine leidige und schwierige Operation war, sollte es in Git auf jeden Fall sauber, schnell und leicht gehen. Vollständige Repositories Damit einzelne Entwickler nicht einen zentralisierten Repository-Server nach historischen Revisionsinformationen abfragen müssen, war es entscheidend, dass jedes Repository für jede Datei eine vollständige Kopie aller vergangenen Revisionen erhält. Ein sauberes internes Design Ein Endanwender mag sich über ein sauberes internes Design vielleicht nicht sonderlich viele Gedanken machen, für Linus und entsprechend auch für andere Git-Entwickler war es dagegen natürlich sehr wichtig. Das Objektmodell von Git weist einfache Strukturen auf, die grundlegende Konzepte für die Rohdaten, die Verzeichnisstruktur, das Aufzeichnen von Änderungen usw. abdecken. Dieses Objektmodell in Verbindung mit einer global eindeutigen Identifizierungstechnik erlaubt im Ergebnis ein sehr sauberes Datenmodell, das in einer verteilten Entwicklungsumgebung verwaltet werden kann. Frei wie in Freiheit (oder in Freibier) Muss man mehr sagen? Da es offensichtlich Bedarf für ein neues VCS gab, setzten sich viele talentierte Softwareprogrammierer zusammen und schufen Git. Es entstand also aus reiner Notwendigkeit!
4 |
Kapitel 1: Einführung
00___Git_945-8.book Seite 5 Donnerstag, 14. Januar 2010 2:25 14
Die Vorgeschichte Der Versuch, die Geschichte der Versionskontrollsysteme vollständig darzulegen, würde den Rahmen dieses Buches sprengen. Es gibt jedoch einige wegweisende, innovative Systeme, die die Grundlage bildeten oder direkt zur Entwicklung von Git führten. (Dieser Abschnitt soll nur punktuell zeigen, wann neue Funktionen eingeführt oder in der FreeSoftware-Gemeinschaft populär wurden.) Das Source Code Control System (SCCS) war eines der ursprünglichen Systeme unter Unix. Es wurde in den frühen 70er Jahren des 20. Jahrhunderts von M. J. Rochkind entwickelt.1 Dabei handelt es sich wohl um das erste VCS, das auf einem Unix-System verfügbar war. Der zentrale Speicher, den das SCCS bereitstellte, wurde als »Repository« bezeichnet, und dieses grundlegende Konzept gibt es bis heute. SCCS bot darüber hinaus ein einfaches Locking-Modell, um die Entwicklung zu serialisieren. Musste ein Entwickler Dateien ausführen und ein Programm testen, dann checkte er sie ohne Sperren aus. Um eine Datei jedoch zu bearbeiten, musste er sie mit einer Sperre auschecken (diese Konvention wird vom Unix-Dateisystem erzwungen). Nach Beendigung der Arbeit checkte er die Datei wieder im Repository ein und entfernte die Sperre. In den frühen 80er Jahren des 20. Jahrhunderts stellte Walter Tichy das Revision Control System (RCS)2 vor. RCS führte Vorwärts- und Rückwärts-Deltas ein, um unterschiedliche Dateirevisionen effizient speichern zu können. Das Concurrent Version System (CVS), 1986 von Dick Grune entworfen und erstmals implementiert, vier Jahre später dann von Berliner et al. neugeschrieben, erweiterte und modifizierte das RCS-Modell, und das mit großem Erfolg. CVS wurde sehr beliebt und war über eine lange Zeit der De-facto-Standard in der Open Source-Gemeinde. CVS wies gegenüber RCS mehrere Vorteile auf, darunter eine verteilte Entwicklung und Repository-weite Änderungssätze für ganze »Module«. Außerdem führte CVS ein neues Paradigma für die Sperren (Locks) ein. Während frühere Systeme verlangt hatten, dass der Entwickler jede Datei sperrte, bevor er sie änderte, und die Entwickler dann entsprechend warten mussten, bis sie an der Reihe waren, gab CVS jedem Entwickler die Berechtigung, auf seine private Arbeitskopie zu schreiben. Änderungen von unterschiedlichen Entwicklern konnten später automatisch vom CVS zusammengeführt werden, es sei denn, zwei Entwickler versuchten, dieselbe Zeile zu ändern. In diesem Fall wurde der Konflikt gekennzeichnet, und die Entwickler mussten eine Lösung finden. Die neuen Regeln für die Sperren erlaubten es unterschiedlichen Entwicklern, gleichzeitig und parallel am Code zu arbeiten.
1
»The Source Code Control System«, IEEE Transactions on Software Engineering 1(4) (1975): 364–370.
2
»RCS – A System for Version Control«, Software Practice and Experience 15 (7) (Juli 1985): 637–654.
Die Vorgeschichte
| 5
00___Git_945-8.book Seite 6 Donnerstag, 14. Januar 2010 2:25 14
Wie es so kommt, führten erkannte Schwächen und Fehler in CVS schließlich zu einem neuen Versionskontrollsystem. Subversion (SVN), eingeführt um das Jahr 2001 herum, wurde in der Free-Software-Gemeinschaft schnell populär. Anders als CVS bestätigt SVN Änderungen atomar und bietet eine deutlich bessere Unterstützung für Verzweigungen. BitKeeper und Mercurial wichen radikal von all den erwähnten Lösungen ab. Beide eliminierten das zentrale Repository; stattdessen wurde der Speicher verteilt, sodass jedem Entwickler seine eigene freigegebene Kopie zur Verfügung gestellt wird. Git wurde von diesem Peer-to-Peer-Modell abgeleitet. Für Mercurial und Monotone schließlich wurde ein Hash-Fingerprint erfunden, mit dem sich der Inhalt einer Datei eindeutig identifizieren lässt. Der Name, der der Datei zugewiesen wird, ist ein Spitzname und bildet lediglich einen bequemen Alias für den Benutzer, nichts weiter. Git greift diese Idee ebenfalls auf. Intern basiert der Git-Identifikator auf dem Inhalt der Datei, ein Konzept, das man als Content-addressable File Store bezeichnet. Das Konzept ist nicht neu. (Siehe z.B. »The Venti Filesystem,« (Plan 9), Bell Labs, http://www.usenix.org/events/fast02/quinlan/quinlan_html/index.html.) Git übernahm laut Linus die Idee umgehend von Monotone.3 Mercurial implementierte das Konzept gleichzeitig mit Git.
Der weitere Verlauf Nachdem die Grundlage geschaffen worden war, von außen noch einige Anstöße gekommen waren und die VCS-Krise sich weiter verschärft hatte, erblickte Git im April 2005 das Licht der Welt. Git wurde am 7. April mit diesem Commit »self-hosted« (es hat sich quasi selbst verwaltet): commit e83c5163316f89bfbde7d9ab23ca2e25604af29 Author: Linus Torvalds
Date: Thu Apr 7 15:13:13 2005 -0700 Initial revision of "git", the information manager from hell
Kurze Zeit später wurde das erste Linux-Commit ausgeführt: commit 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Author: Linus Torvalds Date: Sat Apr 16 15:20:36 2005 -0700 Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full even though we have it. We can create a separate "historical" archive of that later if we want to, and in the meantime it's 3.2GB when imported into git - space that would just make the
3
Private E-Mail.
6 |
Kapitel 1: Einführung
history, git about early
00___Git_945-8.book Seite 7 Donnerstag, 14. Januar 2010 2:25 14
git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Dieses eine Commit überstellte den Hauptteil des gesamten Linux-Kernels in ein GitRepository.4 Es bestand aus folgenden Dingen: 17291 files changed, 6718755 insertions(+), 0 deletions(-)
Ja, genau, damit wurden 6,7 Millionen Zeilen Code übertragen! Nur drei Minuten später wurde der erste Patch, der Git benutzte, auf den Kernel angewandt. Überzeugt davon, dass es funktioniert, kündigte Linus ihn am 20. April 2005 auf der Linux-Kernel-Mailingliste an. Da er sich nun wieder der eigentlichen Entwicklung des Kernels widmen wollte, übergab Linus die Pflege des Git-Quellcodes am 25. Juli 2005 an Junio Hamano, und zwar mit der Bemerkung, dass Junio »die logische Wahl war«. Etwa zwei Monate später wurde die Version 2.6.12 des Linux-Kernels mithilfe von Git veröffentlicht.
Namen sind Schall und Rauch? Linus selbst erklärt den Namen »Git« so: »Ich bin ein egoistischer Kerl und nenne alle meine Projekte nach mir selbst. Erst Linux, jetzt git.«5 Sicher, der Name »Linux« für den Kernel war eine Mischung aus Linus und Minix. Aber ganz offensichtlich kommt eine gehörige Portion Ironie ins Spiel, wenn jemand den britisch-englischen Ausdruck für eine blöde oder nichtsnutzige Person verwendet. In der Zwischenzeit sind andere Leute mit alternativen, vernünftigeren Interpretationen auf den Plan getreten: Global Information Tracker scheint darunter am beliebtesten zu sein.
4
Unter http://kerneltrap.org/node/13996 können Sie nachlesen, wie die alten BitKeeper-Logs (vor 2.5) in ein GitRepository importiert wurden.
5
Siehe http://www.infoworld.com/article/05/04/19/HNtorvaldswork_1.html.
Namen sind Schall und Rauch? | 7
00___Git_945-8.book Seite 8 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 9 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 2
KAPITEL 2
Git installieren
Momentan ist Git (anscheinend) nicht standardmäßig auf irgendeiner GNU/Linux-Distribution oder einem anderen Betriebssystem installiert. Bevor Sie daher Git benutzen können, müssen Sie es installieren. Die dazu nötigen Schritte hängen stark vom Hersteller und der Version Ihres Betriebssystems ab. In diesem Kapitel wird beschrieben, wie man Git unter Linux und auf Microsoft Windows sowie innerhalb von Cygwin installiert.
Die Linux-Binärdistributionen benutzen Viele Linux-Hersteller bieten vorkompilierte Binärpakete an, um die Installation neuer Anwendungen, Werkzeuge und Dienstprogramme zu vereinfachen. Jedes Paket gibt seine Abhängigkeiten an, und der Paketmanager der Distribution installiert typischerweise die Voraussetzungen und das gewünschte Paket auf einmal (wohlgeordnet und automatisch) und in einem Rutsch.
Debian/Ubuntu Auf den meisten Debian- und Ubuntu-Systemen wird Git als Sammlung aus Paketen angeboten, die je nach Bedarf einzeln installiert werden können. Das wichtigste GitPaket heißt git-core, die Dokumentation gibt es in git-doc, weitere Pakete sind die folgenden: git-arch, git-cvs, git-svn Falls Sie ein Projekt von Arch, CVS oder Subversion nach Git übertragen müssen oder den umgekehrten Weg gehen wollen, dann installieren Sie eines oder mehrere dieser Pakete. git-gui, gitk, gitweb Wenn Sie die Repositories in einer grafischen Anwendung oder in Ihrem Webbrowser betrachten wollen, installieren Sie diese Pakete. git-gui ist eine Tcl/Tk-basierte
| 9
00___Git_945-8.book Seite 10 Donnerstag, 14. Januar 2010 2:25 14
grafische Benutzungsoberfläche für Git; gitk ist ein weiterer Git-Browser, geschrieben in Tcl/Tk, der sich allerdings mehr auf die Visualisierung der Projektgeschichte konzentriert. gitweb ist in Perl geschrieben und zeigt ein Git-Repository im Browserfenster an. git-email Dies ist eine wichtige Komponente, falls Sie Git-Patches per E-Mail verschicken wollen, was in manchen Projekten eine gängige Praxis ist. git-daemon-run Installieren Sie dieses Paket, um Ihr Repository freizugeben. Es erzeugt einen Daemon-Dienst, der Ihnen erlaubt, Ihre Repositories über anonyme Download-Anforderungen für die gemeinsame Nutzung freizugeben. Da die Distributionen ganz unterschiedlich sind, ist es am besten, wenn Sie im Paketverzeichnis Ihrer Distribution nach einer vollständigen Liste der Pakete suchen, die mit Git zu tun haben. Vor allem git-doc und git-email sind ausdrücklich zu empfehlen. Debian und Ubuntu enthalten ein Paket namens git, das allerdings nicht Teil des in diesem Buch besprochenen Versionskontrollsystems Git ist. Bei git handelt es sich um ein völlig anderes Programm namens GNU Interactive Tools. Passen Sie auf, dass Sie nicht versehentlich das falsche Paket installieren!
Folgender Befehl installiert die wichtigen Git-Pakete, indem er apt-get als root ausführt: $ sudo apt-get install git-core git-doc gitweb \ git-gui gitk git-email git-svn
Andere Binärdistributionen Um Git auf anderen Linux-Distributionen zu installieren, suchen Sie das (oder die) entsprechende(n) Paket(e). Zur Installation der Software benutzen Sie den distributionseigenen Paketmanager. Auf Gentoo-Systemen nehmen Sie z.B. emerge: $ sudo emerge dev-util/git
Auf Fedora verwenden Sie yum: $ sudo yum install git
Das git von Fedora entspricht ungefähr dem git-core von Debian. Andere i386-FedoraPakete enthalten: git.i386 Die wesentlichen git-Werkzeuge git-all.i386 Ein Metapaket zum Einbeziehen aller Git-Werkzeuge
10 | Kapitel 2: Git installieren
00___Git_945-8.book Seite 11 Donnerstag, 14. Januar 2010 2:25 14
git-arch.i386 Git-Werkzeuge zum Importieren von Arch-Repositories git-cvs.i386 Git-Werkzeuge zum Importieren von CVS-Repositories git-daemon.i386 Git-Protokoll-Daemon git-debuginfo.i386 Debug-Information für das Paket Git git-email.i386 Git-Werkzeuge zum Verschicken von E-Mails git-gui.i386 Grafisches Git-Werkzeug git-svn.i386 Git-Werkzeuge zum Importieren von Subversion-Repositories gitk.i386 Visualisierer des Git-Revisionsbaums Denken Sie auch hier daran, dass manche Distributionen wie bei Debian die Git-Bestandteile auf viele verschiedene Pakete aufteilen. Falls Ihrem System ein bestimmter GitBefehl zu fehlen scheint, müssen Sie wahrscheinlich ein weiteres Paket installieren. Achten Sie darauf, dass die Git-Pakete Ihrer Distribution einigermaßen aktuell sind. Führen Sie git --version aus, nachdem Sie Git auf Ihrem System installiert haben. Falls Ihre Mitarbeiter eine modernere Version von Git benutzen, müssen Sie die vorkompilierten Git-Pakete Ihrer Distribution durch eine selbstkompilierte Version ersetzen. In der Dokumentation des Paketmanagers erfahren Sie, wie Sie bereits installierte Pakete entfernen; im nächsten Abschnitt erklären wir Ihnen, wie Sie Git aus den Quellen kompilieren.
Eine Quellversion beschaffen Besuchen Sie das Git-Master-Repository, falls Sie es vorziehen, den Git-Code von seiner offiziellen Quelle herunterzuladen, oder Sie die wirklich allerneueste Version haben wollen. Momentan ist das Master-Repository für Git-Quellen http://git.kernel.org im Verzeichnis pub/software/scm. Die in diesem Buch beschriebene Version von Git ist etwa 1.6.0, aber sicher werden Sie aus den Quellen die neueste Version herunterladen. Eine Liste aller verfügbaren Versionen finden Sie unter http://kernel.org/pub/software/scm/git. Um das Kompilieren zu beginnen, laden Sie den Quellcode für Version 1.6.0 (oder später) herunter und entpacken ihn:
Eine Quellversion beschaffen | 11
00___Git_945-8.book Seite 12 Donnerstag, 14. Januar 2010 2:25 14
$ wget http://kernel.org/pub/software/scm/git/git-1.6.0.tar.gz $ tar xzf git-1.6.0.tar.gz $ cd git-1.6.0
Kompilieren und Installieren Git ist vergleichbar mit anderen Open Source-Programmen. Sie konfigurieren es einfach, tippen make und installieren es. Kein Problem, oder? Vielleicht doch. Wenn Ihr System die passenden Bibliotheken sowie eine robuste Build-Umgebung aufweist und Sie Git nicht anpassen müssen, ist das Kompilieren des Codes ein Kinderspiel. Falls Ihrer Maschine dagegen ein Compiler oder die Server- und Softwareentwicklungsbibliotheken fehlen oder Sie noch nie eine komplexe Anwendung aus den Quellen zusammengestellt und kompiliert haben, dann sollten Sie diese Lösung nur als letzten Ausweg betrachten. Git lässt sich in hohem Maße konfigurieren, und das Kompilieren sollte nicht auf die leichte Schulter genommen werden. Um das Kompilieren fortzusetzen, werfen Sie einen Blick in die INSTALL-Datei im GitQuellpaket. Die Datei listet verschiedene externe Abhängigkeiten auf, einschließlich der zlib-, openssl- und libcurl-Bibliotheken. Einige der erforderlichen Bibliotheken und Pakete sind ein wenig unklar oder gehören zu größeren Paketen. Hier sind drei Tipps für eine Debian-Distribution (stable): • curl-config, ein kleines Werkzeug zum Extrahieren von Informationen über die lokale curl-Installation, befindet sich im libcurl3-openssl-dev-Paket. • Die Header-Datei expat.h stammt aus dem libexpat1-dev-Paket. • Das Dienstprogramm msgfmt gehört zum gettext-Paket. Da das Kompilieren aus den Quellen als »Entwicklungsarbeit« betrachtet wird, sind die normalen Binärversionen der installierten Bibliotheken nicht ausreichend. Stattdessen benötigen Sie die -dev-Versionen, weil die Entwicklungsvarianten auch noch HeaderDateien mitliefern, die während der Kompilierung gebraucht werden. Falls Sie einige dieser Pakete oder eine notwendige Bibliothek auf Ihrem System nicht finden können, dann zeigen das Makefile und die Konfigurationsoptionen Alternativen. Sollte Ihnen z.B. die expat-Bibliothek fehlen, dann können Sie die Option NO_EXPAT im Makefile setzen. Allerdings fehlen Ihrer Version dann einige Funktionen, wie im Makefile angemerkt. So werden Sie z.B. nicht in der Lage sein, Änderungen mithilfe der Transportmechanismen HTTP und HTTPS auf ein entferntes Repository zu schieben. Andere Makefile-Konfigurationsoptionen unterstützen Portierungen auf verschiedene Plattformen und Distributionen. So betreffen einige Flags das Darwin-Betriebssystem von Mac OS X. Modifizieren Sie die Einstellungen entweder von Hand und stellen Sie die passenden Optionen ein oder stellen Sie fest, welche Parameter automatisch in der obersten INSTALL-Datei gesetzt werden.
12 | Kapitel 2: Git installieren
00___Git_945-8.book Seite 13 Donnerstag, 14. Januar 2010 2:25 14
Sobald Ihre System- und Kompilierungsoptionen gesetzt sind, ist der Rest ganz einfach. Git wird standardmäßig im Home-Verzeichnis in den Unterverzeichnissen ~/bin/, ~/lib/ und ~/share/ installiert. Im Allgemeinen ist diese Standardeinstellung nur dann sinnvoll, wenn Sie Git persönlich benutzen und es nicht für andere Benutzer freigeben müssen. Diese Befehle kompilieren und installieren Git in Ihrem Home-Verzeichnis: $ $ $ $
cd git-1.6.0 ./configure make all make install
Falls Sie Git an einer anderen Stelle installieren wollen, wie etwa /usr/local/, um einen allgemeinen Zugriff zu ermöglichen, fügen Sie dem ./configure-Befehl die Option --prefix=/usr/local hinzu. Führen Sie anschließend make als normaler Benutzer, make install dagegen als root aus: $ $ $ $
cd git-1.6.0 ./configure --prefix=/usr/local make all sudo make install
Um die Git-Dokumentation zu installieren, fügen Sie den make- bzw. make install-Befehlen die Targets doc und install-doc hinzu: $ cd git-1.6.0 $ make all doc $ sudo make install install-doc
Es sind noch einige weitere Bibliotheken erforderlich, um die Dokumentation komplett zusammenzustellen. Alternativ gibt es vorkompilierte Manpages und HTML-Seiten, die auch getrennt installiert werden können; passen Sie allerdings auf, dass Sie sich keine Probleme mit unterschiedlichen Versionen einhandeln, wenn Sie diesen Weg wählen. Eine Version aus den Quellen enthält alle Git-Unterpakete und -Befehle wie etwa gitemail und gitk. Es ist nicht nötig, diese Dienstprogramme extra zu kompilieren oder zu installieren.
Git unter Windows installieren Es gibt für Windows zwei konkurrierende Git-Pakete: ein Cygwin-basiertes Git und eine »native« Version namens msysGit. Ursprünglich wurde nur die Cygwin-Version unterstützt und msysGit war experimentell und instabil. Zur Zeit der Drucklegung dieses Buches jedoch funktionierten beide Versionen gut und unterstützten fast die gleichen Funktionen. Die wichtigste Ausnahme besteht momentan, also bei Git 1.6.0, darin, dass msysGit git-svn nicht richtig unterstützt. Falls Sie auf Interoperabilität zwischen Git und Subversion angewiesen sind, müssen Sie die Cygwin-Version von Git benutzen. Ansonsten ist es eine Frage der persönlichen Vorlieben, für welche Version Sie sich entscheiden.
Git unter Windows installieren
| 13
00___Git_945-8.book Seite 14 Donnerstag, 14. Januar 2010 2:25 14
Wenn Sie sich nicht sicher sind, wie Sie sich entscheiden sollen, schauen Sie diese Faustregeln an: • Falls Sie Cygwin bereits unter Windows benutzen, dann verwenden Sie das CygwinGit, weil es besser mit Ihrer Cygwin-Installation zusammenarbeitet. Z.B. funktionieren alle Dateinamen im Cygwin-Stil in Git, und das Umleiten der Programmein- und -ausgaben funktioniert immer genau wie erwartet. • Falls Sie Cygwin nicht benutzen, ist es einfacher, msysGit zu installieren, weil es sein eigenes Installationsprogramm mitbringt. • Falls Sie Git in die Windows Explorer-Shell integrieren wollen (um z.B. in der Lage zu sein, mit der rechten Maustaste auf einen Ordner zu klicken und »Git GUI Here« oder »Git Bash Here« auszuführen), installieren Sie msysGit. Wollen Sie diese Funktionalität benutzen, ziehen aber dennoch Cygwin vor, dann installieren Sie einfach beide Pakete – das ist ohne Probleme möglich. Sollten Sie nun immer noch Zweifel haben, welches Paket Sie benutzen sollen, dann installieren Sie msysGit. Achten Sie darauf, die neueste Version zu verwenden (1.5.6.1 oder höher), da die Qualität der Windows-Unterstützung von Git in nachfolgenden Versionen immer weiter zunimmt.
Das Cygwin-Git-Paket installieren Beim Cygwin-Git-Paket handelt es sich, wie der Name andeutet, um ein Paket innerhalb des Cygwin-Systems selbst. Um es zu installieren, führen Sie das Cygwin-Programm setup.exe aus, das Sie von http://cygwin.com herunterladen können. Nach dem Start von setup.exe stellen Sie für die meisten Optionen die Standardwerte ein, bis Sie zu der Liste der zu installierenden Pakete kommen. Die Git-Pakete befinden sich in der Kategorie devel, wie Abbildung 2-1 zeigt. Wenn Sie die gewünschten Pakete ausgewählt haben, klicken Sie ein paarmal auf Weiter, bis die Cygwin-Installation abeschlossen ist. Sie können nun die Cygwin Bash Shell aus dem Startmenü heraus starten, das nun den Befehl git enthalten sollte (siehe Abbildung 2-2). Falls Ihre Cygwin-Konfiguration verschiedene Compilerwerkzeuge wie gcc und make enthält, können Sie alternativ auch Ihre eigene Git-Kopie aus dem Quellcode herstellen, indem Sie den gleichen Anweisungen folgen wie unter Linux.
Ein unabhängiges Git installieren (msysGit) Das msysGit-Paket lässt sich auf einem Windows-System leicht installieren, da das Paket all seine Abhängigkeiten enthält. Es besitzt sogar SSH-Befehle zum Generieren der Schlüssel, die die Betreuer des Repository benötigen, um den Zugriff zu steuern. msysGit soll sich gut in die nativen Windows-Anwendungen integrieren, etwa die Windows Explorer-Shell.
14 | Kapitel 2: Git installieren
00___Git_945-8.book Seite 15 Donnerstag, 14. Januar 2010 2:25 14
Abbildung 2-1: Das Cygwin-Setup
Abbildung 2-2: Die Cygwin-Shell
Git unter Windows installieren
| 15
00___Git_945-8.book Seite 16 Donnerstag, 14. Januar 2010 2:25 14
Laden Sie zuerst die neueste Version des Installationsprogramms von http://code.google. com/p/msysgit herunter. Die gesuchte Datei heißt normalerweise ungefähr so: Git-1.5.6. 1-preview20080701.exe. Nach dem Herunterladen führen Sie das Installationsprogramm aus. Die Darstellung sollte in etwa so aussehen wie in Abbildung 2-3.
Abbildung 2-3: Das msysGit-Setup
Je nach der tatsächlich installierten Version müssen Sie bei einem Kompatibilitätshinweis wie in Abbildung 2-4 Next klicken oder auch nicht. Dieser Hinweis betrifft Inkompatibilitäten zwischen Zeilenenden im Windows-Stil und im Unix-Stil, sogenannte CRLF bzw. LF. Klicken Sie einige Male Next, bis Sie die Darstellung aus Abbildung 2-5 sehen. Am besten führen Sie msysGit täglich über den Windows Explorer aus, klicken Sie deshalb die beiden entsprechenden Checkboxen an. Zusätzlich wird ein Icon zum Starten der Git-Bash (einer Kommandozeile, über die die git-Befehle zur Verfügung stehen) im Startmenü im Abschnitt Git installiert. Da die meisten Beispiele in diesem Buch die Kommandozeile benutzen, nehmen Sie die Git-Bash für den Einstieg. Alle Beispiele in diesem Buch funktionieren unter Linux und Windows gleichermaßen gut, wobei Sie allerdings Folgendes beachten müssen: msysGit für Windows benutzt die älteren Git-Befehlsnamen, die in »Die Git-Kommandozeile« auf Seite 19 erwähnt werden. Um den Beispielen mit msysGit zu folgen, geben Sie git-add für git add ein.
16 | Kapitel 2: Git installieren
00___Git_945-8.book Seite 17 Donnerstag, 14. Januar 2010 2:25 14
Abbildung 2-4: msysGit-Hinweis
Abbildung 2-5: msysGit-Wahlmöglichkeiten
Git unter Windows installieren
| 17
00___Git_945-8.book Seite 18 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 19 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 3
KAPITEL 3
Erste Schritte
Git verwaltet Veränderungen. Daraus folgt, dass Git viel mit anderen Versionskontrollsystemen gemein hat. Viele Grundsätze – die Idee eines Commit, das Änderungslog, das Repository – sind gleich, und die Abläufe sind bei einem Großteil der Werkzeuge konzeptuell ähnlich. Git bietet allerdings auch viele Neuheiten. Die Begriffe und Verfahren anderer Versionskontrollsysteme funktionieren in Git möglicherweise anders oder gelten gar nicht. Wie auch immer Ihre bisherigen Erfahrungen aussehen, in diesem Buch erfahren Sie, wie Git arbeitet und wie Sie es zu Ihrem größtmöglichen Nutzen einsetzen. Fangen wir an.
Die Git-Kommandozeile Die Benutzung von Git ist ganz leicht. Geben Sie einfach git ein. Ohne Argumente listet Git seine Optionen und die gebräuchlichsten Unterbefehle auf: $ git git [--version] [--exec-path[=GIT_EXEC_PATH]] [-p|--paginate|--no-pager] [--bare] [--git-dir=GIT_DIR] [--work-tree=GIT_WORK_TREE] [--help] COMMAND [ARGS] The most commonly used git commands are: add Add file contents to the index bisect Find the change that introduced a bug by binary search branch List, create, or delete branches checkout Checkout and switch to a branch clone Clone a repository into a new directory commit Record changes to the repository diff Show changes between commits, the commit and working trees, etc. fetch Download objects and refs from another repository grep Print lines matching a pattern init Create an empty git repository or reinitialize an existing one log Show commit logs merge Join two or more development histories
| 19
00___Git_945-8.book Seite 20 Donnerstag, 14. Januar 2010 2:25 14
mv pull push rebase reset rm show status tag
Move or rename a file, a directory, or a symlink Fetch from and merge with another repository or a local branch Update remote refs along with associated objects Forward-port local commits to the updated upstream head Reset current HEAD to the specified state Remove files from the working tree and from the index Show various types of objects Show the working tree status Create, list, delete, or verify a tag object signed with GPG
Eine vollständige (und ziemlich abschreckende) Liste der git-Unterbefehle erhalten Sie, wenn Sie git help --all eintippen. Wie Sie anhand des Benutzungshinweises erkennen, gibt es ein paar Optionen für git. Die meisten Optionen, gezeigt als [ARGS] in dem Hinweis, gelten für bestimmte Unterbefehle. Z.B. beeinflusst die Option --version den git-Befehl und gibt eine Versionsnummer aus: $ git --version git version 1.6.0
Im Gegensatz dazu ist --amend ein Beispiel für eine Option des git-Unterbefehls commit: $ git commit --amend
Manche Aufrufe erfordern beide Optionsformen (die zusätzlichen Leerzeichen in der Kommandozeile dienen hier lediglich dazu, den Unterbefehl vom Basisbefehl zu trennen, und sind nicht erforderlich): $ git --git-dir=project.git
repack -d
Übrigens erhalten Sie die Dokumentation für die einzelnen git-Unterbefehle, indem Sie entweder git help Unterbefehl oder git Unterbefehl --help eingeben. Ursprünglich wurde Git als eine Sammlung vieler einfacher, getrennter, unabhängiger Befehle geliefert, die getreu der »Unix-Werkzeugkasten«-Philosophie entwickelt wurden: Stelle kleine, kompatible Werkzeuge her. Jeder Befehl trug einen Namen, dessen Bestandteile durch einen Bindestrich getrennt sind, wie etwa git-commit und git-log. Der momentane Trend unter den Entwicklern sieht jedoch so aus, dass ein einziges gitProgramm benutzt wird, hinter das man einen Unterbefehl hängt. Das heißt also, dass beide Formen identisch sind: git commit und git-commit. Wenn Sie http://www.kernel.org/pub/software/scm/git/docs/ besuchen, können Sie die vollständige Git-Dokumentation online lesen.
Git-Befehle verstehen sowohl »kurze« als auch »lange« Optionen. So behandelt z.B. der Befehl git commit die folgenden Beispiele als gleichbedeutend:
20 | Kapitel 3: Erste Schritte
00___Git_945-8.book Seite 21 Donnerstag, 14. Januar 2010 2:25 14
$ git commit -m "Tippfehler entfernt." $ git commit --message="Tippfehler entfernt."
Die Kurzform -m benutzt einen einzelnen Bindestrich, während die Langform --message zwei verwendet. (Das ist konsistent mit der GNU Long Options Extension.) Manche Optionen existieren nur in einer Form. Schließlich können Sie Optionen von einer Liste mit Argumenten über die »DoppelterBindestrich«-Konvention trennen. Benutzen Sie z.B. den doppelten Bindestrich, um den Steuerteil der Befehlszeile von einer Liste mit Operanden, wie etwa Dateinamen, abzuheben: $ git diff -w master origin -- tools/Makefile
Möglicherweise müssen Sie den doppelten Bindestrich einsetzen, um Dateinamen zu trennen und explizit zu kennzeichnen, wenn diese ansonsten fälschlicherweise für einen weiteren Teil des Befehls gehalten werden könnten. Falls Sie z.B. sowohl eine Datei als auch ein Tag namens main.c haben, bekommen Sie unterschiedliche Ergebnisse: # Das Tag namens "main.c" auschecken $ git checkout main.c # Die Datei namens "main.c" auschecken $ git checkout -- main.c
Kurze Einführung in die Benutzung von Git Um git in Aktion zu sehen, wollen wir ein neues Repository anlegen, Inhalt hinzufügen und einige Revisionen verarbeiten. Es gibt zwei grundlegende Techniken zum Etablieren eines Git-Repository. Sie können es entweder von Grund auf neu anlegen, wobei Sie es mit einem vorhandenen Projekt füllen, oder Sie können ein vorhandenes Repository kopieren oder klonen. Es ist einfacher, mit einem leeren Repository zu beginnen, deshalb machen wir es so.
Ein leeres Repository erzeugen Um eine typische Situation nachzuempfinden, wollen wir ein Repository für Ihre persönliche Website aus dem Verzeichnis ~/public_html anlegen und in einem Git-Repository ablegen. Falls Sie noch keinen Inhalt für eine Website in ~/public_html haben, legen Sie das Verzeichnis an und setzen einige einfache Informationen in eine Datei namens index.html: $ mkdir ~/public_html $ cd ~/public_html $ echo 'Meine Website ist da!' > index.html
Kurze Einführung in die Benutzung von Git
| 21
00___Git_945-8.book Seite 22 Donnerstag, 14. Januar 2010 2:25 14
Wandeln Sie ~/public_html oder ein anderes Verzeichnis in ein Git-Repository um, indem Sie git init ausführen: $ git init Initialized empty Git repository in .git/
Git ist es egal, ob Sie mit einem völlig leeren Verzeichnis beginnen oder mit einem Verzeichnis, das voller Dateien ist. Das Konvertieren des Verzeichnisses in ein Git-Repository verläuft in beiden Fällen gleich. Um anzuzeigen, dass Ihr Verzeichnis ein Git-Repository ist, erzeugt der Befehl git init ein verborgenes Verzeichnis namens .git auf der obersten Ebene Ihres Projekts. CVS und Subversion platzieren in jedem der Verzeichnisse Ihres Projektes Unterverzeichnisse namens CVS bzw. .svn für Revisionsinformationen; Git dagegen setzt all seine Revisionsinformationen in dieses eine .git-Verzeichnis auf der obersten Ebene. Inhalt und Zweck der Datendateien werden im Abschnitt »Im .git-Verzeichnis« auf Seite 41 näher vorgestellt. Der Inhalt des ~/public_html-Verzeichnisses bleibt unberührt. Git betrachtet es als Arbeitsverzeichnis Ihres Projekts oder als das Verzeichnis, in dem Sie die Dateien bearbeiten. Im Gegensatz dazu wird das Repository, das in .git verborgen ist, von Git gepflegt.
Eine Datei zum Repository hinzufügen git init legt ein neues Git-Repository an. Zu Anfang ist jedes Git-Repository leer. Damit Inhalt verwaltet wird, müssen Sie ihn explizit im Repository deponieren. Dieser bewusste Schritt trennt die Arbeitsdateien von den wichtigen Dateien.
Mit git add Datei befördern Sie Datei in das Repository: $ git add index.html
Wenn Sie ein Verzeichnis mit mehreren Dateien haben lassen Sie Git alle Dateien im Verzeichnis und in allen Unterverzeichnissen mit git add . hinzufügen. (Das Argument ., der einzelne Punkt, ist eine Abkürzung für das aktuelle Verzeichnis.)
Nach einem add weiß Git, dass die Datei index.html zum Repository gehört. Allerdings hat Git die Datei bisher nur bereitgestellt, also einen Zwischenschritt vor der eigentlichen Bestätigung ausgeführt. Git trennt die Schritte add und commit, um das ganze System beständiger zu machen. Stellen Sie sich vor, wie störend, verwirrend und zeitraubend es wäre, wenn man jedesmal das Repository aktualisieren müsste, nachdem man eine Datei hinzugefügt, entfernt oder geändert hat. Stattdessen können mehrere vorläufige und verwandte Schritte, wie etwa ein add, »stapelweise« verarbeitet werden, wodurch der Zustand des Repository stabil und konsistent bleibt.
22 | Kapitel 3: Erste Schritte
00___Git_945-8.book Seite 23 Donnerstag, 14. Januar 2010 2:25 14
Der Befehl git status zeigt den Zwischenzustand von index.html: $ git status # On branch master # # Initial commit # # Changes to be committed: # (use "git rm --cached ..." to unstage) # # new file: index.html
Der Befehl gibt aus, dass die neue Datei index.html beim nächsten Commit in das Repository aufgenommen wird. Zusätzlich zu den eigentlichen Änderungen am Verzeichnis und den Dateiinhalten zeichnet Git bei jedem Commit weitere Metadaten auf, darunter eine Lognachricht und den Verfasser der Änderung. Bei einem vollständigen git commit-Befehl werden eine Lognachricht und ein Autor angegeben: $ git commit -m "Anfaenglicher Inhalt von public_html" \ --author="Jon Loeliger <[email protected]>" Created initial commit 9da581d: Anfaenglicher Inhalt von public_html 1 files changed, 1 insertions(+), 0 deletions(-) create mode 100644 index.html
Natürlich können Sie auf der Kommandozeile eine Lognachricht festlegen, typischerweise wird die Meldung jedoch während einer interaktiven Bearbeitungssitzung erzeugt. Das bietet Ihnen die Möglichkeit, in Ihrem bevorzugten Editor eine vollständige und detaillierte Nachricht zu schreiben. Damit während eines git commit Ihr Lieblingseditor gestartet wird, stellen Sie die Umgebungsvariable GIT_EDITOR entsprechend ein: # In tcsh $ setenv GIT_EDITOR emacs # In bash $ export GIT_EDITOR=vim
Nachdem Sie das Hinzufügen der neuen Datei zum Repository bestätigt haben, zeigt git status an, dass es keine ausstehenden, bereitgestellten Änderungen mehr gibt, die noch bestätigt werden müssten: $ git status # On branch master nothing to commit (working directory clean)
Git nimmt sich auch die Zeit, Ihnen mitzuteilen, dass Ihr Arbeitsverzeichnis sauber ist, was bedeutet, dass das Arbeitsverzeichnis keine unbekannten oder veränderten Dateien enthält, die von dem abweichen, was sich im Repository befindet.
Kurze Einführung in die Benutzung von Git
| 23
00___Git_945-8.book Seite 24 Donnerstag, 14. Januar 2010 2:25 14
Seltsame Fehlermeldungen Git setzt alles daran, den Verfasser jedes Commit festzustellen. Falls Sie Ihren Namen und Ihre E-Mail-Adresse nicht so eingestellt haben, dass Git sie finden kann, werden Sie seltsame Warnungen bemerken. Sie müssen allerdings nicht in eine Existenzkrise verfallen, wenn Sie eine solche kryptische Fehlermeldung sehen: You don't exist. Go away! (Sie existieren gar nicht. Verschwinden Sie!) Your parents must have hated you! (Ihre Eltern müssen Sie gehasst haben!) Your sysadmin must hate you! (Ihr Sysadmin hasst Sie!)
Der Fehler zeigt an, dass Git nicht in der Lage ist, Ihren wirklichen Namen zu ermitteln, vermutlich wegen eines Problems (Vorhandensein, Lesbarkeit, Länge) mit Ihrer Unix-»gecos«Information. Das Problem kann behoben werden, indem Sie Ihre Namens- und E-MailKonfigurationsinformationen einstellen, wie in »Den Commit-Verfasser konfigurieren« auf Seite 24 (s. u.) beschrieben.
Den Commit-Verfasser konfigurieren Bevor Sie viele Commits an einem Repository vornehmen, sollten Sie einige grundlegende Umgebungs- und Konfigurationsoptionen eintragen. Git muss zumindest Ihren Namen und Ihre E-Mail-Adresse kennen. Sie können Ihre Identität auf jeder CommitBefehlszeile angeben, wie bereits gezeigt, aber das ist eine umständliche Methode, die schnell lästig wird. Speichern Sie stattdessen Ihre Identität mithilfe des Befehls git config in einer Konfigurationsdatei: $ git config user.name "Jon Loeliger" $ git config user.email "[email protected]"
Sie können Git Ihren Namen und Ihre E-Mail-Adresse auch über die Umgebungsvariablen GIT_AUTHOR_NAME und GIT_AUTHOR_EMAIL mitteilen. Diese Variablen setzen alle Konfigurationseinstellungen außer Kraft.
Ein weiteres Commit ausführen Um weitere Eigenschaften von Git zu demonstrieren, wollen wir einige Modifikationen vornehmen und einen komplexen Verlauf von Änderungen im Repository erzeugen. Bestätigen Sie eine Änderung an der Datei index.html. Öffnen Sie dazu die Datei, wandeln Sie sie in HTML um und speichern Sie sie: $ cd ~/public_html # Bearbeiten der Datei index.html
24 | Kapitel 3: Erste Schritte
00___Git_945-8.book Seite 25 Donnerstag, 14. Januar 2010 2:25 14
$ cat index.html Meine Website ist da! $ git commit index.html
Wenn der Editor erscheint, geben Sie einen Commit-Logeintrag ein, z.B. »In HTML konvertieren«, und verlassen den Editor wieder. Es gibt jetzt zwei Versionen von index.html im Repository.
Ihre Commits anschauen Sobald Sie ein oder mehrere Commits im Repository haben, können Sie sie auf vielfältige Weise betrachten. Manche Git-Befehle zeigen die Abfolge der einzelnen Commits, andere zeigen die Zusammenfassung für ein einzelnes Commit und wieder andere zeigen die vollständigen Einzelheiten aller Commits im Repository. Der Befehl git log liefert einen sequenziellen Verlauf der einzelnen Commits im Repository: $ git log commit ec232cddfb94e0dfd5b5855af8ded7f5eb5c90d6 Author: Jon Loeliger <[email protected]> Date: Wed Apr 2 16:47:42 2008 -0500 In HTML konvertieren commit 9da581d910c9c4ac93557ca4859e767f5caf5169 Author: Jon Loeliger <[email protected]> Date: Thu Mar 13 22:38:13 2008 -0500 Anfaenglicher Inhalt von public_html
Die Einträge werden der Reihe nach von den neuesten zu den ältesten1 (der Originaldatei) aufgeführt; jeder Eintrag zeigt den Namen sowie die E-Mail-Adresse des Verfassers des jeweiligen Commit, das Datum des Commit, die Lognachricht für die Änderung und die interne Identifikationsnummer des Commit. Die Commit-ID wird in »Inhaltsadressierbare Namen« auf Seite 36 erläutert, Commits werden in Kapitel 6 besprochen. Um nähere Einzelheiten über ein bestimmtes Commit zu erfahren, verwenden Sie den Befehl git show mit einer Commit-Nummer:
1
Genauer gesagt, sind sie nicht in zeitlicher Reihenfolge angegeben, sondern eher in einer topologischen Anordnung der Commits.
Kurze Einführung in die Benutzung von Git
| 25
00___Git_945-8.book Seite 26 Donnerstag, 14. Januar 2010 2:25 14
$ git show 9da581d910c9c4ac93557ca4859e767f5caf5169 commit 9da581d910c9c4ac93557ca4859e767f5caf5169 Author: Jon Loeliger <[email protected]> Date: Thu Mar 13 22:38:13 2008 -0500 Anfaenglicher Inhalt von public_html diff --git a/index.html b/index.html new file mode 100644 index 0000000..34217e9 --- /dev/null +++ b/index.html @@ -0,0 +1 @@ +Meine Website ist da!
Wenn Sie git show ohne spezielle Commit-Nummer ausführen, zeigt der Befehl einfach die Details des neuesten Commit. Eine andere Darstellung, show-branch, liefert knappe, einzeilige Zusammenfassungen für den aktuellen Entwicklungszweig: $ git show-branch --more=10 [master] In HTML konvertieren [master^] Anfaenglicher Inhalt von public_html
Die Phrase --more=10 zeigt die letzten zehn Versionen. Allerdings existieren momentan nur zwei, und so werden diese beiden gezeigt. (Standardmäßig wird nur das neueste Commit aufgeführt.) Der Name master ist der vorgegebene Name für diesen Zweig. Kapitel 7 geht näher auf Verzweigungen ein, im Abschnitt »Zweige anschauen« auf Seite 103 wird der Befehl git show-branch genauer beschrieben.
Unterschiede zwischen Commits betrachten Um die Unterschiede zwischen den beiden Revisionen von index.html zu sehen, nehmen Sie die beiden vollständigen Commit-ID-Namen und führen damit git diff aus: $ git diff 9da581d910c9c4ac93557ca4859e767f5caf5169 \ ec232cddfb94e0dfd5b5855af8ded7f5eb5c90d6 diff --git a/index.html b/index.html index 34217e9..40b00ff 100644 --- a/index.html +++ b/index.html @@ -1 +1,5 @@ + + Meine Website ist da! + +
26 | Kapitel 3: Erste Schritte
00___Git_945-8.book Seite 27 Donnerstag, 14. Januar 2010 2:25 14
Diese Ausgabe sollte Ihnen vertraut sein: Sie ähnelt dem, was das diff-Programm erzeugt. Laut Konvention ist die erste Revision, 9da581d910c9c4ac93557ca4859e767f5caf5169, die ältere Version des Inhalts, während die zweite Revision, ec232cddfb94e0dfd5b5855af 8ded7f5eb5c90d6, die neuere darstellt. Daher steht vor jeder Zeile neuen Inhalts ein Pluszeichen (+). Macht Ihnen das Angst? Fürchten Sie sich nicht vor diesen einschüchternden Hexadezimalzahlen. Dankenswerterweise bietet Git noch viele kürzere und einfachere Methoden, um solche Befehle auszuführen, ohne dass man riesige, komplizierte Zahlen angeben muss.
Dateien aus Ihrem Repository entfernen und umbenennen Das Entfernen einer Datei aus einem Repository erfolgt analog zum Hinzufügen einer Datei, allerdings mit dem Befehl git rm. Nehmen Sie einmal an, Sie haben die Datei poem. html auf Ihrer Website, und sie wird nicht mehr benötigt: $ cd ~/public_html $ ls index.html poem.html $ git rm poem.html rm 'poem.html' $ git commit -m "Ein Gedicht entfernen" Created commit 364a708: Ein Gedicht entfernen 0 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 poem.html
Das Löschen erfordert genau wie das Hinzufügen zwei Schritte: git rm drückt Ihr Verlangen aus, die Datei zu entfernen, und bereitet die Änderung vor. Anschließend wird die Änderung im Repository von git commit tatsächlich durchgeführt. Auch hier können Sie die Option -m weglassen und eine Lognachricht, wie »Ein Gedicht entfernen«, interaktiv in Ihrem Lieblingstexteditor eingeben. Sie können eine Datei indirekt umbenennen, indem Sie eine Kombination aus git rm und git add benutzen. Schneller und direkter geht es mit git mv. Hier ein Beispiel der ersten Form: $ mv foo.html bar.html $ git rm foo.html rm 'foo.html' $ git add bar.html
In dieser Sequenz müssen Sie mv foo.html bar.html am Anfang ausführen, damit git rm die Datei foo.html nicht permanent aus dem Dateisystem löscht. Hier ist die gleiche Operation, ausgeführt mit git mv. $ git mv foo.html bar.html
Kurze Einführung in die Benutzung von Git
| 27
00___Git_945-8.book Seite 28 Donnerstag, 14. Januar 2010 2:25 14
In beiden Fällen müssen die vorbereiteten Änderungen anschließend bestätigt werden: $ git commit -m "foo nach bar verschoben" Created commit 8805821: foo nach bar verschoben 1 files changed, 0 insertions(+), 0 deletions(-) rename foo.html => bar.html (100%)
Git verarbeitet Operationen zum Verschieben von Dateien anders als die meisten verwandten Systeme, indem es einen Mechanismus anwendet, der auf der Ähnlichkeit des Inhalts zwischen zwei Dateiversionen basiert. Die Eigenheiten dieses Ansatzes werden in Kapitel 5 beschrieben.
Eine Kopie Ihres Repository herstellen Falls Sie den vorangegangenen Schritten gefolgt sind und ein erstes Repository im Verzeichnis ~/public_html angelegt haben, können Sie nun eine vollständige Kopie oder einen Klon dieses Repository herstellen. Dabei hilft Ihnen der Befehl git clone. Auf diese Weise wird Git weltweit für das Arbeiten an Projekten mit denselben Dateien und für das Synchronisieren mit anderen Repositories eingesetzt. Für die Zwecke dieser Anleitung legen wir einfach eine Kopie Ihres Home-Verzeichnisses an und nennen diese meine_website: $ cd ~ $ git clone public_html meine_website
Diese beiden Git-Repositories enthalten nun zwar exakt die gleichen Objekte, Dateien und Verzeichnisse, aber gibt es einige feine Unterschiede. Sie könnten diese Unterschiede mit folgenden Befehlen untersuchen: $ ls -lsa public_html meine_website $ diff -r public_html meine_website
Auf einem lokalen Dateisystem ähnelt das Benutzen von git clone zum Erzeugen einer Kopie eines Repository cp -a oder rsync. Allerdings unterstützt Git eine größere Menge von Repository-Quellen, darunter Netzwerknamen, zum Benennen des zu klonenden Repository. Diese Formen und ihre Verwendung werden in Kapitel 11 erläutert. Nachdem Sie ein Repository geklont haben, können Sie die geklonte Version modifizieren, neue Commits durchführen, seine Logs und den Verlauf untersuchen usw. Es ist ein vollständiges Repository mit einem kompletten Verlauf (History).
Konfigurationsdateien Bei den Konfigurationsdateien von Git handelt es sich um einfache Textdateien im Stil der .ini-Dateien. Sie verzeichnen die verschiedenen Auswahlen und Einstellungen, die von vielen Git-Befehlen benutzt werden. Manche Einstellungen repräsentieren rein persönliche Vorlieben (Sollte ein color.pager verwendet werden?), andere sind wichtig,
28 | Kapitel 3: Erste Schritte
00___Git_945-8.book Seite 29 Donnerstag, 14. Januar 2010 2:25 14
damit ein Repository richtig funktioniert (core.repositoryformatversion), während wieder andere das Verhalten von Befehlen ein wenig verändern (gc.auto). Wie viele Werkzeuge unterstützt auch Git eine Hierarchie von Konfigurationsdateien. In absteigender Rangordnung sind das die folgenden: .git/config Repository-spezifische Konfigurationseinstellungen, die mit der Option --file oder per Default manipuliert werden. Diese Einstellungen haben den höchsten Rang. ~/.gitconfig Benutzerspezifische Konfigurationseinstellungen, die mit der Option --global manipuliert werden. /etc/gitconfig Systemweite Konfigurationseinstellungen, die mit der Option --system manipuliert werden, wenn Sie die richtigen Unix-Dateischreibberechtigungen gesetzt haben. Diese Einstellungen haben den niedrigsten Rang. Je nach Ihrer tatsächlichen Installation kann die Systemeinstellungsdatei irgendwo anders sein, etwa unter /usr/local/ etc/gitconfig, sie kann aber auch komplett fehlen. Um z.B. einen Verfassernamen und eine E-Mail-Adresse für alle Commits in allen Repositories einzurichten, konfigurieren Sie mit dem Befehl git config --global Werte für user.name und user.email in der Datei $HOME/.gitconfig: $ git config --global user.name "Jon Loeliger" $ git config --global user.email "[email protected]"
Um dagegen einen Repository-spezifischen Namen und eine E-Mail-Adresse zu setzen, die eine --global-Einstellung außer Kraft setzen, lassen Sie einfach das Flag --global weg: $ git config user.name "Jon Loeliger" $ git config user.email "[email protected]"
Mit git config -l listen Sie die Einstellungen aller Variablen auf, die in allen Konfigurationsdateien zu finden sind: # $ $ $
Stellt ein brandneues, leeres Repository her mkdir /tmp/new cd /tmp/new git init
# $ $ $
Setzt einige Konfigurationswerte git config --global user.name "Jon Loeliger" git config --global user.email "[email protected]" git config user.email "[email protected]"
$ git config -l user.name=Jon Loeliger [email protected] core.repositoryformatversion=0 core.filemode=true
Konfigurationsdateien
| 29
00___Git_945-8.book Seite 30 Donnerstag, 14. Januar 2010 2:25 14
core.bare=false core.logallrefupdates=true [email protected]
Da die Konfigurationsdateien einfach nur Textdateien sind, können Sie ihren Inhalt mit cat anschauen und mit Ihrem Lieblingstexteditor bearbeiten: # Zeigt nur die Repository-spezifischen Einstellungen an $ cat .git/config [core] repositoryformatversion = 0 filemode = true bare = false logallrefupdates = true [user] email = [email protected]
Benutzen Sie die Option --unset, um eine Einstellung zu entfernen: $ git config --unset --global user.email
Oft gibt es mehrere Konfigurationsoptionen und Umgebungsvariablen, die den gleichen Zweck erfüllen. Z.B. folgt der Editor, der zum Verfassen einer Commit-Lognachricht verwendet werden soll, diesen Schritten in der angezeigten Reihenfolge: 1. GIT_EDITOR-Umgebungsvariable 2. core.editor-Konfigurationsoption 3. VISUAL-Umgebungsvariable 4. EDITOR-Umgebungsvariable 5. vi-Befehl Es gibt mehrere Hundert Konfigurationsparameter. Ich werde Sie hier nicht mit ihnen langweilen, aber im Laufe der Zeit auf einige wichtige hinweisen. Eine umfassende (aber immer noch unvollständige) Liste finden Sie auf der git config-Manpage.
Einen Alias konfigurieren Für Anfänger kommt hier ein Tipp zum Einrichten von Befehlsaliasen. Wenn es einen gebräuchlichen, aber komplexen Git-Befehl gibt, den Sie häufig eintippen, sollten Sie einen einfachen Git-Alias dafür einrichten: $ git config --global alias.show-graph \ 'log --graph --abbrev-commit --pretty=oneline'
In diesem Beispiel habe ich den show-graph-Alias angelegt und zur Benutzung in all meinen Repositories freigegeben. Wenn ich nun den Befehl git show-graph verwende, ist das so, als hätte ich diesen langen git log-Befehl mit den ganzen Optionen eingetippt.
30 | Kapitel 3: Erste Schritte
00___Git_945-8.book Seite 31 Donnerstag, 14. Januar 2010 2:25 14
Ausblick Sicher sind nach den hier durchgeführten Aktionen eine Menge Fragen zur Funktion von Git offen. Wie speichert Git z.B. die einzelnen Versionen einer Datei? Was passiert wirklich bei einem Commit? Woher kommen diese lustigen Commit-Nummern? Wieso heißt es master? Und ist ein »Zweig« wirklich das, was ich vermute? Gute Fragen. Im nächsten Kapitel werden einige Begriffe definiert, Git-Konzepte vorgestellt und die Grundlagen für die Lektionen im Rest des Buches gelegt.
Ausblick | 31
00___Git_945-8.book Seite 32 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 33 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 4
KAPITEL 4
Grundlegende Git-Konzepte
Grundlegende Konzepte Das vorangegangene Kapitel hat eine typische Anwendung von Git präsentiert – und wahrscheinlich einen Haufen Fragen aufgeworfen. Speichert Git bei jedem Commit die gesamte Datei? Was ist die Aufgabe des .git-Verzeichnisses? Wieso sieht eine Commit-ID so seltsam aus? Muss ich sie überhaupt zur Kenntnis nehmen? Wenn Sie schon einmal ein anderes Versionskontrollsystem (VCS) benutzt haben, etwa Subversion oder CVS, dann werden Ihnen die Befehle im letzten Kapitel wahrscheinlich vertraut vorgekommen sein. Git stellt schließlich auch die gleichen Funktionen und Operationen zur Verfügung wie jedes andere moderne VCS. Andererseits gibt es einige grundsätzliche und überraschende Unterschiede. In diesem Kapitel untersuchen wir, wieso und wo sich Git von anderen VCS unterscheidet, indem wir die wesentlichen Komponenten seiner Architektur sowie einige wichtige Konzepte betrachten. Wir konzentrieren uns hier auf die Grundlagen und demonstrieren, wie man mit einem Repository arbeitet. In Kapitel 11 wird dann erläutert, wie man mit vielen Repositories arbeitet, die miteinander verbunden sind. Es mag eine abschreckende Aussicht sein, den Überblick über mehrere Repositories behalten zu müssen, aber dabei gelten genau die Grundlagen, die Sie in diesem Kapitel kennenlernen werden.
Repositories Ein Git-Repository ist einfach eine Datenbank mit allen Informationen, die erforderlich sind, um die Revisionen und den Verlauf eines Projekts aufzubewahren und zu verwalten. Wie bei den meisten Versionskontrollsystemen enthält ein Repository in Git eine vollständige Kopie des gesamten Projekts während seiner ganzen Lebensdauer. Im Gegensatz zu den meisten anderen VCS jedoch bietet das Git-Repository nicht nur eine vollständige Arbeitskopie aller Dateien im Repository, sondern auch eine Kopie des Repository selbst, mit dem gearbeitet werden soll.
| 33
00___Git_945-8.book Seite 34 Donnerstag, 14. Januar 2010 2:25 14
Git unterhält in jedem Repository einen Satz von Konfigurationswerten. Einige von ihnen haben Sie im vorangegangenen Kapitel bereits gesehen, etwa den Namen und die E-MailAdresse des Repository-Benutzers. Im Gegensatz zu den Dateidaten und anderen Repository-Metadaten werden die Konfigurationseinstellungen nicht während des Klonens oder Duplizierens von einem Repository zum nächsten weitergereicht. Stattdessen pflegt und untersucht Git die Informationen zum Konfigurieren und Einrichten je Site, je Benutzer und je Repository. Innerhalb eines Repository unterstützt Git zwei hauptsächliche Datenstrukturen, den Objektspeicher und den Index. All diese Repository-Daten werden in der Wurzel Ihres Arbeitsverzeichnisses in einem verborgenen Unterverzeichnis namens .git gespeichert. Der Objektspeicher soll während einer Klonoperation effizient kopiert werden. Er ist Teil des Mechanismus, der ein vollständig verteiltes VCS ermöglicht. Die Informationen im Index sind flüchtig, gehören nur zu einem Repository und können bei Bedarf erzeugt oder verändert werden. In den beiden nächsten Abschnitten werden der Objektspeicher und der Index näher beschrieben.
Git-Objekttypen Im Kern der Git-Repository-Implementierung befindet sich der Objektspeicher. Er enthält Ihre Datendateien im Original und alle Lognachrichten, Autoreninformationen, Datumsangaben und weiteren Informationen, die erforderlich sind, um eine beliebige Version oder Verzweigung eines Projekts wiederherzustellen. Git setzt nur vier Arten von Objekten in den Objektspeicher: Blobs, Bäume, Commits und Tags. Diese vier atomaren Objekte bilden die Grundlage der höheren Datenstrukturen von Git: Blobs Jede Version einer Datei wird als Blob dargestellt. »Blob« ist die Kurzform von »Binary Large Object« (großes binäres Objekt). Dieser Begriff wird in der Computertechnik häufig benutzt, um eine Variable oder Datei zu bezeichnen, die beliebige Daten enthalten kann und deren interne Struktur vom Programm ignoriert wird. Ein Blob wird als undurchsichtig betrachtet. Ein Blob enthält die Daten einer Datei, aber keine Metadaten über die Datei oder gar ihren Namen. Bäume Ein Baumobjekt repräsentiert eine Ebene von Verzeichnisinformationen. Es verzeichnet Blob-Identifikatoren, Pfadnamen und einige Metadaten für alle Dateien in einem Verzeichnis. Es kann außerdem rekursiv auf andere (Teil-)Baumobjekte verweisen und auf diese Weise eine komplette Hierarchie aus Dateien und Unterverzeichnissen aufbauen.
34 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 35 Donnerstag, 14. Januar 2010 2:25 14
Commits Ein Commit-Objekt enthält Metadaten für jede Änderung, die am Repository vorgenommen wird. Das umfasst auch den Autor, denjenigen, der das Commit ausgeführt hat, den Zeitpunkt des Commit sowie eine Lognachricht. Jedes Commit verweist auf ein Baumobjekt, das in einem vollständigen Schnappschuss den Zustand des Repository zu dem Zeitpunkt erfasst, an dem das Commit ausgeführt wurde. Das erste Commit, auch als Root-Commit bezeichnet, besitzt kein Eltern-Commit. Die meisten Commits besitzen ein Eltern-Commit, allerdings erklären wir in Kapitel 9, wie ein Commit auf mehr als ein Eltern-Commit verweisen kann. Tags Ein Tag-Objekt weist einem bestimmten Objekt, meist einem Commit, einen beliebigen, aber vermutlich für den Benutzer lesbaren Namen zu. Zwar verweist 9da581d910c9c4ac93557ca4859e767f5caf5169 auf ein exaktes und wohldefiniertes Commit, ein vertrauterer Tag-Name wie Ver-1.0-Alpha ist aber sicher sinnvoller! Mit der Zeit ändern sich die Informationen im Objektspeicher und nehmen zu, wobei sie Ihre Bearbeitungsschritte, die Zusätze und Löschungen an Ihrem Projekt verfolgen und modellieren. Um den Festplattenplatz und die Netzwerkbandbreite effizient auszunutzen, komprimiert Git die Objekte und speichert sie in sogenannten Pack-Files, die ebenfalls im Objektspeicher abgelegt werden.
Index Der Index ist eine temporäre und dynamische Binärdatei, die die Verzeichnisstruktur des gesamten Repository beschreibt. Genauer gesagt: Der Index erfasst eine Version der Gesamtstruktur des Projekts zu einem beliebigen Zeitpunkt. Der Zustand des Projekts könnte durch ein Commit und einen Baum von einem beliebigen Punkt im Projektverlauf dargestellt werden, es könnte aber auch ein künftiger Zustand sein, den Sie aktiv entwickeln. Eines der wichtigsten Unterscheidungsmerkmale von Git besteht darin, dass es Ihnen erlaubt, den Inhalt des Index in systematischen, wohldefinierten Schritten zu verändern. Der Index erlaubt eine Trennung zwischen einzelnen Entwicklungsschritten und dem Bestätigen dieser Änderungen durch Commits. Und so funktioniert es. Als Entwickler führen Sie Git-Befehle aus, um Änderungen im Index bereitzustellen. Bei Änderungen werden normalerweise eine Datei oder eine ganze Gruppe von Dateien hinzugefügt, gelöscht oder bearbeitet. Der Index zeichnet diese Änderungen auf und speichert sie sicher, bis Sie bereit sind, sie zu bestätigen. Man kann Änderungen im Index auch ersetzen oder sie aus ihm entfernen. Das bedeutet, dass der Index, angeleitet durch Sie selbst, einen schrittweisen Übergang von einem komplexen Repository-Zustand zu einem anderen, vorzugsweise besseren, Zustand erlaubt.
Grundlegende Konzepte
| 35
00___Git_945-8.book Seite 36 Donnerstag, 14. Januar 2010 2:25 14
Wie Sie in Kapitel 9 sehen werden, spielt der Index eine wichtige Rolle beim Zusammenführen, was es Ihnen ermöglicht, mehrere Versionen derselben Datei gleichzeitig zu verwalten, zu untersuchen und zu manipulieren.
Inhaltsadressierbare Namen Der Git-Objektspeicher ist als inhaltsadressierbares Speichersystem (Content-addressable Storage System, auch: Assoziativspeicher) organisiert und implementiert. Das bedeutet, dass jedes Objekt im Objektspeicher einen eindeutigen Namen besitzt, der durch das Anwenden von SHA1 auf den Inhalt des Objekts erzeugt wird, wodurch sich ein SHA1Hash-Wert ergibt. Da der komplette Inhalt eines Objekts zum Hash-Wert beiträgt, und da der Hash-Wert tatsächlich als eindeutig für diesen speziellen Inhalt betrachtet wird, ist der SHA1-Hash als Index oder Name für dieses Objekt in der Objektdatenbank ausreichend. Jede noch so winzige Änderung an einer Datei verursacht eine Änderung des SHA1-Hash, wodurch die neue Version der Datei separat indiziert wird. SHA1-Werte sind 160-Bit-Werte, die normalerweise als 40-stellige Hexadezimalzahl dargestellt werden, wie etwa 9da581d910c9c4ac93557ca4859e767f5caf5169. Manchmal werden die SHA1-Werte während der Anzeige zu einem kleineren, eindeutigen Präfix abgekürzt. Git-Benutzer sprechen wahlweise von SHA1, Hash-Code oder manchmal auch Objekt-ID.
Global eindeutige Identifikatoren Eine wichtige Eigenschaft der SHA1-Hash-Berechnung besteht darin, dass immer dieselbe ID für identischen Inhalt berechnet wird, unabhängig davon, wo sich dieser Inhalt befindet. Mit anderen Worten: Der gleiche Dateiinhalt in unterschiedlichen Verzeichnissen und sogar auf unterschiedlichen Maschinen ergibt die exakt gleiche SHA1-Hash-ID. Das bedeutet, dass die SHA1-Hash-ID einer Datei global eindeutig ist. Eine entscheidende Folge dieser Eigenschaft ist, dass Dateien oder Blobs beliebiger Größe über das Internet auf Gleichheit untersucht werden können, indem man einfach ihre SHA1-Identifikatoren vergleicht.
Git überwacht den Inhalt Ihnen sollte bewusst sein, dass Git mehr als ein Versionskontrollsystem ist: Git ist ein Content Tracking System (System zur Inhaltsüberwachung bzw. -verfolgung). Dieser Unterschied bestimmt, obschon er nur klein ist, zu einem Großteil das Design von Git und ist vielleicht die Hauptursache dafür, dass Git interne Datenmanipulationen relativ einfach durchführen kann. Allerdings ist es wahrscheinlich auch eines der schwierigsten Konzepte, die neue Benutzer verstehen müssen. Deshalb wollen wir ein wenig ausholen.
36 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 37 Donnerstag, 14. Januar 2010 2:25 14
Die Inhaltsüberwachung von Git drückt sich in zwei entscheidenden Methoden aus, die sich grundlegend von fast allen anderen1 Revisionskontrollsystemen unterscheiden. Erstens beruht der Objektspeicher von Git auf der Hash-Berechnung des Inhalts seiner Objekte, nicht auf den Datei- oder Verzeichnisnamen des ursprünglichen Dateiaufbaus des Benutzers. Das bedeutet, wenn Git eine Datei im Objektspeicher ablegt, dann tut es dies auf der Grundlage des Hash der Daten und nicht auf der Grundlage des Namens der Datei. Um genau zu sein, überwacht Git auch die Datei- oder Verzeichnisnamen nicht, die mit den Dateien auf untergeordnete Weise verknüpft sind. Auch hier verfolgt Git den Inhalt anstelle der Dateien. Falls zwei separate Dateien, die sich in zwei unterschiedlichen Verzeichnissen befinden, exakt den gleichen Inhalt aufweisen, speichert Git eine einzige Kopie dieses Inhalts als Blob im Objektspeicher. Git berechnet den Hash-Code der einzelnen Dateien einzig anhand ihres Inhalts, stellt fest, dass die Dateien dieselben SHA1-Werte und damit den gleichen Inhalt besitzen, legt das Blob-Objekt in den Objektspeicher und indiziert es mit diesem SHA1-Wert. Beide Dateien im Projekt benutzen dieses Objekt für Ihren Inhalt, unabhängig davon, wo sie sich in der Verzeichnisstruktur des Benutzers befinden. Wenn sich eine dieser Dateien ändert, berechnet Git einen neuen SHA1-Wert für sie, stellt fest, dass es sich nun um ein anderes Blob-Objekt handelt, und fügt den neuen Blob in den Objektspeicher ein. Der ursprüngliche Blob verbleibt für die unveränderte Datei im Objektspeicher. Zweitens speichert Gits interne Datenbank effizient jede Version jeder Datei – nicht ihre Unterschiede –, wenn die Dateien von einer Revision zur nächsten übergehen. Da Git den Hash des ganzen Inhalts einer Datei als Namen für diese Datei benutzt, muss es auf jeder vollständigen Kopie der Datei arbeiten. Es kann seine Arbeit oder seine Objektspeichereinträge nicht nur auf einen Teil des Dateiinhalts oder auf die Unterschiede zwischen zwei Revisionen dieser Datei stützen. Die typische Benutzeransicht einer Datei – dass sie Revisionen aufweist und sich von einer Revision zur nächsten zu entwickeln scheint – ist einfach das Ergebnis. Git berechnet diesen Verlauf als Menge der Änderungen zwischen unterschiedlichen Blobs mit variierenden Hashes, anstatt einen Dateinamen und eine Menge von Unterschieden direkt zu speichern. Es wirkt vielleicht seltsam, aber diese Eigenschaft erlaubt Git, bestimmte Aufgaben mit Leichtigkeit durchzuführen.
Pfadname und Inhalt im Vergleich Genau wie viele andere VCS muss Git eine explizite Liste mit Dateien pflegen, die den Inhalt des Repository bilden. Allerdings erfordert das nicht, dass die Liste von Git auf Dateinamen beruht. Git behandelt die Namen der Dateien sogar als eine Form von 1
Monotone, Mercurial, OpenCMS und Venti sind hier nennenswerte Ausnahmen.
Grundlegende Konzepte
| 37
00___Git_945-8.book Seite 38 Donnerstag, 14. Januar 2010 2:25 14
Daten, die sich vom Inhalt dieser Dateien unterscheiden. Auf diese Weise trennt es »Index« von »Daten« im traditionellen Datenbanksinn. Wahrscheinlich hilft es, einen Blick in Tabelle 4-1 zu werfen, wo Git mit anderen bekannten Systemen verglichen wird. Tabelle 4-1: Datenbankvergleich System
Indexmechanismus
Datenspeicher
Traditionelle Datenbank
ISAM
Daten-Records
Unix-Dateisystem
Verzeichnisse (/Pfad/zu/Datei)
Datenblöcke
Git
.git/objects/hash, Baumobjektinhalt
Blob-Objekte, Baumobjekte
Die Namen der Dateien und Verzeichnisse stammen aus dem zugrunde liegenden Dateisystem, allerdings kümmert sich Git eigentlich nicht um die Namen. Git zeichnet lediglich die einzelnen Pfadnamen auf und stellt sicher, dass es die Dateien und Verzeichnisse aus seinem Inhalt, den es anhand des Hash-Wertes indiziert hat, akkurat reproduzieren kann. Gits physischer Datenaufbau ist nicht nach der Dateiverzeichnisstruktur des Benutzers modelliert. Stattdessen weist es eine völlig andere Struktur auf, die nichtsdestotrotz den Originalaufbau des Benutzers wiedergeben kann. Die interne Datenstruktur von Git ist für seine eigenen internen Operationen und Speicherbetrachtungen viel effizienter. Wenn Git ein Arbeitsverzeichnis anlegen muss, sagt es dem Dateisystem: »Hallo! Ich habe diesen großen Blob mit Daten, der unter dem Pfadnamen Pfad/zu/Verzeichnis/Datei abgelegt werden soll. Klingt das für Dich sinnvoll?« Das Dateisystem ist dafür verantwortlich, zu antworten: »Ah, ja, ich erkenne diesen String als eine Menge von Unterverzeichnisnamen und weiß, wo ich den Blob mit Deinen Daten hinpacken soll! Danke!«
Darstellungen des Objektspeichers Wir wollen uns einmal anschauen, wie die Objekte von Git zusammenwirken, um das vollständige System zu formen. Das Blob-Objekt befindet sich ganz »unten« in der Datenstruktur; es verweist auf nichts und wird nur von Baumobjekten referenziert. In den folgenden Abbildungen wird ein Blob jeweils durch ein Rechteck dargestellt. Baumobjekte zeigen auf Blobs und möglicherweise auch auf andere Bäume. Auf jedes Baumobjekt kann auch von vielen unterschiedlichen Commit-Objekten verwiesen werden. Ein Baum wird jeweils durch ein Dreieck repräsentiert. Ein Kreis stellt ein Commit dar. Ein Commit verweist auf einen speziellen Baum, der durch das Commit in das Repository eingeführt wurde. Ein Tag (Markierung) wird durch ein Parallelogram dargestellt. Jedes Tag kann auf höchstens ein Commit verweisen.
38 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 39 Donnerstag, 14. Januar 2010 2:25 14
Der Zweig ist kein grundlegendes Git-Objekt, spielt aber trotzdem eine wesentliche Rolle beim Benennen von Commits. Dargestellt wird ein Zweig als abgerundetes Rechteck. Abbildung 4-1 zeigt, wie alle Teile zusammenpassen. Sie sehen in diesem Diagramm den Zustand eines Repository, nachdem ein einzelnes, erstes Commit zwei Dateien hinzugefügt hat. Beide Dateien befinden sich im obersten Verzeichnis. Sowohl der master-Zweig als auch ein Tag namens V1.0 verweisen auf das Commit mit der ID 8675309. commit 1492 V1.0
tag 2504624
author Jon L tree 8675309
master
Initial commit
branch name
tree 8675309 blob dead23 blob feeb1e
blob dead23
Four score and seven …
Mary had a little lamb …
blob feeb1e
Abbildung 4-1: Git-Objekte
Machen wir es nun ein wenig komplizierter. Wir lassen die beiden Originaldateien so, wie sie sind, und fügen ein neues Unterverzeichnis mit einer Datei darin hinzu. Der resultierende Objektspeicher sieht aus wie in Abbildung 4-2. Wie im vorangegangenen Bild hat das neue Commit ein eigenes Baumobjekt hinzugefügt, mit dem der Gesamtzustand der Verzeichnis- und Dateistruktur dargestellt wird. In diesem Fall handelt es sich um das Baumobjekt mit der ID cafed00d. Da das oberste Verzeichnis durch das Hinzufügen des neuen Unterverzeichnisses geändert wurde, hat sich auch der Inhalt des obersten Baumobjekts geändert. Git führt deshalb einen neuen Baum ein, cafed00d. Allerdings haben sich die Blobs dead23 und feeb1e vom ersten zum zweiten Commit nicht geändert. Git erkennt, dass die IDs gleich geblieben sind, sodass sie direkt von dem neuen Baum cafed00d referenziert und benutzt werden können.
Darstellungen des Objektspeichers | 39
00___Git_945-8.book Seite 40 Donnerstag, 14. Januar 2010 2:25 14
V1.0
commit 11235
tag 2504624 commit 1492
author Jon L tree cafed00d parent 1492 Add a limerick
author Jon L tree 8675309
master
branch name
tree cafed00d
Initial commit
tree 8675309
tree 1010220 blob dead23 blob feeb1e
blob dead23 blob feeb1e
blob dead23
Four score and seven …
Mary had a little lamb …
blob feeb1e
tree 1010220 blob 1010b
There once was a man …
blob 1010b
Abbildung 4-2: Git-Objekte nach dem zweiten Commit
Achten Sie auf die Richtung der Pfeile zwischen den Commits. Das oder die Eltern-Commits kommen zeitlich früher. Deshalb verweist jedes Commit in der Git-Implementierung zurück auf sein(e) Eltern-Commit(s). Manche Leute verwirrt das, weil der Zustand eines Repository herkömmlicherweise in entgegengesetzter Richtung dargestellt wird: als Datenfluss vom Eltern-Commit zu den Kind-Commits. In Kapitel 6 werden wir diese Bilder erweitern, um zu zeigen, wie der Verlauf eines Repository aufgebaut und von den verschiedenen Befehlen manipuliert wird.
40 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 41 Donnerstag, 14. Januar 2010 2:25 14
Git-Konzepte am Werk Nachdem wir nun einige grundsätzliche Fragen geklärt haben, wollen wir uns anschauen, wie all diese Konzepte und Komponenten im Repository selbst zusammenpassen. Legen wir dazu ein neues Repository an und untersuchen die internen Dateien und den Objektspeicher ausführlicher.
Im .git-Verzeichnis Initialisieren Sie zu Beginn ein leeres Repository mit dem Befehl git init und führen Sie dann find aus, um festzustellen, was erzeugt wurde: $ mkdir /tmp/hello $ cd /tmp/hello $ git init Initialized empty Git repository in /tmp/hello/.git/ # Alle Dateien im aktuellen Verzeichnis auflisten $ find . . ./.git ./.git/hooks ./.git/hooks/commit-msg.sample ./.git/hooks/applypatch-msg.sample ./.git/hooks/pre-applypatch.sample ./.git/hooks/post-commit.sample ./.git/hooks/pre-rebase.sample ./.git/hooks/post-receive.sample ./.git/hooks/prepare-commit-msg.sample ./.git/hooks/post-update.sample ./.git/hooks/pre-commit.sample ./.git/hooks/update.sample ./.git/refs ./.git/refs/heads ./.git/refs/tags ./.git/config ./.git/objects ./.git/objects/pack ./.git/objects/info ./.git/description ./.git/HEAD ./.git/branches ./.git/info ./.git/info/exclude
Wie Sie sehen, enthält .git schon ziemlich viele Dinge. Alle Dateien basieren auf einem Template-Verzeichnis, das Sie gegebenenfalls anpassen können. Je nach Ihrer Git-Version sieht Ihre tatsächliche Liste ein wenig anders aus. Z.B. benutzen ältere Versionen von Git nicht das Suffix .sample bei den .git/hooks-Dateien.
Git-Konzepte am Werk | 41
00___Git_945-8.book Seite 42 Donnerstag, 14. Januar 2010 2:25 14
Im Allgemeinen müssen Sie die Dateien in .git nicht anschauen oder manipulieren. Diese »verborgenen« Dateien werden als Teil des Plumbing (quasi des Innenlebens) oder der Konfiguration von Git betrachtet. Git besitzt einige Plumbing-Befehle zum Verändern dieser verborgenen Dateien, die Sie aber nur selten benutzen werden. Zu Anfang ist das .git/objects-Verzeichnis (das Verzeichnis für alle Git-Objekte) leer, abgesehen von einigen Platzhaltern: $ find .git/objects .git/objects .git/objects/pack .git/objects/info
Wir wollen nun sorgfältig ein einfaches Objekt erzeugen: $ echo "hello world" > hello.txt $ git add hello.txt
Wenn Sie »hello world« genau so eingegeben haben, wie es hier gezeigt wird (ohne die Abstände oder die Groß- und Kleinschreibung zu ändern), dann sollte Ihr Objektverzeichnis nun so aussehen: $ find .git/objects .git/objects .git/objects/pack .git/objects/3b .git/objects/3b/18e512dba79e4c8300dd08aeb37f8e728b8dad .git/objects/info
Das sieht alles mysteriös aus, ist es aber nicht, wie in den folgenden Abschnitten erläutert wird.
Objekte, Hashes und Blobs Wenn Git ein Objekt für hello.txt anlegt, ist es ihm egal, dass der Dateiname hello.txt lautet. Git kümmert sich nur um das, was sich innerhalb der Datei befindet: die Folge von zwölf Bytes, die »hello world« wiedergeben, sowie das abschließende Newline-Zeichen (der gleiche Blob, der bereits früher erzeugt wurde). Git führt auf diesem Blob einige Operationen aus, berechnet seinen SHA1-Hash und gibt diesen als Datei in den Objektspeicher ein, deren Name die Hexadezimalrepräsentation des Hash ist. Der Hash lautet in diesem Fall 3b18e512dba79e4c8300dd08aeb37f8e728b8dad. Die 160 Bits eines SHA1-Hash entsprechen 20 Bytes, die eine 40 Byte lange Hexadezimalzahl für die Anzeige benötigen, sodass der Inhalt als .git/objects/3b/18e512dba79e4c8300dd08aeb3 7f8e728b8dad gespeichert wird. Git fügt nach den ersten beiden Stellen ein / ein, um die Effizienz des Dateisystems zu verbessern. (Manche Dateisysteme werden langsamer, wenn man zu viele Dateien in dasselbe Verzeichnis packt; indem man das erste Byte des SHA1 in ein Verzeichnis umwandelt, schafft man ganz leicht eine feste, 256-fache Partitionierung des Namensraums für alle möglichen Objekte bei gleichmäßiger Verteilung.)
42 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 43 Donnerstag, 14. Januar 2010 2:25 14
Woher wissen wir, dass ein SHA1-Hash eindeutig ist? Es besteht eine außerordentlich geringe Wahrscheinlichkeit, dass zwei unterschiedliche Blobs denselben SHA1-Hash ergeben. Dieser Fall wird als Kollision bezeichnet. Allerdings sind SHA1-Kollisionen derartig unwahrscheinlich, dass Sie sicher davon ausgehen können, dass Ihnen so etwas bei der Benutzung von Git niemals unterkommen wird. SHA1 ist ein kryptographisch sicherer Hash. Bisher ist keine Möglichkeit (abgesehen von schierem Glück) bekannt, mit der ein Benutzer absichtlich eine Kollision verursachen könnte. Aber was ist mit zufälligen Kollisionen? Schauen wir einmal. Bei 160 Bits haben Sie 2160 oder etwa 1048 (1 mit 48 Nullen dahinter) mögliche SHA1Hashes. Diese Zahl ist einfach unglaublich riesig. Selbst wenn Sie eine Billion Leute anheuern, die eine Billion Jahre lang pro Sekunde eine Billion neuer, eindeutiger Blobs erzeugen, hätten Sie immer noch erst 1043 Blobs. Falls Sie für 280 zufällige Blobs Hash-Werte erzeugen, könnten Sie eine Kollision finden. Vertrauen Sie nicht uns. Lesen Sie Bruce Schneier.
Um zu zeigen, dass Git wirklich nichts mit dem Inhalt der Datei angestellt hat (es ist immer noch das vertraute »hello world«), können Sie den Hash benutzen, um die Datei wieder aus dem Objektspeicher herauszuholen: $ git cat-file -p 3b18e512dba79e4c8300dd08aeb37f8e728b8dad hello world
Git weiß auch, dass es ein wenig riskant ist, 40 Zeichen von Hand einzutippen, und bietet deshalb einen Befehl an, mit dem man Objekte anhand eines eindeutigen Präfix des Objekt-Hash abfragen kann: $ git rev-parse 3b18e512d 3b18e512dba79e4c8300dd08aeb37f8e728b8dad
Dateien und Bäume Was passiert mit dem Dateinamen des »hello world«-Blobs, nachdem wir ihn sicher im Objektspeicher verstaut haben? Git wäre nicht besonders nützlich, wenn es Dateien nicht anhand ihres Namens suchen könnte. Wie bereits erwähnt, überwacht Git die Pfadnamen der Dateien mithilfe einer anderen Art von Objekt namens Baum. Wenn man git add ausführt, erzeugt Git für den Inhalt aller Dateien, die man hinzufügt, jeweils ein Objekt; allerdings legt es für den Baum nicht gleich ein Objekt an. Stattdessen aktualisiert es den Index. Der Index befindet sich in .git/ index und verfolgt die Dateipfadnamen und die dazugehörenden Blobs. Immer wenn man Befehle wie git add, git rm oder git mv ausführt, aktualisiert Git den Index mit dem neuen Pfadnamen und den Blob-Informationen.
Git-Konzepte am Werk | 43
00___Git_945-8.book Seite 44 Donnerstag, 14. Januar 2010 2:25 14
Sie können zu einem beliebigen Zeitpunkt ein Baumobjekt aus Ihrem aktuellen Index erzeugen, indem Sie mit dem einfachen Befehl git write-tree einen Schnappschuss seiner aktuellen Informationen aufnehmen. Im Moment enthält der Index exakt eine Datei, hello.txt: $ git ls-files -s 100644 3b18e512dba79e4c8300dd08aeb37f8e728b8dad 0
hello.txt
Hier können Sie die Verknüpfung zwischen der Datei hello.txt und dem Blob 3b18e5... sehen. Als Nächstes wollen wir den Zustand des Index erfassen und in einem Baumobjekt speichern: $ git write-tree 68aba62e560c0ebc3396e8ae9335232cd93a3f60 $ find .git/objects .git/objects .git/objects/68 .git/objects/68/aba62e560c0ebc3396e8ae9335232cd93a3f60 .git/objects/pack .git/objects/3b .git/objects/3b/18e512dba79e4c8300dd08aeb37f8e728b8dad .git/objects/info
Jetzt gibt es hier zwei Objekte: das »hello world«-Objekt unter 3b18e5 und ein neues, das Baumobjekt, unter 68aba6. Wie Sie sehen, entspricht der SHA1-Objektname exakt dem Unterverzeichnis und dem Dateinamen in .git/objects. Aber wie sieht ein Baum aus? Da er genau wie der Blob ein Objekt ist, können Sie zum Anschauen den gleichen einfachen Befehl benutzen: $ git cat-file -p 68aba6 100644 blob 3b18e512dba79e4c8300dd08aeb37f8e728b8dad
hello.txt
Der Inhalt des Objekts sollte sich leicht interpretieren lassen. Die erste Zahl, 100644, repräsentiert die Dateiattribute in Oktalschreibweise, was jedem vertraut sein dürfte, der schon einmal den Unix-Befehl chmod verwendet hat. 3b18e5 ist hier der Objektname des »hello world«-Blobs, und hello.txt ist der Name, der mit diesem Blob verknüpft ist. Es lässt sich leicht feststellen, dass das Baumobjekt die Informationen erfasst hat, die sich im Index befanden, als Sie git ls-files -s ausführten.
Ein Hinweis zur Verwendung von SHA1 durch Git Bevor wir uns den Inhalt des Baumobjekts genauer anschauen, wollen wir eine wichtige Eigenschaft von SHA1-Hashes untersuchen: $ git write-tree 68aba62e560c0ebc3396e8ae9335232cd93a3f60
44 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 45 Donnerstag, 14. Januar 2010 2:25 14
$ git write-tree 68aba62e560c0ebc3396e8ae9335232cd93a3f60 $ git write-tree 68aba62e560c0ebc3396e8ae9335232cd93a3f60
Jedes Mal, wenn Sie ein anderes Baumobjekt für den gleichen Index berechnen, erhalten Sie den exakt gleichen SHA1-Hash. Git muss kein neues Baumobjekt erstellen. Falls Sie diese Schritte an Ihrem Computer nachvollziehen, sollten Ihre SHA1-Hash-Werte exakt mit den Werten in diesem Buch übereinstimmen. In dieser Hinsicht ist die Hash-Funktion eine echte Funktion in mathematischem Sinn: Sie erzeugt für eine bestimmte Eingabe immer dieselbe Ausgabe. So eine Hash-Funktion wird manchmal als Digest bezeichnet, um die Tatsache zu betonen, dass sie als eine Art Zusammenfassung für das als Hash berechnete Objekt dient. Natürlich besitzt jede Hash-Funktion, selbst das bescheidene Paritätsbit, diese Eigenschaft. Das ist außerordentlich wichtig. Falls Sie z.B. genau den gleichen Inhalt erschaffen wie ein anderer Entwickler, dann ist ein identischer Hash Beweis genug, dass der komplette Inhalt identisch ist, unabhängig davon, wo oder wann Sie beide gearbeitet haben. Zumindest behandelt Git sie als identisch. Aber warten Sie – sind SHA1-Hash-Werte denn nicht eindeutig? Was ist mit der Billion Leute und der Billion Blobs pro Sekunde geschehen, die niemals eine Kollision verursachen? Diese Frage sorgt üblicherweise für Verwirrung unter neuen Git-Benutzern. Lesen Sie deshalb aufmerksam weiter, denn wenn Sie diesen Unterschied verstehen, ist alles andere in diesem Kapitel einfach. Identische SHA1-Hash-Werte zählen in diesem Fall nicht als Kollision. Es wäre nur dann eine Kollision, wenn zwei unterschiedliche Objekte den gleichen Hash erzeugen würden. Hier haben Sie zwei separate Instanzen des gleichen Inhalts hergestellt, und gleicher Inhalt besitzt immer gleiche Hash-Werte. Git ist von einer weiteren Folge der SHA1-Hash-Funktion abhängig: Es spielt keine Rolle, wie Sie einen Baum namens 68aba62e560c0ebc3396e8ae9335232cd93a3f60 bekommen haben. Wenn Sie ihn haben, können Sie sich ganz sicher darauf verlassen, dass alle anderen Leser dieses Buches ihn auch haben. Bob hat ihn möglicherweise erzeugt, indem er die Commits A und B von Jennie mit dem Commit C von Sergey kombiniert hat, während Sie Commit A von Sue und ein Update von Lakshmi erhalten haben, die die Commits B und C kombiniert hat. Die Ergebnisse sind identisch, und das ermöglicht und erleichtert die verteilte Entwicklung. Wenn Sie Objekt 68aba62e560c0ebc3396e8ae9335232cd93a3f60 suchen und es finden können, dann können Sie sich sicher sein, dass Sie genau die Daten vor sich haben, aus denen der Hash erzeugt wurde (weil SHA1 ein kryptographischer Hash ist). Auch das Gegenteil gilt: Falls Sie ein Objekt mit einem bestimmten Hash nicht in Ihrem Objektspeicher finden, dann können Sie sicher sein, dass Sie keine Kopie von genau diesem Objekt besitzen.
Git-Konzepte am Werk | 45
00___Git_945-8.book Seite 46 Donnerstag, 14. Januar 2010 2:25 14
Das bedeutet, dass Sie feststellen können, ob Ihr Objektspeicher ein bestimmtes Objekt enthält oder nicht, obwohl Sie nichts über seinen (potenziell sehr großen) Inhalt wissen. Der Hash dient daher als zuverlässiges »Label« oder als Name für das Objekt. Git verlässt sich allerdings auch noch auf etwas Stärkeres als diese Schlussfolgerung. Betrachten Sie das neueste Commit (oder sein verknüpftes Baumobjekt). Da es als Teil seines Inhalts den Hash seines Eltern-Commit und seines Baums enthält, und da dieser wiederum den Hash all seiner Teilbäume und Blobs enthält, und zwar rekursiv durch die gesamte Datenstruktur, folgt also durch Induktion, dass der Hash des ursprünglichen Commit eindeutig den Zustand der gesamten Datenstruktur identifiziert, die in diesem Commit wurzelt. Die Implikationen meiner Behauptung aus dem vorhergehenden Absatz führen schließlich zu einer leistungsstarken Anwendung der Hash-Funktion: Sie bietet eine effiziente Möglichkeit, zwei Objekte, selbst zwei sehr große und komplexe Datenstrukturen, miteinander zu vergleichen, ohne beide vollständig zu übertragen2.
Baumhierarchien Es ist ja ganz nett, wenn man Informationen hat, die eine einzige Datei betreffen, wie wir im vorangegangenen Abschnitt gezeigt haben, allerdings enthalten Projekte komplexe, tief verschachtelte Verzeichnisse, die im Laufe der Zeit umstrukturiert und verschoben werden. Wir wollen uns anschauen, wie Git damit zurechtkommt, indem wir ein neues Unterverzeichnis anlegen, das eine identische Kopie der Datei hello.txt enthält: $ pwd /tmp/hello $ mkdir subdir $ cp hello.txt subdir/ $ git add subdir/hello.txt $ git write-tree 492413269336d21fac079d4a4672e55d5d2147ac $ git cat-file -p 4924132693 100644 blob 3b18e512dba79e4c8300dd08aeb37f8e728b8dad 040000 tree 68aba62e560c0ebc3396e8ae9335232cd93a3f60
hello.txt subdir
Der neue oberste Baum enthält zwei Elemente: die ursprüngliche hello.txt-Datei sowie das neue subdir-Verzeichnis, das vom Typ tree und nicht vom Typ blob ist. Bemerken Sie etwas Ungewöhnliches? Schauen Sie sich den Objektnamen von subdir genauer an. Es ist unser alter Freund 68aba62e560c0ebc3396e8ae9335232cd93a3f60! Was ist da gerade passiert? Der neue Baum für subdir enthält nur eine Datei, hello.txt, und diese Datei enthält das gleiche alte »hello world«. Der subdir-Baum ist also identisch
2
Diese Datenstruktur wird in »Commit-Graphen« auf Seite 81 genauer behandelt.
46 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 47 Donnerstag, 14. Januar 2010 2:25 14
mit dem älteren obersten Baum! Und natürlich trägt er denselben SHA1-Objektnamen wie zuvor. Schauen wir uns das Verzeichnis .git/objects an und stellen fest, was die neueste Änderung beeinflusst hat: $ find .git/objects .git/objects .git/objects/49 .git/objects/49/2413269336d21fac079d4a4672e55d5d2147ac .git/objects/68 .git/objects/68/aba62e560c0ebc3396e8ae9335232cd93a3f60 .git/objects/pack .git/objects/3b .git/objects/3b/18e512dba79e4c8300dd08aeb37f8e728b8dad .git/objects/info
Es gibt immer noch nur drei eindeutige Objekte: einen Blob, der »hello world« enthält, einen Baum, der hello.txt enthält, das wiederum den Text »hello world« sowie ein Newline-Zeichen enthält, und einen zweiten Baum, der eine weitere Referenz auf hello.txt zusammen mit dem ersten Baum enthält.
Commits Das nächste Objekt, das wir hier besprechen wollen, ist das Commit. Nachdem hello.txt mit git add hinzugefügt wurde und mit git write-tree das Baumobjekt erzeugt wurde, können Sie mit einfachen Befehlen ein Commit-Objekt herstellen: $ echo -n "Bestaetige eine Datei, die hello sagt\n" \ | git commit-tree 492413269336d21fac079d4a4672e55d5d2147ac 3ede4622cc241bcb09683af36360e7413b9ddf6c
Das sieht dann in etwa so aus: $ git cat-file -p 3ede462 author Jon Loeliger <[email protected]> 1220233277 -0500 committer Jon Loeliger <[email protected]> 1220233277 -0500 Bestaetige eine Datei, die hello sagt
Wenn Sie diesen Schritt auf Ihrem Computer ebenfalls vollzogen haben, dann haben Sie wahrscheinlich festgestellt, dass das generierte Commit-Objekt nicht den gleichen Namen trägt wie in diesem Buch. Falls Sie alles bisher verstanden haben, sollte Ihnen der Grund dafür klar sein: Es ist nicht das gleiche Commit. Das Commit enthält Ihren Namen sowie den Zeitpunkt, zu dem Sie das Commit ausgeführt haben, weshalb es sich natürlich unterscheidet, wenn auch nur leicht. Andererseits hat Ihr Commit den gleichen Baum. Deshalb sind Commit-Objekte getrennt von ihren Baumobjekten: Unterschiedliche Commits beziehen sich oft auf exakt denselben Baum. In diesem Fall ist Git schlau genug, um nur das neue Commit-Objekt zu übertragen – das winzig ist –, anstatt die Baum- und Blob-Objekte anzufassen, die wahrscheinlich viel größer sind.
Git-Konzepte am Werk | 47
00___Git_945-8.book Seite 48 Donnerstag, 14. Januar 2010 2:25 14
Im echten Leben können (und sollten!) Sie die git write-tree- und git commit-treeSchritte auslassen und nur den Befehl git commit benutzen. Sie müssen sich diese ganzen Plumbing-Befehle nicht merken, um ein absolut zufriedener Git-Benutzer zu werden. Ein grundlegendes Commit-Objekt ist ziemlich einfach und stellt die letzte Zutat für ein echtes Revisionskontrollsystem dar. Das gerade gezeigte Commit-Objekt ist das einfachste Commit-Objekt, das möglich ist. Es enthält • den Namen eines Baumobjekts, das die damit verknüpften Dateien wirklich identifiziert, • den Namen der Person, die die neue Version zusammengestellt hat (den Autor), sowie den Zeitpunkt, zu dem dies geschehen ist, • den Namen der Person, die die neue Version in das Repository gesetzt hat (den Committer), sowie den Zeitpunkt, zu dem dies geschehen ist, und • eine Beschreibung des Grundes für diese Revision (die Commit-Nachricht). Autor und Committer sind standardmäßig identisch; es kommt nur gelegentlich vor, dass sie sich unterscheiden. Mit dem Befehl git show --pretty=fuller können Sie sich zusätzliche Details zu einem bestimmten Commit anschauen.
Commit-Objekte werden ebenfalls in einer Graphenstruktur gespeichert, auch wenn sich diese völlig von den Strukturen unterscheidet, die von den Baumobjekten verwendet werden. Wenn Sie ein neues Commit ausführen, können Sie ihm ein oder mehrere ElternCommits zuweisen. Indem Sie dann die Kette der Eltern zurückverfolgen, erschließt sich Ihnen der Verlauf Ihres Projekts. Nähere Informationen über Commits und den CommitGraphen erhalten Sie in Kapitel 6.
Tags Das letzte Objekt schließlich, das Git verwaltet, ist das Tag (Markierung). Git implementiert nur eine Art von Tag-Objekt, allerdings gibt es zwei grundlegende Tag-Typen, die normalerweise als leicht (lightweight) und kommentiert (annotated) bezeichnet werden. Leichte Tags sind einfach Referenzen auf ein Commit-Objekt. Normalerweise werden sie als Repository-eigen betrachtet. Diese Tags erzeugen kein dauerhaftes Objekt im Objektspeicher. Ein kommentiertes Tag ist umfassender und erzeugt ein Objekt. Es enthält eine Nachricht, die Sie angeben, und kann mit einem GnuPG-Schlüssel entsprechend RFC4880 digital unterzeichnet werden.
48 | Kapitel 4: Grundlegende Git-Konzepte
00___Git_945-8.book Seite 49 Donnerstag, 14. Januar 2010 2:25 14
Git behandelt beim Benennen eines Commit leichte und kommentierte Tag-Namen äquivalent. Allerdings funktionieren viele Git-Befehle standardmäßig nur mit kommentierten Tags, da sie als »dauerhafte« Objekte angesehen werden. Sie erzeugen ein kommentiertes, unsigniertes Tag mit einer Nachricht auf einem Commit mit dem Befehl git tag: $ git tag -m"Tag version 1.0" V1.0 3ede462
Sie können das Tag-Objekt mithilfe des Befehls git cat-file -p sehen, aber wie lautet der SHA1 des Tag-Objekts? Um ihn herauszufinden, greifen Sie auf den Tipp aus »Objekte, Hashes und Blobs« auf Seite 42 zurück. $ git rev-parse V1.0 6b608c1093943939ae78348117dd18b1ba151c6a $ git cat-file -p 6b608c object 3ede4622cc241bcb09683af36360e7413b9ddf6c type commit tag V1.0 tagger Jon Loeliger <[email protected]> Sun Oct 26 17:07:15 2008 -0500 Tag version 1.0
Neben der Lognachricht und der Autoreninformation bezieht sich das Tag auf das Commit-Objekt 3ede462. Normalerweise markiert Git ein bestimmtes Commit mit einem Tag, das sich von einem Zweig herleitet. Dieses Verhalten unterscheidet sich deutlich von dem anderer VCS. Meist markiert Git ein Commit-Objekt, das auf ein Baumobjekt veweist, das den Gesamtzustand der kompletten Hierarchie der Dateien und Verzeichnisse in Ihrem Repository umfasst. Erinnern Sie sich an Abbildung 4-1: Das Tag V1.0 verweist auf das Commit namens 1492, das wiederum auf einen Baum (8675309) zeigt, der sich über mehrere Dateien erstreckt. Daher gilt das Tag gleichzeitig für alle Dateien dieses Baums. Das ist ganz anders als z.B. bei CVS, das ein Tag auf jede einzelne Datei anwendet und sich dann darauf verlässt, dass die Sammlung all dieser markierten Dateien eine komplette markierte Revision wiederherstellt. Und während CVS Ihnen erlaubt, das Tag auf einer Datei zu verschieben, verlangt Git ein neues Commit, das die Änderung des Dateizustands auslöst, woraufhin das Tag verschoben wird.
Git-Konzepte am Werk | 49
00___Git_945-8.book Seite 50 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 51 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 5
KAPITEL 5
Dateiverwaltung und der Index
Wenn Ihr Projekt dann unter dem Dach eines Versionskontrollsystems angekommen ist, arbeiten Sie in Ihrem Arbeitsverzeichnis und legen Ihre Änderungen zur Sicherung in das Repository. Git funktioniert ähnlich, schiebt aber noch eine weitere Ebene, nämlich den Index, zwischen das Arbeitsverzeichnis und das Repository, um die Änderungen bereitzustellen oder zu sammeln. Wenn Sie Ihren Code mit Git verwalten, arbeiten Sie im Arbeitsverzeichnis, sammeln die Änderungen im Index und übertragen dann mit einem Commit all das, was sich im Index angehäuft hat, in einem Schwung in das Repository. Stellen Sie sich den Index von Git als eine Menge geplanter oder voraussichtlicher Modifikationen vor. Sie fügen Dateien hinzu und entfernen, verschieben oder bearbeiten sie wiederholt, bis es schließlich zum Commit kommt, das die gesammelten Änderungen dann in das Repository überträgt. Der Großteil der wichtigen Arbeit geht dem eigentlichen Commit-Schritt voran. Merken Sie sich, dass ein Commit ein zweiteiliger Vorgang ist: Bereitstellen der Änderungen und Bestätigen der Änderungen. Eine Änderung, die zwar im Arbeitsverzeichnis zu finden ist, aber nicht im Index, ist nicht bereitgestellt und kann daher nicht bestätigt werden. Aus Gründen der Bequemlichkeit erlaubt Ihnen Git, die beiden Schritte zu kombinieren, wenn Sie eine Datei hinzufügen oder ändern: $ git commit index.html
Diesen Luxus genießen Sie allerdings nicht, wenn Sie eine Datei verschieben oder entfernen. Die beiden Schritte müssen dann getrennt werden: $ git rm index.html $ git commit
Dieses Kapitel1 erklärt, wie Sie den Index und Ihre Sammlung von Dateien verwalten. Es beschreibt, wie Sie eine Datei zu Ihrem Repository hinzufügen und aus ihm entfernen, 1
Ich weiß aus zuverlässiger Quelle, dass dieses Kapitel eigentlich Alles, was Bart Massey an Git hasst heißen sollte.
| 51
00___Git_945-8.book Seite 52 Donnerstag, 14. Januar 2010 2:25 14
wie Sie eine Datei umbenennen und wie Sie den Zustand des Index katalogisieren. Am Ende dieses Kapitels wird Ihnen gezeigt, wie Sie Git dazu bringen, temporäre und andere irrelevante Dateien zu ignorieren, die nicht der Versionskontrolle unterstellt werden müssen.
Es geht um den Index Linus Torvalds hat auf der Git-Mailingliste angeführt, dass man die Stärke von Git nicht begreifen und richtig schätzen kann, wenn man vorher nicht den Sinn des Index verstanden hat. Gits Index enthält keinen Dateiinhalt; er verfolgt einfach, was Sie mit Commits bestätigen wollen. Wenn man git commit ausführt, überprüft Git nicht das Arbeitsverzeichnis, sondern den Index, um festzustellen, was bestätigt werden soll. (Commits werden in Kapitel 6 ausführlich behandelt.) Auch wenn viele der höheren Befehle von Git die Einzelheiten des Index vor Ihnen verbergen und Ihnen die Arbeit erleichtern sollen, müssen Sie den Index und seinen Zustand im Auge behalten. Sie können den Zustand des Index jederzeit mit git status abfragen. Der Befehl sucht ausdrücklich die Dateien heraus, die Git als bereitgestellt betrachtet. Mit »Plumbing«-Befehlen wie git ls-files können Sie außerdem den internen Zustand von Git untersuchen. Wahrscheinlich werden Sie während der Bereitstellung den Befehl git diff recht nützlich finden. (Diffs werden ausführlich in Kapitel 8 besprochen.) Dieser Befehl kann zwei unterschiedliche Gruppen von Änderungen anzeigen: git diff zeigt diejenigen Änderungen an, die in Ihrem Arbeitsverzeichnis verbleiben und nicht bereitgestellt werden, und git diff --cached zeigt diejenigen an, die bereitgestellt und daher beim nächsten Commit verarbeitet werden. Sie können sich von beiden git diff-Varianten durch den Prozess des Bereitstellens von Änderungen leiten lassen. Zu Anfang stellt git diff eine große Menge mit allen Modifikationen dar, --cached dagegen ist leer. Wenn Sie Änderungen für das Commit bereitstellen, verkleinert sich die erste Menge, und die zweite wächst an. Sobald alle Änderungen bereitgestellt sind und auf das Commit warten, ist --cached voll, und git diff zeigt nichts mehr an.
Dateiklassifikationen in Git Git teilt Ihre Dateien in drei Gruppen ein: Tracked (verfolgt) Verfolgte Dateien sind alle Dateien, die sich bereits im Repository befinden, oder alle Dateien, die im Index bereitgestellt wurden. Um eine neue Datei, eineDatei, zu dieser Gruppe hinzuzufügen, führen Sie git add eineDatei aus.
52 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 53 Donnerstag, 14. Januar 2010 2:25 14
Ignored (ignoriert) Eine ignorierte Datei muss im Repository ausdrücklich als »invisible« oder »ignored« deklariert werden, auch wenn sie in Ihrem Arbeitsverzeichnis vorhanden ist. In einem Softwareprojekt gibt es mit der Zeit meist eine ganze Menge an ignorierten Dateien. Dazu gehören u. a. temporäre Dateien, Arbeitsdateien, persönliche Notizen, Compiler-Ausgaben und die meisten Dateien, die beim Kompilieren automatisch generiert werden. Git pflegt eine vorgegebene Liste mit zu ignorierenden Dateien, und Sie können Ihr Repository dann so konfigurieren, dass es weitere erkennt. Ignorierte Dateien werden in »Die Datei .gitignoreT« auf Seite 63 ausführlich besprochen. Untracked (nicht verfolgt) Eine nicht verfolgte Datei ist jede Datei, die nicht in einer der zwei genannten Kategorien zu finden ist. Git betrachtet alle Dateien in Ihrem Arbeitsverzeichnis und zieht sowohl die verfolgten als auch die ignorierten Dateien ab, um die Dateien zu erhalten, die als nicht verfolgt gelten. Wir wollen die unterschiedlichen Kategorien von Dateien untersuchen, indem wir ein brandneues Arbeitsverzeichnis sowie ein Repository anlegen und dann mit einigen Dateien arbeiten: $ cd /tmp/my_stuff $ git init $ git status # On branch master # # Initial commit # nothing to commit (create/copy files and use "git add" to track) $ echo "Neue Daten" > daten $ git status # On branch master # # Initial commit # # Untracked files: # (use "git add ..." to include in what will be committed) # # daten nothing added to commit but untracked files present (use "git add" to track)
Zu Anfang gibt es noch keine Dateien, und die verfolgten, ignorierten und nicht verfolgten Mengen sind leer. Nachdem Sie daten erzeugt haben, zeigt git status eine einzelne, nicht verfolgte Datei an. Editoren und Build-Umgebungen hinterlassen oft temporäre oder flüchtige Dateien in Ihrem Quellcode. Solche Dateien sollen gewöhnlich nicht als »Quelldateien« in einem
Dateiklassifikationen in Git
| 53
00___Git_945-8.book Seite 54 Donnerstag, 14. Januar 2010 2:25 14
Repository verfolgt werden. Damit Git eine Datei in einem Verzeichnis ignoriert, fügen Sie den Namen dieser Datei einfach der speziellen Datei .gitignore hinzu: # Manuelles Erzeugen einer Beispieldatei zum Ignorieren $ touch main.o $ # # # # # # # # #
git status On branch master Initial commit Untracked files: (use "git add ..." to include in what will be committed) daten main.o
$ echo main.o >> .gitignore $ # # # # # # # # #
git status On branch master Initial commit Untracked files: (use "git add ..." to include in what will be committed) .gitignore daten
main.o wird also ignoriert, git status zeigt nun aber eine neue, nicht verfolgte Datei namens .gitignore. Die Datei .gitignore hat zwar für Git eine besondere Bedeutung, wird aber wie jede andere normale Datei in Ihrem Repository verwaltet. Bis .gitignore hinzugefügt wird, betrachtet Git sie als nicht verfolgt. In den nächsten Abschnitten demonstrieren wir, wie sich der Verfolgungsstatus einer Datei ändern lässt und wie man eine Datei zum Index hinzufügt bzw. aus ihm entfernt.
git add benutzen Der Befehl git add stellt eine Datei bereit. Im Hinblick auf die Git-Dateiklassifikation ist es so, dass git add den Status der Datei auf verfolgt setzt, wenn sie bisher nicht den Status verfolgt hatte. Wird git add auf einem Verzeichnisnamen eingesetzt, dann werden alle Dateien und Unterverzeichnisse in diesem Verzeichnis rekursiv bereitgestellt. Betrachten wir wieder unser Beispiel aus dem vorangegangenen Abschnitt: $ git status # On branch master # # Initial commit #
54 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 55 Donnerstag, 14. Januar 2010 2:25 14
# Untracked files: # (use "git add ..." to include in what will be committed) # # .gitignore # daten # Beide neuen Dateien verfolgen. $ git add data .gitignore $ # # # # # # # # # #
git status On branch master Initial commit Changes to be committed: (use "git rm --cached ..." to unstage) new file: .gitignore new file: daten
Das erste git status zeigt Ihnen, dass zwei Dateien nicht verfolgt werden, und erinnert Sie daran, dass Sie nur git add ausführen müssen, um eine Datei zu verfolgen. Nach git add sind daten und .gitignore bereitgestellt und verfolgt und können mit dem nächsten Commit in das Repository eingefügt werden. In Bezug auf das Git-Objektmodell verhält es sich folgendermaßen: In dem Augenblick, in dem Sie git add ausführen, wird die Datei komplett in den Objektspeicher kopiert und mit ihrem resultierenden SHA1-Namen indiziert. Zum Bereitstellen einer Datei sagt man auch »Caching einer Datei«2 oder »eine Datei in den Index setzen«. Mit git ls-files können Sie dem Objektmodell unter die Haube schauen und die SHA1Werte für diese bereitgestellten Dateien ermitteln: $ git ls-files --stage 100644 0487f44090ad950f61955271cf0a2d6c6a83ad9a 0 100644 534469f67ae5ce72a7a274faf30dee3c2ea1746d 0
.gitignore daten
Bei den meisten der täglichen Änderungen innerhalb Ihres Repository wird es sich wahrscheinlich um einfache Bearbeitungen handeln. Nach dem Bearbeiten und vor dem Bestätigen der Änderungen mit Commit führen Sie git add aus, um den Index mit der absolut neuesten und tollsten Version Ihrer Datei zu aktualisieren. Wenn Sie das versäumen, werden Sie zwei unterschiedliche Versionen der Datei haben: eine, die im Objektspeicher erfasst und vom Index referenziert ist, und die andere in Ihrem Arbeitsverzeichnis. Um mit dem Beispiel fortzufahren, ändern wir nun die Datei daten, damit sie sich von der Version im Index unterscheidet, und benutzen den geheimnisvollen Befehl git hashobject Datei (den Sie nur äußerst selten direkt aufrufen werden), um den SHA1-Hash für die neue Version direkt zu berechnen und auszugeben: 2
Sie haben --cached in der git status-Ausgabe gesehen, oder?
git add benutzen
| 55
00___Git_945-8.book Seite 56 Donnerstag, 14. Januar 2010 2:25 14
$ git ls-files --stage 100644 0487f44090ad950f61955271cf0a2d6c6a83ad9a 0 100644 534469f67ae5ce72a7a274faf30dee3c2ea1746d 0
.gitignore daten
# Bearbeiten von "daten" ... $ cat daten Neue Daten Und weitere Daten $ git hash-object daten e476983f39f6e4f453f0fe4a859410f63b58b500
Nachdem die Datei ergänzt wurde, besitzt die vorherige Version der Datei im Objektspeicher und im Index den SHA1-Wert 534469f67ae5ce72a7a274faf30dee3c2ea1746d. Die aktualisierte Version der Datei jedoch besitzt den SHA1-Wert e476983f39f6e4f453f0fe4a 859410f63b58b500. Wir ändern nun den Index, damit er ebenfalls die neue Version enthält: $ git add daten $ git ls-files --stage 100644 0487f44090ad950f61955271cf0a2d6c6a83ad9a 0 100644 e476983f39f6e4f453f0fe4a859410f63b58b500 0
.gitignore daten
Der Index enthält nun die aktualisierte Version der Datei. Das heißt, »Die Datei daten wurde bereitgestellt« oder lässig ausgedrückt: »Die Datei daten ist im Index«. Die zweite Wendung ist nicht ganz akkurat, weil die Datei sich eigentlich im Objektspeicher befindet und der Index lediglich darauf verweist. Das scheinbar nutzlose Spiel mit SHA1-Hashes und dem Index bringt uns auf einen wesentlichen Punkt: Stellen Sie sich git add nicht als »Füge diese Datei hinzu« vor, sondern eher als »Füge diesen Inhalt hinzu«. Auf jeden Fall müssen Sie sich merken, dass die Version der Datei in Ihrem Arbeitsverzeichnis nicht unbedingt synchron mit der Version sein muss, die im Index bereitgestellt wird. Wenn es Zeit für das Commit wird, greift Git auf die Version im Index zurück. Die Option --interactive für git add bzw. git commit kann Ihnen gute Dienste leisten, wenn Sie untersuchen wollen, welche Dateien Sie für ein Commit bereitstellen wollen.
Einige Hinweise zur Benutzung von git commit git commit --all benutzen Die Option -a oder --all für git commit sorgt dafür, dass automatisch alle nicht bereitgestellten, verfolgten Dateiänderungen bereitgestellt werden – einschließlich der Löschungen verfolgter Dateien aus der Arbeitskopie –, bevor das Commit ausführt wird.
56 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 57 Donnerstag, 14. Januar 2010 2:25 14
Wir wollen uns anschauen, wie das funktioniert, indem wir einige Dateien mit unterschiedlichen Bereitstellungseigenschaften einrichten: # Die Datei "fertig" bearbeiten und mit "git add" zum Index hinzufügen # edit fertig $ git add fertig # Die Datei "nochnicht" bearbeiten und nicht bereitstellen # edit nochnicht # Eine neue Datei in ein Unterverzeichnis einfügen, aber nicht in den Index einfügen $ mkdir subdir $ echo Nope >> subdir/neu
Schauen Sie sich mit git status an, was ein normales Commit (ohne Kommandozeilenoptionen) tun würde: $ # # # # # # # # # # # # # # #
git status On branch master Changes to be committed: (use "git reset HEAD ..." to unstage) modified:
fertig
Changed but not updated: (use "git add ..." to update what will be committed) modified:
nochnicht
Untracked files: (use "git add ..." to include in what will be committed) subdir/
Der Index ist hier nur darauf vorbereitet, die Datei namens fertig mit dem Commit zu bestätigen, da es die einzige Datei ist, die bereitgestellt wurde. Falls Sie jedoch git commit --all ausführen, durchläuft Git rekursiv das gesamte Repository, stellt alle bekannten veränderten Dateien bereit und bestätigt sie. Wenn Ihnen in diesem Fall Ihr Editor das Template der Commit-Nachricht präsentiert, sollte zu erkennen sein, dass die geänderte und bekannte Datei nochnicht ebenfalls bestätigt wird: # # # # # # # # # # # # #
Please enter the commit message for your changes. (Comment lines starting with '#' will not be included) On branch master Changes to be committed: (use "git reset HEAD ..." to unstage) modified: modified:
nochnicht fertig
Untracked files: (use "git add ..." to include in what will be committed) subdir/
Einige Hinweise zur Benutzung von git commit | 57
00___Git_945-8.book Seite 58 Donnerstag, 14. Januar 2010 2:25 14
Und da schließlich das Verzeichnis namens subdir neu ist und kein Dateiname oder Pfad darin verfolgt wird, kann nicht einmal die Option --all veranlassen, dass es bestätigt wird: Created commit db7de5f: Ein --all-Ding. 2 files changed, 2 insertions(+), 0 deletions(-)
Git durchläuft zwar rekursiv das Repository und sucht nach geänderten und gelöschten Dateien, das völlig neue Verzeichnis subdir/ mit all seinen Dateien wird jedoch nicht zu einem Bestandteil des Commit.
Commit-Lognachrichten schreiben Falls Sie nicht direkt auf der Kommandozeile eine Lognachricht angeben, startet Git einen Editor und fordert Sie auf, eine Nachricht zu schreiben. Welcher Editor gewählt wird, steht in Ihrer Konfiguration, wie in »Konfigurationsdateien« auf Seite 28 beschrieben ist. Wenn Sie gerade im Editor eine Commit-Lognachricht schreiben und aus irgendwelchen Gründen beschließen, die Operation abzubrechen, dann beenden Sie einfach den Editor, ohne zu speichern. Sie erhalten eine leere Lognachricht. Ist es dazu zu spät, weil Sie bereits gespeichert haben, dann löschen Sie einfach die gesamte Lognachricht und speichern Sie noch einmal. Git verarbeitet ein leeres Commit (ohne Text) nicht.
git rm benutzen Der Befehl git rm ist natürlich das Gegenteil von git add. Er löscht eine Datei sowohl aus dem Repository als auch aus dem Arbeitsverzeichnis. Da das Löschen einer Datei jedoch problematischer sein könnte (falls etwas schiefgeht) als das Hinzufügen einer Datei, geht Git beim Löschen einer Datei etwas sorgfältiger zu Werke. Git löscht eine Datei entweder aus dem Index oder aus dem Index und dem Arbeitsverzeichnis gleichzeitig. Git löscht eine Datei niemals nur aus dem Arbeitsverzeichnis; für diesen Zweck muss der normale rm-Befehl benutzt werden. Beim Löschen einer Datei aus Ihrem Verzeichnis sowie aus dem Index wird der Verlauf der Datei nicht aus dem Repository entfernt. Alle Versionen der Datei, die Teil des Verlaufs sind, der bereits im Repository bestätigt ist, bleiben im Objektspeicher und tragen zu diesem Verlauf bei. Wir wollen nun in Fortführung unseres Beispiels eine »versehentlich« hinzugefügte Datei einführen, die nicht bereitgestellt und irgendwie entfernt werden soll: $ echo "Kram" > oops # Can't "git rm" files Git considers "other" # This should be just "rm oops" $ git rm oops fatal: pathspec 'oops' did not match any files
58 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 59 Donnerstag, 14. Januar 2010 2:25 14
Da git rm ebenfalls eine Operation auf dem Index ist, funktioniert der Befehl nicht mit einer Datei, die nicht zuvor dem Repository oder dem Index hinzugefügt wurde; Git muss eine Datei zuerst erkennen. Wir wollen deshalb die Datei oops aus Versehen bereitstellen: # Versehentlich die Datei "oops" bereitstellen $ git add oops $ # # # # # # # # # # #
git status On branch master Initial commit Changes to be committed: (use "git rm --cached ..." to unstage) new file: .gitignore new file: daten new file: oops
Um eine bereitgestellte Datei in eine nicht bereitgestellte Datei umzuwandeln, benutzen Sie git rm --cached: $ git ls-files --stage 100644 0487f44090ad950f61955271cf0a2d6c6a83ad9a 0 100644 e476983f39f6e4f453f0fe4a859410f63b58b500 0 100644 fcd87b055f261557434fa9956e6ce29433a5cd1c 0
.gitignore daten oops
$ git rm --cached oops rm 'oops' $ git ls-files --stage 100644 0487f44090ad950f61955271cf0a2d6c6a83ad9a 0 100644 e476983f39f6e4f453f0fe4a859410f63b58b500 0
.gitignore daten
Während git rm --cached die Datei aus dem Index entfernt und im Arbeitsverzeichnis belässt, löscht git rm die Datei sowohl aus dem Index als auch aus dem Arbeitsverzeichnis. Es ist gefährlich, git rm --cached zu benutzen, um eine Datei zu einer nicht verfolgten Datei zu machen, und dabei eine Kopie im Arbeitsverzeichnis zu lassen, da man leicht vergessen kann, dass sie nicht mehr verfolgt wird. Diese Vorgehensweise umgeht außerdem Gits Test, ob der Inhalt der Arbeitsdatei aktuell ist. Seien Sie also vorsichtig.
Falls Sie eine Datei nach dem Bestätigen löschen wollen, stellen Sie die Löschanforderung durch ein einfaches git rm Dateiname bereit: $ git commit -m "Einige Dateien hinzufügen" Created initial commit 5b22108: Einige Dateien hinzufügen 2 files changed, 3 insertions(+), 0 deletions(-)
git rm benutzen | 59
00___Git_945-8.book Seite 60 Donnerstag, 14. Januar 2010 2:25 14
create mode 100644 .gitignore create mode 100644 daten $ git rm daten rm 'daten' $ git status # On branch master # Changes to be committed: # (use "git reset HEAD ..." to unstage) # # deleted: daten #
Bevor Git eine Datei löscht, überprüft es, ob die Version der Datei im Arbeitsverzeichnis der neuesten Version im aktuellen Zweig entspricht (der Version, die die Git-Befehle als HEAD bezeichnen). Diese Überprüfung soll einem versehentlichen Verlust der Änderungen (aufgrund Ihrer Bearbeitung) vorbeugen, die an der Datei vorgenommen wurden. Damit git rm funktioniert, muss die Datei im Arbeitsverzeichnis entweder dem HEAD oder dem Inhalt des Index entsprechen. Verwenden Sie git rm -f, um das Löschen Ihrer Datei zu erzwingen. Diese Option stellt einen ausdrücklichen Auftrag dar und löscht die Datei selbst dann, wenn Sie sie nach Ihrem letzten Commit geändert haben.
Und falls Sie eine Datei, die Sie versehentlich gelöscht haben, wirklich wiederhaben wollen, dann fügen Sie sie einfach wieder hinzu: $ git add daten fatal: pathspec 'daten' did not match any files
Verdammte Axt! Git hat auch die Arbeitskopie gelöscht! Aber keine Panik. Versionskontrollsysteme sind wirklich gut darin, alte Versionen von Dateien wiederherzustellen: $ git checkout HEAD -- daten $ cat daten Neue Daten Und weitere Daten $ git status # On branch master nothing to commit (working directory clean)
git mv benutzen Nehmen Sie einmal an, Sie müssen eine Datei verschieben oder umbenennen. Sie könnten eine Kombination aus git rm auf der alten Datei und git add auf der neuen Datei benutzen. Oder Sie setzen direkt git mv ein. Bei einem Repository mit der Datei Kram, die
60 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 61 Donnerstag, 14. Januar 2010 2:25 14
Sie in neuerKram umbenennen wollen, sind die folgenden Befehlsfolgen äquivalente GitOperationen: $ mv stuff neuerKram $ git rm Kram $ git add neuerKram
und $ git mv Kram neuerKram
In beiden Fällen entfernt Git den Pfadnamen Kram aus dem Index, fügt den neuen Pfadnamen neuerKram hinzu, behält den ursprünglichen Inhalt von Kram im Objektspeicher und verknüpft diesen Inhalt neu mit dem Pfadnamen neuerKram. Nun, da daten wieder zurück im Beispiel-Repository ist, wollen wir es umbenennen und die Änderung bestätigen: $ git mv daten meinedaten $ git status # On branch master # Changes to be committed: # (use "git reset HEAD ..." to unstage) # # renamed: daten -> meinedaten # $ git commit -m"daten nach meinedaten verschoben" Created commit ec7d888: daten nach meinedaten verschoben 1 files changed, 0 insertions(+), 0 deletions(-) rename daten => meinedaten (100%)
Wenn Sie irgendwann den Verlauf der Datei überprüfen, könnte es Sie irritieren, dass Git augenscheinlich den Verlauf der ursprünglichen daten-Datei verloren hat und sich nur noch erinnern kann, daten in den aktuellen Namen umbenannt zu haben: $ git log meinedaten commit ec7d888b6492370a8ef43f56162a2a4686aea3b4 Author: Jon Loeliger <[email protected]> Date: Sun Nov 2 19:01:20 2008 -0600 daten nach meinedaten verschoben
Git kennt den vollständigen Verlauf noch, allerdings beschränkt sich die Ausgabe auf den von Ihnen im Befehl angegebenen Dateinamen. Die Option --follow fordert Git auf, durch das Log zurückzugehen und den gesamten Verlauf zu ermitteln, der mit dem Inhalt verknüpft ist: $ git log --follow meinedaten commit ec7d888b6492370a8ef43f56162a2a4686aea3b4 Author: Jon Loeliger <[email protected]> Date: Sun Nov 2 19:01:20 2008 -0600
git mv benutzen | 61
00___Git_945-8.book Seite 62 Donnerstag, 14. Januar 2010 2:25 14
daten nach meinedaten verschoben commit 5b22108820b6638a86bf57145a136f3a7ab71818 Author: Jon Loeliger <[email protected]> Date: Sun Nov 2 18:38:28 2008 -0600 Einige Dateien hinzufügen
Eines der klassischen Probleme von Versionskontrollsystemen besteht darin, dass das Umbenennen einer Datei dazu führen kann, dass sie den Verlauf der Datei aus den Augen verlieren. Git bewahrt diese Informationen selbst nach einem Umbenennen auf.
Ein Hinweis zum Überwachen des Umbenennens Lassen Sie uns ein wenig darüber reden, wie Git das Umbenennen von Dateinamen überwacht. Subversion, ein Beispiel für die traditionelle Revisionskontrolle, muss sich mächtig anstrengen, um den Überblick zu behalten, wenn eine Datei umbenannt und verschoben wird, da es eigentlich nur die Diffs, also die Unterschiede zwischen den Dateien verfolgt. Wenn Sie eine Datei verschieben, dann ist das im Prinzip genauso, als würden Sie alle Zeilen aus der alten Datei löschen und sie der neuen Datei hinzufügen. Es wäre allerdings ziemlich ineffizient, wenn man den gesamten Inhalt einer Datei immer wieder übertragen und speichern müsste, nur weil man der Datei einen neuen Namen verpassen möchte – stellen Sie sich einmal vor, Sie wollten ein ganzes Unterverzeichnis mit Tausenden von Dateien umbenennen. Um diese Lage zu erleichtern, verfolgt Subversion explizit jedes Umbenennen. Falls Sie hello.txt in subdir/hello.txt umbenennen wollen, müssen Sie svn mv anstelle von svn rm und svn add verwenden. Ansonsten hat Subversion keine Möglichkeit zu erkennen, dass es sich um ein Umbenennen handelt, und muss die gesamte ineffiziente Abfolge von Löschen und Hinzufügen durchlaufen, die wir gerade beschrieben haben. Angesichts der außergewöhnlichen Funktion des Verfolgens einer Umbenennung benötigt der Subversion-Server ein spezielles Protokoll, um seinen Clients zu sagen: »Bitte verschiebe hello.txt nach subdir/hello.txt.« Darüber hinaus muss jeder Subversion-Client dafür sorgen, dass er diese (relativ seltene) Operation korrekt ausführt. Git andererseits beobachtet das Umbenennen nicht. Sie können hello.txt an eine beliebge Stelle verschieben oder kopieren. Dabei werden jedoch nur die Baumobjekte beeinflusst. (Erinnern Sie sich, dass Baumobjekte die Beziehungen zwischen dem Inhalt speichern, während der Inhalt selbst in Blobs gespeichert ist.) Ein Blick auf die Unterschiede zwischen den beiden Bäumen macht klar, dass der Blob namens 3b18e5... an einen neuen Ort verschoben wurde. Und selbst wenn Sie die Unterschiede nicht explizit untersuchen, weiß jeder Teil des Systems bereits, dass er diesen Blob hat, sodass jeder Teil auch weiß, dass er keine weitere Kopie davon benötigt.
62 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 63 Donnerstag, 14. Januar 2010 2:25 14
Hier, wie an vielen anderen Stellen auch, erleichtert das einfache, Hash-basierte Speichersystem von Git Vieles, das andere Revisionskontrollsysteme verwirrt oder dort gar nicht funktioniert.
Probleme beim Verfolgen einer Umbenennung Das Verfolgen des Umbenennens einer Datei sorgt für eine anhaltende Debatte unter den Entwicklern von Versionskontrollsystemen. Ein einfaches Umbenennen reicht schon aus, um Missstimmung zu erzeugen. Der Streit spitzt sich jedoch noch zu, wenn erst der Name der Datei sich ändert und dann ihr Inhalt. Die Szenarien werden in diesem Fall zunehmend philosophisch: Ist diese »neue« Datei wirklich umbenannt oder ist sie der alten Datei einfach nur noch ähnlich? Wie ähnlich muss die neue Datei sein, damit sie als dieselbe Datei betrachtet wird? Wie wird damit umgegangen, wenn Sie einen Patch anwenden, der eine Datei löscht und irgendwo eine ähnliche Datei anlegt? Was passiert, wenn eine Datei in zwei unterschiedlichen Zweigen auf zwei verschiedene Weisen umbenannt wird? Ist es weniger fehleranfällig, wenn man in solchen Situationen Umbenennungen automatisch entdeckt, wie Git es tut, oder soll man vom Benutzer verlangen, Umbenennungen explizit zu kennzeichnen, wie in Subversion? In der Praxis scheint das Git-Verfahren für den Umgang mit Dateiumbenennungen überlegen zu sein, weil es einfach zu viele Möglichkeiten gibt, eine Datei umzubenennen, und Menschen kaum in der Lage sind abzusichern, dass Subversion sie alle kennt. Dennoch gibt es kein perfektes System für den Umgang mit Umbenennungen … bisher.
Die Datei .gitignore Sie haben in diesem Kapitel bereits erfahren, wie Sie die Datei .gitignore verwenden können, um main.o, eine irrelevante Datei, zu übergehen. Wie im Beispiel gezeigt, können Sie jede Datei überspringen, indem Sie ihren Namen im selben Verzeichnis in die Datei .gitignore setzen. Darüber hinaus haben Sie die Möglichkeit, die Datei überall zu ignorieren, indem Sie ihren Namen in die .gitignore-Datei im obersten Verzeichnis Ihres Repository aufnehmen. Git unterstützt aber auch einen viel stärkeren Mechanismus. Eine .gitignore-Datei kann eine Liste mit Dateinamenmustern enthalten, die festlegen, welche Dateien ignoriert werden sollen. Das Format von .gitignore sieht folgendermaßen aus: • Leere Zeilen werden ignoriert, und Zeilen, die mit einem Hash-Zeichen (#) beginnen, können für Kommentare benutzt werden. Das Hash-Zeichnen repräsentiert allerdings keinen Kommentar, wenn es anderem Text auf der Zeile folgt. • Ein einfacher, normaler Dateiname entspricht einer Datei in einem Verzeichnis dieses Namens.
Die Datei .gitignore | 63
00___Git_945-8.book Seite 64 Donnerstag, 14. Januar 2010 2:25 14
• Ein Verzeichnis wird durch einen nachfolgenden Schrägstrich (/) gekennzeichnet. Das entspricht dem angegebenen Verzeichnis und allen Unterverzeichnissen, erfasst aber nicht eine Datei oder einen symbolischen Link. • Ein Muster, das Shell-Globbing-Zeichen, wie z.B. ein Asterisk (*) enthält, wird als Shell-Glob-Muster erweitert. Genau wie beim normalen Shell-Globbing kann der Treffer die Verzeichnisgrenzen nicht überschreiten und deshalb erfasst ein Asterisk immer nur einen einzigen Datei- oder Verzeichnisnamen. Ein Asterisk kann aber trotzdem Teil eines Musters sein, das Schrägstriche enthält, mit denen sich Verzeichnisnamen als Teil des Musters angeben lassen (z.B. debug/32bit/*.o). • Ein vorangestelltes Ausrufezeichen (!) kehrt den Sinn des Musters auf dem Rest der Zeile um. Darin ist jede Datei enthalten, die von einem vorherigen Muster ausgeschlossen wurde, von einer Umkehrungsregel aber erfasst wird. Ein umgekehrtes Muster setzt Regeln mit niedrigerer Priorität außer Kraft. Git erlaubt Ihnen außerdem, in jedem Verzeichnis Ihres Repository eine .gitignore-Datei zu haben. Jede Datei beeinflusst ihr Verzeichnis und alle Unterverzeichnisse. Die .gitignore-Regeln wirken hintereinander: Sie können die Regeln in einem höheren Verzeichnis außer Kraft setzen, indem Sie in eines der Unterverzeichnisse ein umgekehrtes Muster (mit dem vorangestellten !) aufnehmen. Um eine Hierarchie mit mehreren .gitignore-Verzeichnissen aufzulösen und Ergänzungen an der Liste der ignorierten Dateien auf der Kommandozeile zuzulassen, beachtet Git diese Rangfolge (von der höchsten zur niedrigsten): • Muster, die auf der Kommandozeile angegeben werden. • Muster, die aus .gitignore im selben Verzeichnis gelesen werden. • Muster in übergeordneten Verzeichnissen, nach oben verlaufend. Die Muster aus dem aktuellen Verzeichnis überstimmen also die Muster aus dem Elternverzeichnis. Elternverzeichnisse, die sich nahe beim aktuellen Verzeichnis befinden, haben eine höhere Priorität als Elternverzeichnisse, die weiter oben in der Verzeichnishierarchie liegen. • Muster aus der Datei .git/info/exclude. • Muster aus der Datei, die von der Konfigurationsvariablen core.excludefile angegeben wird. Da .gitignore als normale Datei in Ihrem Repository behandelt wird, wird es während der Klonoperationen kopiert und gilt für alle Kopien Ihres Repository. Im Allgemeinen sollten Sie nur dann Einträge in Ihre der Versionskontrolle unterliegenden .gitignore-Dateien setzen, wenn die Muster universell für alle abgeleiteten Repositories gelten. Wenn das Ausschlussmuster speziell für Ihr eigenes Repository gilt und nicht auf einen Klon Ihres Repository angewandt werden sollte (oder darf), dann sollten Sie das Muster stattdessen in die Datei .git/info/exclude setzen, weil diese Datei während der Klonopera-
64 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 65 Donnerstag, 14. Januar 2010 2:25 14
tionen nicht weiterverbreitet wird. Das Format und die Behandlung der Muster entsprechen denen von .gitignore-Dateien. Hier ist ein weiteres Szenario. Typischerweise werden .o-Dateien, die vom Compiler aus den Quellen generiert werden, ausgeschlossen. Um .o-Dateien zu ignorieren, setzen Sie *.o in Ihre oberste .gitignore-Datei. Was tun Sie jedoch, wenn Sie eine bestimmte *.oDatei hatten, die von jemand anderem bereitgestellt wurde und für die Sie selbst keinen Ersatz generieren konnten? Wahrscheinlich werden Sie diese spezielle Datei explizit überwachen und haben dann vermutlich eine solche Konfiguration: $ cd mein_paket $ cat .gitignore *.o $ cd mein_paket/herstellerdateien $ cat .gitignore !treiber.o
Die Kombination aus Regeln bedeutet, dass Git alle .o-Dateien innerhalb des Repository ignoriert, aber eine Ausnahme überwacht, nämlich die Datei treiber.o im Unterverzeichnis herstellerdateien.
Eine ausführliche Darstellung des Objektmodells und der Dateien von Git Sie haben inzwischen die grundlegenden Fähigkeiten zum Verwalten von Dateien erworben. Dennoch kann es verwirrend sein, den Überblick darüber zu behalten, welche Datei sich wo befindet – im Arbeitsverzeichnis, im Index oder im Repository. Betrachten Sie die folgenden vier Bilder, die den Fortgang einer Datei namens datei1 beim Bearbeiten, Bereitstellen im Index und abschließenden Bestätigen darstellen. Alle Abbildungen zeigen gleichzeitig Ihr Arbeitsverzeichnis, den Index und den Objektspeicher. Zur Vereinfachung wollen wir im Zweig master bleiben. Der Ausgangszustand ist in Abbildung 5-1 zu sehen. Das Arbeitsverzeichnis enthält hier zwei Dateien namens datei1 und datei2, mit dem Inhalt »foo« bzw. »bar«. Zusätzlich zu datei1 und datei2 im Arbeitsverzeichnis enthält der master-Zweig ein Commit, das einen Baum mit exakt dem gleichen Inhalt »foo« und »bar« für die Dateien datei1 und datei2 aufzeichnet. Darüber hinaus verzeichnet der Index die SHA1-Werte a23bf und 9d3a2 für diese Dateiinhalte. Arbeitsverzeichnis, Index und Objektspeicher sind synchron und im Einklang. Nichts ist unsauber. Abbildung 5-2 zeigt die Änderungen nach dem Bearbeiten von datei1 im Arbeitsverzeichnis. Der Inhalt dieser Datei besteht nun aus »quux«. Im Index oder im Objektspeicher hat sich nichts geändert, aber das Arbeitsverzeichnis wird nun als schmutzig betrachtet.
Eine ausführliche Darstellung des Objektmodells und der Dateien von Git | 65
00___Git_945-8.book Seite 66 Donnerstag, 14. Januar 2010 2:25 14
Working directory project
file1
file2 foo
bar
Index
file1
file2
Object store master
a23bf
9d3a2 foo
bar
Abbildung 5-1: Ausgangssituation: Dateien und Objekte
Es kommt zu einigen interessanten Änderungen, wenn Sie die Bearbeitung von datei1 mit dem Befehl git add datei1 bereitstellen. Wie Abbildung 5-3 zeigt, nimmt Git zuerst die Version von datei1 aus dem Arbeitsverzeichnis, berechnet eine SHA1-Hash-ID (bd71363) für ihren Inhalt und legt diese ID im Objektspeicher ab. Als Nächstes zeichnet Git im Index auf, dass der Pfadname datei1 auf den neuen SHA1-Wert bd71363 aktualisiert wurde. Da sich der Inhalt von datei2 nicht geändert hat und datei2 auch noch nicht durch ein git add bereitgestellt wurde, verweist der Index weiterhin auf das ursprüngliche Blob-Objekt.
66 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 67 Donnerstag, 14. Januar 2010 2:25 14
Working directory project 1. Edit file1 file1 foo
file2 quux
bar
Index
file1
file2
Object store master
a23bf
9d3a2 foo
bar
Abbildung 5-2: Nach dem Bearbeiten von datei1
An dieser Stelle haben Sie datei1 im Index bereitgestellt, und das Arbeitsverzeichnis und der Index stimmen überein. Allerdings wird der Index im Hinblick auf HEAD als unsauber angesehen, weil er von dem Baum abweicht, der im Objektspeicher für das HEAD-Commit des master-Zweigs aufgezeichnet wurde.3 3
Sie können einen unsauberen Index auch in der anderen Richtung bekommen, ungeachtet des Zustands des Arbeitsverzeichnisses. Indem Sie ein Nicht-HEAD-Commit aus dem Objektspeicher in den Index auslesen und die entsprechenden Dateien nicht in das Arbeitsverzeichnis auschecken, erzeugen Sie eine Situation, in der Index und Arbeitsverzeichnis nicht in Übereinstimmung sind und der Index mit Blick auf den HEAD unsauber ist.
Eine ausführliche Darstellung des Objektmodells und der Dateien von Git | 67
00___Git_945-8.book Seite 68 Donnerstag, 14. Januar 2010 2:25 14
Working directory project
file1
file2 quux
bar
Index
2a. Add file1 to Object store
file1
file2
Object store master
2b. Update index
a23bf
9d3a2 foo
bar
bd71363 quux
Abbildung 5-3: Nach git add
Nachdem schließlich alle Änderungen im Index bereitgestellt wurden, wendet ein Commit sie auf das Repository an. Die Auswirkungen von git commit werden in Abbildung 5-4 gezeigt. Wie Abbildung 5-4 zeigt, löst das commit drei Schritte aus. Erstens wird das virtuelle Baumobjekt, das sich im Index befindet, in ein echtes Baumobjekt umgewandelt und unter seinem SHA1-Namen im Objektspeicher abgelegt. Zweitens wird ein neues Commit-Objekt mit Ihrer Lognachricht erzeugt. Das neue Commit verweist auf das neu erzeugte Baumobjekt und außerdem auf das vorhergehende oder Eltern-Commit. Drittens wird die Referenz des master-Zweigs vom letzten Commit auf das neu angelegte Commit-Objekt verschoben, das damit zum neuen master-HEAD wird.
68 | Kapitel 5: Dateiverwaltung und der Index
00___Git_945-8.book Seite 69 Donnerstag, 14. Januar 2010 2:25 14
Working directory project
file1
file2 quux
bar
Index
3a. Convert index into tree object file1
Object store
file2
3c. Update branch ref
master
3b. Make commit object
a23bf
9d3a2 foo
bar
bd71363 quux
Abbildung 5-4: Nach dem git commit
Interessanterweise sind nun das Arbeitsverzeichnis, der Index und der Objektspeicher (repräsentiert durch den HEAD des master-HEAD) wieder synchron und in Übereinstimmung – genau wie in Abbildung 5-1.
Eine ausführliche Darstellung des Objektmodells und der Dateien von Git | 69
00___Git_945-8.book Seite 70 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 71 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 6
KAPITEL 6
Commits
In Git dient ein Commit dazu, die Änderungen an einem Repository aufzuzeichnen. Auf den ersten Blick scheint ein Git-Commit sich nicht von einem Commit oder Einchecken in anderen Versionskontrollsystemen zu unterscheiden. Hinter den Kulissen jedoch operiert ein Git-Commit auf einzigartige Weise. Wenn ein Commit auftritt, zeichnet Git einen Schnappschuss des Index auf und legt diesen Schnappschuss im Objektspeicher ab. (Das Vorbereiten des Index für ein Commit wird in Kapitel 5 behandelt.) Dieser Schnappschuss enthält keine Kopie jeder Datei und jedes Verzeichnisses im Index, da eine solche Strategie enorme und unerschwingliche Mengen an Speicher erfordern würde. Stattdessen vergleicht Git den aktuellen Zustand des Index mit dem vorangegangenen Schnappschuss und leitet auf diese Weise eine Liste der betroffenen Dateien und Verzeichnisse ab. Git erzeugt neue Blobs für alle Dateien, die sich verändert haben, sowie neue Bäume für alle Verzeichnisse, die sich verändert haben. Alle Blob- oder Baumobjekte, die sich nicht geändert haben, werden wiederverwendet. Commit-Schnappschüsse werden aneinandergekettet, wobei jeder neue Schnappschuss auf seinen Vorgänger zeigt. Mit der Zeit werden Folgen aus Änderungen als eine Reihe aus Commits dargestellt. Es wirkt vielleicht aufwendig, wenn man den gesamten Index mit einem vorherigen Zustand vergleicht, allerdings verläuft der ganze Prozess bemerkenswert schnell, weil jedes Git-Objekt einen SHA1-Hash-Wert besitzt. Wenn zwei Objekte, und das betrifft sogar zwei Teilbäume, den gleichen SHA1-Hash haben, sind die Objekte identisch. Git kann eine Menge rekursiver Vergleiche vermeiden, indem es Teilbäume ausdünnt, die den gleichen Inhalt haben. Es gibt eine eineindeutige Beziehung zwischen einer Menge von Änderungen im Repository und einem Commit: Ein Commit ist die einzige Methode, mit der sich Änderungen in ein Repository einführen lassen, und jede Änderung im Repository muss durch ein Commit eingeführt werden. Diese Tatsache bringt Verantwortung mit sich. Unter keinen
| 71
00___Git_945-8.book Seite 72 Donnerstag, 14. Januar 2010 2:25 14
Umständen dürfen sich Repository-Daten ändern, ohne dass die Änderung aufgezeichnet wird! Stellen Sie sich nur einmal das Chaos vor, das Sie erwartet, wenn sich der Inhalt des Master-Repository geändert hat und es keinen Vermerk darüber gibt, wie das geschehen ist oder wer das aus welchem Grund veranlasst hat. Meist werden Commits explizit von einem Entwickler eingeführt, Git selbst kann aber ebenfalls Commits auslösen. Wie Sie in Kapitel 9 sehen werden, verursacht eine MergeOperation ein Commit im Repository, und zwar zusätzlich zu den Commits, die von den Benutzern vor dem Merge vorgenommen wurden. Wie Sie über ein Commit entscheiden, hängt ganz von Ihnen und Ihren Vorlieben oder Ihrem Entwicklungsstil ab. Im Allgemeinen sollten Sie ein Commit zu wohldefinierten Zeitpunkten durchführen, wenn sich Ihre Entwicklung im Stillstand befindet, etwa wenn ein Testdurchlauf stattfindet, wenn Feierabend ist oder zu ähnlichen Anlässen. Zögern Sie jedoch nicht, Commits durchzuführen! Git eignet sich sehr gut für häufige Commits und bietet eine große Anzahl von Befehlen, mit denen Sie sie manipulieren können. Sie werden später feststellen, dass mehrere Commits – mit jeweils kleinen, wohldefinierten Änderungen – eine bessere Organisation der Änderungen und eine leichtere Manipulation der Patches nach sich ziehen.
Atomare Änderungsmengen (Changesets) Jedes Git-Commit repräsentiert eine einzige, atomare Änderungsmenge in Bezug auf den vorherigen Zustand. Ungeachtet der Anzahl der Verzeichnisse, Dateien, Zeilen oder Bytes, die sich mit einem Commit ändern,1 werden entweder alle oder keine Änderungen angewandt. Im Hinblick auf das zugrunde liegende Objektmodell ist die Atomarität durchaus sinnvoll: Ein Commit-Schnappschuss steht für die gesamte Menge an modifizierten Dateien und Verzeichnissen. Er muss den einen Baumzustand oder den anderen repräsentieren, und eine Änderungsmenge zwischen zwei Zustandsschnappschüssen stellt eine vollständige Baum-zu-Baum-Transformation dar. (Mehr über abgeleitete Unterschiede zwischen Commits erfahren Sie in Kapitel 8.) Betrachten Sie einmal das Vorgehen beim Verschieben einer Funktion von einer Datei in eine andere. Wenn Sie die Löschung mit einem Commit vornehmen und dann mit einem zweiten Commit folgen, um die Funktion wieder hinzuzufügen, bleibt eine kleine »semantische Lücke« im Verlauf Ihres Repository, während der die Funktion einfach nicht vorhanden ist. Zwei Commits in der anderen Reihenfolge sind ebenfalls problematisch. In beiden Fällen ist Ihr Code vor dem ersten und nach dem zweiten Commit semantisch konsistent, nach dem ersten Commit dagegen ist er fehlerhaft. 1
Git zeichnet außerdem ein Modus-Flag auf, das die Ausführbarkeit der einzelnen Dateien anzeigt. Änderungen an diesem Flag sind ebenfalls Teil einer Änderungsmenge.
72 | Kapitel 6: Commits
00___Git_945-8.book Seite 73 Donnerstag, 14. Januar 2010 2:25 14
Mit einem atomaren Commit jedoch, das die Funktion gleichzeitig löscht und hinzufügt, bleibt Ihnen diese semantische Lücke im Verlauf erspart. In Kapitel 10 erfahren Sie, wie Sie Ihre Commits am besten konstruieren und organisieren. Git ist es egal, wieso sich die Dateien ändern. Das heißt, der Inhalt der Änderungen spielt keine Rolle. Als Entwickler könnten Sie eine Funktion von hier nach dort verschieben und erwarten, dass das als ein einheitlicher Schritt behandelt wird. Sie könnten aber auch alternativ das Löschen mit einem Commit bestätigen und dann später ein Commit für das Hinzufügen ausführen. Git kümmert das nicht. Es hat nichts mit der Semantik dessen zu tun, was sich in den Dateien befindet. Damit kommen wir aber zu einem der wesentlichen Gründe dafür, dass Git Atomarität implementiert: Sie erlaubt es Ihnen, Ihre Commits passender zu strukturieren, indem Sie einige bewährte Methoden befolgen. Letztlich können Sie damit rechnen, dass Git Ihr Repository nicht in irgendeinem Übergangszustand zwischen zwei Commit-Schnappschüssen zurücklässt.
Commits festlegen Unabhängig davon, ob Sie einzeln oder im Team an Ihrem Code arbeiten, ist das Festlegen der jeweiligen Commits eine wichtige Aufgabe. Um z.B. einen Zweig zu erzeugen, müssen Sie ein Commit wählen, von dem Sie abzweigen; um Codevariationen zu vergleichen, müssen Sie zwei Commits angeben, und um den Commit-Verlauf zu bearbeiten, müssen Sie eine Sammlung von Commits vorgeben. In Git können Sie auf jeden Commit über eine explizite oder implizite Referenz verweisen. Sie haben bereits explizite und auch einige implizite Referenzen gesehen. Die eindeutige, 40-stellige Hex-SHA1-Commit-ID ist eine explizite Referenz, während HEAD, das immer auf das neueste Commit verweist, eine implizite Referenz darstellt. Manchmal allerdings ist keine der beiden Referenzen geeignet. Zum Glück bietet Git viele unterschiedliche Mechanismen zum Benennen eines Commit, die jeweils ihre Vorteile haben und manchmal – je nach Kontext – sinnvoller sind als andere. Wenn man z.B. ein bestimmtes Commit mit einem Kollegen bespricht, der an denselben Daten, aber in einer verteilten Umgebung arbeitet, ist es am besten, wenn man einen Commit-Namen benutzt, der garantiert in beiden Repositories gleich ist. Falls Sie andererseits innerhalb Ihres eigenen Repository arbeiten und sich auf einen Zustand beziehen müssen, der vor einigen Commits in einem Zweig vorhanden war, funktioniert ein einfacher relativer Name hervorragend.
Absolute Commit-Namen Der strengste Name für ein Commit ist sein Hash-Identifikator. Bei der Hash-ID handelt es sich um einen absoluten Namen, was bedeutet, dass sie sich nur auf exakt ein Commit
Commits festlegen | 73
00___Git_945-8.book Seite 74 Donnerstag, 14. Januar 2010 2:25 14
beziehen kann. Es spielt keine Rolle, wo sich das Commit im Verlauf des gesamten Repository befindet – die Hash-ID kennzeichnet immer dasselbe Commit. Jede Commit-ID ist global eindeutig – nicht nur für ein Repository, sondern für alle Repositories. Falls z.B. ein Entwickler Ihnen schreibt und sich auf eine bestimmte Commit-ID in seinem Repository bezieht und Sie das gleiche Commit in Ihrem Repository finden, dann können Sie sicher davon ausgehen, dass Sie dasselbe Commit mit demselben Inhalt haben. Da außerdem die Daten, die zu einer Commit-ID beitragen, den Zustand des kompletten Repository-Baums sowie den vorherigen Commit-Status enthalten, kann durch eine induktive Annahme noch eine viel stärkere Aussage getroffen werden: Sie können sich sicher sein, dass Sie beide über die gleiche Entwicklungslinie reden, die bis zu einschließlich diesem Commit geführt hat. Da eine 40-stellige SHA1-Zahl in Hexadezimalschreibweise einen lästigen und fehleranfälligen Eintrag ergibt, erlaubt Ihnen Git, diese Zahl innerhalb der Objektdatenbank eines Repository zu einem eindeutigen Präfix abzukürzen. Hier ist ein Beispiel aus dem Git-eigenen Repository: $ git log -1 --pretty=oneline HEAD 1fbb58b4153e90eda08c2b022ee32d90729582e6 Merge git://repo.or.cz/git-gui $ git log -1 --pretty=oneline 1fbb error: short SHA1 1fbb is ambiguous. fatal: ambiguous argument '1fbb': unknown revision or path not in the working tree. Use '--' to separate paths from revisions $ git log -1 --pretty=oneline 1fbb58 1fbb58b4153e90eda08c2b022ee32d90729582e6 Merge git://repo.or.cz/git-gui
Ein Tag-Name ist zwar nicht global eindeutig, stellt aber insofern einen absoluten Namen dar, als er auf ein eindeutiges Commit verweist und sich mit der Zeit nicht ändert (außer natürlich, Sie ändern ihn explizit).
Refs und Symrefs Eine Referenz oder Ref ist eine SHA1-Hash-ID, die auf ein Objekt innerhalb des GitObjektspeichers verweist. Sie kann sich zwar auf jedes beliebige Git-Objekt beziehen, meist aber verweist sie auf ein Commit-Objekt. Eine symbolische Referenz oder Symref ist ein Name, der indirekt auf ein Git-Objekt verweist. Es ist trotzdem nur ein Ref. Lokale Topic-Zweignamen, entfernte Tracking-Zweignamen und Tag-Namen sind Refs. Jede symbolische Referenz besitzt einen expliziten, vollständigen Namen, der mit refs/ beginnt. Diese Referenzen sind hierarchisch im Verzeichnis .git/refs/ des Repository gespeichert. Es werden im Prinzip drei unterschiedliche Namensräume in refs/ abgebildet: refs/heads/ref für Ihre lokalen Zweige, refs/remotes/ref für Ihre entfernten Tracking-Zweige und refs/tags/ref für Ihre Tags. (Zweige werden in Kapitel 7 sowie in Kapitel 11 ausführlich behandelt.)
74 | Kapitel 6: Commits
00___Git_945-8.book Seite 75 Donnerstag, 14. Januar 2010 2:25 14
So ist z.B. der Name dev eines lokalen Topic-Zweigs in Wirklichkeit eine Kurzform von refs/heads/dev. Entfernte Tracking-Zweige befinden sich im Namensraum refs/remotes/, origin/master bezeichnet deshalb eigentlich refs/remotes/origin/master. Und ein Tag wie v2.6.23 ist die Kurzform von refs/tags/v2.6.23. Sie können entweder einen vollständigen Ref-Namen oder seine Abkürzung verwenden. Wenn Sie jedoch einen Zweig und ein Tag desselben Namens haben, wendet Git eine Heuristik zur Unterscheidung an und benutzt den ersten Treffer entsprechend dieser Liste von der git rev-parse-Manpage: .git/ref .git/refs/ref .git/refs/tags/ref .git/refs/heads/ref .git/refs/remotes/ref .git/refs/remotes/ref/HEAD
Die erste Regel gilt normalerweise nur für HEAD, ORIG_HEAD, FETCH_HEAD und MERGE_HEAD. Technisch gesehen kann der Name des Git-Verzeichnisses, .git, geändert werden. Deshalb benutzt die interne Git-Dokumentation die Variable $GIT_DIR anstelle des Literals .git.
Git pflegt für bestimmte Aufgaben automatisch mehrere spezielle Symrefs. Diese können überall eingesetzt werden, wo ein Commit ausgeführt wird: HEAD HEAD verweist immer auf das neueste Commit im aktuellen Zweig. Wenn Sie Zweige wechseln, wird HEAD angepasst, sodass es wieder auf das neueste Commit des neuen
Zweigs zeigt. ORIG_HEAD
Bestimmte Operationen, etwa Merge (Zusammenführen) und Reset (Zurücksetzen), zeichnen die vorhergehende Version von HEAD in ORIG_HEAD auf, bevor sie es auf einen neuen Wert setzen. Sie können ORIG_HEAD benutzen, um den vorhergegangenen Zustand wiederherzustellen oder zu ihm zurückzukehren oder um einen Vergleich anzustellen. FETCH_HEAD
Wenn entfernte Repositories verwendet werden, zeichnet git fetch die Köpfe aller Zweige, die abgerufen wurden, in der Datei .git/FETCH_HEAD auf. FETCH_HEAD ist eine Abkürzung für den Kopf des letzten abgerufenen Zweigs und gilt nur unmittelbar nach einer Fetch- (also Abruf-)Operation. Mithilfe dieses Symref können Sie den HEAD der Commits von git fetch auch dann finden, wenn ein anonymer Abruf verwendet wird, der nicht speziell einen Zweignamen angibt. Die fetch-Operation wird in Kapitel 11 behandelt.
Commits festlegen | 75
00___Git_945-8.book Seite 76 Donnerstag, 14. Januar 2010 2:25 14
MERGE_HEAD
Wenn ein Merge im Gang ist, wird die Spitze des anderen Zweigs zeitweilig im Symref MERGE_HEAD aufgezeichnet. Mit anderen Worten: MERGE_HEAD ist das Commit, das zu HEAD zusammengeführt wird. Diese ganzen symbolischen Referenzen werden durch den Plumbing-Befehl git symbolic-ref verwaltet. Es ist zwar möglich, mit einem dieser symbolischen Namen (z.B. HEAD) einen eigenen Zweig zu erzeugen, aber das ist keine gute Idee.
Es gibt eine ganze Menge Sonderzeichenvarianten für Ref-Namen. Die gebräuchlichsten, das Dach (^) und die Tilde (~), werden im nächsten Abschnitt beschrieben. In einem anderen Trick mit Refs können Doppelpunkte benutzt werden, um auf alternative Versionen einer bekannten Datei zu verweisen, die in einen Merge-Konflikt verwickelt ist. Dieses Vorgehen wird in Kapitel 9 beschrieben.
Relative Commit-Namen Git bietet auch Mechanismen, um ein Commit relativ zu einer anderen Referenz zu kennzeichnen. Bei der anderen Referenz handelt es sich meist um die Spitze eines Zweiges. Einige dieser Namen haben Sie bereits gesehen, z.B. master und master^, wobei sich master^ immer auf das vorletzte Commit auf dem master-Zweig bezieht. Es gibt auch noch weitere: Sie können master^^, master~2 und sogar einen komplexen Namen wie master~10^2~2^2 verwenden. Mit Ausnahme des ersten Root-Commit2 wird jedes Commit von wenigstens einem früheren Commit, vielleicht sogar vielen Commits abgeleitet. Direkte Vorfahren werden dabei als Eltern-Commits bezeichnet. Damit ein Commit mehrere Eltern-Commits hat, muss es das Ergebnis einer Merge-Operation sein. Als Ergebnis gibt es ein Eltern-Commit für jeden Zweig, der zu einem Merge-Commit beigetragen hat. Innerhalb einer Generation dient das Dach dazu, ein anderes Eltern-Commit auszuwählen. Gehen wir von einem Commit C aus, dann ist C^1 das erste Eltern-Commit, C^2 das zweite Eltern-Commit, C^3 das dritte usw., wie Abbildung 6-1 zeigt. Die Tilde dient dazu, vor ein Eltern-Commit zu springen und eine der vorangegangenen Generationen auszuwählen. Wenn wir hier wieder vom Commit C ausgehen, dann bezeichnet C~1 das erste Eltern-Commit, C~2 das erste Großeltern-Commit und C~3 das erste Urgroßeltern-Commit. Wenn es mehrere Eltern in einer Generation gibt, dann wird 2
Ja, man kann tatsächlich mehrere Root-Commits in ein Repository einführen. Das kommt z.B. vor, wenn zwei unterschiedliche Projekte und ihre kompletten Repositories zusammengebracht und zu einem zusammengeführt werden.
76 | Kapitel 6: Commits
00___Git_945-8.book Seite 77 Donnerstag, 14. Januar 2010 2:25 14
C^1
C^2
C
C^3 Abbildung 6-1: Mehrere Elternnamen
dem ersten Eltern-Commit des ersten Eltern-Commit gefolgt. Sie werden vielleicht auch bemerken, dass sowohl C^1 als auch C~1 sich auf das erste Eltern-Commit beziehen; beide Namen sind korrekt (Abbildung 6-2).
C~3
C~2
C~1
C^2
C
C^3 Abbildung 6-2: Mehrere Generationsnamen
Git unterstützt auch noch andere Abkürzungen und Kombinationen. Die abgekürzten Formen C^ und C~ sind identisch mit C^1 bzw. C~1. C^^ ist das Gleiche wie C^1^1, und da es »das erste Eltern-Commit des ersten Eltern-Commit von Commit C« bedeutet, verweist es auf das gleiche Commit wie C~2. Indem man eine Ref und Instanzen von Dach und Tilde kombiniert, können beliebige Commits aus dem Vorgänger-Commit-Graphen von Ref ausgewählt werden. Denken Sie jedoch daran, dass diese Namen relativ zum aktuellen Wert von Ref sind. Wird auf der Spitze von Ref ein neues Commit ausgeführt, wird der Commit-Graph durch eine neue Generation ergänzt und jeder »Eltern«-Name rückt im Verlauf und im Graphen weiter nach hinten.
Commits festlegen | 77
00___Git_945-8.book Seite 78 Donnerstag, 14. Januar 2010 2:25 14
Hier ist ein Beispiel aus Gits eigener Geschichte, als der master-Zweig von Git bei Commit 1fbb58b4153e90eda08c2b022ee32d90729582e6 war. Mithilfe des Befehls git showbranch --more=35 und einer Beschränkung der Ausgabe auf die letzten zehn Zeilen können Sie den Verlauf des Graphen untersuchen und entdecken eine komplexe ZweigMerge-Struktur: $ git rev-parse master 1fbb58b4153e90eda08c2b022ee32d90729582e6 $ git show-branch --more=35 | tail -10 -- [master~15] Merge branch 'maint' -- [master~3^2^] Merge branch 'maint-1.5.4' into maint +* [master~3^2^2^] wt-status.h: declare global variables as extern -- [master~3^2~2] Merge branch 'maint-1.5.4' into maint -- [master~16] Merge branch 'lt/core-optim' +* [master~16^2] Optimize symlink/directory detection +* [master~17] rev-parse --verify: do not output anything on error +* [master~18] rev-parse: fix using "--default" with "--verify" +* [master~19] rev-parse: add test script for "--verify" +* [master~20] Add svn-compatible "blame" output format to git-svn $ git rev-parse master~3^2^2^ 32efcd91c6505ae28f87c0e9a3e2b3c0115017d8
Zwischen master~15 und master~16 fand ein Merge statt, der eine Reihe weiterer Merges sowie ein einfaches Commit namens master~3^2^2^ einführte. Dabei handelt es sich um Commit 32efcd91c6505ae28f87c0e9a3e2b3c0115017d8. Der Befehl git rev-parse ist die letzte Autorität beim Übersetzen jeder Form von Commit-Namen – tag, relativ, abgekürzt oder absolut – in eine tatsächliche, absolute Commit-Hash-ID innerhalb der Objektdatenbank.
Der Commit-Verlauf Alte Commits anschauen Der wichtigste Befehl zum Anzeigen des Verlaufs von Commits ist git log. Er besitzt mehr Optionen, Parameter, Selektoren, Formatierer und anderen Schnickenpfiffi als das sagenhafte ls. Aber keine Bange: Genau wie bei ls müssen Sie nicht sofort alle Einzelheiten auswendig lernen. In seiner parameterlosen Form funktioniert git log genau wie git log HEAD, d.h. es gibt die Lognachricht zu jedem einzelnen Commit in der History aus, der von HEAD aus erreichbar ist. Änderungen werden beginnend mit dem HEAD-Commit angezeigt, es arbeitet sich dann rückwärts durch den Graphen. Mit hoher Wahrscheinlichkeit werden sie dann in umgekehrter chronologischer Reihenfolge vorliegen; denken Sie aber daran, dass Git sich an den Commit-Graphen und nicht an die Zeit hält, wenn es im Verlauf zurückreist.
78 | Kapitel 6: Commits
00___Git_945-8.book Seite 79 Donnerstag, 14. Januar 2010 2:25 14
Wenn Sie ein Commit à la git log commit angeben, beginnt das Log bei dem genannten Commit und arbeitet sich zurück. Diese Form des Befehls eignet sich zum Betrachten der Geschichte eines Zweiges: $ git log master commit 1fbb58b4153e90eda08c2b022ee32d90729582e6 Merge: 58949bb... 76bb40c... Author: Junio C Hamano Date: Thu May 15 01:31:15 2008 -0700 Merge git://repo.or.cz/git-gui * git://repo.or.cz/git-gui: git-gui: Delete branches with 'git branch -D' to clear config git-gui: Setup branch.remote,merge for shorthand git-pull git-gui: Update German translation git-gui: Don't use '$$cr master' with aspell earlier than 0.60 git-gui: Report less precise object estimates for database compression commit 58949bb18a1610d109e64e997c41696e0dfe97c3 Author: Chris Frey Date: Wed May 14 19:22:18 2008 -0400 Documentation/git-prune.txt: document unpacked logic Clarifies the git-prune manpage, documenting that it only prunes unpacked objects. Signed-off-by: Chris Frey Signed-off-by: Junio C Hamano commit c7ea453618e41e05a06f05e3ab63d555d0ddd7d9 ...
Die Logs sind zuverlässig, allerdings ist es mit Sicherheit weder praktisch noch besonders aussagekräftig, wenn man den gesamten Verlauf eines Repository noch einmal aufrollt. Meist ist ein eingeschränkter Verlauf deutlich informativer. Man kann z.B. einen Commit-Bereich zum Einschränken des Verlaufs angeben, und zwar mit der Form von..bis. Damit zeigt git log alle Commits von von bis einschließlich bis. Hier ist ein Beispiel: $ git log --pretty=short --abbrev-commit master~12..master~10 commit 6d9878c... Author: Jeff King clone: bsd shell portability fix commit 30684df... Author: Jeff King t5000: tar portability fix
Der Commit-Verlauf
| 79
00___Git_945-8.book Seite 80 Donnerstag, 14. Januar 2010 2:25 14
Hier zeigt git log die Commits zwischen master~12 und master~10 oder die 10. und 11. vorhergehenden Commits auf dem Master-Zweig. Mehr über Bereiche erfahren Sie in »Commit-Bereiche« auf Seite 85. Das vorangegangene Beispiel führt darüber hinaus zwei Formatierungsoptionen ein, --pretty=short und --abbrev-commit. Das erste Flag ist für die Menge von Informationen über jedes Commit verantwortlich und tritt in mehreren Variationen auf, einschließlich oneline, short und full. Das zweite Flag fordert ganz einfach, dass die Hash-IDs abgekürzt werden. -p gibt den Patch oder die Änderungen aus, die durch das Commit ausgelöst werden: $ git log -1 -p 4fe86488 commit 4fe86488e1a550aa058c081c7e67644dd0f7c98e Author: Jon Loeliger <[email protected]> Date: Wed Apr 23 16:14:30 2008 -0500 Add otherwise missing --strict option to unpack-objects summary. Signed-off-by: Jon Loeliger <[email protected]> Signed-off-by: Junio C Hamano diff --git a/Documentation/git-unpack-objects.txt b/Documentation/git-unpack-objects.txt index 3697896..50947c5 100644 --- a/Documentation/git-unpack-objects.txt +++ b/Documentation/git-unpack-objects.txt @@ -8,7 +8,7 @@ git-unpack-objects - Unpack objects from a packed archive SYNOPSIS --------'git-unpack-objects' [-n] [-q] [-r] <pack-file +'git-unpack-objects' [-n] [-q] [-r] [--strict] <pack-file
Beachten Sie außerdem die Option -1: Sie beschränkt die Ausgabe auf ein einziges Commit. Man kann auch -n eingeben, um die Ausgabe auf höchstens n Commits zu beschränken. Die Option --stat benennt die Dateien, die bei einem Commit geändert wurden, und zählt, wie viele Zeilen in jeder einzelnen Datei modifiziert wurden: $ git log --pretty=short --stat master~12..master~10 commit 6d9878cc60ba97fc99aa92f40535644938cad907 Author: Jeff King clone: bsd shell portability fix git-clone.sh | 3 +-1 files changed, 1 insertions(+), 2 deletions(-)
80 | Kapitel 6: Commits
00___Git_945-8.book Seite 81 Donnerstag, 14. Januar 2010 2:25 14
commit 30684dfaf8cf96e5afc01668acc01acc0ade59db Author: Jeff King t5000: tar portability fix t/t5000-tar-tree.sh | 8 ++++---1 files changed, 4 insertions(+), 4 deletions(-)
Vergleichen Sie die Ausgabe von git log --stat mit der Ausgabe von git diff --stat. Es gibt einen fundamentalen Unterschied zwischen den beiden Ausgaben: Die erste Variante erzeugt eine Zusammenfassung für jedes einzelne Commit, das in dem Bereich angegeben ist, während die zweite Ausgabe eine Zusammenfassung des Gesamtunterschieds zwischen zwei Repository-Zuständen ausgibt, die auf der Kommandozeile genannt wurden.
Ein weiterer Befehl zum Anzeigen von Objekten aus dem Objektspeicher ist git show. Mit seiner Hilfe können Sie ein Commit sehen: $ git show HEAD~2
Oder auch ein bestimmtes Blob-Objekt: $ git show origin/master:Makefile
Der im letzten git show gezeigte Blob ist das Makefile aus dem Zweig namens origin/master.
Commit-Graphen »Darstellungen des Objektspeichers« auf Seite 38 hat einige Bilder vorgestellt, die Ihnen helfen sollen, sich die Anordnung und die Zusammenhänge zwischen den Objekten in Gits Datenmodell vorzustellen. Solche Skizzen sind sehr erhellend, vor allem wenn Git Ihnen bisher völlig fremd war. Allerdings wird selbst ein kleines Repository mit nur einer Handvoll Commits, Merges und Patches schnell sehr sperrig und unhandlich, wenn man es in solchem Detail abbilden will. So zeigt Abbildung 6-3 einen vollständigeren, aber dennoch vereinfachten Commit-Graphen. Stellen Sie sich vor, wie er aussehen würde, wenn alle Commits und Datenstrukturen vorhanden wären. Eine Beobachtung über Commits kann den Plan ganz außerordentlich vereinfachen: Jedes Commit führt ein Baumobjekt ein, das das gesamte Repository repräsentiert. Deshalb kann ein Commit einfach als schlichter Name dargestellt werden. Abbildung 6-4 zeigt den gleichen Commit-Graphen wie Abbildung 6-3, ohne die Baumund Blob-Objekte wiederzugeben. Zum Zweck der Erörterung oder Veranschaulichung werden Zweignamen normalerweise ebenfalls in Commit-Graphen gezeigt. In der Informatik ist ein Graph eine Sammlung von Knoten und eine Menge von Kanten zwischen den Knoten. Es gibt mehrere Typen von Graphen mit unterschiedlichen Eigen-
Der Commit-Verlauf
| 81
00___Git_945-8.book Seite 82 Donnerstag, 14. Januar 2010 2:25 14
pr-17
master
dev
Abbildung 6-3: Ein vollständiger Commit-Graph pr-17
master
dev
Abbildung 6-4: Vereinfachter Commit-Graph
82 | Kapitel 6: Commits
00___Git_945-8.book Seite 83 Donnerstag, 14. Januar 2010 2:25 14
schaften. Git benutzt einen besonderen Graphen namens gerichteter azyklischer Graph. Ein solcher Graph besitzt zwei wichtige Eigenschaften. Erstens sind die Kanten innerhalb des Graphen alle zwischen zwei Knoten gerichtet. Zweitens gibt es, wenn man bei einem beliebigen Knoten im Graphen startet, keinen Pfad entlang der gerichteten Kanten, der zurück zum Startknoten führt. Git implementiert den Verlauf der Commits innerhalb eines Repository als gerichteten azyklischen Graphen. Im Commit-Graphen stellt jeder Knoten ein einzelnes Commit dar, alle Kanten sind von einem Nachfahrenknoten zu einem Elternknoten gerichtet und formen auf diese Weise eine Vorfahrenbeziehung. Die Graphen, die Sie in Abbildung 6-3 und in Abbildung 6-4 gesehen haben, sind solche gerichteten azyklischen Graphen. Wenn man vom Verlauf der Commits spricht und die Beziehung zwischen den Commits in einem Graphen diskutiert, werden die einzelnen Commit-Knoten oft beschriftet, wie in Abbildung 6-5 zu sehen ist. pr-17
E
F
G master
A
B
C
D
H
Abbildung 6-5: Beschrifteter Commit-Graph
In diesen Diagrammen verläuft die Zeit etwa von links nach rechts. A ist das erste Commit, da es kein Eltern-Commit besitzt, B ist nach A aufgetreten. Sowohl E als auch C kamen nach B, man kann aber keine Aussage über den relativen Zeitverlauf zwischen C und E treffen; beide hätten jeweils vor dem anderen auftreten können. Um genau zu sein, kümmert sich Git eigentlich nicht um die Zeit oder den Zeitablauf (absolut oder relativ) der Commits. Die tatsächliche Zeit in der realen Welt, zu der ein Commit stattgefunden hat, kann irreführend sein, da die Uhr des Computers möglicherweise falsch oder inkonsistent eingestellt ist. In einer verteilten Entwicklungsumgebung wird das Problem noch verschärft. Zeitstempeln kann man nicht vertrauen. Sicher ist jedoch, dass ungeachtet der Zeitstempel, die auf den Commits kleben, Commit X den Repository-Zustand vor dem Repository-Zustand von Commit Y erfasst, wenn Commit Y auf Eltern-Commit X zeigt. Die Commits E und C teilen sich ein Eltern-Commit, nämlich B. Das heißt, dass B der Ursprung eines Zweiges ist. Der Master-Zweig beginnt mit den Commits A, B, C und D.
Der Commit-Verlauf
| 83
00___Git_945-8.book Seite 84 Donnerstag, 14. Januar 2010 2:25 14
Indes formt die Folge aus den Commits A, B, E, F und G den Zweig namens pr-17. Der Zweig pr-17 zeigt auf Commit G. (Mehr dazu erfahren Sie in Kapitel 7.) Da es ein Merge, d.h. eine Zusammenführung ist, besitzt H mehr als ein Eltern-Commit – in diesem Fall D und G. Obwohl H zwei Eltern hat, ist es nur auf dem Master-Zweig vorhanden, da pr-17 auf G verweist. (Die Merge-Operation wird in Kapitel 9 genauer besprochen.) In der Praxis werden die Feinheiten sich vermischender Commits als unwichtig erachtet. Auch die Implementierungsdetails eines Commit, das zurück auf sein Eltern-Commit verweist, werden häufig ignoriert, wie Abbildung 6-6 zeigt. Die Zeit verläuft immer noch ungefähr von links nach rechts, es sind zwei Zweige zu sehen und ein Merge-Commit (H) ist gekennzeichnet, aber die eigentlichen gerichteten Kanten sind vereinfacht, weil sie implizit verstanden werden. pr-17
master
H Abbildung 6-6: Commit-Graph ohne Pfeile
Diese Art von Commit-Graph wird oft benutzt, um über den Betrieb bestimmter GitBefehle zu reden und darüber, wie diese jeweils den Verlauf der Commits ändern. Graphen bilden eine relativ abstrakte Repräsentation des tatsächlichen Commit-Verlaufs und stehen damit im Gegensatz zu Werkzeugen (wie etwa gitk und git show-branch), die konkrete Repräsentationen der Commit-Verlaufsgraphen liefern. In diesen Werkzeugen wird die Zeit jedoch meist von unten nach oben, vom ältesten zum jüngsten Zeitpunkt gezeigt. Im Grunde handelt es sich um die gleichen Informationen.
Mit gitk den Commit-Graphen betrachten Ein Graph ist von Natur aus eine visuelle Hilfe, mit der Sie sich komplizierte Strukturen und Beziehungen verdeutlichen können. Der Befehl gitk3 kann ein Bild des gerichteten azyklischen Graphen eines Repository zeichnen, wann immer Sie es wollen. 3
Ja, das ist einer der wenigen Git-Befehle, die nicht als »Unterbefehle« betrachtet werden, daher wird er als gitk und nicht als git gitk angegeben.
84 | Kapitel 6: Commits
00___Git_945-8.book Seite 85 Donnerstag, 14. Januar 2010 2:25 14
Schauen wir unsere Beispiel-Website an: $ cd public_html $ gitk
Das Programm gitk ist sehr vielseitig, wir wollen uns jedoch auf den Graphen beziehen. Die Graph-Ausgabe sieht ungefähr so aus wie in Abbildung 6-7.
Abbildung 6-7: Ein Merge mit gitk betrachtet
Folgendes müssen Sie wissen, um die gerichteten azyklischen Graphen der Commits zu verstehen. Zunächst einmal: Jedes Commit kann null oder mehr Eltern haben: • Normale Commits haben exakt ein Eltern-Commit, bei dem es sich um das vorhergehende Commit im Verlauf handelt. Wenn Sie eine Änderung vornehmen, ist Ihre Änderung der Unterschied zwischen Ihrem neuen Commit und dessen Eltern-Commit. • Es gibt normalerweise ein Commit ohne Eltern-Commits: das erste Commit, das ganz unten im Graphen auftaucht. • Ein Merge-Commit, wie etwa dasjenige ganz oben im Graphen, hat mehr als ein Eltern-Commit. Ein Commit mit mehr als einem Kind bildet die Stelle, an der der Verlauf sich geteilt und einen Zweig geformt hat. In Abbildung 6-7 bildet das Commit Mein Gedicht entfernen den Verzweigungspunkt. Es gibt keine permanente Aufzeichnung der Verzweigungsstartpunkte, allerdings kann Git sie mithilfe des Befehls git merge-base algorithmisch ermitteln.
Commit-Bereiche Viele Git-Befehle erlauben Ihnen, einen Commit-Bereich festzulegen. In seiner einfachsten Ausführung ist ein Commit-Bereich eine Kurzform für eine Reihe von Commits. Komplexere Formen erlauben Ihnen, Commits »einzuschließen« und »auszuschließen«. Ein Bereich wird durch doppelte Punkte angedeutet (..), wie in start..end, wobei start und end mithilfe der Formen angegeben werden können, die im Abschnitt »Commits
Der Commit-Verlauf
| 85
00___Git_945-8.book Seite 86 Donnerstag, 14. Januar 2010 2:25 14
festlegen« auf Seite 73 beschrieben sind. Typischerweise dient ein Bereich dazu, einen Zweig oder einen Teil eines Zweiges zu untersuchen. Weiter vorn im Abschnitt »Alte Commits anschauen« auf Seite 78 haben Sie erfahren, wie Sie einen Commit-Bereich mit git log benutzen. In dem Beispiel wurde der Bereich master~12..master~10 dazu verwendet, das 11. und 10. vorangegangene Commit im Master-Zweig zu bezeichnen. Betrachten Sie zur Verdeutlichung den Commit-Graphen in Abbildung 6-8. Zweig M wird über einen Teil seines Commit-Verlaufs dargestellt, der linear ist. M~14
M~13
M~12
M~11
M~10
A
B
M~9 M
Abbildung 6-8: Linearer Commit-Verlauf
Erinnern Sie sich daran, dass die Zeit von links nach rechts verläuft, sodass M~14 das älteste gezeigte, M~9 das neueste gezeigte und A das elftletzte Commit ist. Der Bereich M~12..M~10 repräsentiert zwei Commits, die 11.- und 10.-ältesten Commits, die mit A und B bezeichnet sind. Der Bereich schließt nicht M~12 ein. Wieso nicht? Das ist eine Definitionsfrage. Ein Commit-Bereich, start..end, ist als die Menge der vom Ende end erreichbaren Commits definiert, die nicht von start erreichbar sind. Mit anderen Worten, »das Commit end wird einbezogen«, während »das Commit start ausgeschlossen wird«. Meist wird das durch die Wendung »in end, aber nicht in start« vereinfacht.
Erreichbarkeit in Graphen In der Graphentheorie sagt man, dass ein Knoten X von einem anderen Knoten A aus erreichbar ist, wenn Sie bei A starten, den Regeln entsprechend die Bögen des Graphen entlangreisen und bei X ankommen können. Die Menge der erreichbaren Knoten für einen Knoten A ist die Sammlung aller Knoten, die von A aus erreichbar sind. In einem Git-Commit-Graphen besteht die Menge der erreichbaren Commits aus all denjenigen Commits, die Sie von einem bestimmten Commit aus erreichen können, indem Sie die gerichteten Elternverbindungen durchlaufen. Konzeptuell und in Bezug auf den Datenfluss ist die Menge der erreichbaren Commits die Menge der Vorfahren-Commits, die in ein bestimmtes Anfangs-Commit einfließt und zu diesem beiträgt.
Indem Sie für git log ein Commit Y angeben, fordern Sie Git dazu auf, das Log für alle Commits anzuzeigen, die von Y aus erreichbar sind. Sie können ein Commit X sowie alle Commits, die von X aus erreichbar sind, mit dem Ausdruck ^X ausschließen.
86 | Kapitel 6: Commits
00___Git_945-8.book Seite 87 Donnerstag, 14. Januar 2010 2:25 14
Kombiniert man die beiden Formen, dann ist git log ^X Y das Gleiche wie git log X..Y und könnte als »Gib mir alle Commits, die von Y aus erreichbar sind, und gib mir keine Commits, die bis zu einschließlich X führen« umschrieben werden. Der Commit-Bereich X..Y ist mathematisch äquivalent mit ^X Y. Sie können ihn sich auch als eine Mengensubtraktion vorstellen: Benutze alles, was bis zu Y führt, minus allem, was bis zu einschließlich X führt. Um wieder auf die Commit-Folge aus dem Beispiel zurückzukommen: Hier sehen Sie, wie M~12..M~10 nur zwei Commits festlegt, A und B. Beginnen Sie mit allem, was bis zu M~10 führt, wie in der ersten Zeile von Abbildung 6-9 gezeigt wird. Suchen Sie alles, was bis zu einschließlich M~12 führt, wie in der zweiten Zeile der Abbildung zu sehen ist. Und schließlich subtrahieren Sie M~12 von M~10, um die Commits zu erhalten, die in der dritten Zeile der Abbildung stehen. …
M~14
M~13
M~12
…
…
M~14
M~13
M~11
M~10
A
B
M~11
M~10
A
B
M~12
…
Abbildung 6-9: Hier werden Bereiche als Mengensubtraktion interpretiert
Wenn der Verlauf Ihres Repository eine einfache lineare Folge von Commits darstellt, dann ist es relativ leicht verständlich, wie ein Bereich funktioniert. Sind allerdings Zweige oder Merges an dem Graphen beteiligt, wird alles etwas kompliziert. Deshalb ist es wichtig, die entscheidende Definition zu verstehen. Schauen wir uns einige weitere Beispiele an. Im Fall eines master-Zweigs mit einem linearen Verlauf (wie in Abbildung 6-10) sind die Mengen B..E, ^B E sowie C, D und E äquivalent.
A
B
C
D
E
master
Abbildung 6-10: Ein einfacher linearer Verlauf
Der Commit-Verlauf
| 87
00___Git_945-8.book Seite 88 Donnerstag, 14. Januar 2010 2:25 14
In Abbildung 6-11 wurde der master-Zweig in Commit V mit dem topic-Zweig unter B zusammengeführt.
T
U
A
B
C
D
V
W
X
Y
topic
Z
master
Abbildung 6-11: Master in Topic zusammengeführt
Der Bereich topic..master repräsentiert diese Commits in master, nicht aber in topic. Da jedes Commit auf dem master-Zweig bis einschließlich V (..., T, U, V) zu topic beiträgt, werden diese Commits ausgeschlossen, wodurch W, X, Y und Z übrigbleiben. Die Umkehrung des vorherigen Beispiels wird in Abbildung 6-12 gezeigt. Hier wurde topic in master zusammengeführt.
A
B
V
W
topic
X
Y
Z
master
Abbildung 6-12: Topic in Master zusammengeführt
In diesem Beispiel ist der Bereich topic..master, der wieder diese Commits in master, nicht aber topic repräsentiert, die Menge der Commits auf dem master-Zweig, die bis zu einschließlich V, W, X, Y und Z führt. Wir müssen jedoch ein bisschen vorsichtig sein und den vollständigen Verlauf des topicZweigs betrachten. Bedenken Sie den Fall, wo er ursprünglich als Zweig von master begann und dann wieder mit diesem Zweig zusammengeführt wurde (Abbildung 6-13).
U
A
B
C
D
V
W
X
Y
Abbildung 6-13: Verzweigung und Merge (Zusammenführung)
88 | Kapitel 6: Commits
topic
Z
master
00___Git_945-8.book Seite 89 Donnerstag, 14. Januar 2010 2:25 14
In diesem Fall enthält topic..master nur die Commits W, X, Y und Z. Erinnern Sie sich: Der Bereich schließt alle Commits aus, die (durch Zurück- bzw. Nach-links-Gehen über den Graphen) von topic (d.h. die Commits D, C, B, A und früher) sowie V, U und früher vom Eltern-Commit von B aus erreichbar sind. Das Ergebnis ist einfach W bis Z. Es gibt zwei weitere mögliche Kombinationen: Wenn Sie entweder das start- oder das end-Commit aus dem Bereich herauslassen, wird HEAD angenommen. Das bedeutet, ..end ist äquivalent mit HEAD..end und start.. ist äquivalent mit start..HEAD. Und schließlich, genau wie start..end als Darstellung einer Mengensubtraktionsoperation betrachtet werden kann, repräsentiert die Notation A...B (mit drei Punkten) die symmetrische Differenz zwischen A und B oder die Menge von Commits, die entweder von A oder von B aus erreichbar sind, nicht jedoch von beiden. Wegen der Symmetrie der Funktion kann kein Commit wirklich als »Start« oder »Ende« angesehen werden. In diesem Sinn sind A und B »gleich«. Förmlicher wird die Menge der Revisionen in der symmetrischen Differenz zwischen A und B, A...B, angegeben durch $ git rev-list A B --not $(git merge-base --all A B)
Schauen wir uns das Beispiel in Abbildung 6-14 an.
A
B
C
D
E
F
G
H
U
V
W
X
Y
I
Z
master
dev
Abbildung 6-14: Symmetrische Differenz
Wir können die einzelnen Teile der Definition der symmetrischen Differenz berechnen: master...dev = (master OR dev) AND NOT (merge-base --all master dev)
Die Commits, die zu master beitragen, sind (I, H, ..., B, A, W, V, U). Die Commits, die zu dev beitragen, sind (Z, Y, ..., U, C, B, A). Die Vereinigung dieser beiden Mengen ist (A, ..., I, U, ..., Z). Die Merge-Basis zwischen master und dev ist Commit W. In komplexeren Fällen könnte es mehrere Merge-Basen geben, hier haben wir aber nur eine. Die Commits, die zu W beitragen, sind (W, V, U, C, B und A); das sind auch die Commits, die sowohl master als auch dev gemein haben, die also entfernt werden müssen, um die symmetrische Differenz zu formen: (I, H, Z, Y, X, G, F, E, D). Es hilft vielleicht, wenn Sie sich die symmetrische Differenz zwischen zwei Zweigen A und B so vorstellen: »Zeige alles in Zweig A oder in Zweig B, aber nur zurück bis zu der Stelle, an der sich die beiden Zweige geteilt haben«.
Der Commit-Verlauf
| 89
00___Git_945-8.book Seite 90 Donnerstag, 14. Januar 2010 2:25 14
Nachdem wir uns nun damit befasst haben, was Commit-Bereiche sind, wie man sie schreibt und wie sie funktionieren, müssen wir deutlich machen, dass Git eigentlich keinen echten Bereichsoperator unterstützt. Es ist nur eine Bequemlichkeit in der Schreibweise, dass A..B die zugrunde liegende Form ^A B repräsentiert. Git erlaubt auf seiner Kommandozeile sogar noch eine viel stärkere Manipulation der Commit-Mengen. Befehle, die einen Bereich akzeptieren, nehmen sogar eine beliebige Folge von »eingeschlossenen« und »ausgeschlossenen« Commits entgegen. Sie könnten z.B. git log ^dev ^topic ^bugfix master verwenden, um Commits in master, aber nicht in einem der Zweige dev, topic oder bugfix auszuwählen. Diese Beispiele sind vielleicht ein bisschen abstrakt. Die Stärke der Bereichsdarstellung zeigt sich, wenn Sie bedenken, dass jeder Zweigname als Teil des Bereichs verwendet werden kann. Falls, wie in »Tracking-Zweige« auf Seite 197 beschrieben wird, einer Ihrer Zweige die Commits aus einem anderen Repository repräsentiert, können Sie schnell diejenige Menge der Commits ermitteln, die zwar in Ihrem Repository, nicht jedoch in einem anderen Repository sind!
Commits suchen (und finden) Ein Teil eines guten Revisionskontrollsystems ist die Unterstützung, die es für die »Archäologie« und die Untersuchung eines Repository bietet. Git kennt mehrere Mechanismen, mit deren Hilfe Sie in Ihrem Repository Commits suchen können, die bestimmten Kriterien entsprechen.
git bisect verwenden Der Befehl git bisect stellt ein leistungsfähiges Werkzeug zum Isolieren eines bestimmten fehlerhaften Commit auf der Grundlage praktisch beliebiger Suchkriterien dar. git bisect eignet sich ganz besonders für Gelegenheiten, in denen Sie entdecken, dass irgendetwas »Falsches« oder »Schlechtes« Ihr Repository beeinflusst, und Sie wissen, dass der Code eigentlich in Ordnung war. Nehmen wir z.B. an, dass Sie am Linux-Kernel arbeiten und ein Test-Booten fehlschlägt. Sie sind sich aber sicher, dass das Booten früher schon einmal funktioniert hat – vielleicht letzte Woche oder bei einem früheren Release-Tag. In diesem Fall ist Ihr Repository von einem bekannten »guten« in einen bekannten »schlechten« Zustand übergegangen. Aber wann? Welches Commit hat den Schaden verursacht? Das ist genau die Frage, bei deren Beantwortung Sie git bisect unterstützen soll. Die einzige echte Suchanforderung besteht darin, dass Sie bei ausgechecktem Repository in der Lage sein sollen festzustellen, ob es Ihrer Suchanforderung entspricht oder nicht. In diesem Fall müssen Sie diese Frage beantworten können: »Kompiliert und bootet die Version des Kernels, die ausgecheckt wurde?« Sie müssen außerdem eine »gute« und eine
90 | Kapitel 6: Commits
00___Git_945-8.book Seite 91 Donnerstag, 14. Januar 2010 2:25 14
»schlechte« Version bzw. einen entsprechenden Commit kennen, bevor Sie anfangen, damit die Suche eingeschränkt werden kann. git bisect wird oft verwendet, um ein bestimmtes Commit zu isolieren, das einen Rück-
schritt oder einen Bug in das Repository getragen hat. Wenn Sie z.B. am Linux-Kernel arbeiten, dann kann Ihnen git bisect dabei helfen, Probleme und Bugs zu finden, wie etwa fehlschlagendes Kompilieren, fehlschlagendes Booten oder Boot-Vorgänge, die bestimmte Aufgaben nicht ausführen können oder denen irgendwelche gewünschten Leistungsmerkmale fehlen. In all diesen Fällen unterstützt Sie git bisect dabei, das genaue Commit zu isolieren und zu ermitteln, das das Problem verursacht hat. Der Befehl git bisect wählt systematisch ein neues Commit in einem kleiner werdenden Bereich, der durch das »gute« Verhalten am einen Ende und das »schlechte« Verhalten am anderen Ende eingegrenzt wird. Schließlich wird der Bereich exakt auf das eine Commit eingeengt, das für das fehlerhafte Verhalten verantwortlich ist. Sie müssen nicht mehr tun, als zu Anfang ein gutes und ein schlechtes Commit vorzugeben und dann wiederholt die Frage zu beantworten: »Funktioniert diese Version?« Zu Beginn müssen Sie ein gutes und ein schlechtes Commit ermitteln. In der Praxis handelt es sich bei der schlechten Version oft um Ihren aktuellen HEAD, da dies die Stelle ist, an der Sie arbeiteten, als Sie plötzlich bemerkten, dass etwas schiefläuft oder dass es einen Bug zu beheben gibt. Eine erste gute Version zu finden, kann etwas schwieriger sein, da diese üblicherweise irgendwo im Verlauf begraben ist. Vermutlich können Sie eine Version irgendwo im Verlauf des Repository benennen oder erraten, von der Sie wissen, dass sie richtig funktioniert. Dies könnte ein markiertes Release wie v2.6.25 oder ein Commit vor 100 Revisionen, master~100, auf Ihrem Master-Zweig sein. Idealerweise liegt das gute Commit »nah« bei Ihrem schlechten Commit (master~25 ist besser als master~100) und ist nicht zu weit in der Vergangenheit verschüttet. Auf jeden Fall müssen Sie wissen oder überprüfen können, dass es tatsächlich ein gutes Commit ist. Es ist sehr wichtig, dass Sie den git bisect-Prozess aus einem sauberen Arbeitsverzeichnis heraus starten. Der Prozess arrangiert Ihr Arbeitsverzeichnis notwendigerweise so, dass es mehrere unterschiedliche Versionen Ihres Repository enthält. Wenn Sie mit einem unsauberen Arbeitsverzeichnis beginnen, handeln Sie sich nur Ärger ein; die Änderungen im Arbeitsverzeichnis könnten leicht verloren gehen. Wir verwenden in unserem Beispiel einen Klon des Linux-Kernels und weisen Git nun an, eine Suche zu beginnen: $ cd linux-2.6 $ git bisect start
Nach dem Initiieren einer zweigeteilten Suche tritt Git in einen »Bisect-Modus« ein, in dem es einige Zustandsinformationen für sich selbst einrichtet. Git nutzt einen abgesonderten HEAD, um die aktuelle ausgecheckte Version des Repository zu verwalten. Dieser
Commits suchen (und finden)
| 91
00___Git_945-8.book Seite 92 Donnerstag, 14. Januar 2010 2:25 14
abgesonderte HEAD ist im Prinzip ein anonymer Zweig, der verwendet werden kann, um innerhalb des Repository herumzuhüpfen und bei Bedarf auf unterschiedliche Revisionen zu zeigen. Teilen Sie nun Git mit, welches Commit schlecht ist. Da es sich hierbei typischerweise um Ihre aktuelle Version handelt, stellen Sie einfach die Revision auf Ihren aktuellen HEAD:4 # Sage git, dass die HEAD-Version nicht funktioniert $ git bisect bad
Sagen Sie Git nun noch, welche Version in Ordnung ist: $ git bisect good v2.6.27 Bisecting: 3857 revisions left to test after this [cf2fa66055d718ae13e62451bb546505f63906a2] Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6
Durch das Identifizieren einer guten und einer schlechten Version wird ein Bereich von Commits eingegrenzt, in dem der Übergang von Gut zu Schlecht auftritt. Git sagt Ihnen bei jedem Schritt entlang des Weges, wie viele Revisionen sich in diesem Bereich befinden. Darüber hinaus verändert Git Ihr Arbeitsverzeichnis, indem es eine Revision auscheckt, die sich ungefähr in der Mitte zwischen den guten und den schlechten Endpunkten befindet. Jetzt müssen Sie diese Frage beantworten: »Ist diese Version gut oder schlecht?« Immer wenn Sie die Frage beantworten, engt Git den Suchraum auf die Hälfte ein, identifiziert eine neue Revision, checkt sie aus und wiederholt die »Gut oder schlecht?«-Frage. Nehmen Sie an, dass diese Version »gut« ist: $ git bisect good Bisecting: 1939 revisions left to test after this [2be508d847392e431759e370d21cea9412848758] Merge git://git.infradead.org/mtd-2.6
Wie Sie sehen, sind von 3857 Revisionen nun noch 1939 im Rennen. Machen wir weiter: $ git bisect good Bisecting: 939 revisions left to test after this [b80de369aa5c7c8ce7ff7a691e86e1dcc89accc6] 8250: Add more OxSemi devices $ git bisect bad Bisecting: 508 revisions left to test after this [9301975ec251bab1ad7cfcb84a688b26187e4e4a] Merge branch 'genirq-v28-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip
Bei einem perfekten Bisection-Durchlauf sind log2 der ursprünglichen Anzahl an Revisionsschritten nötig, um die Menge auf ein Commit einzugrenzen.
4
Für die neugierigen Leser, die dieses Beispiel nachvollziehen wollen: HEAD ist hier Commit 49fdf6785fd660e18a1eb4588928f47e9fa29a9a.
92 | Kapitel 6: Commits
00___Git_945-8.book Seite 93 Donnerstag, 14. Januar 2010 2:25 14
Nach einer weiteren »Gut«- und »Schlecht«-Antwort: $ git bisect good Bisecting: 220 revisions left to test after this [7cf5244ce4a0ab3f043f2e9593e07516b0df5715] mfd: check for platform_get_irq() return value in sm501 $ git bisect bad Bisecting: 104 revisions left to test after this [e4c2ce82ca2710e17cb4df8eb2b249fa2eb5af30] ring_buffer: allocate buffer page pointer
Während des Bisection-Prozesses führt Git ein Log Ihrer Antworten zusammen mit deren Commit-IDs: $ git bisect log git bisect start # bad: [49fdf6785fd660e18a1eb4588928f47e9fa29a9a] Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block git bisect bad 49fdf6785fd660e18a1eb4588928f47e9fa29a9a # good: [3fa8749e584b55f1180411ab1b51117190bac1e5] Linux 2.6.27 git bisect good 3fa8749e584b55f1180411ab1b51117190bac1e5 # good: [cf2fa66055d718ae13e62451bb546505f63906a2] Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6 git bisect good cf2fa66055d718ae13e62451bb546505f63906a2 # good: [2be508d847392e431759e370d21cea9412848758] Merge git://git.infradead.org/mtd-2.6 git bisect good 2be508d847392e431759e370d21cea9412848758 # bad: [b80de369aa5c7c8ce7ff7a691e86e1dcc89accc6] 8250: Add more OxSemi devices git bisect bad b80de369aa5c7c8ce7ff7a691e86e1dcc89accc6 # good: [9301975ec251bab1ad7cfcb84a688b26187e4e4a] Merge branch 'genirq-v28-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip git bisect good 9301975ec251bab1ad7cfcb84a688b26187e4e4a # bad: [7cf5244ce4a0ab3f043f2e9593e07516b0df5715] mfd: check for platform_get_irq() return value in sm501 git bisect bad 7cf5244ce4a0ab3f043f2e9593e07516b0df5715
Falls Sie sich während dieses Vorgangs verirren oder aus einem anderen Grund neu anfangen wollen, geben Sie den Befehl git bisect replay mit der Logdatei als Eingabe ein. Das ist ein ausgezeichneter Mechanismus, um einen Schritt in diesem Pfad »zurückzugehen« und einen anderen Weg zu erkunden. Wir wollen uns dem Defekt mit fünf weiteren »Schlecht«-Antworten annähern: $ git bisect bad Bisecting: 51 revisions left to test after this [d3ee6d992821f471193a7ee7a00af9ebb4bf5d01] ftrace: make it depend on DEBUG_KERNEL $ git bisect bad Bisecting: 25 revisions left to test after this [3f5a54e371ca20b119b73704f6c01b71295c1714] ftrace: dump out
Commits suchen (und finden)
| 93
00___Git_945-8.book Seite 94 Donnerstag, 14. Januar 2010 2:25 14
ftrace buffers to console on panic $ git bisect bad Bisecting: 12 revisions left to test after this [8da3821ba5634497da63d58a69e24a97697c4a2b] ftrace: create _mcount_loc section $ git bisect bad Bisecting: 6 revisions left to test after this [fa340d9c050e78fb21a142b617304214ae5e0c2d] tracing: disable tracepoints by default $ git bisect bad Bisecting: 2 revisions left to test after this [4a0897526bbc5c6ac0df80b16b8c60339e717ae2] tracing: tracepoints, samples
Sie könnten den Befehl git bisect visualize verwenden, um die Menge der Commits, die sich immer noch im Bereich unserer Überlegungen befinden, visuell zu untersuchen. Git benutzt das grafische Werkzeug gitk, wenn die Umgebungsvariable DISPLAY gesetzt ist. Falls nicht, nimmt Git stattdessen git log. In diesem Fall könnte auch --pretty=oneline ganz nützlich sein. $ git bisect visualize --pretty=oneline fa340d9c050e78fb21a142b617304214ae5e0c2d b07c3f193a8074aa4afe43cfa8ae38ec4c7ccfa9 0a16b6075843325dc402edf80c1662838b929aff instrumentation - scheduler 4a0897526bbc5c6ac0df80b16b8c60339e717ae2 24b8d831d56aac7907752d22d2aba5d8127db6f6 97e1c18e8d17bd87e1e383b2e9d9fc740332c8e2
tracing: disable tracepoints by default ftrace: port to tracepoints tracing, sched: LTTng tracing: tracepoints, samples tracing: tracepoints, documentation tracing: Kernel Tracepoints
Die aktuelle Revision, die infrage kommt, befindet sich ungefähr in der Mitte des Bereichs: $ git bisect good Bisecting: 1 revisions left to test after this [b07c3f193a8074aa4afe43cfa8ae38ec4c7ccfa9] ftrace: port to tracepoints
Wenn Sie schließlich die letzte Revision testen und Git die eine Revision isoliert hat, die das Problem verursacht hat,5 wird sie angezeigt: $ git bisect good fa340d9c050e78fb21a142b617304214ae5e0c2d is first bad commit commit fa340d9c050e78fb21a142b617304214ae5e0c2d Author: Ingo Molnar <[email protected]> Date: Wed Jul 23 13:38:00 2008 +0200 tracing: disable tracepoints by default
5
Nein, dieses Commit hat nicht unbedingt ein Problem verursacht. Die »Gut«- und »Schlecht«-Antworten wurden konstruiert, und deshalb sind wir hier gelandet.
94 | Kapitel 6: Commits
00___Git_945-8.book Seite 95 Donnerstag, 14. Januar 2010 2:25 14
while it's arguably low overhead, we don't enable new features by default. Signed-off-by: Ingo Molnar <[email protected]> :040000 040000 4bf5c05869a67e184670315c181d76605c973931 fd15e1c4adbd37b819299a9f0d4a6ff589721f6c M init
Wenn schließlich Ihr Bisection-Durchlauf fertig ist und Sie das Bisection-Log und den gesicherten Zustand abgeschlossen haben, müssen Sie Git das unbedingt mitteilen. Wie Sie sich sicher erinnern, wird der gesamte Bisection-Vorgang, also die zweigeteilte Suche, auf einem abgesonderten HEAD durchgeführt: $ git branch * (no branch) master $ git bisect reset Switched to branch "master" $ git branch * master
Mit dem Befehl git bisect reset gelangen Sie wieder zurück in Ihren ursprünglichen Zweig.
git blame benutzen Ein weiteres Werkzeug zum Identifizieren eines bestimmten Commit ist git blame. Dieser Befehl teilt Ihnen mit, wer zuletzt die einzelnen Zeilen einer Datei modifiziert hat und bei welchem Commit die Änderung bestätigt wurde: $ git blame -L 35, init/version.c 4865ecf1 (Serge E. Hallyn 2006-10-02 02:18:14 -0700 35) }, ^1da177e (Linus Torvalds 2005-04-16 15:20:36 -0700 36) }; 4865ecf1 (Serge E. Hallyn 2006-10-02 02:18:14 -0700 37) EXPORT_SYMBOL_GPL(init_uts_ns); 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 38) c71551ad (Linus Torvalds 2007-01-11 18:18:04 -0800 39) /* FIXED STRINGS! Don't touch! */ c71551ad (Linus Torvalds 2007-01-11 18:18:04 -0800 40) const char linux_banner[] = 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 41) "Linux version " UTS_RELEASE " (" LINUX_COMPILE_BY "@" 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 42) LINUX_COMPILE_HOST ") (" LINUX_COMPILER ") " UTS_VERSION "\n"; 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 43) 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 44) const char linux_proc_banner[] = 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 45) "%s version %s" 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 46) " (" LINUX_COMPILE_BY "@" LINUX_COMPILE_HOST ")" 3eb3c740 (Roman Zippel 2007-01-10 14:45:28 +0100 47) " (" LINUX_COMPILER ") %s\n";
Commits suchen (und finden)
| 95
00___Git_945-8.book Seite 96 Donnerstag, 14. Januar 2010 2:25 14
Mit der Spitzhacke suchen Während git blame Sie über den aktuellen Zustand einer Datei in Kenntnis setzt, durchsucht git log -Sstring den Verlauf der Diffs einer Datei nach einem vorgegebenen String. Indem er die eigentlichen Diffs, also die Unterschiede zwischen den Revisionen durchsucht, kann der Befehl Commits finden, die eine Änderung sowohl bei Ergänzungen als auch bei den Löschungen durchführen. $ git log -Sinclude --pretty=oneline --abbrev-commit init/version.c cd354f1... [PATCH] remove many unneeded #includes of sched.h 4865ecf... [PATCH] namespaces: utsname: implement utsname namespaces 63104ee... kbuild: introduce utsrelease.h 1da177e... Linux-2.6.12-rc2
Jedes der auf der linken Seite aufgeführten Commits (cd354f1… usw.) fügt entweder Zeilen hinzu oder löscht Zeilen, die das Wort include enthalten. Seien Sie jedoch vorsichtig: Wenn ein Commit exakt die gleiche Anzahl an Zeilen mit Ihrer Schlüsselphrase sowohl hinzufügt als auch löscht, wird das nicht angezeigt. Damit gezählt wird, muss das Commit eine Änderung in der Anzahl der Ergänzungen und der Löschungen aufweisen. Die Option -S von git log wird auch als Pickaxe (Spitzhacke) bezeichnet. Das ist sozusagen Archäologie mit roher Gewalt.
96 | Kapitel 6: Commits
00___Git_945-8.book Seite 97 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 7
KAPITEL 7
Zweige
Ein Zweig (auch englisch »branch« genannt) ist das grundlegende Mittel zum Starten einer separaten Entwicklungslinie in einem Softwareprojekt. Bei einem Zweig handelt es sich um eine Abspaltung aus einer Art vereinigtem Ausgangszustand, die es erlaubt, die Entwicklung gleichzeitig in mehrere Richtungen voranzutreiben und potenziell verschiedene Versionen des Projekts herzustellen. Oft wird ein Zweig an anderen Zweigen abgestimmt und wieder mit ihnen zusammengeführt, um getrennt durchgeführte Leistungen wieder zu vereinen. Git lässt viele Zweige und damit auch viele unterschiedliche Entwicklungslinien innerhalb eines Repository zu. Das Verzweigungssystem von Git ist leichtgewichtig und einfach. Darüber hinaus bietet Git eine erstklassige Unterstützung für Merges (Zusammenführungen). Aus diesem Grund verwenden die meisten Git-Benutzer Zweige gern und oft. In diesem Kapitel zeigen wir Ihnen, wie Sie Zweige auswählen, anlegen, betrachten und entfernen. Außerdem bieten wir Ihnen einige bewährte Methoden, damit Ihre Zweige nicht am Ende einem Manzanita-Baum ähneln.1
Gründe für den Einsatz von Zweigen Für die Erzeugung eines Zweiges gibt es eine schier endlose Zahl von technischen, philosophischen, betrieblichen und sogar sozialen Gründen. Hier sind einige verbreitete Erklärungen: • Ein Zweig repräsentiert oft eine individuelle Kundenversion. Falls Sie mit Version 1.1 Ihres Projekts beginnen wollen, aber wissen, dass einige Ihrer Kunden lieber bei Version 1.0 bleiben, dann pflegen Sie die alte Version als separaten Zweig weiter. 1
OK, OK. Das ist ein kleiner, buschartiger Baum, der sich sehr stark verzweigt. Er kommt vor allem in Nordamerika vor. Heimischer Verwandter sind die Bärentrauben. Eine bessere Analogie ist vielleicht der BanyanBaum.
| 97
00___Git_945-8.book Seite 98 Donnerstag, 14. Januar 2010 2:25 14
• Ein Zweig kann eine Entwicklungsphase einkapseln, wie etwa den Prototyp, die Beta-Version, eine stabile oder noch nicht ausgereifte Ausgabe. Stellen Sie sich die Version »1.1« einfach ebenfalls als getrennte Phase vor – die gepflegte Version. • Ein Zweig kann die Entwicklung einer speziellen Funktion oder die Untersuchungen über einen besonders komplexen Bug isolieren. So könnten Sie z.B. einen Zweig einführen, um eine wohldefinierte und konzeptuell isolierte Aufgabe auszuführen oder einen Merge mehrerer Zweige vor der Freigabe einer Version zu erleichtern. Es mag Ihnen vielleicht übertrieben erscheinen, nur zum Ausmerzen eines Bugs einen neuen Zweig anzulegen, doch das Verzweigungssystem von Git eignet sich für solche kleinen Einsatzfälle ganz besonders gut. • Ein einzelner Zweig kann die Arbeit eines einzelnen Mitarbeiters repräsentieren. Ein weiterer Zweig – der »Integrations«-Zweig – dient dann speziell dazu, die Arbeiten zu vereinen. Git bezeichnet solche Zweige als Topic-Zweige oder Entwicklungszweige. Das Wort »Topic« (Thema) deutet darauf hin, dass jeder Zweig im Repository einen bestimmten Zweck verfolgt. Außerdem kennt Git das Konzept eines Tracking-Zweigs oder Zweigs, mit dem die Klone eines Repository synchron gehalten werden. In Kapitel 11 wird näher erläutert, wie man Tracking-Zweige benutzt.
Zweig oder Tag? Zweige und Tags scheinen ähnlich, vielleicht sogar austauschbar zu sein. Wann sollte man daher einen Tag-Namen und wann einen Zweignamen benutzen? Tags und Zweige dienen unterschiedlichen Zwecken. Ein Tag soll ein statischer Name sein, der sich über die Zeit nicht ändert oder verschiebt. Einmal angewandt, sollten Sie es in Ruhe lassen. Es dient als Stütze im Boden und als Referenzpunkt. Ein Zweig andererseits ist dynamisch und verschiebt sich mit jedem Commit, das Sie ausführen. Der Zweigname ist dazu gedacht, Ihrer laufenden Entwicklung zu folgen. Seltsamerweise können Sie einem Zweig und einem Tag den gleichen Namen geben. In diesem Fall müssen Sie ihre vollständige Ref-Namen verwenden, um sie zu unterscheiden. Z.B. könnten Sie refs/tags/v1.0 und refs/heads/v1.0 benutzen. Möglicherweise wollen Sie den gleichen Namen als Zweignamen während der Entwicklung verwenden und ihn dann beim Abschluss Ihrer Entwicklung in einen Tag-Namen umwandeln. Wie Sie Zweige und Tags letztendlich nennen, müssen Sie selbst festlegen, etwa in Ihren Projektrichtlinien. Sie müssen jedoch das wesentliche Unterscheidungsmerkmal beachten: Ist dieser Name statisch und unveränderbar oder ist er für die Entwicklung dynamisch? Die erste Variante sollte ein Tag werden, die zweite ein Zweig.
98 | Kapitel 7: Zweige
00___Git_945-8.book Seite 99 Donnerstag, 14. Januar 2010 2:25 14
Zweignamen Der Name, den Sie einem Zweig zuweisen, ist prinzipiell beliebig, allerdings gibt es einige Einschränkungen. Der Standardzweig in einem Repository wird als master bezeichnet. In diesem Zweig bewahren die meisten Entwickler die robusteste und zuverlässigste Entwicklungslinie des Repository auf. An dem Namen master ist nichts Magisches, außer dass Git ihn während der Initialisierung eines Repository einführt. Falls Sie wollen, können Sie den master-Zweig umbenennen oder sogar löschen. Allerdings ist es wahrscheinlich am besten, wenn Sie ihn so lassen, wie er ist. Um die Skalierbarkeit und die grundsätzliche Organisation zu unterstützen, können Sie einen hierarchischen Zweignamen anlegen, der einem Unix-Pfadnamen ähnelt. Nehmen Sie z.B. an, dass Sie Teil eines Entwicklungsteams sind, das eine große Menge Bugs behebt. Es könnte sich als sinnvoll erweisen, die Entwicklung der einzelnen Reparaturen in eine hierarchische Struktur unter dem Zweignamen bug zu legen, und zwar in separate Zweige, die irgendwie bug/pr-1023 und bug/pr-17 heißen. Falls Sie feststellen, dass Sie sehr viele Zweige haben oder einfach nur unglaublich gut organisiert sind, können Sie diese Schrägstrichsyntax verwenden, um Ihre Zweignamen zu organisieren. Ein Grund für die Benutzung von hierarchischen Zweignamen besteht darin, dass Git, genau wie die Unix-Shell, Wildcards unterstützt. Z.B. könnten Sie bei einem Namensschema wie bug/pr-1023 und bug/pr-17 mit einem cleveren und vertrauten Kürzel alle bug-Zweige auf einmal auswählen. git show-branch 'bug/*'
Was man in Zweignamen tun und lassen sollte Zweignamen müssen einigen einfachen Regeln genügen: • Sie können den Schrägstrich (/) benutzen, um ein hierarchisches Namensschema zu erzeugen. Allerdings darf der Name nicht mit einem Schrägstrich enden. • Komponenten, die nicht durch Schrägstriche getrennt sind, dürfen mit einem Punkt (.) beginnen. Ein Zweigname wie feature/.new ist ungültig • Der Name darf nicht zwei aufeinanderfolgende Punkte (..) enthalten. • Außerdem darf der Name Folgendes nicht enthalten: • Ein Leerzeichen oder ein anderes Whitespace-Zeichen • Ein Zeichen, das für Git eine besondere Bedeutung besitzt, darunter die Tilde (~), das Dach (^), den Doppelpunkt (:), das Fragezeichen (?), den Asterisk (*) und die geöffnete eckige Klammer ([) • Ein ASCII-Steuerzeichen, d.h. ein Byte mit einem niedrigeren Wert als \040 oktal oder das DEL-Zeichen (\177 oktal)
Zweignamen | 99
00___Git_945-8.book Seite 100 Donnerstag, 14. Januar 2010 2:25 14
Diese Regeln für Zweignamen werden vom Plumbing-Befehl git check-ref-format durchgesetzt und sollen sicherstellen, dass die Zweignamen sowohl einfach eingegeben als auch als Dateinamen innerhalb des .git-Verzeichnisses und der Skripten benutzt werden können.
Zweige benutzen Es kann in einem Repository zu jedem Zeitpunkt viele unterschiedliche Zweige geben, allerdings ist immer nur höchstens ein Zweig »aktiv« oder »aktuell«. Der aktive Zweig bestimmt, welche Dateien in das Arbeitsverzeichnis ausgecheckt werden. Darüber hinaus ist der aktuelle Zweig oft ein impliziter Operand in Git-Befehlen, wie etwa das Ziel der Merge-Operation. Standardmäßig ist master der aktive Zweig; Sie können aber jeden Zweig zum aktuellen Zweig machen. In Kapitel 6 habe ich Commit-Graph-Diagramme vorgestellt, die mehrere Zweige enthalten. Denken Sie an diese Graphenstruktur, wenn Sie Zweige manipulieren, weil Ihnen das dabei hilft, das elegante und einfache Objektmodell zu etablieren, das den Zweigen in Git zugrunde liegt.
Ein Zweig erlaubt dem Inhalt des Repository, in viele Richtungen, nämlich eine pro Zweig, auseinanderzudriften. Sobald ein Repository wenigstens einen Zweig abgeteilt hat, wird ein Commit entweder auf den einen oder den anderen Zweig angewandt, je nachdem, welcher aktiv ist. Jeder Zweig in einem bestimmten Repository muss einen eindeutigen Namen tragen. Der Name bezieht sich immer auf die neueste Revision, die auf diesem Zweig durch ein Commit bestätigt wurde. Das neueste Commit auf einem Zweig wird Spitze oder Kopf des Zweiges genannt. Git zeichnet keine Informationen darüber auf, woher ein Zweig stammt. Stattdessen verschiebt sich der Zweigname schrittweise vorwärts, wenn auf dem Zweig neue Commits vorgenommen werden. Ältere Commits müssen deshalb mit ihrem Hash oder über einen relativen Namen wie dev~5 benannt werden. Falls Sie ein bestimmtes Commit im Auge behalten wollen – weil es z.B. einen stabilen Punkt im Projekt repräsentiert oder es sich um eine Version handelt, die Sie testen wollen –, können Sie ihm explizit einen TagNamen zuweisen. Da das Original-Commit, mit dem ein Zweig gestartet wurde, nicht ausdrücklich gekennzeichnet ist, kann man dieses Commit (oder sein Äquivalent) algorithmisch suchen, indem man den Namen des Originalzweigs verwendet, aus dem der neue Zweig abgespaltet wurde: $ git merge-base Originalzweig neuer-Zweig
Ein Merge (Zusammenführung) ist das Gegenteil eines Zweigs bzw. einer Verzweigung. Wenn Sie einen Merge ausführen, wird der Inhalt eines oder mehrerer Zweige mit einem
100 | Kapitel 7: Zweige
00___Git_945-8.book Seite 101 Donnerstag, 14. Januar 2010 2:25 14
impliziten Zielzweig zusammengeführt. Allerdings eliminiert ein Merge weder irgendwelche Quellzweige noch deren Namen. Der ziemlich komplexe Vorgang des Zusammenführens von Zweigen steht im Zentrum von Kapitel 9. Sie können sich einen Zweignamen als einen Zeiger auf ein bestimmtes (wiewohl sich entwickelndes) Commit vorstellen. Ein Zweig enthält die Commits, die ausreichend sind, um den gesamten Verlauf des Projekts entlang des Zweigs, aus dem es gekommen ist, zu rekonstruieren, und zwar bis zurück an den Anfang des Projekts. In Abbildung 7-1 verweist der Zweigname dev auf das oberste Commit (den Kopf) Z. Wollten Sie den Repository-Zustand bei Z wiederherstellen, wären alle Commits erforderlich, die von Z zurück bis zum Original-Commit A erreichbar sind. Der erreichbare Teil des Graphen ist mit dicken Linien hervorgehoben und deckt alle Commits ab außer (S, G, H, J, K, L).
P
Q
R
U
A
B
C
D
V
S
W
E
X
F J
testing
Y
G K
H L
Z
dev
master
Stable
Abbildung 7-1: Commits, die von dev aus erreichbar sind
Alle Zweignamen sowie der durch Commits bestätigte Inhalt in den einzelnen Zweigen liegen lokal in Ihrem Repository. Wenn Sie Ihr Repository anderen zugänglich machen, können Sie diese veröffentlichen bzw. beschließen, einen oder mehrere Zweige mit den dazugehörigen Commits anderen zur Verfügung zu stellen. Das Veröffentlichen eines Zweigs muss explizit geschehen. Falls Ihr Repository geklont ist, werden Ihre Zweignamen und die Entwicklung auf diesen Zweigen ebenfalls Teil der neu geklonten Repository-Kopie.
Zweige erzeugen Ein neuer Zweig beruht auf einem vorhandenen Commit innerhalb des Repository. Es bleibt ganz Ihnen überlassen, das Commit zu ermitteln und festzulegen, das als Start des neuen Zweiges dienen soll. Git unterstützt eine beliebig komplexe Verzweigungsstruktur, einschließlich verzweigender Zweige und der Abspaltung mehrerer Zweige vom selben Commit.
Zweige erzeugen
| 101
00___Git_945-8.book Seite 102 Donnerstag, 14. Januar 2010 2:25 14
Auch die Lebensdauer eines Zweigs unterliegt Ihrer Entscheidung. Ein Zweig kann kurzoder langlebig sein. Während der Lebenszeit des Repository darf ein bestimmter Zweigname mehrere Male hinzugefügt und gelöscht werden. Nachdem Sie das Commit identifiziert haben, von dem ein Zweig ausgehen soll, setzen Sie einfach den Befehl git branch. Das heißt, um einen neuen Zweig vom HEAD Ihres aktuellen Zweigs aus zu erzeugen, damit Problem Report #1138 erledigt wird, würden Sie folgenden Befehl benutzen: $ git branch prs/pr-1138
Die Grundform des Befehls sieht so aus: git branch Zweig [Start-Commit]
Wenn kein Start-Commit angegeben ist, wird standardmäßig die Revision benutzt, die zuletzt auf dem aktuellen Zweig durch ein Commit bestätigt wurde. Mit anderen Worten wird ein neuer Zweig standardmäßig dort gestartet, wo Sie gerade arbeiten. Beachten Sie, dass der Befehl git branch lediglich den Namen eines Zweigs in das Repository einführt. Er ändert nicht Ihr Arbeitsverzeichnis dahingehend, dass der neue Zweig benutzt wird. Es ändern sich keine Dateien des Arbeitsverzeichnisses, es kommt nicht zu impliziten Änderungen des Zweigkontexts, es werden keine neuen Commits ausgeführt. Der Befehl erzeugt lediglich einen benannten Zweig am angegebenen Commit. Sie können nicht einmal anfangen, auf dem neuen Zweig zu arbeiten, da Sie zuerst dorthin wechseln müssen, wie später in »Zweige auschecken« auf Seite 105 gezeigt wird. Manchmal wollen Sie ein anderes Commit als Anfang eines Zweigs angeben. Nehmen Sie z.B. an, dass Ihr Projekt für jeden gemeldeten Bug einen neuen Zweig anlegt und Sie von einem Bug in einer bestimmten Version hören. Es ist sicher bequemer, den Parameter Start-Commit zu benutzen, als das Arbeitsverzeichnis in den Zweig umzuschalten, der diese Version repräsentiert. Normalerweise gibt es in Ihrem Projekt Konventionen, die es Ihnen erlauben, mit Sicherheit ein Start-Commit festzulegen. Um z.B. ein Bugfix an der Version 2.3 Ihrer Software vorzunehmen, könnten Sie einen Zweig namens rel-2.3 als Start-Commit erzeugen: $ git branch prs/pr-1138 rel-2.3
Der einzige Commit-Name, der garantiert eindeutig ist, ist die Hash-ID. Falls Sie die Hash-ID kennen, können Sie sie direkt benutzen: $ git branch prs/pr-1138 db7de5feebef8bcd18c5356cb47c337236b50c13
Zweignamen auflisten Der Befehl git branch listet die Zweignamen auf, die er im Repository findet: $ git branch bug/pr-1 dev * master
102 | Kapitel 7: Zweige
00___Git_945-8.book Seite 103 Donnerstag, 14. Januar 2010 2:25 14
In diesem Beispiel werden drei Topic-Zweige gezeigt. Der Zweig, der gerade in Ihren Arbeitsbaum ausgecheckt ist, wird durch den Asterisk gekennzeichnet. Dieses Beispiel zeigt außerdem zwei weitere Zweige, nämlich bug/pr-1 und dev. Ohne zusätzliche Parameter werden nur die Topic-Zweige im Repository aufgelistet. Wie Sie in Kapitel 11 sehen werden, könnte es zusätzliche Remote-Tracking-Zweige in Ihrem Repository geben. Diese listen Sie mit der Option -r auf. Sowohl Topic- als auch RemoteZweige listen Sie mit -a auf.
Zweige anschauen Der Befehl git show-branch liefert eine ausführlichere Ausgabe als git branch, indem er in ungefähr umgekehrt chronologischer Reihenfolge die Commits auflistet, die zu einem oder mehreren Zweigen beitragen. Wie bei git branch werden ohne Optionen die TopicZweige aufgelistet, -r zeigt Remote-Tracking-Zweige und -a zeigt alle Zweige. Schauen wir uns ein Beispiel an: $ git show-branch ! [bug/pr-1] Fix Problem Report 1 * [dev] Neue Entwicklung verbessern ! [master] Bobs Fixes hinzugefügt --* [dev] Neue Entwicklung verbessern * [dev^] Eine neue Entwicklung beginnen + [bug/pr-1] Fix Problem Report 1 +*+ [master] Bobs Fixes hinzugefügt
Die git show-branch-Ausgabe ist in zwei Abschnitte unterteilt, die durch eine Zeile mit Bindestrichen getrennt sind. Der Abschnitt über der Trennlinie zeigt die Namen der Zweige eingeschlossen in eckige Klammern, und zwar je einen pro Zeile. Jeder Zweigname ist mit einer einzelnen Ausgabespalte verknüpft, die entweder mit einem Ausrufezeichen oder – falls es sich außerdem um den aktuellen Zweig handelt – einem Asterisk gekennzeichnet ist. In dem gezeigten Beispiel starten die Commits im Zweig bug/pr-1 in der ersten Spalte, Commits im aktuellen Zweig dev starten in der zweiten Spalte und Commits im dritten Zweig master starten in der dritten Spalte. Für einen schnelleren Zugriff ist für jeden Zweig im oberen Abschnitt außerdem die erste Zeile der Lognachricht aus dem neuesten Commit auf diesem Zweig aufgeführt. Der untere Abschnitt der Ausgabe ist eine Matrix, die angibt, welche Commits in jedem Zweig vorhanden sind. Auch hier ist jedes Commit mit der ersten Zeile der Lognachricht für dieses Commit aufgeführt. In einem Zweig ist ein Commit vorhanden, wenn es ein Pluszeichen (+), einen Asterisk (*) oder ein Minuszeichen (–) in der Spalte dieses Zweigs gibt. Das Pluszeichen zeigt an, dass das Commit in einem Zweig ist, der Asterisk hebt hervor, dass das Commit im aktiven Zweig vorhanden ist. Das Minuszeichen weist auf ein Merge-Commit hin.
Zweige anschauen
| 103
00___Git_945-8.book Seite 104 Donnerstag, 14. Januar 2010 2:25 14
Beide folgende Commits sind z.B. durch Asteriske gekennzeichnet und im dev-Zweig vorhanden: * *
[dev] Neue Entwicklung verbessern [dev^] Eine neue Entwicklung starten
Diese beiden Commits sind in einem anderen Zweig nicht vertreten. Sie sind in umgekehrter chronologischer Reihenfolge aufgelistet: Das neueste Commit steht oben, das älteste unten. Eingeschlossen in eckige Klammern auf jeder Commit-Zeile zeigt Git außerdem einen Namen für dieses Commit. Wie bereits erwähnt, weist Git den Zweignamen dem neuesten Commit zu. Vorangegangene Commits tragen den gleichen Namen mit einem abschließenden Dach (^). In Kapitel 6 haben Sie master als Namen des neuesten Commit und master^ als Namen für das vorletzte Commit kennengelernt. Entsprechend sind dev und dev^ die Namen der beiden neuesten Commits im Zweig dev. Die Commits innerhalb eines Zweig sind zwar sortiert, die Zweige selbst aber werden in beliebiger Reihenfolge aufgelistet. Das liegt daran, dass alle Zweige den gleichen Status haben; es gibt keine Regel, die besagt, dass ein Zweig wichtiger wäre als ein anderer. Falls ein Commit in mehreren Zweigen vorhanden ist, trägt es ein Pluszeichen oder einen Asterisk für jeden Zweig. Das heißt, dass das letzte Commit, das in der vorherigen Ausgabe zu sehen war, in allen drei Zweigen vorkommt: +*+ [master] Bobs Fixes hinzugefügt
Das erste Pluszeichen bedeutet, dass das Commit sich in bug/pr-1 befindet, der Asterisk heißt, dass das gleiche Commit auch im aktiven Zweig dev zu finden ist, und das letzte Pluszeichen bedeutet, dass das Commit auch im master-Zweig vorliegt. Wenn der Befehl git show-branch aufgerufen wird, durchläuft er alle Commits in allen Zweigen, die gezeigt werden, und stoppt das Auflisten auf dem neuesten Commit, das in allen Zweigen vorkommt. In diesem Fall hat Git vier Commits aufgeführt, bevor es eines gefunden hat, das in allen drei Zweigen vorhanden ist (Bobs Fixes hinzugefügt). Dort hat es dann angehalten. Das Stoppen beim ersten gemeinsamen Commit ist eine Standardheuristik für ein vernünftiges Verhalten. Es wird angenommen, dass das Erreichen eines solchen gemeinsamen Punkts genügend Kontext liefert, um zu verstehen, wie die Zweige miteinander zusammenhängen. Falls Sie aus irgendeinem Grund in der Geschichte der Commits weiter zurückgehen wollen, benutzen Sie die Option --more=Zahl, mit der Sie die Anzahl der zusätzlichen Commits angeben, die Sie sehen wollen, während Sie entlang des gemeinsamen Zweigs in der Zeit zurückwandern. Der Befehl git show-branch akzeptiert eine Menge von Zweignamen als Parameter, wodurch er Ihnen erlaubt, den Verlauf, der für diese Zweige gezeigt wird, zu beschränken. Falls z.B. ein neuer Zweig namens bug/pr-2 hinzugefügt wird, der beim masterCommit startet, würde das so aussehen:
104 | Kapitel 7: Zweige
00___Git_945-8.book Seite 105 Donnerstag, 14. Januar 2010 2:25 14
$ git branch bug/pr-2 master $ git show-branch ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt * [dev] Neue Entwicklung verbessern ! [master] Bobs Fixes hinzugefügt ---* [dev] Neue Entwicklung verbessern * [dev^] Eine neue Entwicklung starten + [bug/pr-1] Fix Problem Report 1 ++*+ [bug/pr-2] Bobs Fixes hinzugefügt
Mit dem folgenden Befehl zeigen Sie den Commit-Verlauf nur für die Zweige bug/pr-1 und bug/pr-2: $ git show-branch bug/pr-1 bug/pr-2
Bei nur einigen wenigen Zweigen mag das ja in Ordnung sein, wenn es aber viele solche Zweige gäbe, würde es sehr schnell nerven, sie alle einzeln zu nennen. Zum Glück erlaubt Git die Wildcard-Filterung von Zweignamen. Mit dem einfacheren bug/*-WildcardNamen kann man das gleiche Ergebnis erzielen: $ git show-branch bug/pr-1 bug/pr-2 ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt -+ [bug/pr-1] Fix Problem Report 1 ++ [bug/pr-2] Bobs Fixes hinzugefügt $ git show-branch bug/* ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt -+ [bug/pr-1] Fix Problem Report 1 ++ [bug/pr-2] Bobs Fixes hinzugefügt
Zweige auschecken Wie bereits weiter vorn in diesem Kapitel erwähnt, kann Ihr Arbeitsverzeichnis nur einen Zweig gleichzeitig wiedergeben. Um das Arbeiten in einem anderen Zweig zu starten, führen Sie den Befehl git checkout aus. git checkout macht den angegebenen Zweig zum neuen, aktuellen Arbeitszweig. Es ändert die Datei- und Verzeichnisstruktur Ihres Arbeitsbaums so, dass diese dem Zustand des angegebenen Zweigs entspricht. Wie Sie allerdings sehen werden, baut Git Sicherungen ein, damit Sie keine Daten verlieren, die Sie noch nicht durch Commits bestätigt haben. Darüber hinaus bietet Ihnen git checkout Zugriff auf alle Zustände des Repository von der Spitze des Zweigs bis an den Anfang des Projekts. Wie Sie sich vielleicht aus Kapitel 6 erinnern, hat das seinen Grund darin, dass jedes Commit einen Schnappschuss des gesamten Repository-Zustands zu einem bestimmten Augenblick aufzeichnet.
Zweige auschecken
| 105
00___Git_945-8.book Seite 106 Donnerstag, 14. Januar 2010 2:25 14
Ein einfaches Beispiel für das Auschecken eines Zweigs Nehmen Sie an, Sie wollen vom dev-Zweig im Beispiel aus dem vorigen Abschnitt wechseln und Ihre Aufmerksamkeit stattdessen der Lösung des Problems zuwenden, das mit dem Zweig bug/pr-1 verknüpft ist. Schauen wir uns den Zustand des Arbeitsverzeichnisses vor und nach git checkout an: $ git branch bug/pr-1 bug/pr-2 * dev master $ git checkout bug/pr-1 Switched to branch "bug/pr-1" $ git branch * bug/pr-1 bug/pr-2 dev master
Die Dateien und die Verzeichnisstruktur Ihres Arbeitsverzeichnisses wurden an den Zustand und den Inhalt des neuen Zweigs bug/pr-1 angepasst. Um jedoch die Dateien zu sehen, die Ihr Arbeitsverzeichnis gewechselt hat, um den Zustand an der Spitze dieses Zweigs widerzuspiegeln, müssen Sie einen normalen Unix-Befehl wie ls benutzen. Das Auswählen eines neuen Zweigs könnte dramatische Auswirkungen auf Ihre Arbeitsbaumdateien und die Verzeichnisstruktur haben. Natürlich hängt das Ausmaß dieser Änderung von den Unterschieden zwischen Ihrem aktuellen Zweig und dem neuen Zielzweig ab, den Sie auschecken wollen. Das Wechseln der Zweige hat folgende Auswirkungen: • Dateien und Verzeichnisse, die in dem Zweig vorliegen, der ausgecheckt wird, aber nicht im aktuellen Zweig, werden aus dem Objektspeicher ausgecheckt und in den Arbeitsbaum gelegt. • Dateien und Verzeichnisse, die im aktuellen Zweig vorhanden sind, in dem ausgecheckten Zweig jedoch fehlen, werden aus dem Arbeitsbaum entfernt. • Dateien, die in beiden Zweigen vorkommen, werden verändert und spiegeln damit den Inhalt wider, der im ausgecheckten Zweig vorhanden ist. Seien Sie nicht beunruhigt, wenn es so aussieht, als würde das Auschecken fast sofort geschehen. Ein verbreiteter Anfängerfehler besteht darin, zu denken, dass das Auschecken nicht funktioniert hat, weil das System sofort zurückkehrt, nachdem angeblich riesige Änderungen vorgenommen wurden. Das ist eine der Eigenschaften, in denen sich Git wirklich und stark von vielen anderen Versionskontrollsystemen unterscheidet. Git ist ausgesprochen gut darin, die paar Dateien und Verzeichnisse zu ermitteln, die tatsächlich beim Auschecken geändert werden mussten.
106 | Kapitel 7: Zweige
00___Git_945-8.book Seite 107 Donnerstag, 14. Januar 2010 2:25 14
Auschecken trotz unbestätigter Änderungen Git verhindert das versehentliche Löschen oder Verändern von Daten in Ihrem lokalen Arbeitsbaum, ohne dass Sie das ausdrücklich anfordern müssen. Dateien und Verzeichnisse, die nicht überwacht werden, werden immer in Ruhe gelassen; Git entfernt oder modifiziert sie nicht. Falls Sie jedoch lokale Änderungen an einer Datei haben, die sich von den Änderungen im neuen Zweig unterscheiden, gibt Git eine solche Fehlermeldung aus und weigert sich, den Zielzweig auszuchecken: $ git branch bug/pr-1 bug/pr-2 dev * master $ git checkout dev error: Entry 'NeuerKram' not uptodate. Cannot merge.
In diesem Fall warnt eine Meldung Sie, dass irgendetwas Git dazu gebracht hat, die Anforderung zum Auschecken zu stoppen. Aber was? Sie können es herausfinden, indem Sie den Inhalt der Datei NeuerKram untersuchen, da diese lokal im aktuellen Arbeitsverzeichnis modifiziert wurde. Außerdem schauen Sie sich den Zielzweig dev an: # Zeigen, wie NeuerKram im Arbeitsverzeichnis aussieht $ cat NeuerKram Irgendetwas Irgendetwas anderes # Zeigen, dass die lokale Version der Datei eine zusätzliche Zeile enthält, die # im aktuellen Zweig des Arbeitsverzeichnisses (master) nicht bestätigt ist $ git diff NeuerKram diff --git a/NeuerKram b/NeuerKram index 0f2416e..5e79566 100644 --- a/NeuerKram +++ b/NeuerKram @@ -1 +1,2 @@ Irgendetwas +Irgendetwas anderes # Zeigen, wie die Datei im dev-Zweig aussieht $ git show dev:NeuerKram Irgendetwas Eine Änderung
Hätte Git frecherweise die Anforderung zum Auschecken des dev-Zweigs befolgt, wären Ihre lokalen Modifikationen von NeuerKram in Ihrem Arbeitsverzeichnis durch die Version von dev überschrieben worden. Git entdeckt standardmäßig diesen potenziellen Verlust und verhindert, dass er geschieht.
Zweige auschecken
| 107
00___Git_945-8.book Seite 108 Donnerstag, 14. Januar 2010 2:25 14
Falls es Ihnen egal ist, ob Änderungen in Ihrem Arbeitsverzeichnis verloren gehen, können Sie Git mit der Option -f zwingen, das Auschecken durchzuführen.
Allerdings weist der Cannot merge-Teil der Fehlermeldung von Git darauf hin, wie Git Ihre Datei schützen kann, wenn Sie ihm die Möglichkeit dazu einräumen. Wir wollen untersuchen, was Sie tun müssen, um den Wechsel durchzuführen und dennoch Ihre Änderungen zu sichern. Die Fehlermeldung, die besagt, dass NeuerKram not uptodate (nicht auf dem neuesten Stand) ist, könnte darauf hindeuten, dass Sie die Datei innerhalb des Index aktualisieren müssen und dann mit dem Auschecken fortfahren können. Allerdings reicht das noch nicht. Der Einsatz von git add, beispielsweise zum Aktualisieren des neuen Inhalts von NeuerKram im Index, setzt nur den Inhalt dieser Datei in den Index; es wird kein Commit durchgeführt. Git kann den neuen Zweig immer noch nicht auschecken, ohne dass die Änderungen verloren gehen. Das funktioniert also auch nicht. $ git add NeuerKram $ git checkout dev error: Entry 'NeuerKram' would be overwritten by merge. Cannot merge.
Tatsächlich würde es immer noch überschrieben werden. Es reicht also nicht, die Änderung dem Index hinzuzufügen. Sie könnten an dieser Stelle auch einfach git commit aufrufen, um die Änderung im aktuellen Zweig (master) zu bestätigen. Nehmen Sie aber an, Sie wollen, dass die Änderung stattdessen im neuen Zweig dev geschieht. Es scheint ausweglos zu sein: Sie können Ihre Änderung erst in den Zweig dev packen, wenn sie ausgecheckt ist, und Git erlaubt Ihnen das Auschecken nicht, weil es eine Änderung gegeben hat. Zum Glück gibt es einen Weg aus dieser Zwickmühle.
Änderungen in einem anderen Zweig zusammenführen Im vorangegangenen Abschnitt widersprach der aktuelle Zustand Ihres Arbeitsverzeichnisses dem des Zweigs, in den Sie wechseln wollten. Daher ist ein Merge nötig: Die Änderungen in Ihrem Arbeitsverzeichnis müssen mit den Dateien zusammengeführt werden, die ausgecheckt werden. Falls möglich oder speziell mit der Option -m angefordert, versucht Git Ihre lokale Änderung in das neue Arbeitsverzeichnis zu überführen, indem es eine Merge-Operation zwischen Ihren lokalen Änderungen und dem Zielzweig ausführt. $ git checkout -m dev M NeuerKram Switched to branch "dev"
Git hat hier die Datei NeuerKram geändert und den Zweig dev erfolgreich ausgecheckt.
108 | Kapitel 7: Zweige
00___Git_945-8.book Seite 109 Donnerstag, 14. Januar 2010 2:25 14
Diese Merge-Operation erfolgt vollständig in Ihrem Arbeitsverzeichnis. Sie führt auf keinem der Zweige ein Merge-Commit ein. In gewisser Weise ist sie analog zum Befehl cvs update, da die lokalen Änderungen mit den Zielzweig zusammengeführt werden und in Ihrem Arbeitsverzeichnis verbleiben. Sie müssen in diesen Szenarien allerdings vorsichtig sein. Es mag zwar so aussehen, als ob der Merge sauber durchgeführt worden wäre und alles in Ordnung sei, jedoch hat Git einfach nur die Datei modifiziert und die Merge-Konfliktindikatoren dringelassen; Sie müssen also vorhandene Konflikte immer noch auflösen: $ cat NeuerKram Irgendetwas <<<<<<< dev:NeuerKram Eine Änderung ======= Irgendetwas anderes >>>>>>> local:NeuerKram
In Kapitel 9 erfahren Sie mehr über Merges und lernen hilfreiche Techniken kennen, mit denen sich Merge-Konflikte lösen lassen. Falls Git einen Zweig auschecken, in ihn wechseln und Ihre lokalen Änderungen sauber und ohne Konflikte zusammenführen kann, ist die Anforderung zum Auschecken erfolgreich verlaufen. Nehmen Sie einmal an, Sie sind im master-Zweig in Ihrem Entwicklungs-Repository und haben einige Änderungen an der Datei NeuerKram vorgenommen. Außerdem merken Sie, dass die Änderungen, die Sie gemacht haben, eigentlich an einem anderen Zweig hätten geschehen sollen, vielleicht weil sie Problem Report #1 erledigen und im Zweig bug/ pr-1 mit einem Commit bestätigt werden sollten. Gehen Sie so vor: Starten Sie im master-Zweig. Nehmen Sie Änderungen an einigen Dateien vor; diese Änderungen werden hier durch das Hinzufügen des Textes Ein Bugfix zu der Datei NeuerKram repräsentiert: $ git show-branch ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt ! [dev] Mit dem Entwickeln von NeuerKram begonnen * [master] Bobs Fixes hinzugefügt ---+ [dev] Mit dem Entwickeln von NeuerKram begonnen + [dev^] Neue Entwicklung verbessern + [dev~2] Eine neue Entwicklung starten + [bug/pr-1] Fix Problem Report 1 +++* [bug/pr-2] Bobs Fixes hinzugefügt $ echo "Ein Bugfix" >> NeuerKram $ cat NeuerKram Irgendetwas Ein Bugfix
Zweige auschecken
| 109
00___Git_945-8.book Seite 110 Donnerstag, 14. Januar 2010 2:25 14
An dieser Stelle merken Sie, dass die gesamte Arbeit im Zweig bug/pr-1 mit einem Commit bestätigt werden sollte und nicht im master-Zweig. Zum Vergleich, so sieht die Datei NeuerKram im Zweig bug/pr-1 vor dem Auschecken im nächsten Schritt aus: $ git show bug/pr-1:NeuerKram Irgendetwas
Um Ihre Änderungen in den gewünschten Zweig zu überführen, versuchen Sie einfach, ihn auszuchecken : $ git checkout bug/pr-1 M NeuerKram Switched to branch "bug/pr-1" $ cat NeuerKram Irgendetwas Ein Bugfix
Git war hier in der Lage, die Änderungen aus Ihren Arbeitsverzeichnissen und den Zielzweig korrekt zusammenzuführen und sie in Ihrer neuen Arbeitsverzeichnisstruktur zu lassen. Mit dem Befehl git diff könnten Sie überprüfen, ob der Merge tatsächlich erwartungsgemäß abgelaufen ist: $ git diff diff --git a/NeuerKram b/NeuerKram index 0f2416e..b4d8596 100644 --- a/NeuerKram +++ b/NeuerKram @@ -1 +1,2 @@ Irgendetwas +Ein Bugfix
Der einzeilige Zusatz ist korrekt.
Einen neuen Zweig anlegen und auschecken Ein anderes relativ häufig auftretendes Szenario tritt ein, wenn Sie einen neuen Zweig anlegen und gleichzeitig in ihn wechseln wollen. Git bietet mit der Option -b neuer-Zweig eine Abkürzung zu diesem Ziel. Beginnen wir an derselben Stelle wie im vorigen Beispiel. Allerdings müssen Sie nun einen neuen Zweig starten, anstatt Änderungen in einen bestehenden Zweig einzuchecken. Mit anderen Worten, Sie befinden sich im master-Zweig, bearbeiten Dateien und merken plötzlich, dass Sie alle Änderungen lieber in einem völlig neuen Zweig namens bug/pr-3 bestätigen wollen. Sie gehen so vor: $ git branch bug/pr-1 bug/pr-2 dev * master $ git checkout -b bug/pr-3
110 | Kapitel 7: Zweige
00___Git_945-8.book Seite 111 Donnerstag, 14. Januar 2010 2:25 14
M NeuerKram Switched to a new branch "bug/pr-3" $ git show-branch ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt * [bug/pr-3] Bobs Fixes hinzugefügt ! [dev] Mit dem Entwickeln von NeuerKram begonnen ! [master] Bobs Fixes hinzugefügt ----+ [dev] Mit dem Entwickeln von NeuerKram begonnen + [dev^] Neue Entwicklung verbessern + [dev~2] Eine neue Entwicklung starten + [bug/pr-1] Fix Problem Report 1 ++*++ [bug/pr-2] Bobs Fixes hinzugefügt
Solange nicht irgendein Problem verhindert, dass ein Befehl zum Auschecken abgeschlossen wird, entspricht der Befehl $ git checkout -b neuer-Zweig Startpunkt
genau dieser Sequenz aus zwei Befehlen: $ git branch neuer-Zweig Startpunkt $ git checkout neuer-Zweig
Abgesonderte HEAD-Zweige Normalerweise ist es ratsam, nur die Spitze eines Zweigs auszuchecken, indem man den Zweig direkt benennt. Daher wechselt git checkout standardmäßig zur Spitze eines gewünschten Zweigs. Sie können jedoch ein beliebiges Commit auschecken. In so einem Fall erzeugt Git eine Art anonymen Zweig für Sie, der als abgesonderter HEAD bezeichnet wird. Git legt einen abgesonderten HEAD an, wenn Sie: • Ein Commit auschecken, das nicht der Kopf eines Zweigs ist. • Einen Tracking-Zweig auschecken. Sie könnten das tun, um Änderungen zu untersuchen, die zuvor aus einem entfernten Repository in Ihr Repository gebracht wurden. • Das Commit auschecken, das von einem Tag referenziert wird. Sie könnten das tun, um ein Release auf der Grundlage der markierten Versionen der Dateien zusammenzustellen. • Eine git bisect-Operation starten, wie in »git bisect verwenden« auf Seite 90 beschrieben. • Den Befehl git submodule update einsetzen. In diesen Fällen teilt Ihnen Git mit, dass Sie in einen abgesonderten HEAD gewechselt sind: # Ich habe eine Kopie der Git-Quellen bei der Hand! $ cd git.git
Zweige auschecken
| 111
00___Git_945-8.book Seite 112 Donnerstag, 14. Januar 2010 2:25 14
$ git checkout v1.6.0 Note: moving to "v1.6.0" which isn't a local branch If you want to create a new branch from this checkout, you may do so (now or later) by using -b with the checkout command again. Example: git checkout -b HEAD is now at ea02eef... GIT 1.6.0
Falls Sie, wenn Sie sich selbst auf einem abgesonderten HEAD wiederfinden, später beschließen, dass Sie an dieser Stelle neue Commits ausführen und diese behalten wollen, müssen Sie zuerst einen neuen Zweig erzeugen: $ git checkout -b neuer-Zweig
Dadurch erhalten Sie einen neuen, sauberen Zweig auf der Grundlage des Commit, auf dem der abgesonderte HEAD war. Sie können dann mit der normalen Entwicklung fortfahren. Im Prinzip haben Sie dem Zweig, der zuvor anonym war, einen Namen verpasst. Um herauszufinden, ob Sie auf einem abgesonderten HEAD sind, fragen Sie einfach: $ git branch * (no branch) master
Falls Sie andererseits mit dem abgesonderten HEAD fertig sind und diesen Zustand einfach aufgeben wollen, können Sie zu einem benannten Zweig konvertieren, indem Sie einfach git checkout Zweig eingeben: $ git checkout master Previous HEAD position was ea02eef... GIT 1.6.0 Checking out files: 100% (608/608), done. Switched to branch "master" $ git branch * master
Zweige löschen Der Befehl git branch -d Zweig löscht den benannten Zweig aus einem Repository. Git verhindert, dass Sie den aktuellen Zweig entfernen: $ git branch -d bug/pr-3 error: Cannot delete the branch 'bug/pr-3' which you are currently on.
Durch das Löschen des aktuellen Zweigs würde Git nicht mehr feststellen können, wie der resultierende Arbeitsverzeichnisbaum aussehen soll. Sie müssen stattdessen immer einen nicht aktuellen Zweig nennen. Es gibt allerdings noch ein anderes kleines Problem: Git erlaubt es Ihnen nicht, einen Zweig zu löschen, der Commits enthält, die nicht auch auf dem aktuellen Zweig vorhanden sind. Das bedeutet, dass Git verhindert, dass Sie versehentlich Entwicklungen in Commits löschen, die verloren wären, wenn der Zweig gelöscht werden würde.
112 | Kapitel 7: Zweige
00___Git_945-8.book Seite 113 Donnerstag, 14. Januar 2010 2:25 14
$ git checkout master Switched to branch "master" $ git branch -d bug/pr-3 error: The branch 'bug/pr-3' is not an ancestor of your current HEAD. If you are sure you want to delete it, run 'git branch -D bug/pr-3'.
In der git show-branch-Ausgabe ist das Commit »Einen Bugfix für pr-3 hinzugefügt« nur im Zweig bug/pr-3 zu finden. Falls dieser Zweig gelöscht würde, gäbe es keine Möglichkeit mehr, auf dieses Commit zuzugreifen. Indem Git anmerkt, dass der Zweig bug/pr-3 kein Vorfahr Ihres aktuellen HEAD ist, teilt es Ihnen mit, dass die Entwicklungslinie, die durch den Zweig bug/pr-3 repräsentiert wird, nicht zu der Entwicklung des aktuellen Zweigs, master, beiträgt. Git verlangt nicht, dass alle Zweige in den master-Zweig eingefügt werden, bevor sie gelöscht werden können. Denken Sie daran: Ein Zweig ist einfach nur ein Name oder Zeiger auf ein Commit, das tatsächlichen Inhalt enthält. Stattdessen hält Git Sie davon ab, versehentlich Inhalt aus dem zu löschenden Zweig zu verlieren, der nicht in Ihren aktuellen Zweig eingefügt ist. Wenn der Inhalt aus dem gelöschten Zweig bereits in dem anderen Zweig vorhanden ist, würden das Auschecken dieses Zweigs und das anschließende Anfordern des Löschens des Zweigs aus diesem Kontext funktionieren. Ein anderer Ansatz besteht darin, den Inhalt aus dem Zweig, den Sie löschen wollen, mit dem aktuellen Zweig zusammenzuführen (siehe Kapitel 9). Danach kann der andere Zweig sicher gelöscht werden: $ git merge bug/pr-3 Updating 7933438..401b78d Fast forward NeuerKram | 1 + 1 files changed, 1 insertions(+), 0 deletions(-) $ git show-branch ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt ! [bug/pr-3] Einen Bugfix für pr-3 hinzugefügt ! [dev] Mit dem Entwickeln von NeuerKram begonnen * [master] Einen Bugfix für pr-3 hinzugefügt ----+ * [bug/pr-3] Einen Bugfix für pr-3 hinzugefügt + [dev] Mit dem Entwickeln von NeuerKram begonnen + [dev^] Neue Entwicklung verbessern + [dev~2] Eine neue Entwicklung starten + [bug/pr-1] Fix Problem Report 1 ++++* [bug/pr-2] Bobs Fixes hinzugefügt $ git branch -d bug/pr-3 Deleted branch bug/pr-3.
Zweige löschen | 113
00___Git_945-8.book Seite 114 Donnerstag, 14. Januar 2010 2:25 14
$ git show-branch ! [bug/pr-1] Fix Problem Report 1 ! [bug/pr-2] Bobs Fixes hinzugefügt ! [dev] Mit dem Entwickeln von NeuerKram begonnen * [master] Einen Bugfix für pr-3 hinzugefügt ---* [master] Einen Bugfix für pr-3 hinzugefügt + [dev] Mit dem Entwickeln von NeuerKram begonnen + [dev^] Neue Entwicklung verbessern + [dev~2] Eine neue Entwicklung starten + [bug/pr-1] Fix Problem Report 1 +++* [bug/pr-2] Bobs Fixes hinzugefügt
Wie die Fehlermeldung vorschlägt, können Sie schließlich die Sicherheitsüberprüfung von Git außer Kraft setzen, indem Sie -D anstelle von -d benutzen. Tun Sie das, wenn Sie sich sicher sind, dass Sie den zusätzlichen Inhalt in diesem Zweig nicht haben wollen. Git führt keinerlei historische Aufzeichnungen über die Zweignamen, die erzeugt, verschoben, manipuliert, zusammengeführt oder gelöscht werden. Sobald ein Zweigname entfernt wurde, ist er verschwunden. Der Verlauf der Commits in diesem Zweig ist jedoch eine andere Geschichte. Git entfernt irgendwann schließlich Commits, die nicht mehr referenziert werden und von einem benannten Ref, wie etwa einem Zweig- oder Tag-Namen, aus erreichbar sind. Falls Sie diese Commits behalten wollen, müssen Sie sie entweder mit einem anderen Zweig zusammenführen, einen Zweig für sie anlegen oder eine Tag-Referenz auf sie richten. Ohne einen Verweis auf sie sind Commits und Blobs ansonsten unerreichbar und werden schließlich vom Werkzeug git gc als Müll entsorgt. Falls Sie versehentlich Zweige oder andere Refs entfernt haben, stellen Sie sie wieder her. Dazu verwenden Sie den Befehl git reflog. Andere Befehle, wie etwa git fsck, und Konfigurationsoptionen, wie etwa gc.reflogExpire und gc.pruneExpire, helfen Ihnen ebenfalls dabei, verloren gegangene Commits, Dateien und Zweigköpfe wiederherzustellen.
114 | Kapitel 7: Zweige
00___Git_945-8.book Seite 115 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 8
KAPITEL 8
Diffs
Bei einem Diff handelt es sich um eine kompakte Zusammenfassung der Unterschiede (Differenzen, daher der Name »Diff«) zwischen zwei Elementen. Sind z.B. zwei Dateien gegeben, vergleicht der Unix- und Linux-diff-Befehl die Dateien zeilenweise und fasst die Abweichungen in einem Diff zusammen, wie im folgenden Code demonstriert wird. Im Beispiel ist initial eine Version mit einem Text, rewrite ist eine nachfolgende Überarbeitung. Die Option -u erzeugt ein vereinheitlichtes Diff, ein standardisiertes Format, das weit verbreitet ist, um Modifikationen weiterzugeben. $ cat initial Now is the time For all good men To come to the aid Of their country.
$ cat rewrite Today is the time For all good men And women To come to the aid Of their country.
$ diff -u initial rewrite --- initial 1867-01-02 11:22:33.000000000 -0500 +++ rewrite 2000-01-02 11:23:45.000000000 -0500 @@ -1,4 +1,5 @@ -Now is the time +Today is the time For all good men +And women To come to the aid Of their country.
Schauen wir uns das Diff genauer an. Im Header wird die ursprüngliche Datei durch --angedeutet und die neue Datei durch +++. Die @@-Zeile liefert den Zeilennummerkontext für beide Dateiversionen. Eine Zeile, die mit einem Minuszeichen (-) eingeleitet wird, muss aus der Originaldatei gelöscht werden, um die neue Datei herzustellen. Umgekehrt muss eine Zeile mit einem Pluszeichen (+) am Anfang zum Original hinzugefügt werden, um die neue Datei zu erzeugen. Eine Zeile, die mit einem Leerzeichen beginnt, ist in beiden Dateien gleich und wird von der Option -u als Kontext mitgeliefert.
| 115
00___Git_945-8.book Seite 116 Donnerstag, 14. Januar 2010 2:25 14
An sich bietet ein Diff keinen Grund oder keine Begründung für eine Änderung, noch rechtfertigt es den Ausgangs- oder Endzustand. Dennoch liefert ein Diff mehr als nur eine Kurzfassung der Unterschiede zweier Dateien. Es bietet eine förmliche Beschreibung, wie man eine Datei in eine andere überführen kann. (Solche Anweisungen sind sinnvoll, wenn man Änderungen durchführt oder rückgängig macht.) Darüber hinaus kann ein Diff sogar noch erweitert werden, um die Unterschiede zwischen mehreren Dateien und ganzen Verzeichnishierarchien anzuzeigen. Das Unix-diff kann die Unterschiede für alle Dateipaare berechnen, die in zwei Verzeichnishierarchien zu finden sind. Der Befehl diff -r durchläuft alle Hierarchien hintereinander, paart die Dateien anhand der Pfadnamen (z. B. original/src/main.c und neu/src/main.c) und fasst die Unterschiede zwischen den einzelnen Paaren zusammen. diff -r -u erzeugt eine Menge von vereinheitlichten Diffs, mit der zwei Hierarchien verglichen werden. Git besitzt seinen eigenen Diff-Mechanismus und kann daher gleichfalls eine Zusammenfassung von Unterschieden ausgeben. Der Befehl git diff kann Dateien vergleichen, ähnlich dem Unix-diff-Befehl. Außerdem kann Git wie bei diff -r zwei Baumobjekte durchlaufen und eine Darstellung der Abweichungen generieren. git diff weist aber seine eigenen Feinheiten und leistungsfähigen Eigenschaften auf, die auf die speziellen Bedürfnisse von Git-Benutzern zugeschnitten sind. Technisch gesehen, repräsentiert ein Baumobjekt nur eine Verzeichnisebene im Repository. Es enthält Informationen über die unmittelbaren Dateien des Verzeichnisses sowie die direkten Unterverzeichnisse, katalogisiert aber nicht den kompletten Inhalt aller Unterverzeichnisse. Da jedoch ein Baumobjekt auf die Baumobjekte der einzelnen Unterverzeichnisse verweist, repräsentiert das Baumobjekt an der Wurzel des Projekts im Prinzip das gesamte Projekt zu einem bestimmten Zeitpunkt. Daher können wir durchaus davon sprechen, dass git diff »zwei« Bäume durchläuft.
In diesem Kapitel behandeln wir einige der Grundlagen von git diff sowie einige seiner besonderen Fähigkeiten. Sie werden lernen, wie Sie Git dazu bringen, redaktionelle Änderungen in Ihrem Arbeitsverzeichnis ebenso anzuzeigen wie beliebige Änderungen zwischen zwei Commits innerhalb Ihres Projektverlaufs. Sie erfahren, wie das Git-Diff Ihnen dabei hilft, wohlstrukturierte Commits während Ihres normalen Entwicklungsprozesses durchzuführen, und erlernen außerdem die Herstellung von Git-Patches, die in Kapitel 13 ausführlicher beschrieben werden.
Formen des git diff-Befehls Wenn Sie zwei unterschiedliche Baumobjekte auf der Wurzelebene zum Vergleich herausgreifen, liefert git diff alle Abweichungen zwischen den beiden Projektzuständen. Das ist wirkungsstark. Sie könnten ein solches Diff einsetzen, um in großem Maßstab
116 | Kapitel 8: Diffs
00___Git_945-8.book Seite 117 Donnerstag, 14. Januar 2010 2:25 14
von einem Projektzustand in einen anderen zu konvertieren. Falls z.B. Sie und Ihr Mitarbeiter Code für dasselbe Projekt entwickeln, könnte ein Diff auf Wurzelebene im Prinzip jederzeit die Repositories synchronisieren. Es gibt prinzipiell drei Quellen für Baum- oder baumartige Objekte, die mit git diff benutzt werden, nämlich • ein Baumobjekt irgendwo innerhalb des gesamten Commit-Graphen, • Ihr Arbeitsverzeichnis und • den Index. Typischerweise werden die Bäume, die in einem git diff-Befehl verglichen werden, über Commits, Zweignamen oder Tags angesprochen. Es reicht jedoch ein Commit-Name, wie in »Commits festlegen« auf Seite 73 besprochen wird. Außerdem können sowohl die Datei- und Verzeichnishierarchie Ihres Arbeitsverzeichnisses als auch die komplette Hierarchie der Dateien, die im Index bereitgestellt werden, als Bäume behandelt werden. Der Befehl git diff kann vier grundlegende Vergleiche mit verschiedenen Kombinationen der genannten drei Quellen durchführen: git diff git diff zeigt den Unterschied zwischen Ihrem Arbeitsverzeichnis und dem Index.
Es stellt heraus, was in Ihrem Arbeitsverzeichnis unsauber ist und daher ein Kandidat, um für das nächste Commit bereitgestellt zu werden. Dieser Befehl enthüllt nicht die Unterschiede zwischen dem, was sich in Ihrem Index befindet, und dem, was permanent im Repository gespeichert ist (ganz zu schweigen von den entfernten Repositories, mit denen Sie möglicherweise noch arbeiten). git diff Commit
Diese Form fasst die Unterschiede zwischen Ihrem Arbeitsverzeichnis und dem angegebenen Commit zusammen. Gebräuchliche Varianten dieses Befehls nennen HEAD oder einen bestimmten Zweignamen als Commit. git diff --cached Commit
Dieser Befehl zeigt die Unterschiede zwischen den bereitgestellten Änderungen im Index und dem angegebenen Commit. Ein gebräuchliches Commit für den Vergleich – und die Vorgabe, falls kein Commit genannt wurde – ist HEAD. Mit HEAD zeigt Ihnen dieser Befehl, wie Ihr nächstes Commit den aktuellen Zweig verändert. Falls Ihnen die Option --cached komisch vorkommt, dann denken Sie vielleicht lieber an das Synonym --staged. Es ist seit Git-Version 1.6.1 verfügbar. git diff Commit1 Commit2
Wenn Sie zwei beliebige Commits angeben, zeigt dieser Befehl die Unterschiede zwischen den beiden. Er ignoriert den Index und das Arbeitsverzeichnis. Er ist die Waffe der Wahl für beliebige Vergleiche zwischen zwei Bäumen, die sich bereits in Ihrem Objektspeicher befinden.
Formen des git diff-Befehls
| 117
00___Git_945-8.book Seite 118 Donnerstag, 14. Januar 2010 2:25 14
Die Anzahl der Parameter auf der Kommandozeile bestimmt, welche grundlegende Form benutzt und was verglichen wird. Sie können zwei Commits oder Bäume vergleichen. Die zu vergleichenden Elemente müssen nicht in einer direkten oder indirekten Eltern-KindBeziehung zueinander stehen. Wenn Sie keine Baumobjekte angeben, vergleicht git diff implizite Quellen, etwa Ihren Index oder das Arbeitsverzeichnis. Wir wollen untersuchen, wie sich diese unterschiedlichen Formen in das Git-Objektmodell einfügen. Das Beispiel in Abbildung 8-1 zeigt ein Projektverzeichnis mit zwei Dateien. Die Datei datei1 wurde im Arbeitsverzeichnis geändert; Ihr Inhalt lautet jetzt nicht mehr »foo«, sondern »quux«. Diese Änderung wurde mit git add datei1 im Index bereitgestellt, aber noch nicht mit einem Commit bestätigt. Working directory project
file1 This is the working directory version
file2 quux
bar
git diff
Index
git diff HEAD file1
file2
Object store
git diff --cached master HEAD
a23bf This is the HEAD version
9d3a2 foo
bar
bd71363 quux This is the version “in the index”
Abbildung 8-1: Verschiedene Dateiversionen, die miteinander verglichen werden können
118 | Kapitel 8: Diffs
00___Git_945-8.book Seite 119 Donnerstag, 14. Januar 2010 2:25 14
Es wurde jeweils eine Version der Datei datei1 im Arbeitsverzeichnis, im Index und im HEAD erkannt. Auch wenn die Version von datei1, die »im Index« ist, bd71363, eigentlich als Blob-Objekt im Objektspeicher gespeichert wurde, wird sie doch indirekt über das virtuelle Baumobjekt, das der Index ist, referenziert. Ebenso wird die HEAD-Version der Datei, a23bf, durch mehrere Schritte indirekt referenziert. Dieses Beispiel demonstriert die Änderungen in datei1 nur dem Namen nach. Die fetten Pfeile in der Abbildung zeigen auf die Baum- oder virtuellen Baumobjekte, um Sie daran zu erinnern, dass der Vergleich tatsächlich auf den kompletten Bäumen basiert und nicht nur auf einzelnen Dateien. Anhand von Abbildung 8-1 können Sie nun sehen, dass die Benutzung von git diff ohne Argumente eine gute Technik zum Überprüfen der Bereitschaft des nächsten Commit ist. Solange dieser Befehl Ausgaben von sich gibt, haben Sie Änderungen oder Bearbeitungen in Ihrem Arbeitsverzeichnis, die noch nicht bereitgestellt wurden. Prüfen Sie die Bearbeitungen an den einzelnen Dateien. Wenn Sie mit Ihrer Arbeit zufrieden sind, stellen Sie die Datei mit git add bereit. Nachdem Sie das getan haben, ergibt das nächste git diff keine Diff-Ausgabe mehr für diese Datei. Auf diese Weise können Sie sich schrittweise durch alle unsauberen Dateien in Ihrem Arbeitsverzeichnis bewegen, bis es keine Diffs mehr gibt, was bedeuten würde, dass alle Dateien im Index bereitgestellt sind. Vergessen Sie nicht, außerdem nach neuen oder gelöschten Dateien zu suchen. Der Befehl git diff --cached zeigt jederzeit während der Bereitstellung die ergänzenden Änderungen und/ oder solche Änderungen, die bereits im Index bereitsgestellt wurden und im nächsten Commit verarbeitet werden. Wenn Sie fertig sind, erfasst git commit alle Änderungen in Ihrem Arbeitsverzeichnis für ein neues Commit. Sie sind nicht gezwungen, alle Änderungen aus Ihrem Arbeitsverzeichnis für ein einzelnes Commit bereitzustellen. Um genau zu sein: Falls Sie feststellen, dass Sie konzeptuell unterschiedliche Änderungen in Ihrem Arbeitsverzeichnis haben, die in unterschiedliche Commits gelangen sollten, können Sie eine Gruppe zu einem Zeitpunkt bereitstellen und die anderen Änderungen weiterhin im Arbeitsverzeichnis lassen. Ein Commit erfasst nur Ihre bereitgestellten Änderungen. Wiederholen Sie dann den Vorgang, indem Sie die nächste Gruppe von Dateien für ein passendes nachfolgendes Commit bereitstellen. Der scharfsinnige Leser wird sicher bemerkt haben, dass wir zwar vier grundlegende Formen des git diff-Befehls vorgestellt haben, aber nur drei mit fetten Pfeilen in Abbildung 8-1 hervorgehoben wurden. Welches ist also die vierte? Es gibt nur ein Baumobjekt, das von Ihrem Arbeitsverzeichnis repräsentiert wird, und es gibt nur ein Baumobjekt, das vom Index repräsentiert wird. Im Beispiel gibt es ein Commit im Objektspeicher mit seinem Baum. Allerdings besitzt der Objektspeicher wahrscheinlich viele Commits, die nach unterschiedlichen Zweigen und Tags benannt sind, die alle Bäume haben, die mit git diff verglichen werden können. Daher vergleicht die vierte Form von git diff einfach zwei beliebige Commits (Bäume), die bereits im Objektspeicher gespeichert wurden.
Formen des git diff-Befehls
| 119
00___Git_945-8.book Seite 120 Donnerstag, 14. Januar 2010 2:25 14
Zusätzlich zu den vier Grundformen von git diff gibt es noch eine Unzahl von Optionen. Hier sehen Sie einige der nützlicheren: --M Die Option --M entdeckt Umbenennungen und generiert eine vereinfachte Ausgabe, die anstelle des kompletten Entfernens und anschließenden Hinzufügens der Quelldatei lediglich die Dateiumbenennung aufzeichnet. Wurde beim Umbenennen nicht nur der Name gewechselt, sondern auch der Inhalt geändert, gibt Git das bekannt. -w oder --ignore-all-space Sowohl -w als auch --ignore-all-space vergleichen Zeilen, ohne Whitespace-Änderungen gesondert zu beachten. --stat Die Option --stat fügt Statistiken über den Unterschied zwischen zwei Baumzuständen hinzu. Ihre Ausgabe besteht aus einer kompakten Syntax, die aussagt, wie viele Zeilen sich geändert haben, wie viele hinzugefügt und wie viele ignoriert wurden. --color Die Option --color koloriert die Ausgabe; die unterschiedlichen Arten von Änderungen in dem Diff werden jeweils durch eigene Farben repräsentiert. Man kann den Befehl git diff schließlich noch so einschränken, dass er nur die Diffs für bestimmte Dateien oder Verzeichnisse zeigt. Die Option -a für git diff ist nicht einmal entfernt der Option -a für git commit ähnlich. Um sowohl bereitgestellte als auch nicht bereitgestellte Änderungen zu erhalten, verwendet man git diff HEAD. Dieser Mangel an Symmetrie ist nicht nur bedauerlich, sondern auch wenig intuitiv.
Ein einfaches git diff-Beispiel Wir konstruieren hier das Szenario aus Abbildung 8-1, gehen es durch und schauen uns die verschiedenen Formen von git diff in Aktion an. Zuerst wollen wir ein einfaches Repository mit zwei Dateien einrichten: $ mkdir /tmp/diff_beispiel $ cd /tmp/diff_beispiel $ git init Initialized empty Git repository in /tmp/diff_example/.git/ $ echo "foo" > datei1 $ echo "bar" > datei2 $ git add datei1 datei2 $ git commit -m"datei1 und datei2 hinzufügen" [master (root-commit)]: created fec5ba5: "datei1 und datei2 hinzufügen"
120 | Kapitel 8: Diffs
00___Git_945-8.book Seite 121 Donnerstag, 14. Januar 2010 2:25 14
2 files changed, 2 insertions(+), 0 deletions(-) create mode 100644 datei1 create mode 100644 datei2
Nun bearbeiten wir datei1, indem wir das Wort »foo« durch »quux« ersetzen: $ echo "quux" > datei1
Die datei1 wurde im Arbeitsverzeichnis verändert, aber noch nicht bereitgestellt. Dieser Zustand entspricht nicht der Situation, die in Abbildung 8-1 dargestellt wird, aber Sie können trotzdem einen Vergleich vornehmen. Sie sollten eine Ausgabe erwarten, wenn Sie das Arbeitsverzeichnis mit dem Index oder den vorhandenen HEAD-Versionen vergleichen. Allerdings dürfte es keinen Unterschied zwischen dem Index und dem HEAD geben, da nichts bereitgestellt wurde. (Mit anderen Worten: Das, was bereitgestellt wurde, ist immer noch der aktuelle HEAD-Baum.) # Vergleich von Arbeitsverzeichnis und Index $ git diff diff --git a/datei1 b/datei1 index 257cc56..d90bda0 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +quux # Vergleich von Arbeitsverzeichnis und HEAD $ git diff HEAD diff --git a/datei1 b/datei1 index 257cc56..d90bda0 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +quux # Vergleich von Index und HEAD, immer noch identisch $ git diff --cached $
git diff hat also eine Ausgabe erzeugt, und datei1 kann bereitgestellt werden. Also tun
wir das jetzt: $ git add datei1 $ git status # On branch master # Changes to be committed: # (use "git reset HEAD ..." to unstage) # # modified: datei1
Ein einfaches git diff-Beispiel
| 121
00___Git_945-8.book Seite 122 Donnerstag, 14. Januar 2010 2:25 14
Hier wurde exakt die Situation kopiert, die in Abbildung 8-1 beschrieben ist. Da datei1 jetzt bereitgestellt ist, sind das Arbeitsverzeichnis und der Index synchron und sollten keine Unterschiede zeigen. Es gibt nun jedoch Unterschiede zwischen der HEAD-Version und sowohl dem Arbeitsverzeichnis als auch der bereitgestellten Version im Index: # Vergleich von Arbeitsverzeichnis und Index $ git diff # Vergleich von Arbeitsverzeichnis und HEAD $ git diff HEAD diff --git a/datei1 b/datei1 index 257cc56..d90bda0 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +quux # Vergleich von Index und HEAD $ git diff --cached diff --git a/datei1 b/datei1 index 257cc56..d90bda0 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +quux
Führten Sie nun git commit aus, würde das neue Commit die bereitgestellten Änderungen erfassen, die vom letzten Befehl gezeigt wurden, nämlich git diff --cached (der, wie bereits erwähnt, das neue Synonym git diff --staged besitzt). Um nun einmal alles durcheinanderzubringen: Was würde passieren, wenn Sie datei1 bearbeitet hätten, bevor Sie ein Commit durchgeführt hätten? Schauen wir einmal! $ echo "baz" > datei1 # Vergleich von Arbeitsverzeichnis und Index $ git diff diff --git a/datei1 b/datei1 index d90bda0..7601807 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -quux +baz # Vergleich von Arbeitsverzeichnis und HEAD $ git diff HEAD diff --git a/datei1 b/datei1 index 257cc56..7601807 100644
122 | Kapitel 8: Diffs
00___Git_945-8.book Seite 123 Donnerstag, 14. Januar 2010 2:25 14
--- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +baz # Vergleich von Index und HEAD $ git diff --cached diff --git a/datei1 b/datei1 index 257cc56..d90bda0 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +quux
Alle drei Diff-Operationen zeigen nun irgendeine Form von Unterschied! Welche Version wird jedoch bestätigt werden? Erinnern Sie sich: git commit erfasst den Zustand, der im Index vorherrscht. Und was ist im Index? Es ist der Inhalt, der durch den Befehl git diff --cached oder git diff --staged aufgezeigt wird, oder die Version von datei1, die das Wort »quux« enthält! $ git commit -m"quux für alle" [master]: created f8ae1ec: "quux für alle" 1 files changed, 1 insertions(+), 1 deletions(-)
Der Objektspeicher enthält nun zwei Commits; wir wollen daher die allgemeine Form des git diff-Befehls ausprobieren: # Vergleich von vorhergehender HEAD-Version mit aktueller HEAD-Version $ git diff HEAD^ HEAD diff --git a/datei1 b/datei1 index 257cc56..d90bda0 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -foo +quux
Dieses Diff bestätigt, dass das vorhergehende Commit datei1 geändert hat, indem es »foo« durch »quux« ersetzt hat. Ist nun alles synchronisiert? Nein. Die Arbeitsverzeichniskopie von datei1 enthält »baz«: $ git diff diff --git a/datei1 b/datei1 index d90bda0..7601807 100644 --- a/datei1 +++ b/datei1 @@ -1 +1 @@ -quux +baz
Ein einfaches git diff-Beispiel
| 123
00___Git_945-8.book Seite 124 Donnerstag, 14. Januar 2010 2:25 14
git diff und Commit-Bereiche Es gibt zwei zusätzliche Formen von git diff, die einiger Erläuterung bedürfen, vor allem im Vergleich zu git log. Der Befehl git diff unterstützt eine Syntax mit zwei Punkten, um den Unterschied zwischen zwei Commits darzustellen. Die folgenden beiden Befehle sind deshalb äquivalent: git diff master bug/pr-1 git diff master..bug/pr-1
Leider bedeutet die Syntax mit den zwei Punkten in git diff etwas völlig anderes als die in git log, die Sie in Kapitel 6 kennengelernt haben. Es lohnt sich, git diff und git log einmal miteinander zu vergleichen, weil auf diese Weise die Beziehungen der beiden Befehle zu den Änderungen, die an Repositories geschehen, hervorgehoben werden. Merken Sie sich diese Punkte, um das folgende Beispiel besser zu verstehen: • git diff kümmert sich nicht um den Verlauf und die Geschichte der Dateien, die es vergleicht, oder um irgendwelche Zweige. • git log achtet ganz genau darauf, wie eine Datei geändert wurde, um zu einer anderen Datei zu werden – etwa, wenn zwei Zweige voneinander abweichen –, und was in den einzelnen Zweigen geschehen ist. Die Befehle log und diff führen zwei grundlegend verschiedene Operationen aus. Während log auf einer Menge von Commits tätig wird, arbeitet diff auf zwei unterschiedlichen Endpunkten. Stellen Sie sich die folgende Abfolge von Ereignissen vor: 1. Jemand erzeugt einen neuen Zweig aus dem master-Zweig heraus, um den Bug pr-1 zu reparieren, und nennt ihn bug/pr-1. 2. Derselbe Entwickler fügt die Zeile »Fix Problem Report 1« in eine Datei im Zweig bug/pr-1 ein. 3. Währenddessen repariert ein anderer Entwickler Bug pr-3 im master-Zweig und fügt die Zeile »Fix Problem Report 3« in dieselbe Datei im master-Zweig ein. Kurz, in je eine Datei in jedem Zweig wurde eine Zeile eingefügt. Wenn Sie sich auf einer hohen Ebene die Änderungen an den Zweigen anschauen, können Sie sehen, wann der Zweig bug/pr-1 gestartet wurde und wann die einzelnen Änderungen erfolgt sind: $ git show-branch master bug/pr-1 * [master] Bugfix für pr-3 hinzugefügt ! [bug/pr-1] Fix Problem Report 1 -* [master] Bugfix für pr-3 hinzugefügt + [bug/pr-1] Fix Problem Report 1 *+ [master^] Bobs Fixes hinzugefügt
124 | Kapitel 8: Diffs
00___Git_945-8.book Seite 125 Donnerstag, 14. Januar 2010 2:25 14
Wenn Sie git log -p master..bug/pr-1 eintippen, sehen Sie ein Commit, weil die Syntax master..bug/pr-1 alle Commits in bug/pr-1 repräsentiert, die nicht auch noch in master sind. Der Befehl geht zurück an die Stelle, an der bug/pr-1 von master abgezweigt ist, schaut sich aber nichts an, was seitdem im Zweig master passiert ist: $ git log -p master..bug/pr-1 commit 8f4cf5757a3a83b0b3dbecd26244593c5fc820ea Author: Jon Loeliger <[email protected]> Date: Wed May 14 17:53:54 2008 -0500 Fix Problem Report 1 diff --git a/fertig b/fertig index f3b6f0e..abbf9c5 100644 --- a/fertig +++ b/fertig @@ -1,3 +1,4 @@ stupid znill frot-less +Fix Problem Report 1
Im Gegensatz dazu zeigt git diff master..bug/pr-1 die Gesamtmenge der Unterschiede zwischen den beiden Bäumen, die durch die Köpfe der Zweige master und bug/pr-1 repräsentiert werden. Der Verlauf spielt keine Rolle, nur der aktuelle Zustand der Dateien ist wichtig: $ git diff master..bug/pr-1 diff --git a/NeuerKram b/NeuerKram index b4d8596..0f2416e 100644 --- a/NeuerKram +++ b/NeuerKram @@ -1,2 +1 @@ Irgendetwas -Fix Problem Report 3 diff --git a/fertig b/fertig index f3b6f0e..abbf9c5 100644 --- a/fertig +++ b/fertig @@ -1,3 +1,4 @@ stupid znill frot-less +Fix Problem Report 1
Die git diff-Ausgabe bedeutet also, dass Sie von der Datei im master-Zweig zu der Version im bug/pr-1-Zweig kommen können, indem Sie die Zeile »Fix Problem Report 3« aus der Datei entfernen und dann die Zeile »Fix Problem Report 1« hinzufügen. Wie Sie sehen, enthält dieses Diff Commits aus beiden Zweigen. Bei diesem kleinen Beispiel scheint das nicht so wichtig zu sein, betrachten Sie jedoch einmal das Beispiel in Abbildung 8-2 mit umfassenderen Entwicklungslinien in zwei Zweigen.
git diff und Commit-Bereiche | 125
00___Git_945-8.book Seite 126 Donnerstag, 14. Januar 2010 2:25 14
A
B
C
D
E
F
G
V
W
X
Y
Z
H
master
maint
Abbildung 8-2: git diff bei längerem Verlauf
In diesem Fall stellt git log master..maint die fünf einzelnen Commits V, W, ..., Z dar. Auf der anderen Seite repräsentiert git diff master..maint die Unterschiede in den Bäumen bei H und Z, also eine Menge von elf Commits: C, D, ..., H und V, ..., Z. Sowohl git log als auch git diff akzeptieren die Form Commit1...Commit2, um eine symmetrische Differenz zu erzeugen. Allerdings liefern wie zuvor git log Commit1...Commit2 und git diff Commit1...Commit2 unterschiedliche Ergebnisse. Wie in »Commit-Bereiche« auf Seite 85 besprochen, zeigt der Befehl git log Commit1... Commit2 die Commits an, die von einem der beiden Commits, nicht jedoch von beiden aus erreichbar sind. Deshalb würde git log master...maint im vorigen Beispiel C, D, ..., H und V, ..., Z ergeben. Die Reihenfolge dieser Commits ist wichtig. git diff A B ist nicht identisch mit git diff B A.
Die symmetrische Differenz in git diff zeigt die Unterschiede zwischen Commit2 und einem Commit, das ein gemeinsamer Vorfahr (oder die Merge-Basis) von Commit1 und Commit2 ist. Bei der Genealogie aus Abbildung 8-2 kombiniert git diff master...maint die Änderungen in den Commits V, W, ..., Z.
git diff mit Pfadbegrenzung Der Befehl git diff operiert standardmäßig auf der gesamten Verzeichnisstruktur, die an einem bestimmten Baumobjekt hängt. Sie können jedoch mit derselben Pfadbegrenzungstechnik arbeiten, die auch git log einsetzt, um die Ausgabe von git diff auf eine Teilmenge des Repository zu beschränken. So zeigt z.B. git diff --stat an einer Stelle1 in der Entwicklung des Git-eigenen Repository Folgendes an: $ git diff --stat master~5 master Documentation/git-add.txt Documentation/git-cherry.txt 1
| |
d2b3691b61d516a0ad2bf700a2a5d9113ceff0b1
126 | Kapitel 8: Diffs
2 +6 +++++
00___Git_945-8.book Seite 127 Donnerstag, 14. Januar 2010 2:25 14
Documentation/git-commit-tree.txt | 2 +Documentation/git-format-patch.txt | 2 +Documentation/git-gc.txt | 2 +Documentation/git-gui.txt | 4 +Documentation/git-ls-files.txt | 2 +Documentation/git-pack-objects.txt | 2 +Documentation/git-pack-redundant.txt | 2 +Documentation/git-prune-packed.txt | 2 +Documentation/git-prune.txt | 2 +Documentation/git-read-tree.txt | 2 +Documentation/git-remote.txt | 2 +Documentation/git-repack.txt | 2 +Documentation/git-rm.txt | 2 +Documentation/git-status.txt | 2 +Documentation/git-update-index.txt | 2 +Documentation/git-var.txt | 2 +Documentation/gitk.txt | 2 +builtin-checkout.c | 7 ++++builtin-fetch.c | 6 ++-git-bisect.sh | 29 ++++++++++++-------------t/t5518-fetch-exit-status.sh | 37 ++++++++++++++++++++++++++++++++++ 23 files changed, 83 insertions(+), 40 deletions(-)
Um die Ausgabe auf Änderungen in Documentation zu beschränken, könnten Sie stattdessen git diff --stat master~5 master Documentation eingeben: $ git diff --stat master~5 master Documentation Documentation/git-add.txt | 2 +Documentation/git-cherry.txt | 6 ++++++ Documentation/git-commit-tree.txt | 2 +Documentation/git-format-patch.txt | 2 +Documentation/git-gc.txt | 2 +Documentation/git-gui.txt | 4 ++-Documentation/git-ls-files.txt | 2 +Documentation/git-pack-objects.txt | 2 +Documentation/git-pack-redundant.txt | 2 +Documentation/git-prune-packed.txt | 2 +Documentation/git-prune.txt | 2 +Documentation/git-read-tree.txt | 2 +Documentation/git-remote.txt | 2 +Documentation/git-repack.txt | 2 +Documentation/git-rm.txt | 2 +Documentation/git-status.txt | 2 +Documentation/git-update-index.txt | 2 +Documentation/git-var.txt | 2 +Documentation/gitk.txt | 2 +19 files changed, 25 insertions(+), 19 deletions(-)
Natürlich können Sie die Diffs auch nach einer einzigen Datei filtern: $ git diff master~5 master Documentation/git-add.txt diff --git a/Documentation/git-add.txt b/Documentation/git-add.txt index bb4abe2..1afd0c6 100644 --- a/Documentation/git-add.txt
git diff mit Pfadbegrenzung | 127
00___Git_945-8.book Seite 128 Donnerstag, 14. Januar 2010 2:25 14
+++ b/Documentation/git-add.txt @@ -246,7 +246,7 @@ characters that need C-quoting. `core.quotepath` configuration can be used to work this limitation around to some degree, but backslash, double-quote and control characters will still have problems. -See Also +SEE ALSO -------linkgit:git-status[1] linkgit:git-rm[1]
Im folgenden Beispiel, das ebenfalls aus dem Git-eigenen Repository stammt, durchsucht die Option -S"String" die letzten 50 Commits im master-Zweig nach Änderungen, die String enthalten: $ git diff -S"octopus" master~50 diff --git a/Documentation/RelNotes-1.5.5.3.txt b/Documentation/RelNotes-1.5.5.3.txt new file mode 100644 index 0000000..f22f98b --- /dev/null +++ b/Documentation/RelNotes-1.5.5.3.txt @@ -0,0 +1,12 @@ +GIT v1.5.5.3 Release Notes +========================== + +Fixes since v1.5.5.2 +-------------------+ + * "git send-email --compose" did not notice that non-ascii contents + needed some MIME magic. + + * "git fast-export" did not export octopus merges correctly. + +Also comes with various documentation updates.
Wird Git mit -S benutzt (die Option wird oft als Pickaxe oder Spitzhacke bezeichnet), listet es die Diffs auf, bei denen sich ändert, wie oft der angegebene String in dem Diff benutzt wird. Sie können sich das konzeptuell so vorstellen: »Wo wird der angegebene String entweder eingeführt oder entfernt?« Ein Beispiel für diese Option im Zusammenhang mit git log finden Sie in »Mit der Spitzhacke suchen« auf Seite 96.
Wie Subversion und Git Diffs ableiten – ein Vergleich Die meisten Systeme, wie CVS oder Subversion, überwachen eine Reihe von Revisionen und speichern einfach die Änderungen zwischen den einzelnen Dateipaaren. Diese Technik soll Speicherplatz und Aufwand sparen. Intern wenden solche Systeme eine Menge Zeit auf, um über Sachen nachzudenken, wie die Folge der Änderungen zwischen A und B. Wenn Sie z.B. Ihre Dateien aus dem zentralen Repository aktualisieren, erinnert sich Subversion daran, dass Sie beim letzten Aktua-
128 | Kapitel 8: Diffs
00___Git_945-8.book Seite 129 Donnerstag, 14. Januar 2010 2:25 14
lisieren der Datei bei Revision r1095 waren. Nun ist das Repository aber bei Revision r1123. Das bedeutet, dass der Server Ihnen das Diff zwischen r1095 und r1123 schicken muss. Sobald Ihr Subversion-Client diese Diffs hat, kann er sie in Ihre Arbeitskopie einbauen und r1123 herstellen. (Auf diese Weise vermeidet es Subversion, Ihnen bei jeder Aktualisierung den Inhalt aller Dateien zu schicken.) Um Festplattenplatz zu sparen, speichert Subversion außerdem sein eigenes Repository als eine Folge von Diffs auf dem Server. Wenn Sie nach den Diffs zwischen r1095 und r1123 fragen, sucht es die einzelnen Diffs für jede Version zwischen diesen beiden Versionen, fügt sie zu einem großen Diff zusammen und schickt Ihnen das Ergebnis. Git dagegen funktioniert anders. Wie Sie gesehen haben, enthält jedes Commit in Git einen Baum, der alle Dateien auflistet, die von diesem Commit aufgenommen wurden. Die Bäume sind unabhängig voneinander. Git-Benutzer reden natürlich immer noch von Diffs und Patches, weil diese außerordentlich nützlich sind. In Git handelt es sich jedoch bei einem Diff und einem Patch um abgeleitete Daten, nicht um die grundlegenden Daten, die sie in CVS oder Subversion darstellen. Wenn Sie einen Blick in das .git-Verzeichnis werfen, werden Sie kein einziges Diff finden; schauen Sie dagegen in ein Subversion-Repository, dann merken Sie, dass es hauptsächlich aus Diffs besteht. So wie Subversion in der Lage ist, die komplette Menge der Unterschiede zwischen r1095 und r1123 abzuleiten, kann Git die Unterschiede zwischen zwei beliebigen Zuständen beschaffen und ableiten. Dabei muss Subversion allerdings jede Version zwischen r1095 und r1123 anschauen, Git hingegen kümmert sich nicht um die Zwischenschritte. Jede Revision besitzt ihren eigenen Baum, allerdings benötigt Git diese nicht, um das Diff zu generieren; Git kann direkt auf den Schnappschüssen des kompletten Zustands der jeweiligen Versionen operieren. Dieser einfache Unterschied in den Speichersystemen ist einer der wichtigsten Gründe dafür, dass Git so viel schneller ist als andere Revisionskontrollsysteme.
Wie Subversion und Git Diffs ableiten – ein Vergleich | 129
00___Git_945-8.book Seite 130 Donnerstag, 14. Januar 2010 2:25 14
00___Git_945-8.book Seite 131 Donnerstag, 14. Januar 2010 2:25 14
Kapitel 9
KAPITEL 9
Merges
Git ist ein verteiltes Versionskontrollsystem (distributed version control system, DVCS). Es erlaubt einem Entwickler, der etwa in Japan sitzt, und einem anderen Entwickler in New Jersey, Änderungen unabhängig voneinander vorzunehmen und aufzuzeichnen. Diese beiden Entwickler können ihre Änderungen jederzeit kombinieren – ganz ohne ein zentrales Repository. In diesem Kapitel erfahren Sie, wie man zwei oder mehr unterschiedliche Entwicklungslinien miteinander kombiniert. Ein Merge vereinigt zwei oder mehr Zweige mit Commit-Verläufen. Am häufigsten werden bei einem Merge nur zwei Zweige verbunden, obwohl Git auch Merges von drei, vier oder noch mehr Zweigen gleichzeitig unterstützt. In Git muss ein Merge innerhalb eines Repository auftreten – das heißt, alle Zweige, die zusammengeführt werden sollen, müssen im selben Repository vorliegen. Wie die Zweige in das Repository gelangen, ist nicht wichtig. (Wie Sie in Kapitel 11 sehen werden, bietet Git Mechanismen, mit denen auf andere Repositories verwiesen werden kann und mit denen man entfernte Zweige in das aktuelle Arbeits-Repository holt.) Wenn die Modifikationen in einem Zweig nicht im Konflikt mit den Modifikationen stehen, die in einem anderen Zweig gefunden werden, berechnet Git ein Merge-Ergebnis und erzeugt ein neues Commit, das den neuen, vereinten Zustand repräsentiert. Sollten die Zweige jedoch einander widersprechen, was vorkommt, wenn Änderungen versuchen, dieselbe Zeile in derselben Datei zu modifizieren, löst Git den Konflikt nicht auf, sondern markiert diese umstrittenen Änderungen als »unmerged« (nicht zusammengeführt) im Index und überlässt den Ausgleich Ihnen, dem Entwickler. Kann Git den Merge nicht automatisch ausführen, haben ebenfalls Sie das letzte Wort, indem Sie das abschließende Commit ausführen, nachdem alle Konflikte aufgelöst wurden.
| 131
00___Git_945-8.book Seite 132 Donnerstag, 14. Januar 2010 2:25 14
Merge-Beispiele Um anderer_Zweig mit Zweig zusammenzuführen, müssen Sie den Zielzweig auschecken und die anderen Zweige mit ihm verbinden: $ git checkout Zweig $ git merge anderer_Zweig
Wir wollen zwei Beispiel-Merges durcharbeiten, einen ohne Konflikt und einen mit wesentlichen Überschneidungen. Um die Beispiele in diesem Kapitel zu vereinfachen, wollen wir mehrere Zweige verwenden, die wir mithilfe der Techniken aus Kapitel 7 erzeugen.
Für einen Merge vorbereiten Bevor Sie einen Merge beginnen, sollten Sie am besten erst einmal Ihr Arbeitsverzeichnis aufräumen. Während eines normalen Merge erzeugt Git neue Versionen von Dateien und legt diese in Ihrem Arbeitsverzeichnis ab, wenn es fertig ist. Darüber hinaus benutzt Git den Index, um temporäre und Zwischenversionen von Dateien während der Operation zu speichern. Falls Sie modifizierte Dateien in Ihrem Arbeitsverzeichnis haben oder den Index über git add oder git rm geändert haben, besitzt Ihr Repository ein unsauberes Arbeitsverzeichnis bzw. einen unsauberen Index