2 A tour of git: the basics
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/>.
11 Copyright © 2006, 2007 Bryan O’Sullivan.
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.
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.
22 Portions Copyright © 2007 Carl Worth.
24 Changes made by Carl include the following:
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
32 The source of this modified version can be obtained via git:
34 git clone git://cworth.org/git/hgbook-git
38 git clone http://cworth.org/git/hgbook-git
40 and can be [browsed online](http://git.cworth.org/git/hgbook-git)
42 ### 2.1 Installing git on your system
44 Prebuilt binary packages of git are available for many popular
45 operating systems. These make it easy to start using git on your
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.
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).
65 apt-get install git-core
81 apt-get install git-core
85 A git-core package is available through
86 [macports](http://macports.org). Once macports is enabled, the command
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
105 ### 2.2 Getting started
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
116 #### 2.2.1 Built-in help
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>"?]
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?]
138 ### 2.3 Working with a repository
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.
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.
149 #### 2.3.1 Creating a local copy of a remote repository
151 As suggested, a repository can be copied through normal file-copying
152 commands. But git also provides a "git clone" tool for copying a
153 repository. This provides a means of copying a repository over the
154 network, and is also useful with a local repository since it is much
155 more efficient than creating a normal copy, (creating a local clones
158 We've assembled a simple repository that will be used in the examples
159 throughout this chapter. Go ahead and clone this repository now so
160 that you will be able to follow along:
162 $ git clone git://cworth.org/git/hello
163 Initialized empty Git repository in /tmp/hello/.git/
164 remote: Generating pack...
165 remote: Done counting 15 objects.
166 remote: Deltifying 15 objects...
167 remote: 100% (15/15) done
168 remote: Total 15 (delta 2), reused 15 (delta remote: 2)
169 Indexing 15 objects...
171 Resolving 2 deltas...
174 If for some reason you are prevented from talking on the git: port,
175 then there is also the capability to clone a repository (less
176 efficiently) over http:
178 $ git clone http://cworth.org/git/hello
179 Initialized empty Git repository in /tmp/hello/.git/
180 Getting alternates list for http://cworth.org/git/hello
181 Getting pack list for http://cworth.org/git/hello
182 Getting index for pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
183 Getting pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
184 which contains a1a0e8b392b17caf50325498df54802fe3c03710
185 walk a1a0e8b392b17caf50325498df54802fe3c03710
186 walk 72d4f10e4a27dbb09ace1503c20dbac1912ee451
187 walk 13ed136b983a9c439eddeea8a1c2076cffbb685f
188 walk 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
189 walk db7117a9dd9a6e57e8632ea5848e1101eee0fbde
191 If our clone succeeded, we should now have a local directory called
192 hello. This directory will contain some files.
196 drwxr-xr-x 3 cworth cworth 4096 2007-09-27 16:40 hello
200 These files have the same contents and history in our repository as
201 they do in the repository we cloned.
203 Every git repository is complete, self-contained, and
204 independent. It contains its own private copy of a project’s files and
205 history. A cloned repository remembers the location of the repository
206 it was cloned from, but it does not communicate with that repository,
207 or any other, unless you tell it to.
209 What this means for now is that we’re free to experiment with our
210 repository, safe in the knowledge that it’s a private “sandbox” that
211 won’t affect anyone else.
213 #### 2.3.2 What’s in a repository?
215 When we take a more detailed look inside a repository, we can see that
216 it contains a directory named .git. This is where git keeps all
217 of its metadata for the repository.
221 . .. .git hello.c Makefile
223 The contents of the .git directory and its subdirectories are private
224 to git. Every other file and directory in the repository is
225 yours to do with as you please.
227 To introduce a little terminology, the .git directory is the “real”
228 repository, and all of the files and directories that coexist with it
229 are said to live in the working directory. An easy way to remember the
230 distinction is that the repository contains the history of your
231 project, while the working directory contains a snapshot of your
232 project at a particular point in history.
234 ### 2.4 A tour through history
236 One of the first things we might want to do with a new, unfamiliar
237 repository is understand its history. The “git log” command gives us a
241 commit a1a0e8b392b17caf50325498df54802fe3c03710
242 Author: Bryan O'Sullivan <bos@serpentine.com>
243 Date: Tue Sep 6 15:43:07 2005 -0700
247 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
248 Author: Bryan O'Sullivan <bos@serpentine.com>
249 Date: Tue Sep 6 13:15:58 2005 -0700
251 Get make to generate the final binary from a .o file.
253 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
254 Author: Bryan O'Sullivan <bos@serpentine.com>
255 Date: Tue Sep 6 13:15:43 2005 -0700
257 Introduce a typo into hello.c.
259 commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
260 Author: Bryan O'Sullivan <mpm@selenic.com>
261 Date: Fri Aug 26 01:21:28 2005 -0700
265 commit db7117a9dd9a6e57e8632ea5848e1101eee0fbde
266 Author: Bryan O'Sullivan <mpm@selenic.com>
267 Date: Fri Aug 26 01:20:50 2005 -0700
269 Create a standard "hello, world" program
271 By default, this command prints a brief paragraph of output for each
272 change to the project that was recorded. In git terminology, we
273 call each of these recorded events a commit.
275 The fields in a record of output from “git log” are as follows.
277 * commit This field consists of a string of 40 hexadecimal characters.
278 This is a unique identifier for referring to particular commits.
279 * Author The identity of the person who authored the commit. This
280 field consist of two sub-fields for the user's name and email
281 address, (or at least an email-like idenitifer). Note that git
282 stores a separate "Committer" field for the person who commited
283 the change, (since often an author will email a change to a
284 maintainer that commits it). The "git log" command doesn't display
285 the Committer, but other git tools do.
286 * Date The date and time on which the commit was authored, (again
287 stored separately from the date the change was committed).
288 timezone in which it was created. (The date and time are displayed
289 in the timezone of the person who created the commit.)
290 * commit message The text message that the creator of the commit
291 entered to describe the commit, (generally a one-line summary
292 followed by more supporting text).
294 The default output printed by “git log” is purely a summary; it is
295 missing a lot of detail.
297 #### 2.4.1 Commits, revisions, and talking to other people
299 As English is a notoriously sloppy language, and computer science has
300 a hallowed history of terminological confusion (why use one term when
301 four will do?), revision control has a variety of words and phrases
302 that mean the same thing. If you are talking about git history
303 with other people, you will find that what we have called a “commit”
304 is often called a "revision". In other systems, a similar notion
305 is referred to as a "changeset". You might even see abbreviations of
306 these terms such as "rev", "change", or even "cset".
308 While it may not matter much what word you use to refer to the concept
309 of “a commit”, it's important to know how to name “a specific
310 commit”. We have already seen one means of referring to a particular
311 commit, the 40-character hexadecimal string shown by "git log". These
312 commit identifiers are powerful because they are permanent, unique
313 identifiers that always identify the same commit in any copy of a
314 repository. If two users are examining a working directory associated
315 with the same commit identifier, then those two users have precisely
316 the same contents in all files, and exactly the same history leading
319 So there are places where it is often important to archive the
320 complete commit identifier, (perhaps in bug-tracking systems to
321 indicate a specific commit that fixes a bug, for example). But often,
322 in more casual settings, it's more convenient to use abbreviated
323 commit identifiers. Git accept any unique prefix of a commit
324 identifier, (and for reasonably-sized project the first 8 or 10
325 characters are almost always unique).
327 And unlike the permanent commit identifiers, git also provides
328 transient means of identifying commits. In fact, in day-to-day use of
329 git, you will probably use these names more than commit
330 identifiers. One example is branch names, (such as the default
331 "master" branch in any git repository), or any project-specific branch
332 names such as "stable", "experimental", or "crazy-insane-changes". Git
333 also provides a special name "HEAD" which always refers to the current
336 #### 2.4.2 Naming related commits
338 Git offers simple ways to name revisions that are related to
339 particular revisions in the history. One syntax is the ~ suffix which
340 refers to the parent of a commit, or if followed by a number, to the
341 Nth parent. For example, since "HEAD" refers to the most recent commit
342 in the current branch, "HEAD~", refers to the previous commit, and
343 "HEAD~2" refers to two commits back in the history.
345 Another useful syntax is .. which can be used to specify a range of
346 commits. So "origin..master" specifies everything that has been
347 committed to master since it diverged from origin.
349 #### 2.4.3 Viewing specific revisions
351 You can use "git log" to explore the range syntax just introduced. For
352 example, to see a list of the most recent 3 revisions you can use
353 "HEAD~3..", (the destination of the range is implicitly HEAD in this
357 commit a1a0e8b392b17caf50325498df54802fe3c03710
358 Author: Bryan O'Sullivan <bos@serpentine.com>
359 Date: Tue Sep 6 15:43:07 2005 -0700
363 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
364 Author: Bryan O'Sullivan <bos@serpentine.com>
365 Date: Tue Sep 6 13:15:58 2005 -0700
367 Get make to generate the final binary from a .o file.
369 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
370 Author: Bryan O'Sullivan <bos@serpentine.com>
371 Date: Tue Sep 6 13:15:43 2005 -0700
373 Introduce a typo into hello.c.
375 #### 2.4.4 Other log filters
377 Besides filtering by commit identifiers, git allows you to easily
378 filter the log output according to which files (or directories) are
379 modified by listing them after "--" which is necessary to distinguish
380 commit names from file names:
382 $ git log -- Makefile
383 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
384 Author: Bryan O'Sullivan <bos@serpentine.com>
385 Date: Tue Sep 6 13:15:58 2005 -0700
387 Get make to generate the final binary from a .o file.
389 commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
390 Author: Bryan O'Sullivan <mpm@selenic.com>
391 Date: Fri Aug 26 01:21:28 2005 -0700
395 And "git log" can also filter based on the dates at which commits were
398 $ git log --since="2 weeks ago" --until="yesterday"
400 [XXX: By default, "git log" displays author dates as "Date"
401 but then uses commit dates when given a --since option. That
402 seems like broken defaults to me. Why the inconsistency?]
404 Another useful option is -n or --max-count which, unsurprisingly,
405 limits the maximum number of commits to be displayed.
407 #### 2.4.5 More detailed information
409 While the default information printed by “git log” is useful if you
410 already know what you’re looking for, you may need to see more details
411 of the change, such as the "diffstat" information with --stat:
413 $ git log --stat --max-count=3
414 commit a1a0e8b392b17caf50325498df54802fe3c03710
415 Author: Bryan O'Sullivan <bos@serpentine.com>
416 Date: Tue Sep 6 15:43:07 2005 -0700
421 1 files changed, 2 insertions(+), 6 deletions(-)
423 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
424 Author: Bryan O'Sullivan <bos@serpentine.com>
425 Date: Tue Sep 6 13:15:58 2005 -0700
427 Get make to generate the final binary from a .o file.
430 1 files changed, 2 insertions(+), 0 deletions(-)
432 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
433 Author: Bryan O'Sullivan <bos@serpentine.com>
434 Date: Tue Sep 6 13:15:43 2005 -0700
436 Introduce a typo into hello.c.
439 1 files changed, 1 insertions(+), 1 deletions(-)
441 Or perhaps you'd like to see the actual patch content of each change,
442 which you can get with -p. That commit with the word typo in its name
443 looks suspicous, so let's tak a closer look. Remember that we can name
444 it as master~3, HEAD~3, or any prefix of its commit identifier, (such
447 $ git log -p -n 1 13ed136b
448 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
449 Author: Bryan O'Sullivan <bos@serpentine.com>
450 Date: Tue Sep 6 13:15:43 2005 -0700
452 Introduce a typo into hello.c.
454 diff --git a/hello.c b/hello.c
455 index ed55ec0..80b260c 100644
460 int main(int argc, char **argv)
462 - printf("hello, world!\n");
463 + printf("hello, world!\");
467 Of course, wanting to see all this information for a single commit is
468 such a common operation that it's given its own name in git, "git
469 show". So "git show 13ed136b" is a much easier way to get exactly the
473 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
474 Author: Bryan O'Sullivan <bos@serpentine.com>
475 Date: Tue Sep 6 13:15:43 2005 -0700
477 Introduce a typo into hello.c.
479 diff --git a/hello.c b/hello.c
480 index ed55ec0..80b260c 100644
485 int main(int argc, char **argv)
487 - printf("hello, world!\n");
488 + printf("hello, world!\");
492 ### 2.5 All about command options
494 Let’s take a brief break from exploring git commands to discuss
495 a pattern in the way that they work; you may find this useful to keep
496 in mind as we continue our tour.
498 Git has a consistent and straightforward approach to dealing
499 with the options that you can pass to commands. It follows the
500 conventions for options that are common to modern Linux and Unix
503 * Most options have long names. For example, as we’ve already seen,
504 the “git log" command accepts a --max-count=<number> option.
505 * Some options have short, single-character names. Often these are
506 aliases for long commands, (such as "-n <number>" instead of
507 --max-count=<number>), but sometimes the option exists in
508 short-form with no long-form equivalent, (such as -p). [XXX: It
509 wouldn't hurt to fix this by adding --patch, etc. right?]
510 * Long options start with two dashes (e.g. --max-count), while short
511 options start with one (e.g. -n).
513 * Option naming and usage is consistent across commands. For
514 example, every command that lets you specify a commit identifier
515 or range will accept the same expressions, (HEAD~3,
516 origin..master, 72d4f10e, etc), while any command that can be
517 limited by paths will accept the same expressions ("-- doc/
520 Many commands that print output of some kind can be made more quiet by
521 passing the -q or --quiet options.
523 ### 2.6 Making and reviewing changes
525 Now that we have a grasp of viewing history in git, let’s take a
526 look at making some changes and examining them.
528 The first thing we’ll do is isolate our experiment in a repository of
529 its own. We use the “git clone” command, but we don’t need to clone a
530 copy of the remote repository. Since we already have a copy of it
531 locally, we can just clone that instead. This is much faster than
532 cloning over the network, and cloning a local repository uses less
533 disk space in most cases, too.
536 $ git clone hello my-hello
537 Initialized empty Git repository in /tmp/my-hello/.git/
540 [XXX We say "empty" here, (presumably from the git-init part),
541 but shouldn't the command also report the succesful clone
542 which makes it non-empty? And what the heck does "0 blocks"
545 As an aside, it’s often good practice to keep a “pristine” copy of a
546 remote repository around, which you can then make temporary clones of
547 to create sandboxes for each task you want to work on. This lets you
548 work on multiple tasks in parallel, each isolated from the others
549 until it’s complete and you’re ready to integrate it back. Because
550 local clones are so cheap, there’s almost no overhead to cloning and
551 destroying repositories whenever you want.
553 Alternatively, you can achieve much the same effect by creating
554 multiple branches in a single repository, (but we won't go into detail
555 on how to do that in this chapter). Some people greatly appreciate
556 having multiple branches in a single repository rather than having
557 many repositories cluttering up their filesystem. Other people prefer
558 the ability to have working-tree changes, and intermediate build
559 files, etc. each isolated in a separate repository per branch. Both
560 modes are very well-supported by git, so it's really a matter of which
561 you find most appropriate at any time given your tastes and project
564 In our my-hello repository, we have a file hello.c that contains the
565 classic “hello, world” program. Let’s use the ancient and venerable
566 sed command to edit this file so that it prints a second line of
567 output. (I’m only using sed to do this because it’s easy to write a
568 scripted example this way. Since you’re not under the same constraint,
569 you probably won’t want to use sed; simply use your preferred text
570 editor to do the same thing.)
572 $ sed -i '/printf/a\\tprintf("hello again!\\n");' hello.c
574 The “git status” command will tell us what git knows about the files
581 # Changed but not updated:
582 # (use "git add <file>..." to update what will be committed)
586 no changes added to commit (use "git add" and/or "git commit -a")
588 We see that “git status” command prints a line with "modified" for
589 hello.c. The “git status” command will not print any output for files
590 that have not been modified.
592 Notice that we didn’t need to inform git that we were going to modify
593 the file before we started, or that we had modified the file after we
594 were done; it was able to figure this out itself.
596 It’s a little bit helpful to know that we’ve modified hello.c, but we
597 might prefer to know exactly what changes we’ve made to it. To do
598 this, we use the “git diff” command.
601 diff --git a/hello.c b/hello.c
602 index 9a3ff79..6d28887 100644
606 int main(int argc, char **argv)
608 printf("hello, world!\");
609 + printf("hello again!\n");
613 ### 2.7 Recording changes in a new commit
615 We can modify files, build and test our changes, and use “git status”
616 and “git diff” to review our changes, until we’re satisfied with what
617 we’ve done and arrive at a natural stopping point where we want to
618 record our work in a new commit.
620 The “git commit” command lets us create a new changeset; we’ll usually
621 refer to this as “making a commit” or “committing”.
623 #### 2.7.1 Setting up a username
625 When you try to run “git commit” for the first time, it might not do
626 exactly what you want. Git records your name and address with each
627 change that you commit, (as both author and committer unless you tell
628 it otherwise), so that you and others will later be able to tell who
629 made each change. Git tries to automatically figure out a sensible
630 name and address to attribute to both author and committer. It will
631 attempt each of the following methods, in order, (stopping for each field as soon as a value is found):
633 1. If you specify a --author option to the “git commit” command on
634 the command line, followed by a "Real Name <email@example.com>"
635 string, then this name and addresss will be used for the author
636 fields. The committer fields will still be determined as
637 below. This option is very helpful for when applying a commit
638 originally authored by someone other than yourself.
639 2. If any of the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL,
640 GIT_COMMITTER_NAME, or GIT_COMMITER_EMAIL environment variables
641 are set, then those values will be used for the corresponding
643 3. If you have a file in your home directory called .gitconfig, with
644 name or email settings in the [user] section, then these values
645 will be used to set any remaining author and committer
646 fields. For more details on the contents of this file, refer to
648 4. If you have a file in the local repository called .git/config,
649 again with name or email settings in the [user] section, then
650 these values will be used to set any remaining author and
652 5. If you have set the EMAIL environment variable, this will be used
653 to set author and committer email addresses if still unset.
654 6. git will query your system to find out your real name from
655 available GECOS field and your username, hostname, and domain to
656 construct an email address, (or at least an identifier resembling
659 If all of these mechanisms fail, "git commit" will fail, printing an
660 error message instructing you how to use "git config" to tell git your
661 name and email address.
663 You should think of the GIT_AUTHOR/COMMITER_NAME/EMAIL environment
664 variables and the --author option to the “git commit” command as ways
665 to override git’s default selection. For normal use, the simplest and
666 most robust way to set your information is by creating a .gitconfig
667 file, (either manually or with the "git config" command); see below
670 ##### Creating a git configuration file
672 To set your name and email address, just use the following commands:
674 git config --global user.name "Your Name"
675 git config --global user.email "you@example.com"
677 The --global option means that this command will set global
678 information, (affecting all repositories on this machine), in the
679 .gitconfig file in your home directory. Alternately, you could omit
680 the --global which would make the change take effect only in the local
681 repository. This is convenient if you want to have different email
682 addresses associated with different projects, for example.
684 Of course, git's configuration file is a simple-to-edit plain-text
685 file, so instead of using the above commands, you can also just edit
686 the files directly. Use your favorite editor to create a file called
687 .gitconfig in your home directory, (or if you ran the above commands
688 then it will be there already). The initial contents of your
689 .gitconfig should look like this.
691 # This is a git configuration file.
694 email = you@example.com
696 Similarly, you can make a repository-specific configuration by editing
697 .git/config in the local repository. It will already have some
698 sections present, (created by the "git clone"), just add a [user]
701 The “[user]” line begins a section of the config file, so you can read
702 the “name = ...” line as meaning “set the value of the name item in
703 the user section”. This is the same notion expressed with the
704 "user.name" syntax on the git-config command line. A section
705 continues until a new section begins, or the end of the file. Git
706 ignores empty lines and treats any text from “#” to the end of a line
709 ##### Choosing a user name
711 You can use any text you like as the value of the name and email
712 configuration items, since this information is for reading by other
713 people, not for interpreting by git. It is conventional to use a valid
714 email address, but some, (notably Linus Torvalds, the original author
715 of git), actually like the default user@hostname convention that git
716 falls back on without any additional information. There's no
717 requirement that the email address actually be valid, and perhaps it's
718 useful to be reminded which machine was used to create particular
721 #### 2.7.2 Writing a commit message
723 When we commit a change, git drops us into a text editor to
724 enter a message that will describe the modifications we’ve made in
725 this commit. This is called the commit message. It will be a record
726 for readers of what we did and why, and it will be printed by “git log”
727 after we’ve finished committing.
731 Note: The -a on the command-line instructs git to commit the new
732 content of *all* tracked files that have been modified. This is a
733 convenience over explicitly listing filenames to be committed on the
734 "git commit" command line. It is useful to use "git commit <files>"
735 when there is a need to commit only some subset of the files that have
738 If new files need to be committed for the first time, just use "git
739 add <file>" before "git commit -a". If a file needs to be removed,
740 just remove it as normal before committing and "git commit -a" will
741 notice that---it does not need to be explicitly told about the
744 The editor that the “git commit” command drops us into will contain an
745 empty line, followed by a number of lines starting with “#”.
748 # Please enter the commit message for your changes.
749 # (Comment lines starting with '#' will not be included)
751 # Changes to be committed:
752 # (use "git reset HEAD <file>..." to unstage)
757 git ignores the lines that start with “#”; it uses them only
758 to tell us which files it’s recording changes to. Modifying or
759 deleting these lines has no effect.
761 #### 2.7.3 Writing a good commit message
763 A good commit message will generally have a single line that
764 summarizes the commit, a blank line, and then one or more pargraphs
765 with supporting detail. Since many tools only print the first line of
766 a commit message by default, it’s important that the first line stands
769 One example of a first-line-only viewer is "git log
770 --pretty=short". Other examples include graphical history viewers such
771 as gitk and gitview, and web-based viewers such as gitweb and cgit.
773 Here’s a real example of a commit message that doesn’t follow
774 this guideline, and hence has a summary that is not readable.
776 $ git log --pretty=short
777 commit 3ef5535144da88a854f7930503845cd44506c2e2
778 Author: Censored Person <censored.person@example.org>
780 include buildmeister/commondefs. Add an exports and install
782 As far as the remainder of the contents of the commit message are
783 concerned, there are no hard-and-fast rules. git itself doesn’t
784 interpret or care about the contents of the commit message, though
785 your project may have policies that dictate a certain kind of
788 My personal preference is for short, but informative, commit messages
789 that tell me something that I can’t figure out with a quick glance at
790 the output of “git log -p".
792 #### 2.7.4 Aborting a commit
794 If you decide that you don’t want to commit while in the middle of
795 editing a commit message, simply exit from your editor without saving
796 the file that it’s editing. This will cause nothing to happen to
797 either the repository or the working directory.
799 #### 2.7.5 Admiring our new handiwork
801 Once we’ve finished the commit, we can use the “git show” command to
802 display the commit we just created. As discussed previously, this
803 command produces output that is identical to “git log -p”, but for
804 only a single revision, (and the most recent revision by default):
807 commit 018cfb742be6176443ffddac454e593e802ddf3e
808 Author: Carl Worth <cworth@cworth.org>
809 Date: Thu Sep 27 23:55:00 2007 -0700
811 Added an extra line of output.
813 If I would have been clever I would have fixed that old typo
816 diff --git a/hello.c b/hello.c
817 index 9a3ff79..6d28887 100644
821 int main(int argc, char **argv)
823 printf("hello, world!\");
824 + printf("hello again!\n");
828 Note that you will not see the same commit identifier for your commit,
829 even if the change you made is identical to mine. The commit
830 identifier incorporates not only the contents of the files, but commit
831 message, the author and committer names and emails, and the author and
832 commit dates. (OK, so now you probably know enough to be able to guess
833 the right command to produce a commit with exactly the commit
834 identifier shown above. Can you do it?)
836 #### 2.7.6 Fixing up a broken commit (before anyone else sees it)
838 So now that we've cloned a local repository, made a change to the
839 code, setup our name and email address, and made a commit with a
840 careful message, we're just about ready to share our change with the
841 world. But wait, we forgot to try to compile it didn't we?
844 cc -c -o hello.o hello.c
845 hello.c:10:9: warning: missing terminating " character
846 hello.c:10:9: warning: missing terminating " character
847 hello.c: In function ‘main’:
848 hello.c:10: error: missing terminating " character
849 hello.c:11: error: expected ‘)’ before ‘;’ token
850 hello.c:13: warning: passing argument 1 of ‘printf’ makes pointer from integer without a cast
851 hello.c:13: error: expected ‘;’ before ‘}’ token
852 make: *** [hello.o] Error 1
854 Oh look. The code's broken and doesn't compile. We don't want to share
855 code in this state. For situations where you notice one tiny detail
856 that got left out of the last commit, (a silly syntax error, a
857 misspelling in a comment or commit messsage), git provides a very
858 handy tool for just changing the last commit.
860 So fix that typo, (a missing 'n' between the '\' and the '"'), with
861 your editor or with something like this:
863 sed -i 's/\\"/\\n"/' hello.c
865 And then you can just amend the previous commit rather than creating a
866 new one with the --amend option to "git commit":
868 $ git commit -a --amend
870 Note that we use -a to include the code change here. And that helps
871 point out a situation where "git commit" is useful without the -a
872 option, "git commit --amend" is a useful command for amend just the
873 last commit message, without committing any new code changes, even if
874 some files have been modified in the working tree.
876 And here's the final result:
879 commit 839b58d021c618bd0e1d336d4d5878a0082672e6
880 Author: Carl Worth <cworth@cworth.org>
881 Date: Thu Sep 27 23:55:00 2007 -0700
883 Added an extra line of output and fixed the typo bug.
885 diff --git a/hello.c b/hello.c
886 index 9a3ff79..ca750e0 100644
891 int main(int argc, char **argv)
893 - printf("hello, world!\");
894 + printf("hello, world!\n");
895 + printf("hello again!\n");
899 I can't help but point out that this really was a poor example for
900 --amend. The end result is a single commit that does two independent
901 things, (fixes one bug and adds one new feature). It's much better to
902 create a code history where each commit makes an independent change,
903 (and as small as possible). This is important for several reasons:
905 * Small changes are easier to review
907 * Independent changes are easier to split up if only part of the
908 series gets accepted "upstream" for one reason or another.
910 * The smaller the changes are the more useful the history will be
911 when actually using the history, not just viewing it. This is
912 particularly important when doing "git bisect"---that's a powerful
913 tool for isolating the single commit that introduces a bug. And
914 it's much more powerful if the commit it isolates is as small as
917 So it's a good thing this document is available under a license that
918 allows for distribution of modified versions. Someone should clean up
919 the --amend example to not teach bad habits like I did above. [Note:
920 All this bad-habit stuff was introduced by me, and was not present in
921 Bryan's original chapter. -Carl]
923 ### 2.8 Sharing changes
925 We mentioned earlier that repositories in git are
926 self-contained. This means that the commit we just created exists
927 only in our my-hello repository. Let’s look at a few ways that we can
928 propagate this change into other repositories.
930 #### 2.8.1 Pulling changes from another repository
932 To get started, let’s clone our original hello repository, which does
933 not contain the change we just committed. We’ll call our temporary
934 repository hello-pull.
937 $ git clone hello hello-pull
938 Initialized empty Git repository in /tmp/hello-pull/.git/
941 We could use the “git pull” command to apply changes from my-hello to
942 our master branch in hello-pull. However, blindly pulling unknown
943 changes into a repository is a somewhat scary prospect. The "git pull"
944 command is coneptually the combination of two commands, "git fetch"
945 and "git merge"; we can run those separately to examine the changes
946 before applying them locally. First we do the fetch:
949 $ git fetch ../my-hello
950 remote: Generating pack...
951 Unpacking 3 objects...
953 remote: Done counting 5 objects.
954 Result has 3 objects.
955 Deltifying 3 objects...
956 100% remote: (3/3) done
957 Total 3 (delta 1), reused 0 (delta 0)
959 The fetched commits (or commit in this case) are available as the name
960 FETCH_HEAD. [XXX: Shouldn't git-fetch print that name out to the user
961 if the user didn't provide a specific branch name to fetch into.] And
962 the difference between what we had before and what exists on
963 FETCH_HEAD can easily be examined with the ..FETCH_HEAD range
966 $ git log ..FETCH_HEAD
967 commit 839b58d021c618bd0e1d336d4d5878a0082672e6
968 Author: Carl Worth <cworth@cworth.org>
969 Date: Thu Sep 27 23:55:00 2007 -0700
971 Added an extra line of output and fixed the typo bug.
973 Since these commits actually exist in the local repository now, we
974 don't need to fetch or pull them from the remote repository again---we
975 can now use "git merge" to apply the previously fetched commits. (A
976 mercurial user might notice here that git does not have the race
977 condition between "hg incoming" and "hg pull" that mercurial has since
978 the commits are fetched only once.)
980 $ git merge FETCH_HEAD
981 Updating a1a0e8b..839b58d
984 1 files changed, 2 insertions(+), 1 deletions(-)
986 Notice that "git merge" reports that our branch pointer has been
987 updated from a1a0e8b to 839b58d. Also, this is a "fast forward"
988 meaning that the new commits are a linear sequence on top of the
989 commit we already hand. In other words, there wasn't any divergence
990 between these two repositories so no actual "merge" commit was
993 This separation of fetch and merge is useful when you need to
994 carefully review some changes before applying them. But often you're
995 in a situation where you know you trust the remote repository and you
996 simply want to pull those changes as conveniently as possible, (no
997 extra commands, no typing a magic name like FETCH_HEAD). This is the
998 case when the tracking upstream development of a project with git. And
999 in that case, the above steps are as simple as just executing "git
1000 pull". So let's repeat all that the simpler way:
1003 $ git clone hello hello-tracking
1004 Initialized empty Git repository in /tmp/hello-tracking/.git/
1007 $ git pull ../my-hello
1008 remote: Generating pack...
1009 remote: Done counting 5 objects.
1010 Result has 3 objects.
1011 Deltifying 3 objects...
1012 Unpacking 3 objects...
1013 remote: 100% (3/3) done
1014 Total 3 (delta 1), reused 0 (delta 0)
1016 Updating a1a0e8b..839b58d
1019 1 files changed, 2 insertions(+), 1 deletions(-)
1021 It should be plain to see that the "git pull" command really did the
1022 combined sequence of "git fetch" and "git merge". Also, if you want to
1023 pull from the same repository you cloned from originally, (which is
1024 the common case for the upstream-tracking scenario), then "git pull"
1025 with no explicit repository is suffcient, and it will default to
1026 pulling from the same repository as the original clone.
1028 [XXX: The structure of the preceding section follows that of the
1029 original hgbook. But an alternate structure that arranged to pull from
1030 the originally cloned repository (as would be common) would allow for
1031 more straightforward use of git's features. For example, instead of
1032 the silly FETCH_HEAD stuff it would allow for "git fetch" and "git log
1033 master..origin" to be a very nice replacement for "hg
1034 incoming". Similarly, below, "git log origin..master" would make a
1035 nice replacement for "hg outgoing" which is something I didn't offer
1036 at all. One could also use git's remotes with the myriad repositories
1037 as used here, but it would require doing things like "git remote add
1038 <some-name> ../hello-pull" and that seems like a bit much to introduce
1039 for a turorial of this level. If nothing else, if the above section
1040 seems a little intimidating, understand that it's because things are
1041 not presented in the most natural "git way", (and I'm a little too
1042 tired to fix it tonight).]
1044 Note: Mercurial users who are reading this might wonder if there's a
1045 need for the equivalent of "hg update" after doing a "git pull". And
1046 the answer is no. Unlike mercurial, "git pull" and "git merge" will
1047 automatically update the workind-directory files as necessary.
1049 #### 2.8.2 Checking out previous revisions
1051 It's often useful to examine the working-tree state of some specific
1052 revision other than the tip of some branch. For example, maybe you
1053 would like to build a particular tagged version, or maybe you'd like
1054 to test the behavior of the code before a particular change was
1055 introduced. To do this, use "git checkout" and pass it the name of any
1056 revision, (with a branch name, a tag name, or any other commit
1057 identifier). For example, to examine our project before the original
1058 typo was introduced:
1060 $ git checkout 0a633bf5
1061 Note: moving to "0a633bf5" which isn't a local branch
1062 If you want to create a new branch from this checkout, you may do so
1063 (now or later) by using -b with the checkout command again. Example:
1064 git checkout -b <new_branch_name>
1065 HEAD is now at 0a633bf... Create a makefile
1067 The note that git gives us is to indicate that we are checking out a
1068 non-branch revision. This is perfectly fine if we are just exploring
1069 history, but if we actually wanted to use this revision as the basis
1070 for new commits, we would first have to create a new branch name as it
1073 If we were to use "git checkout" with a branch name, then that would
1074 change the current branch, (meaning that any new commits would advance
1075 that branch pointer).
1077 For now, let's return back to the tip of the master branch by just
1078 checking it out again:
1080 $ git checkout master
1081 Previous HEAD position was 0a633bf... Create a makefile
1082 Switched to branch "master"
1084 #### 2.8.3 Pushing changes to another repository
1086 Git lets us push changes to another repository, from the repository
1087 we’re currently visiting. As with previous examples, above, we’ll
1088 first create a temporary repository to push our changes into. But
1089 instead of using "git clone", this time we'll use "git init" to make a
1090 repository from an empty directory. We do this to create a "bare"
1091 repository which is simply a repository that has no working-directory
1092 files associated with it. In general, you should only push to bare
1099 Initialized empty Git repository in /tmp/hello-push/
1101 And then we'll go back to our my-hello repository to perform the
1102 push. Since this is our very first push into this repository we need
1103 to tell git which branches to push. The easiest way to do this is to
1104 use --all to indicate all branches:
1107 $ git push ../hello-push --all
1108 updating 'refs/heads/master'
1109 from 0000000000000000000000000000000000000000
1110 to 839b58d021c618bd0e1d336d4d5878a0082672e6
1112 Done counting 18 objects.
1113 Deltifying 18 objects...
1115 Writing 18 objects...
1117 Total 18 (delta 3), reused 0 (delta 0)
1118 Unpacking 18 objects...
1120 refs/heads/master: 0000000000000000000000000000000000000000 -> 839b58d021c618bd0e1d336d4d5878a0082672e6
1122 For subsequent pushes we don't need to specify --all as "git push"
1123 will push all branches that exist in both the local and remote
1126 What happens if we try to pull or push changes and the receiving
1127 repository already has those changes? Nothing too exciting.
1129 $ git push ../hello-push
1130 Everything up-to-date
1132 #### 2.8.4 Sharing changes over a network
1134 The commands we have covered in the previous few sections are not
1135 limited to working with local repositories. Each works in exactly the
1136 same fashion over a network connection; simply pass in a URL or an ssh
1137 host:/path/name specification instead of a local path.
1140 Open Publication License
1142 Version 1.0, 8 June 1999
1144 ### D.1 Requirements on both unmodified and modified versions
1146 The Open Publication works may be reproduced and distributed in whole
1147 or in part, in any medium physical or electronic, provided that the
1148 terms of this license are adhered to, and that this license or an
1149 incorporation of it by reference (with any options elected by the
1150 author(s) and/or publisher) is displayed in the reproduction.
1152 Proper form for an incorporation by reference is as follows:
1154 Copyright (c) year by author’s name or designee. This material may be
1155 distributed only subject to the terms and conditions set forth in the
1156 Open Publication License, vx.y or later (the latest version is
1157 presently available at
1158 [http://www.opencontent.org/openpub/][http://www.opencontent.org/openpub/]).
1160 The reference must be immediately followed with any options elected by
1161 the author(s) and/or publisher of the document (see section D.6).
1163 Commercial redistribution of Open Publication-licensed material is
1166 Any publication in standard (paper) book form shall require the
1167 citation of the original publisher and author. The publisher and
1168 author’s names shall appear on all outer surfaces of the book. On all
1169 outer surfaces of the book the original publisher’s name shall be as
1170 large as the title of the work and cited as possessive with respect to
1175 The copyright to each Open Publication is owned by its author(s) or
1178 ### D.3 Scope of license
1180 The following license terms apply to all Open Publication works,
1181 unless otherwise explicitly stated in the document.
1183 Mere aggregation of Open Publication works or a portion of an Open
1184 Publication work with other works or programs on the same media shall
1185 not cause this license to apply to those other works. The aggregate
1186 work shall contain a notice specifying the inclusion of the Open
1187 Publication material and appropriate copyright notice.
1189 Severability. If any part of this license is found to be unenforceable
1190 in any jurisdiction, the remaining portions of the license remain in
1193 No warranty. Open Publication works are licensed and provided “as is”
1194 without warranty of any kind, express or implied, including, but not
1195 limited to, the implied warranties of merchantability and fitness for
1196 a particular purpose or a warranty of non-infringement.
1198 ### D.4 Requirements on modified works
1200 All modified versions of documents covered by this license, including
1201 translations, anthologies, compilations and partial documents, must
1202 meet the following requirements:
1204 1. The modified version must be labeled as such.
1205 2. The person making the modifications must be identified and the
1206 modifications dated.
1207 3. Acknowledgement of the original author and publisher if
1208 applicable must be retained according to normal academic citation
1210 4. The location of the original unmodified document must be identified.
1211 5. The original author’s (or authors’) name(s) may not be used to
1212 assert or imply endorsement of the resulting document without the
1213 original author’s (or authors’) permission.
1215 ### D.5 Good-practice recommendations
1217 In addition to the requirements of this license, it is requested from
1218 and strongly recommended of redistributors that:
1220 1. If you are distributing Open Publication works on hardcopy or
1221 CD-ROM, you provide email notification to the authors of your
1222 intent to redistribute at least thirty days before your
1223 manuscript or media freeze, to give the authors time to provide
1224 updated documents. This notification should describe
1225 modifications, if any, made to the document.
1226 2. All substantive modifications (including deletions) be either
1227 clearly marked up in the document or else described in an
1228 attachment to the document.
1229 3. Finally, while it is not mandatory under this license, it is
1230 considered good form to offer a free copy of any hardcopy and
1231 CD-ROM expression of an Open Publication-licensed work to its
1234 ### D.6 License options
1236 The author(s) and/or publisher of an Open Publication-licensed
1237 document may elect certain options by appending language to the
1238 reference to or copy of the license. These options are considered part
1239 of the license instance and must be included with the license (or its
1240 incorporation by reference) in derived works.
1242 1. To prohibit distribution of substantively modified versions
1243 without the explicit permission of the author(s). “Substantive
1244 modification” is defined as a change to the semantic content of
1245 the document, and excludes mere changes in format or
1246 typographical corrections.
1248 To accomplish this, add the phrase “Distribution of substantively
1249 modified versions of this document is prohibited without the
1250 explicit permission of the copyright holder.” to the license
1253 2. To prohibit any publication of this work or derivative works in
1254 whole or in part in standard (paper) book form for commercial
1255 purposes is prohibited unless prior permission is obtained from
1256 the copyright holder.
1258 To accomplish this, add the phrase “Distribution of the work or
1259 derivative of the work in any standard (paper) book form is
1260 prohibited unless prior permission is obtained from the copyright
1261 holder.” to the license reference or copy.