]> git.cworth.org Git - hgbook-git/blob - tour.mdwn
Fix wording (use diverged instead of derived)
[hgbook-git] / tour.mdwn
1 ## Chapter 2
2 A tour of git: the basics
3
4 ### 2.0 Copyright
5
6 This document is a modified version of a document originally titled
7 "Distributed revision control with Mercurial" and originally authored
8 by Bryan O’Sullivan. The original document was obtained from
9 <http://hgbook.red-bean.com/>.
10
11 Copyright © 2006, 2007 Bryan O’Sullivan.
12
13 This material may be distributed only subject to the terms and
14 conditions set forth in version 1.0 of the Open Publication
15 License. Please refer to Appendix D for the license text.
16
17 As this is a modified version, the name of Bryan O'Sullivan is used
18 only to properly credit him with the original text. The appearance of
19 his name here explicitly does not assert or imply his endorsement of
20 this modified document.
21
22 Portions Copyright © 2007 Carl Worth.
23
24 Changes made by Carl include the following:
25
26   * 2007-09-27:
27     * Convert from HTML to markdown source syntax
28     * Eliminate all content except Chapter 2 and Appendix D
29     * Eliminate line numbers from examples
30     * Modified to describe git instead of mercurial
31
32 The source of this modified version can be obtained via git:
33
34         git clone git://cworth.org/git/hgbook-git
35
36 or
37
38         git clone http://cworth.org/git/hgbook-git
39
40 and can be [browsed online](http://git.cworth.org/git/hgbook-git)
41
42 ### 2.1  Installing git on your system
43
44 Prebuilt binary packages of git are available for many popular
45 operating systems. These make it easy to start using git on your
46 computer immediately.
47
48 #### 2.1.1  Linux
49
50 Because each Linux distribution has its own packaging tools, policies,
51 and rate of development, it’s difficult to give a comprehensive set of
52 instructions on how to install git binaries. The version of
53 git that you will end up with can vary depending on how active
54 the person is who maintains the package for your distribution.
55
56 To keep things simple, I will focus on installing git from the
57 command line under the most popular Linux distributions. Most of these
58 distributions provide graphical package managers that will let you
59 install git with a single click. The package name to look for is
60 often git, but is sometimes git-core, (due to an unfortunate name
61 with git, meaning GNU Interactive Tools).
62
63   * Debian
64
65         apt-get install git-core
66
67   * Fedora Core
68
69         yum install git
70
71   * Gentoo
72
73         emerge git
74
75   * OpenSUSE
76
77         yum install git
78
79   * Ubuntu
80
81         apt-get install git-core
82
83 #### 2.1.2  Mac OS X
84
85 A git-core package is available through
86 [macports](http://macports.org). Once macports is enabled, the command
87 to install git is:
88
89         port install git-core
90
91 #### 2.1.3  Windows
92
93 Git has long been available as part of cygwin, and works reasonably
94 well in that environment. Some people find cygwin a particularly
95 inelegant approach to running git and would prefer a "native"
96 solution. To this end, the [msysgit
97 project](http://code.google.com/p/msysgit/) is rapidly putting
98 together a solution including various packages with full
99 installers. These include GitMe, a package to install the entire
100 development environment necessary to work on improving the msysgit
101 port of git, and WinGit, a package for installing just git itself
102 without the development environment, (still in Alpha as of September
103 2007).
104
105 ### 2.2  Getting started
106
107 To begin, we’ll use the “git version” command to find out whether git
108 is actually installed properly. Versions 1.5 and newer of git are much
109 more friendly to new users than versions 1.4 and older. If you aren't
110 yet running version 1.5 or newer, it's highly recommended that you
111 upgrade.
112
113         $ git version
114         git version 1.5.3.2
115
116 #### 2.2.1  Built-in help
117
118 Git provides a built-in help system. This is invaluable for those
119 times when you find yourself stuck trying to remember how to run a
120 command. If you are completely stuck, simply run “git help”; it will
121 print a brief list of commonly-used commands, along with a description
122 of what each does. If you ask for help on a specific command (such as
123 "git help init"), it prints more detailed information. [XXX: Does "git
124 help <foo>" work universally as a built-in or does it expect man to be
125 present and just call out to "man git-<foo>"?]
126
127         [XXX: The original hgbook includes the complete output of "hg
128         help init" at this point. I'm not including the corresponding
129         "git help init" output as it would be excessively long. The
130         description alone is quite reasonable, (other than a
131         not-too-helpful aside about the obsolete git-init-db command),
132         but it only comes after a full screen's worth of options
133         details. Might it make sense to have a more summarized help
134         output for "git help <foo>" than all of the documentation
135         available for git-<foo>? And perhaps alos provide a "git -v
136         help" similar to "hg -v help" for more?]
137
138 ### 2.3  Working with a repository
139
140 In git, everything happens inside a repository. The repository
141 for a project contains all of the files that “belong to” that project,
142 along with a historical record of the project’s files.
143
144 There’s nothing particularly magical about a repository; it is simply
145 a directory tree in your filesystem that git treats as
146 special. You can rename or delete a repository any time you like,
147 using either the command line or your file browser.
148
149 #### 2.3.1  Making a local copy of a repository
150
151 Copying a repository is just a little bit special. While you could use
152 a normal file copying command to make a copy of a repository, it’s
153 best to use a built-in command that git provides. This command
154 is called “git clone”, because it creates an identical copy of an
155 existing repository.
156
157         $ git clone git://cworth.org/git/hello
158         Initialized empty Git repository in /tmp/hello/.git/
159         remote: Generating pack...
160         remote: Done counting 15 objects.
161         remote: Deltifying 15 objects...
162         remote:  100% (15/15) done
163         remote: Total 15 (delta 2), reused 15 (delta remote: 2)
164         Indexing 15 objects...
165          100% (15/15) done
166         Resolving 2 deltas...
167          100% (2/2) done
168
169 If for some reason you are prevented from talking on the git: port,
170 then there is also the capability to clone a repository (less
171 efficiently) over http:
172
173         $ git clone http://cworth.org/git/hello
174         Initialized empty Git repository in /tmp/hello/.git/
175         Getting alternates list for http://cworth.org/git/hello
176         Getting pack list for http://cworth.org/git/hello
177         Getting index for pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
178         Getting pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
179          which contains a1a0e8b392b17caf50325498df54802fe3c03710
180         walk a1a0e8b392b17caf50325498df54802fe3c03710
181         walk 72d4f10e4a27dbb09ace1503c20dbac1912ee451
182         walk 13ed136b983a9c439eddeea8a1c2076cffbb685f
183         walk 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
184         walk db7117a9dd9a6e57e8632ea5848e1101eee0fbde
185
186 If our clone succeeded, we should now have a local directory called
187 hello. This directory will contain some files.
188
189         $ ls -l
190         total 4
191         drwxr-xr-x 3 cworth cworth 4096 2007-09-27 16:40 hello
192         $ ls hello
193         hello.c  Makefile
194
195 These files have the same contents and history in our repository as
196 they do in the repository we cloned.
197
198 Every git repository is complete, self-contained, and
199 independent. It contains its own private copy of a project’s files and
200 history. A cloned repository remembers the location of the repository
201 it was cloned from, but it does not communicate with that repository,
202 or any other, unless you tell it to.
203
204 What this means for now is that we’re free to experiment with our
205 repository, safe in the knowledge that it’s a private “sandbox” that
206 won’t affect anyone else.
207
208 #### 2.3.2  What’s in a repository?
209
210 When we take a more detailed look inside a repository, we can see that
211 it contains a directory named .git. This is where git keeps all
212 of its metadata for the repository.
213
214         $ cd hello
215         $ ls -a
216         .  ..  .git  hello.c  Makefile
217
218 The contents of the .git directory and its subdirectories are private
219 to git. Every other file and directory in the repository is
220 yours to do with as you please.
221
222 To introduce a little terminology, the .git directory is the “real”
223 repository, and all of the files and directories that coexist with it
224 are said to live in the working directory. An easy way to remember the
225 distinction is that the repository contains the history of your
226 project, while the working directory contains a snapshot of your
227 project at a particular point in history.
228
229 ### 2.4  A tour through history
230
231 One of the first things we might want to do with a new, unfamiliar
232 repository is understand its history. The “git log” command gives us a
233 view of history.
234
235         $ git log
236         commit a1a0e8b392b17caf50325498df54802fe3c03710
237         Author: Bryan O'Sullivan <bos@serpentine.com>
238         Date:   Tue Sep 6 15:43:07 2005 -0700
239         
240             Trim comments.
241         
242         commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
243         Author: Bryan O'Sullivan <bos@serpentine.com>
244         Date:   Tue Sep 6 13:15:58 2005 -0700
245         
246             Get make to generate the final binary from a .o file.
247         
248         commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
249         Author: Bryan O'Sullivan <bos@serpentine.com>
250         Date:   Tue Sep 6 13:15:43 2005 -0700
251         
252             Introduce a typo into hello.c.
253         
254         commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
255         Author: Bryan O'Sullivan <mpm@selenic.com>
256         Date:   Fri Aug 26 01:21:28 2005 -0700
257         
258             Create a makefile
259         
260         commit db7117a9dd9a6e57e8632ea5848e1101eee0fbde
261         Author: Bryan O'Sullivan <mpm@selenic.com>
262         Date:   Fri Aug 26 01:20:50 2005 -0700
263         
264             Create a standard "hello, world" program
265
266 By default, this command prints a brief paragraph of output for each
267 change to the project that was recorded. In git terminology, we
268 call each of these recorded events a commit.
269
270 The fields in a record of output from “git log” are as follows.
271
272   * commit This field consists of a string of 40 hexadecimal characters.
273     This is a unique identifier for referring to particular commits.
274   * Author The identity of the person who authored the commit. This
275     field consist of two sub-fields for the user's name and email
276     address, (or at least an email-like idenitifer). Note that git
277     stores a separate "Committer" field for the person who commited
278     the change, (since often an author will email a change to a
279     maintainer that commits it). The "git log" command doesn't display
280     the Committer, but other git tools do.
281   * Date The date and time on which the commit was authored, (again
282     stored separately from the date the change was committed).
283     timezone in which it was created. (The date and time are displayed
284     in the timezone of the person who created the commit.)
285   * commit message The text message that the creator of the commit
286     entered to describe the commit, (generally a one-line summary
287     followed by more supporting text).
288
289 The default output printed by “git log” is purely a summary; it is
290 missing a lot of detail.
291
292 #### 2.4.1  Commits, revisions, and talking to other people
293
294 As English is a notoriously sloppy language, and computer science has
295 a hallowed history of terminological confusion (why use one term when
296 four will do?), revision control has a variety of words and phrases
297 that mean the same thing. If you are talking about git history
298 with other people, you will find that what we have called a “commit”
299 is often called a "revision". In other systems, a similar notion
300 is referred to as a "changeset". You might even see abbreviations of
301 these terms such as "rev", "change", or even "cset".
302
303 While it may not matter much what word you use to refer to the concept
304 of “a commit”, it's important to know how to name “a specific
305 commit”. We have already seen one means of referring to a particular
306 commit, the 40-character hexadecimal string shown by "git log". These
307 commit identifiers are powerful because they are permanent, unique
308 identifiers that always identify the same commit in any copy of a
309 repository. If two users are examining a working directory associated
310 with the same commit identifier, then those two users have precisely
311 the same contents in all files, and exactly the same history leading
312 to that commit.
313
314 So there are places where it is often important to archive the
315 complete commit identifier, (perhaps in bug-tracking systems to
316 indicate a specific commit that fixes a bug, for example). But often,
317 in more casual settings, it's more convenient to use abbreviated
318 commit identifiers. Git accept any unique prefix of a commit
319 identifier, (and for reasonably-sized project the first 8 or 10
320 characters are almost always unique).
321
322 And unlike the permanent commit identifiers, git also provides
323 transient means of identifying commits. In fact, in day-to-day use of
324 git, you will probably use these names more than commit
325 identifiers. One example is branch names, (such as the default
326 "master" branch in any git repository), or any project-specific branch
327 names such as "stable", "experimental", or "crazy-insane-changes". Git
328 also provides a special name "HEAD" which always refers to the current
329 branch.
330
331 #### 2.4.2 Naming related commits
332
333 Git offers simple ways to name revisions that are related to
334 particular revisions in the history. One syntax is the ~ suffix which
335 refers to the parent of a commit, or if followed by a number, to the
336 Nth parent. For example, since "HEAD" refers to the most recent commit
337 in the current branch, "HEAD~", refers to the previous commit, and
338 "HEAD~2" refers to two commits back in the history.
339
340 Another useful syntax is .. which can be used to specify a range of
341 commits. So "origin..master" specifies everything that has been
342 committed to master since it diverged from origin.
343
344 #### 2.4.3  Viewing specific revisions
345
346 You can use "git log" to explore the range syntax just introduced. For
347 example, to see a list of the most recent 3 revisions you can use
348 "HEAD~3..", (the destination of the range is implicitly HEAD in this
349 case):
350
351         $ git log HEAD~3..
352         commit a1a0e8b392b17caf50325498df54802fe3c03710
353         Author: Bryan O'Sullivan <bos@serpentine.com>
354         Date:   Tue Sep 6 15:43:07 2005 -0700
355         
356             Trim comments.
357         
358         commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
359         Author: Bryan O'Sullivan <bos@serpentine.com>
360         Date:   Tue Sep 6 13:15:58 2005 -0700
361         
362             Get make to generate the final binary from a .o file.
363         
364         commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
365         Author: Bryan O'Sullivan <bos@serpentine.com>
366         Date:   Tue Sep 6 13:15:43 2005 -0700
367         
368             Introduce a typo into hello.c.
369
370 #### 2.4.4 Other log filters
371
372 Besides filtering by commit identifiers, git allows you to easily
373 filter the log output according to which files (or directories) are
374 modified by listing them after "--" wihch is necessary to distinguish
375 commit names from file names:
376
377         $ git log -- Makefile
378         commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
379         Author: Bryan O'Sullivan <bos@serpentine.com>
380         Date:   Tue Sep 6 13:15:58 2005 -0700
381         
382             Get make to generate the final binary from a .o file.
383         
384         commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
385         Author: Bryan O'Sullivan <mpm@selenic.com>
386         Date:   Fri Aug 26 01:21:28 2005 -0700
387         
388             Create a makefile
389
390 And "git log" can also filter based on the dates at which commits were
391 created:
392
393         $ git log --since="2 weeks ago" --until="yesterday"
394
395 Another useful option is -n or --max-count which, unsurprisingly,
396 limits the maximum number of commits to be displayed.
397
398 #### 2.4.5  More detailed information
399
400 While the default information printed by “git log” is useful if you
401 already know what you’re looking for, you may need to see more details
402 of the change, such as the "diffstat" information with --stat:
403
404         $ git log --stat --max-count=3
405         commit a1a0e8b392b17caf50325498df54802fe3c03710
406         Author: Bryan O'Sullivan <bos@serpentine.com>
407         Date:   Tue Sep 6 15:43:07 2005 -0700
408         
409             Trim comments.
410         
411          hello.c |    8 ++------
412          1 files changed, 2 insertions(+), 6 deletions(-)
413         
414         commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
415         Author: Bryan O'Sullivan <bos@serpentine.com>
416         Date:   Tue Sep 6 13:15:58 2005 -0700
417         
418             Get make to generate the final binary from a .o file.
419         
420          Makefile |    2 ++
421          1 files changed, 2 insertions(+), 0 deletions(-)
422         
423         commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
424         Author: Bryan O'Sullivan <bos@serpentine.com>
425         Date:   Tue Sep 6 13:15:43 2005 -0700
426         
427             Introduce a typo into hello.c.
428         
429          hello.c |    2 +-
430          1 files changed, 1 insertions(+), 1 deletions(-)
431
432 Or perhaps you'd like to see the actual patch content of each change,
433 which you can get with -p. That commit with the word typo in its name
434 looks suspicous, so let's tak a closer look. Remember that we can name
435 it as master~3, HEAD~3, or any prefix of its commit identifier, (such
436 as 13ed136b):
437
438         $ git log -p -n 1 13ed136b
439         commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
440         Author: Bryan O'Sullivan <bos@serpentine.com>
441         Date:   Tue Sep 6 13:15:43 2005 -0700
442         
443             Introduce a typo into hello.c.
444         
445         diff --git a/hello.c b/hello.c
446         index ed55ec0..80b260c 100644
447         --- a/hello.c
448         +++ b/hello.c
449         @@ -11,6 +11,6 @@
450          
451          int main(int argc, char **argv)
452          {
453         -       printf("hello, world!\n");
454         +       printf("hello, world!\");
455                 return 0;
456          }
457
458 Of course, wanting to see all this information for a single commit is
459 such a common operation that it's given its own name in git, "git
460 show". So "git show 13ed136b" is a much easier way to get exactly the
461 same output:
462
463         $ git show 13ed136b
464         commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
465         Author: Bryan O'Sullivan <bos@serpentine.com>
466         Date:   Tue Sep 6 13:15:43 2005 -0700
467         
468             Introduce a typo into hello.c.
469         
470         diff --git a/hello.c b/hello.c
471         index ed55ec0..80b260c 100644
472         --- a/hello.c
473         +++ b/hello.c
474         @@ -11,6 +11,6 @@
475          
476          int main(int argc, char **argv)
477          {
478         -       printf("hello, world!\n");
479         +       printf("hello, world!\");
480                 return 0;
481          }
482
483 ### 2.5  All about command options
484
485 Let’s take a brief break from exploring git commands to discuss
486 a pattern in the way that they work; you may find this useful to keep
487 in mind as we continue our tour.
488
489 Git has a consistent and straightforward approach to dealing
490 with the options that you can pass to commands. It follows the
491 conventions for options that are common to modern Linux and Unix
492 systems.
493
494   * Most options have long names. For example, as we’ve already seen,
495     the “git log" command accepts a --max-count=<number> option.
496   * Some options have short, single-character names. Often these are
497     aliases for long commands, (such as "-n <number>" instead of
498     --max-count=<number>), but sometimes the option exists in
499     short-form with no long-form equivalent, (such as -p). [XXX: It
500     wouldn't hurt to fix this by adding --patch, etc. right?]
501   * Long options start with two dashes (e.g. --max-count), while short
502     options start with one (e.g. -n).
503
504   * Option naming and usage is consistent across commands. For
505     example, every command that lets you specify a commit identifier
506     or range will accept the same expressions, (HEAD~3,
507     origin..master, 72d4f10e, etc), while any command that can be
508     limited by paths will accept the same expressions ("-- doc/
509     some-file.c"), etc.
510
511 Many commands that print output of some kind can be made more quiet by
512 passing the -q or --quiet options.
513
514 ### 2.6  Making and reviewing changes
515
516 Now that we have a grasp of viewing history in git, let’s take a
517 look at making some changes and examining them.
518
519 The first thing we’ll do is isolate our experiment in a repository of
520 its own. We use the “git clone” command, but we don’t need to clone a
521 copy of the remote repository. Since we already have a copy of it
522 locally, we can just clone that instead. This is much faster than
523 cloning over the network, and cloning a local repository uses less
524 disk space in most cases, too.
525
526         $ cd ..
527         $ git clone hello my-hello
528         Initialized empty Git repository in /tmp/my-hello/.git/
529         0 blocks
530
531         [XXX We say "empty" here, (presumably from the git-init part),
532         but shouldn't the command also report the succesful clone
533         which makes it non-empty? And what the heck does "0 blocks"
534         mean?]
535
536 As an aside, it’s often good practice to keep a “pristine” copy of a
537 remote repository around, which you can then make temporary clones of
538 to create sandboxes for each task you want to work on. This lets you
539 work on multiple tasks in parallel, each isolated from the others
540 until it’s complete and you’re ready to integrate it back. Because
541 local clones are so cheap, there’s almost no overhead to cloning and
542 destroying repositories whenever you want.
543
544 Alternatively, you can achieve much the same effect by creating
545 multiple branches in a single repository, (but we won't go into detail
546 on how to do that in this chapter). Some people greatly appreciate
547 having multiple branches in a single repository rather than having
548 many repositories cluttering up their filesystem. Other people prefer
549 the ability to have working-tree changes, and intermediate build
550 files, etc. each isolated in a separate repository per branch. Both
551 modes are very well-supported by git, so it's really a matter of which
552 you find most appropriate at any time given your tastes and project
553 workflows.
554
555 In our my-hello repository, we have a file hello.c that contains the
556 classic “hello, world” program. Let’s use the ancient and venerable
557 sed command to edit this file so that it prints a second line of
558 output. (I’m only using sed to do this because it’s easy to write a
559 scripted example this way. Since you’re not under the same constraint,
560 you probably won’t want to use sed; simply use your preferred text
561 editor to do the same thing.)
562
563         $ sed -i '/printf/a\\tprintf("hello again!\\n");' hello.c     
564
565 The “git status” command will tell us what git knows about the files
566 in the repository.
567
568         $ ls 
569         hello.c  Makefile
570         $ git status
571         # On branch master
572         # Changed but not updated:
573         #   (use "git add <file>..." to update what will be committed)
574         #
575         #       modified:   hello.c
576         #
577         no changes added to commit (use "git add" and/or "git commit -a")
578
579 We see that “git status” command prints a line with "modified" for
580 hello.c. The “git status” command will not print any output for files
581 that have not been modified.
582
583 Notice that we didn’t need to inform git that we were going to modify
584 the file before we started, or that we had modified the file after we
585 were done; it was able to figure this out itself.
586
587 It’s a little bit helpful to know that we’ve modified hello.c, but we
588 might prefer to know exactly what changes we’ve made to it. To do
589 this, we use the “git diff” command.
590
591         $ git diff
592         diff --git a/hello.c b/hello.c
593         index 9a3ff79..6d28887 100644
594         --- a/hello.c
595         +++ b/hello.c
596         @@ -8,5 +8,6 @@
597          int main(int argc, char **argv)
598          {
599                 printf("hello, world!\");
600         +       printf("hello again!\n");
601                 return 0;
602          }
603
604 ### 2.7  Recording changes in a new commit
605
606 We can modify files, build and test our changes, and use “git status”
607 and “git diff” to review our changes, until we’re satisfied with what
608 we’ve done and arrive at a natural stopping point where we want to
609 record our work in a new commit.
610
611 The “git commit” command lets us create a new changeset; we’ll usually
612 refer to this as “making a commit” or “committing”.
613
614 #### 2.7.1  Setting up a username
615
616 When you try to run “git commit” for the first time, it might not do
617 exactly what you want. Git records your name and address with each
618 change that you commit, (as both author and committer unless you tell
619 it otherwise), so that you and others will later be able to tell who
620 made each change. Git tries to automatically figure out a sensible
621 name and address to attribute to both author and committer. It will
622 attempt each of the following methods, in order, (stopping for each field as soon as a value is found):
623
624   1. If you specify a --author option to the “git commit” command on
625      the command line, followed by a "Real Name <email@example.com>"
626      string, then this name and addresss will be used for the author
627      fields. The committer fields will still be determined as
628      below. This option is very helpful for when applying a commit
629      originally authored by someone other than yourself.
630   2. If any of the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL,
631      GIT_COMMITTER_NAME, or GIT_COMMITER_EMAIL environment variables
632      are set, then those values will be used for the corresponding
633      fields.
634   3. If you have a file in your home directory called .gitconfig, with
635      name or email settings in the [user] section, then these values
636      will be used to set any remaining author and committer
637      fields. For more details on the contents of this file, refer to
638      section 2.7.1 below.
639   4. If you have a file in the local repository called .git/config,
640      again with name or email settings in the [user] section, then
641      these values will be used to set any remaining author and
642      committer fields.
643   5. If you have set the EMAIL environment variable, this will be used
644      to set author and committer email addresses if still unset.
645   6. git will query your system to find out your real name from
646      available GECOS field and your username, hostname, and domain to
647      construct an email address, (or at least an identifier resembling
648      an email address).
649
650 If all of these mechanisms fail, "git commit" will fail, printing an
651 error message instructing you how to use "git config" to tell git your
652 name and email address.
653
654 You should think of the GIT_AUTHOR/COMMITER_NAME/EMAIL environment
655 variables and the --author option to the “git commit” command as ways
656 to override git’s default selection. For normal use, the simplest and
657 most robust way to set your information is by creating a .gitconfig
658 file, (either manually or with the "git config" command); see below
659 for details.
660
661 ##### Creating a git configuration file
662
663 To set your name and email address, just use the following commands:
664
665         git config --global user.name "Your Name"
666         git config --global user.email "you@example.com"
667
668 The --global option means that this command will set global
669 information, (affecting all repositories on this machine), in the
670 .gitconfig file in your home directory. Alternately, you could omit
671 the --global which would make the change take effect only in the local
672 repository. This is convenient if you want to have different email
673 addresses associated with different projects, for example.
674
675 Of course, git's configuration file is a simple-to-edit plain-text
676 file, so instead of using the above commands, you can also just edit
677 the files directly. Use your favorite editor to create a file called
678 .gitconfig in your home directory, (or if you ran the above commands
679 then it will be there already). The initial contents of your
680 .gitconfig should look like this.
681
682         # This is a git configuration file. 
683         [user]
684                 name = Your Name
685                 email = you@example.com
686
687 Similarly, you can make a repository-specific configuration by editing
688 .git/config in the local repository. It will already have some
689 sections present, (created by the "git clone"), just add a [user]
690 section as above.
691
692 The “[user]” line begins a section of the config file, so you can read
693 the “name = ...” line as meaning “set the value of the name item in
694 the user section”. This is the same notion expressed with the
695 "user.name" syntax on the git-config command line.  A section
696 continues until a new section begins, or the end of the file. Git
697 ignores empty lines and treats any text from “#” to the end of a line
698 as a comment.
699
700 ##### Choosing a user name
701
702 You can use any text you like as the value of the name and email
703 configuration items, since this information is for reading by other
704 people, not for interpreting by git. It is conventional to use a valid
705 email address, but some, (notably Linus Torvalds, the original author
706 of git), actually like the default user@hostname convention that git
707 falls back on without any additional information. There's no
708 requirement that the email address actually be valid, and perhaps it's
709 useful to be reminded which machine was used to create particular
710 commits.
711
712 #### 2.7.2  Writing a commit message
713
714 When we commit a change, git drops us into a text editor to
715 enter a message that will describe the modifications we’ve made in
716 this commit. This is called the commit message. It will be a record
717 for readers of what we did and why, and it will be printed by “git log”
718 after we’ve finished committing.
719
720         $ git commit -a
721
722 Note: The -a on the command-line instructs git to commit all changes
723 to tracked files. Without this, "git commit" will only commit changes
724 that have been previously staged for committing with "git add
725 file". The most common usage is to commit with "git commit -a" and
726 only use "git add file; git commit" when there is a need to commit
727 only some subset of changes that have been made.
728
729 The editor that the “git commit” command drops us into will contain an
730 empty line, followed by a number of lines starting with “#”.
731
732         empty line
733         # Please enter the commit message for your changes.
734         # (Comment lines starting with '#' will not be included)
735         # On branch master
736         # Changes to be committed:
737         #   (use "git reset HEAD <file>..." to unstage)
738         #
739         #       modified:   hello.c
740         #       
741
742 git ignores the lines that start with “#”; it uses them only
743 to tell us which files it’s recording changes to. Modifying or
744 deleting these lines has no effect.
745
746 #### 2.7.3  Writing a good commit message
747
748 A good commit message will generally have a single line that
749 summarizes the commit, a blank line, and then one or more pargraphs
750 with supporting detail. Since many tools only print the first line of
751 a commit message by default, it’s important that the first line stands
752 alone.
753
754 One example of a first-line-only viewer is "git log
755 --pretty=short". Other examples include graphical history viewers such
756 as gitk and gitview, and web-based viewers such as gitweb and cgit.
757
758 Here’s a real example of a commit message that doesn’t follow
759 this guideline, and hence has a summary that is not readable.
760
761         $ git log --pretty=short
762         commit 3ef5535144da88a854f7930503845cd44506c2e2
763         Author: Censored Person <censored.person@example.org>
764         
765             include buildmeister/commondefs.   Add an exports and install
766
767 As far as the remainder of the contents of the commit message are
768 concerned, there are no hard-and-fast rules. git itself doesn’t
769 interpret or care about the contents of the commit message, though
770 your project may have policies that dictate a certain kind of
771 formatting.
772
773 My personal preference is for short, but informative, commit messages
774 that tell me something that I can’t figure out with a quick glance at
775 the output of “git log -p".
776
777 #### 2.7.4  Aborting a commit
778
779 If you decide that you don’t want to commit while in the middle of
780 editing a commit message, simply exit from your editor without saving
781 the file that it’s editing. This will cause nothing to happen to
782 either the repository or the working directory.
783
784 #### 2.7.5  Admiring our new handiwork
785
786 Once we’ve finished the commit, we can use the “git show” command to
787 display the commit we just created. As discussed previously, this
788 command produces output that is identical to “git log -p”, but for
789 only a single revision, (and the most recent revision by default):
790
791         $ git show
792         commit 018cfb742be6176443ffddac454e593e802ddf3e
793         Author: Carl Worth <cworth@cworth.org>
794         Date:   Thu Sep 27 23:55:00 2007 -0700
795         
796             Added an extra line of output.
797             
798             If I would have been clever I would have fixed that old typo
799             while I was at it...
800         
801         diff --git a/hello.c b/hello.c
802         index 9a3ff79..6d28887 100644
803         --- a/hello.c
804         +++ b/hello.c
805         @@ -8,5 +8,6 @@
806          int main(int argc, char **argv)
807          {
808                 printf("hello, world!\");
809         +       printf("hello again!\n");
810                 return 0;
811          }
812
813 Note that you will not see the same commit identifier for your commit,
814 even if the change you made is identical to mine. The commit
815 identifier incorporates not only the contents of the files, but commit
816 message, the author and committer names and emails, and the author and
817 commit dates. (OK, so now you probably know enough to be able to guess
818 the right command to produce a commit with exactly the commit
819 identifier shown above. Can you do it?)
820
821 #### 2.7.6 Fixing up a broken commit (before anyone else sees it)
822
823 So now that we've cloned a local repository, made a change to the
824 code, setup our name and email address, and made a commit with a
825 careful message, we're just about ready to share our change with the
826 world. But wait, we forgot to try to compile it didn't we?
827
828         $ make
829         cc    -c -o hello.o hello.c
830         hello.c:10:9: warning: missing terminating " character
831         hello.c:10:9: warning: missing terminating " character
832         hello.c: In function ‘main’:
833         hello.c:10: error: missing terminating " character
834         hello.c:11: error: expected ‘)’ before ‘;’ token
835         hello.c:13: warning: passing argument 1 of ‘printf’ makes pointer from integer without a cast
836         hello.c:13: error: expected ‘;’ before ‘}’ token
837         make: *** [hello.o] Error 1
838
839 Oh look. The code's broken and doesn't compile. We don't want to share
840 code in this state. For situations where you notice one tiny detail
841 that got left out of the last commit, (a silly syntax error, a
842 misspelling in a comment or commit messsage), git provides a very
843 handy tool for just changing the last commit.
844
845 So fix that typo, (a missing 'n' between the '\' and the '"'), with
846 your editor or with something like this:
847
848         sed -i 's/\\"/\\n"/' hello.c
849
850 And then you can just amend the previous commit rather than creating a
851 new one with the --amend option to "git commit":
852
853         $ git commit -a --amend
854
855 Note that we use -a to include the code change here. And that helps
856 point out a situation where "git commit" is useful without the -a
857 option, "git commit --amend" is a useful command for amend just the
858 last commit message, without committing any new code changes, even if
859 some files have been modified in the working tree.
860
861 And here's the final result:
862
863         $ git show
864         commit 839b58d021c618bd0e1d336d4d5878a0082672e6
865         Author: Carl Worth <cworth@cworth.org>
866         Date:   Thu Sep 27 23:55:00 2007 -0700
867         
868             Added an extra line of output and fixed the typo bug.
869         
870         diff --git a/hello.c b/hello.c
871         index 9a3ff79..ca750e0 100644
872         --- a/hello.c
873         +++ b/hello.c
874         @@ -7,6 +7,7 @@
875          
876          int main(int argc, char **argv)
877          {
878         -       printf("hello, world!\");
879         +       printf("hello, world!\n");
880         +       printf("hello again!\n");
881                 return 0;
882          }
883
884 I can't help but point out that this really was a poor example for
885 --amend. The end result is a single commit that does two independent
886 things, (fixes one bug and adds one new feature). It's much better to
887 create a code history where each commit makes an independent change,
888 (and as small as possible). This is important for several reasons:
889
890   * Small changes are easier to review
891
892   * Independent changes are easier to split up if only part of the
893     series gets accepted "upstream" for one reason or another.
894
895   * The smaller the changes are the more useful the history will be
896     when actually using the history, not just viewing it. This is
897     particularly important when doing "git bisect"---that's a powerful
898     tool for isolating the single commit that introduces a bug. And
899     it's much more powerful if the commit it isolates is as small as
900     possible.
901
902 So it's a good thing this document is available under a license that
903 allows for distribution of modified versions. Someone should clean up
904 the --amend example to not teach bad habits like I did above. [Note:
905 All this bad-habit stuff was introduced by me, and was not present in
906 Bryan's original chapter. -Carl]
907
908 ### 2.8  Sharing changes
909
910 We mentioned earlier that repositories in git are
911 self-contained. This means that the commit we just created exists
912 only in our my-hello repository. Let’s look at a few ways that we can
913 propagate this change into other repositories.
914
915 #### 2.8.1  Pulling changes from another repository
916
917 To get started, let’s clone our original hello repository, which does
918 not contain the change we just committed. We’ll call our temporary
919 repository hello-pull.
920
921         $ cd ..
922         $ git clone hello hello-pull
923         Initialized empty Git repository in /tmp/hello-pull/.git/
924         0 blocks
925
926 We could use the “git pull” command to apply changes from my-hello to
927 our master branch in hello-pull. However, blindly pulling unknown
928 changes into a repository is a somewhat scary prospect. The "git pull"
929 command is coneptually the combination of two commands, "git fetch"
930 and "git merge"; we can run those separately to examine the changes
931 before applying them locally. First we do the fetch:
932
933         $ cd hello-pull
934         $ git fetch ../my-hello
935         remote: Generating pack...
936         Unpacking 3 objects...
937          100% (3/3) done
938         remote: Done counting 5 objects.
939         Result has 3 objects.
940         Deltifying 3 objects...
941          100% remote: (3/3) done
942         Total 3 (delta 1), reused 0 (delta 0)
943
944 The fetched commits (or commit in this case) are available as the name
945 FETCH_HEAD. [XXX: Shouldn't git-fetch print that name out to the user
946 if the user didn't provide a specific branch name to fetch into.] And
947 the difference between what we had before and what exists on
948 FETCH_HEAD can easily be examined with the ..FETCH_HEAD range
949 notation:
950
951         $ git log ..FETCH_HEAD
952         commit 839b58d021c618bd0e1d336d4d5878a0082672e6
953         Author: Carl Worth <cworth@cworth.org>
954         Date:   Thu Sep 27 23:55:00 2007 -0700
955         
956             Added an extra line of output and fixed the typo bug.
957
958 Since these commits actually exist in the local repository now, we
959 don't need to fetch or pull them from the remote repository again---we
960 can now use "git merge" to apply the previously fetched commits. (A
961 mercurial user might notice here that git does not have the race
962 condition between "hg incoming" and "hg pull" that mercurial has since
963 the commits are fetched only once.)
964
965         $ git merge FETCH_HEAD
966         Updating a1a0e8b..839b58d
967         Fast forward
968          hello.c |    3 ++-
969          1 files changed, 2 insertions(+), 1 deletions(-)
970
971 Notice that "git merge" reports that our branch pointer has been
972 updated from a1a0e8b to 839b58d. Also, this is a "fast forward"
973 meaning that the new commits are a linear sequence on top of the
974 commit we already hand. In other words, there wasn't any divergence
975 between these two repositories so no actual "merge" commit was
976 created.
977
978 This separation of fetch and merge is useful when you need to
979 carefully review some changes before applying them. But often you're
980 in a situation where you know you trust the remote repository and you
981 simply want to pull those changes as conveniently as possible, (no
982 extra commands, no typing a magic name like FETCH_HEAD). This is the
983 case when the tracking upstream development of a project with git. And
984 in that case, the above steps are as simple as just executing "git
985 pull". So let's repeat all that the simpler way:
986
987         $ cd ..
988         $ git clone hello hello-tracking
989         Initialized empty Git repository in /tmp/hello-tracking/.git/
990         0 blocks
991         $ cd hello-tracking
992         $ git pull ../my-hello
993         remote: Generating pack...
994         remote: Done counting 5 objects.
995         Result has 3 objects.
996         Deltifying 3 objects...
997         Unpacking 3 objects...
998         remote:  100% (3/3) done
999         Total 3 (delta 1), reused 0 (delta 0)
1000          100% (3/3) done
1001         Updating a1a0e8b..839b58d
1002         Fast forward
1003          hello.c |    3 ++-
1004          1 files changed, 2 insertions(+), 1 deletions(-)
1005
1006 It should be plain to see that the "git pull" command really did the
1007 combined sequence of "git fetch" and "git merge". Also, if you want to
1008 pull from the same repository you cloned from originally, (which is
1009 the common case for the upstream-tracking scenario), then "git pull"
1010 with no explicit repository is suffcient, and it will default to
1011 pulling from the same repository as the original clone.
1012
1013 [XXX: The structure of the preceding section follows that of the
1014 original hgbook. But an alternate structure that arranged to pull from
1015 the originally cloned repository (as would be common) would allow for
1016 more straightforward use of git's features. For example, instead of
1017 the silly FETCH_HEAD stuff it would allow for "git fetch" and "git log
1018 master..origin" to be a very nice replacement for "hg
1019 incoming". Similarly, below, "git log origin..master" would make a
1020 nice replacement for "hg outgoing" which is something I didn't offer
1021 at all. One could also use git's remotes with the myriad repositories
1022 as used here, but it would require doing things like "git remote add
1023 <some-name> ../hello-pull" and that seems like a bit much to introduce
1024 for a turorial of this level. If nothing else, if the above section
1025 seems a little intimidating, understand that it's because things are
1026 not presented in the most natural "git way", (and I'm a little too
1027 tired to fix it tonight).]
1028
1029 #### 2.8.2  Checking out previous revisions
1030
1031 If any users of mercurial are reading this, they might wonder if
1032 there's a need for the equivalent of "hg update" after doing a "git
1033 pull". And the answer is no. Unlike mercurial, "git pull" and "git
1034 merge" will automatically update the workind-directory files as
1035 necessary.
1036
1037 But there's another function provided by "hg update" which is to
1038 update the working-directory files to a particular revision. In git,
1039 this functionality is provided by the "git checkout" command. To
1040 checkout a particular branch, tag, or an arbitrary revions, simply
1041 give the appropriate name to the "git checkout" command. For example,
1042 to examine the files as they existed before the original typo
1043 introduction, we could do:
1044
1045         $ git checkout 0a633bf5
1046         Note: moving to "0a633bf5" which isn't a local branch
1047         If you want to create a new branch from this checkout, you may do so
1048         (now or later) by using -b with the checkout command again. Example:
1049           git checkout -b <new_branch_name>
1050         HEAD is now at 0a633bf... Create a makefile
1051
1052 The note that git gives us is to indicate that we are checking out a
1053 non-branch revision. This is perfectly fine if we are just exploring
1054 history, but if we actually wanted to use this revision as the basis
1055 for new commits, we would first have to create a new branch name as it
1056 describes.
1057
1058 For now, let's return back to the tip of the master branch by just
1059 checking it out again:
1060
1061         $ git checkout master
1062         Previous HEAD position was 0a633bf... Create a makefile
1063         Switched to branch "master"
1064
1065 #### 2.8.3  Pushing changes to another repository
1066
1067 Git lets us push changes to another repository, from the repository
1068 we’re currently visiting. As with previous examples, above, we’ll
1069 first create a temporary repository to push our changes into. But
1070 instead of using "git clone", this time we'll use "git init" to make a
1071 repository from an empty directory. We do this to create a "bare"
1072 repository which is simply a repository that has no working-directory
1073 files associated with it. In general, you should only push to bare
1074 repositories.
1075
1076         $ cd ..
1077         $ mkdir hello-push
1078         $ cd hello-push
1079         $ git --bare init
1080         Initialized empty Git repository in /tmp/hello-push/
1081
1082 And then we'll go back to our my-hello repository to perform the
1083 push. Since this is our very first push into this repository we need
1084 to tell git which branches to push. The easiest way to do this is to
1085 use --all to indicate all branches:
1086
1087         $ cd ../my-hello
1088         $ git push ../hello-push --all
1089         updating 'refs/heads/master'
1090           from 0000000000000000000000000000000000000000
1091           to   839b58d021c618bd0e1d336d4d5878a0082672e6
1092         Generating pack...
1093         Done counting 18 objects.
1094         Deltifying 18 objects...
1095          100% (18/18) done
1096         Writing 18 objects...
1097          100% (18/18) done
1098         Total 18 (delta 3), reused 0 (delta 0)
1099         Unpacking 18 objects...
1100          100% (18/18) done
1101         refs/heads/master: 0000000000000000000000000000000000000000 -> 839b58d021c618bd0e1d336d4d5878a0082672e6
1102
1103 For subsequent pushes we don't need to specify --all as "git push"
1104 will push all branches that exist in both the local and remote
1105 repositories.
1106
1107 What happens if we try to pull or push changes and the receiving
1108 repository already has those changes? Nothing too exciting.
1109
1110         $ git push ../hello-push
1111         Everything up-to-date
1112
1113 #### 2.8.4  Sharing changes over a network
1114
1115 The commands we have covered in the previous few sections are not
1116 limited to working with local repositories. Each works in exactly the
1117 same fashion over a network connection; simply pass in a URL or an ssh
1118 host:/path/name specification instead of a local path.
1119
1120 ## Appendix D
1121 Open Publication License
1122
1123 Version 1.0, 8 June 1999 
1124
1125 ### D.1  Requirements on both unmodified and modified versions
1126
1127 The Open Publication works may be reproduced and distributed in whole
1128 or in part, in any medium physical or electronic, provided that the
1129 terms of this license are adhered to, and that this license or an
1130 incorporation of it by reference (with any options elected by the
1131 author(s) and/or publisher) is displayed in the reproduction.
1132
1133 Proper form for an incorporation by reference is as follows: 
1134
1135 Copyright (c) year by author’s name or designee. This material may be
1136 distributed only subject to the terms and conditions set forth in the
1137 Open Publication License, vx.y or later (the latest version is
1138 presently available at
1139 [http://www.opencontent.org/openpub/][http://www.opencontent.org/openpub/]).
1140
1141 The reference must be immediately followed with any options elected by
1142 the author(s) and/or publisher of the document (see section D.6).
1143
1144 Commercial redistribution of Open Publication-licensed material is
1145 permitted.
1146
1147 Any publication in standard (paper) book form shall require the
1148 citation of the original publisher and author. The publisher and
1149 author’s names shall appear on all outer surfaces of the book. On all
1150 outer surfaces of the book the original publisher’s name shall be as
1151 large as the title of the work and cited as possessive with respect to
1152 the title.
1153
1154 ### D.2  Copyright
1155
1156 The copyright to each Open Publication is owned by its author(s) or
1157 designee.
1158
1159 ### D.3  Scope of license
1160
1161 The following license terms apply to all Open Publication works,
1162 unless otherwise explicitly stated in the document.
1163
1164 Mere aggregation of Open Publication works or a portion of an Open
1165 Publication work with other works or programs on the same media shall
1166 not cause this license to apply to those other works. The aggregate
1167 work shall contain a notice specifying the inclusion of the Open
1168 Publication material and appropriate copyright notice.
1169
1170 Severability. If any part of this license is found to be unenforceable
1171 in any jurisdiction, the remaining portions of the license remain in
1172 force.
1173
1174 No warranty. Open Publication works are licensed and provided “as is”
1175 without warranty of any kind, express or implied, including, but not
1176 limited to, the implied warranties of merchantability and fitness for
1177 a particular purpose or a warranty of non-infringement.
1178
1179 ### D.4  Requirements on modified works
1180
1181 All modified versions of documents covered by this license, including
1182 translations, anthologies, compilations and partial documents, must
1183 meet the following requirements:
1184
1185   1. The modified version must be labeled as such. 
1186   2. The person making the modifications must be identified and the
1187      modifications dated.
1188   3. Acknowledgement of the original author and publisher if
1189      applicable must be retained according to normal academic citation
1190      practices.
1191   4. The location of the original unmodified document must be identified. 
1192   5. The original author’s (or authors’) name(s) may not be used to
1193      assert or imply endorsement of the resulting document without the
1194      original author’s (or authors’) permission.
1195
1196 ### D.5  Good-practice recommendations
1197
1198 In addition to the requirements of this license, it is requested from
1199 and strongly recommended of redistributors that:
1200
1201   1. If you are distributing Open Publication works on hardcopy or
1202      CD-ROM, you provide email notification to the authors of your
1203      intent to redistribute at least thirty days before your
1204      manuscript or media freeze, to give the authors time to provide
1205      updated documents. This notification should describe
1206      modifications, if any, made to the document.
1207   2. All substantive modifications (including deletions) be either
1208      clearly marked up in the document or else described in an
1209      attachment to the document.
1210   3. Finally, while it is not mandatory under this license, it is
1211      considered good form to offer a free copy of any hardcopy and
1212      CD-ROM expression of an Open Publication-licensed work to its
1213      author(s).
1214
1215 ### D.6  License options
1216
1217 The author(s) and/or publisher of an Open Publication-licensed
1218 document may elect certain options by appending language to the
1219 reference to or copy of the license. These options are considered part
1220 of the license instance and must be included with the license (or its
1221 incorporation by reference) in derived works.
1222
1223   1. To prohibit distribution of substantively modified versions
1224      without the explicit permission of the author(s). “Substantive
1225      modification” is defined as a change to the semantic content of
1226      the document, and excludes mere changes in format or
1227      typographical corrections.
1228
1229      To accomplish this, add the phrase “Distribution of substantively
1230      modified versions of this document is prohibited without the
1231      explicit permission of the copyright holder.” to the license
1232      reference or copy.
1233
1234   2. To prohibit any publication of this work or derivative works in
1235      whole or in part in standard (paper) book form for commercial
1236      purposes is prohibited unless prior permission is obtained from
1237      the copyright holder.
1238
1239      To accomplish this, add the phrase “Distribution of the work or
1240      derivative of the work in any standard (paper) book form is
1241      prohibited unless prior permission is obtained from the copyright
1242      holder.” to the license reference or copy.