2 A tour of git: the basics
6 This document is a modified version originally known as "Distributed
7 revision control with Mercurial" and originally authored by Bryan
8 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 ### 2.1 Installing git on your system
34 Prebuilt binary packages of git are available for many popular
35 operating systems. These make it easy to start using git on your
40 Because each Linux distribution has its own packaging tools, policies,
41 and rate of development, it’s difficult to give a comprehensive set of
42 instructions on how to install git binaries. The version of
43 git that you will end up with can vary depending on how active
44 the person is who maintains the package for your distribution.
46 To keep things simple, I will focus on installing git from the
47 command line under the most popular Linux distributions. Most of these
48 distributions provide graphical package managers that will let you
49 install git with a single click. The package name to look for is
50 often git, but is sometimes git-core, (due to an unfortunate name
51 with git, meaning GNU Interactive Tools).
55 apt-get install git-core
75 A git-core package is available through
76 [macports](http://macports.org). Once macports is enabled, the command
83 Git has long been available as part of cygwin, and works reasonably
84 well in that environment. Some people find cygwin a particularly
85 inelegant approach to running git and would prefer a "native"
86 solution. To this end, the [msysgit
87 project](http://code.google.com/p/msysgit/) is rapidly putting
88 together a solution including various packages with full
89 installers. These include GitMe, a package to install the entire
90 development environment necessary to work on improving the msysgit
91 port of git, and WinGit, a package for installing just git itself
92 without the development environment, (still in Alpha as of September
95 ### 2.2 Getting started
97 To begin, we’ll use the “git version” command to find out whether git
98 is actually installed properly. Versions 1.5 and newer of git are much
99 more friendly to new users than versions 1.4 and older. If you aren't
100 yet running version 1.5 or newer, it's highly recommended that you
106 #### 2.2.1 Built-in help
108 Git provides a built-in help system. This is invaluable for those
109 times when you find yourself stuck trying to remember how to run a
110 command. If you are completely stuck, simply run “git help”; it will
111 print a brief list of commonly-used commands, along with a description
112 of what each does. If you ask for help on a specific command (such as
113 "git help init"), it prints more detailed information. [XXX: Does "git
114 help <foo>" work universally as a built-in or does it expect man to be
115 present and just call out to "man git-<foo>"?]
117 [XXX: The original hgbook includes the complete output of "hg
118 help init" at this point. I'm not including the corresponding
119 "git help init" output as it would be excessively long. The
120 description alone is quite reasonable, (other than a
121 not-too-helpful aside about the obsolete git-init-db command),
122 but it only comes after a full screen's worth of options
123 details. Might it make sense to have a more summarized help
124 output for "git help <foo>" than all of the documentation
125 available for git-<foo>? And perhaps alos provide a "git -v
126 help" similar to "hg -v help" for more?]
128 ### 2.3 Working with a repository
130 In git, everything happens inside a repository. The repository
131 for a project contains all of the files that “belong to” that project,
132 along with a historical record of the project’s files.
134 There’s nothing particularly magical about a repository; it is simply
135 a directory tree in your filesystem that git treats as
136 special. You can rename or delete a repository any time you like,
137 using either the command line or your file browser.
139 #### 2.3.1 Making a local copy of a repository
141 Copying a repository is just a little bit special. While you could use
142 a normal file copying command to make a copy of a repository, it’s
143 best to use a built-in command that git provides. This command
144 is called “git clone”, because it creates an identical copy of an
147 $ git clone git://cworth.org/git/hello
148 Initialized empty Git repository in /tmp/hello/.git/
149 remote: Generating pack...
150 remote: Done counting 15 objects.
151 remote: Deltifying 15 objects...
152 remote: 100% (15/15) done
153 remote: Total 15 (delta 2), reused 15 (delta remote: 2)
154 Indexing 15 objects...
156 Resolving 2 deltas...
159 If for some reason you are prevented from talking on the git: port,
160 then there is also the capability to clone a repository (less
161 efficiently) over http:
163 $ git clone http://cworth.org/git/hello
164 Initialized empty Git repository in /tmp/hello/.git/
165 Getting alternates list for http://cworth.org/git/hello
166 Getting pack list for http://cworth.org/git/hello
167 Getting index for pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
168 Getting pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
169 which contains a1a0e8b392b17caf50325498df54802fe3c03710
170 walk a1a0e8b392b17caf50325498df54802fe3c03710
171 walk 72d4f10e4a27dbb09ace1503c20dbac1912ee451
172 walk 13ed136b983a9c439eddeea8a1c2076cffbb685f
173 walk 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
174 walk db7117a9dd9a6e57e8632ea5848e1101eee0fbde
176 If our clone succeeded, we should now have a local directory called
177 hello. This directory will contain some files.
181 drwxr-xr-x 3 cworth cworth 4096 2007-09-27 16:40 hello
185 These files have the same contents and history in our repository as
186 they do in the repository we cloned.
188 Every git repository is complete, self-contained, and
189 independent. It contains its own private copy of a project’s files and
190 history. A cloned repository remembers the location of the repository
191 it was cloned from, but it does not communicate with that repository,
192 or any other, unless you tell it to.
194 What this means for now is that we’re free to experiment with our
195 repository, safe in the knowledge that it’s a private “sandbox” that
196 won’t affect anyone else.
198 #### 2.3.2 What’s in a repository?
200 When we take a more detailed look inside a repository, we can see that
201 it contains a directory named .git. This is where git keeps all
202 of its metadata for the repository.
206 . .. .git hello.c Makefile
208 The contents of the .git directory and its subdirectories are private
209 to git. Every other file and directory in the repository is
210 yours to do with as you please.
212 To introduce a little terminology, the .git directory is the “real”
213 repository, and all of the files and directories that coexist with it
214 are said to live in the working directory. An easy way to remember the
215 distinction is that the repository contains the history of your
216 project, while the working directory contains a snapshot of your
217 project at a particular point in history.
219 ### 2.4 A tour through history
221 One of the first things we might want to do with a new, unfamiliar
222 repository is understand its history. The “git log” command gives us a
226 commit a1a0e8b392b17caf50325498df54802fe3c03710
227 Author: Bryan O'Sullivan <bos@serpentine.com>
228 Date: Tue Sep 6 15:43:07 2005 -0700
232 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
233 Author: Bryan O'Sullivan <bos@serpentine.com>
234 Date: Tue Sep 6 13:15:58 2005 -0700
236 Get make to generate the final binary from a .o file.
238 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
239 Author: Bryan O'Sullivan <bos@serpentine.com>
240 Date: Tue Sep 6 13:15:43 2005 -0700
242 Introduce a typo into hello.c.
244 commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
245 Author: Bryan O'Sullivan <mpm@selenic.com>
246 Date: Fri Aug 26 01:21:28 2005 -0700
250 commit db7117a9dd9a6e57e8632ea5848e1101eee0fbde
251 Author: Bryan O'Sullivan <mpm@selenic.com>
252 Date: Fri Aug 26 01:20:50 2005 -0700
254 Create a standard "hello, world" program
256 By default, this command prints a brief paragraph of output for each
257 change to the project that was recorded. In git terminology, we
258 call each of these recorded events a commit.
260 The fields in a record of output from “git log” are as follows.
262 * commit This field consists of a string of 40 hexadecimal characters.
263 This is a unique identifier for referring to particular commits.
264 * Author The identity of the person who authored the commit. This
265 field consist of two sub-fields for the user's name and email
266 address, (or at least an email-like idenitifer). Note that git
267 stores a separate "Committer" field for the person who commited
268 the change, (since often an author will email a change to a
269 maintainer that commits it). The "git log" command doesn't display
270 the Committer, but other git tools do.
271 * Date The date and time on which the commit was authored, (again
272 stored separately from the date the change was committed).
273 timezone in which it was created. (The date and time are displayed
274 in the timezone of the person who created the commit.)
275 * commit message The text message that the creator of the commit
276 entered to describe the commit, (generally a one-line summary
277 followed by more supporting text).
279 The default output printed by “git log” is purely a summary; it is
280 missing a lot of detail.
282 Figure [2.1][8] provides a graphical representation of the history of
283 the hello repository, to make it a little easier to see which
284 direction history is “flowing” in. We’ll be returning to this figure
285 several times in this chapter and the chapter that follows.
292 Graphical history of the hello repository
296 #### 2.4.1 Commits, revisions, and talking to other people
298 As English is a notoriously sloppy language, and computer science has
299 a hallowed history of terminological confusion (why use one term when
300 four will do?), revision control has a variety of words and phrases
301 that mean the same thing. If you are talking about git history
302 with other people, you will find that what we have called a “commit”
303 is often called a "revision". In other systems, a similar notion
304 is referred to as a "changeset". You might even see abbreviations of
305 these terms such as "rev", "change", or even "cset".
307 While it may not matter much what word you use to refer to the concept
308 of “a commit”, it's important to know how to name “a specific
309 commit”. We have already seen one means of referring to a particular
310 commit, the 40-character hexadecimal string shown by "git log". These
311 commit identifiers are powerful because they are permanent, unique
312 identifiers that always identify the same commit in any copy of a
313 repository. If two users are examining a working directory associated
314 with the same commit identifier, then those two users have precisely
315 the same contents in all files, and exactly the same history leading
318 So there are places where it is often important to archive the
319 complete commit identifier, (perhaps in bug-tracking systems to
320 indicate a specific commit that fixes a bug, for example). But often,
321 in more casual settings, it's more convenient to use abbreviated
322 commit identifiers. Git accept any unique prefix of a commit
323 identifier, (and for reasonably-sized project the first 8 or 10
324 characters are almost always unique).
326 And unlike the permanent commit identifiers, git also provides
327 transient means of identifying commits. In fact, in day-to-day use of
328 git, you will probably use these names more than commit
329 identifiers. One example is branch names, (such as the default
330 "master" branch in any git repository), or any project-specific branch
331 names such as "stable", "experimental", or "crazy-insane-changes". Git
332 also provides a special name "HEAD" which always refers to the current
335 #### 2.4.2 Naming related commits
337 Git offers simple ways to name revisions that are related to
338 particular revisions in the history. One syntax is the ~ suffix which
339 refers to the parent of a commit, or if followed by a number, to the
340 Nth parent. For example, since "HEAD" refers to the most recent commit
341 in the current branch, "HEAD~", refers to the previous commit, and
342 "HEAD~2" refers to two commits back in the history.
344 Another useful syntax is .. which can be used to specify a range of
345 commits. So "origin..master" specifies everything that has been
346 committed to master since it derived from origin.
348 #### 2.4.3 Viewing specific revisions
350 You can use "git log" to explore the range syntax just introduced. For
351 example, to see a list of the most recent 3 revisions you can use
352 "HEAD~3..", (the destination of the range is implicitly HEAD in this
356 commit a1a0e8b392b17caf50325498df54802fe3c03710
357 Author: Bryan O'Sullivan <bos@serpentine.com>
358 Date: Tue Sep 6 15:43:07 2005 -0700
362 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
363 Author: Bryan O'Sullivan <bos@serpentine.com>
364 Date: Tue Sep 6 13:15:58 2005 -0700
366 Get make to generate the final binary from a .o file.
368 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
369 Author: Bryan O'Sullivan <bos@serpentine.com>
370 Date: Tue Sep 6 13:15:43 2005 -0700
372 Introduce a typo into hello.c.
374 #### 2.4.4 Other log filters
376 Besides filtering by commit identifiers, git allows you to easily
377 filter the log output according to which files (or directories) are
378 modified by listing them after "--" wihch is necessary to distinguish
379 commit names from file names:
381 $ git log -- Makefile
382 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
383 Author: Bryan O'Sullivan <bos@serpentine.com>
384 Date: Tue Sep 6 13:15:58 2005 -0700
386 Get make to generate the final binary from a .o file.
388 commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
389 Author: Bryan O'Sullivan <mpm@selenic.com>
390 Date: Fri Aug 26 01:21:28 2005 -0700
394 And "git log" can also filter based on the dates at which commits were
397 $ git log --since="2 weeks ago" --until="yesterday"
399 Another useful option is -n or --max-count which, unsurprisingly,
400 limits the maximum number of commits to be displayed.
402 #### 2.4.3 More detailed information
404 While the default information printed by “git log” is useful if you
405 already know what you’re looking for, you may need to see more details
406 of the change, such as the "diffstat" information with --stat:
408 $ git log --stat --max-count=3
409 commit a1a0e8b392b17caf50325498df54802fe3c03710
410 Author: Bryan O'Sullivan <bos@serpentine.com>
411 Date: Tue Sep 6 15:43:07 2005 -0700
416 1 files changed, 2 insertions(+), 6 deletions(-)
418 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
419 Author: Bryan O'Sullivan <bos@serpentine.com>
420 Date: Tue Sep 6 13:15:58 2005 -0700
422 Get make to generate the final binary from a .o file.
425 1 files changed, 2 insertions(+), 0 deletions(-)
427 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
428 Author: Bryan O'Sullivan <bos@serpentine.com>
429 Date: Tue Sep 6 13:15:43 2005 -0700
431 Introduce a typo into hello.c.
434 1 files changed, 1 insertions(+), 1 deletions(-)
436 Or perhaps you'd like to see the actual patch content of each change,
437 which you can get with -p. That commit with the word typo in its name
438 looks suspicous, so let's tak a closer look. Remember that we can name
439 it as master~3, HEAD~3, or any prefix of its commit identifier, (such
442 $ git log -p -n 1 13ed136b
443 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
444 Author: Bryan O'Sullivan <bos@serpentine.com>
445 Date: Tue Sep 6 13:15:43 2005 -0700
447 Introduce a typo into hello.c.
449 diff --git a/hello.c b/hello.c
450 index ed55ec0..80b260c 100644
455 int main(int argc, char **argv)
457 - printf("hello, world!\n");
458 + printf("hello, world!\");
462 Of course, wanting to see all this information for a single commit is
463 such a common operation that it's given its own name in git, "git
464 show". So "git show 13ed136b" is a much easier way to get exactly the
468 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
469 Author: Bryan O'Sullivan <bos@serpentine.com>
470 Date: Tue Sep 6 13:15:43 2005 -0700
472 Introduce a typo into hello.c.
474 diff --git a/hello.c b/hello.c
475 index ed55ec0..80b260c 100644
480 int main(int argc, char **argv)
482 - printf("hello, world!\n");
483 + printf("hello, world!\");
487 ### 2.5 All about command options
489 Let’s take a brief break from exploring git commands to discuss
490 a pattern in the way that they work; you may find this useful to keep
491 in mind as we continue our tour.
493 Git has a consistent and straightforward approach to dealing
494 with the options that you can pass to commands. It follows the
495 conventions for options that are common to modern Linux and Unix
498 * Most options have long names. For example, as we’ve already seen,
499 the “git log" command accepts a --max-count=<number> option.
500 * Some options have short, single-character names. Often these are
501 aliases for long commands, (such as "-n <number>" instead of
502 --max-count=<number>), but sometimes the option exists in
503 short-form with no long-form equivalent, (such as -p). [XXX: It
504 wouldn't hurt to fix this by adding --patch, etc. right?]
505 * Long options start with two dashes (e.g. --max-count), while short
506 options start with one (e.g. -n).
508 * Option naming and usage is consistent across commands. For
509 example, every command that lets you specify a commit identifier
510 or range will accept the same expressions, (HEAD~3,
511 origin..master, 72d4f10e, etc), while any command that can be
512 limited by paths will accept the same expressions ("-- doc/
515 Many commands that print output of some kind can be made more quiet by
516 passing the -q or --quiet options.
518 ### 2.6 Making and reviewing changes
520 Now that we have a grasp of viewing history in git, let’s take a
521 look at making some changes and examining them.
523 The first thing we’ll do is isolate our experiment in a repository of
524 its own. We use the “git clone” command, but we don’t need to clone a
525 copy of the remote repository. Since we already have a copy of it
526 locally, we can just clone that instead. This is much faster than
527 cloning over the network, and cloning a local repository uses less
528 disk space in most cases, too.
531 $ git clone hello my-hello
532 Initialized empty Git repository in /home/cworth/src/hgbook-git/my-hello/.git/
535 [XXX We say "empty" here, (presumably from the git-init part),
536 but shouldn't the command also report the succesful clone
537 which makes it non-empty? And what the heck does "0 blocks"
540 As an aside, it’s often good practice to keep a “pristine” copy of a
541 remote repository around, which you can then make temporary clones of
542 to create sandboxes for each task you want to work on. This lets you
543 work on multiple tasks in parallel, each isolated from the others
544 until it’s complete and you’re ready to integrate it back. Because
545 local clones are so cheap, there’s almost no overhead to cloning and
546 destroying repositories whenever you want.
548 Alternatively, you can achieve much the same effect by creating
549 multiple branches in a single repository, (but we won't go into detail
550 on how to do that in this chapter). Some people greatly appreciate
551 having multiple branches in a single repository rather than having
552 many repositories cluttering up their filesystem. Other people prefer
553 the ability to have working-tree changes, and intermediate build
554 files, etc. each isolated in a separate repository per branch. Both
555 modes are very well-supported by git, so it's really a matter of which
556 you find most appropriate at any time given your tastes and project
559 In our my-hello repository, we have a file hello.c that contains the
560 classic “hello, world” program. Let’s use the ancient and venerable
561 sed command to edit this file so that it prints a second line of
562 output. (I’m only using sed to do this because it’s easy to write a
563 scripted example this way. Since you’re not under the same constraint,
564 you probably won’t want to use sed; simply use your preferred text
565 editor to do the same thing.)
567 $ sed -i '/printf/a\\tprintf("hello again!\\n");' hello.c
569 The “git status” command will tell us what git knows about the files
576 # Changed but not updated:
577 # (use "git add <file>..." to update what will be committed)
581 no changes added to commit (use "git add" and/or "git commit -a")
583 We see that “git status” command prints a line with "modified" for
584 hello.c. The “git status” command will not print any output for files
585 that have not been modified.
587 Notice that we didn’t need to inform git that we were going to modify
588 the file before we started, or that we had modified the file after we
589 were done; it was able to figure this out itself.
591 It’s a little bit helpful to know that we’ve modified hello.c, but we
592 might prefer to know exactly what changes we’ve made to it. To do
593 this, we use the “git diff” command.
596 diff --git a/hello.c b/hello.c
597 index 9a3ff79..6d28887 100644
601 int main(int argc, char **argv)
603 printf("hello, world!\");
604 + printf("hello again!\n");
608 ### 2.7 Recording changes in a new changeset
610 We can modify files, build and test our changes, and use “hg status”
611 and “hg diff” to review our changes, until we’re satisfied with what
612 we’ve done and arrive at a natural stopping point where we want to
613 record our work in a new changeset.
615 The “hg commit” command lets us create a new changeset; we’ll usually
616 refer to this as “making a commit” or “committing”.
618 #### 2.7.1 Setting up a username
620 When you try to run “hg commit” for the first time, it is not
621 guaranteed to succeed. Mercurial records your name and address with
622 each change that you commit, so that you and others will later be able
623 to tell who made each change. Mercurial tries to automatically figure
624 out a sensible username to commit the change with. It will attempt
625 each of the following methods, in order:
627 1. If you specify a -u option to the “hg commit” command on the
628 command line, followed by a username, this is always given the
630 2. If you have set the HGUSER environment variable, this is checked next.
631 3. If you create a file in your home directory called .hgrc, with a
632 username entry, that will be used next. To see what the contents
633 of this file should look like, refer to section [2.7.1][11]
635 4. If you have set the EMAIL environment variable, this will be used
637 5. Mercurial will query your system to find out your local user name
638 and host name, and construct a username from these
639 components. Since this often results in a username that is not
640 very useful, it will print a warning if it has to do this.
642 If all of these mechanisms fail, Mercurial will fail, printing an
643 error message. In this case, it will not let you commit until you set
646 You should think of the HGUSER environment variable and the -u option
647 to the “hg commit” command as ways to override Mercurial’s default
648 selection of username. For normal use, the simplest and most robust
649 way to set a username for yourself is by creating a .hgrc file; see
652 ##### Creating a Mercurial configuration file
654 To set a user name, use your favourite editor to create a file called
655 .hgrc in your home directory. Mercurial will use this file to look up
656 your personalised configuration settings. The initial contents of your
657 .hgrc should look like this.
659 # This is a Mercurial configuration file.
661 username = Firstname Lastname <email.address@domain.net>
663 The “[ui]” line begins a section of the config file, so you can read
664 the “username = ...” line as meaning “set the value of the username
665 item in the ui section”. A section continues until a new section
666 begins, or the end of the file. Mercurial ignores empty lines and
667 treats any text from “#” to the end of a line as a comment.
669 ##### Choosing a user name
671 You can use any text you like as the value of the username config
672 item, since this information is for reading by other people, but for
673 interpreting by Mercurial. The convention that most people follow is
674 to use their name and email address, as in the example above.
676 Note: Mercurial’s built-in web server obfuscates email addresses, to
677 make it more difficult for the email harvesting tools that spammers
678 use. This reduces the likelihood that you’ll start receiving more junk
679 email if you publish a Mercurial repository on the web.
681 #### 2.7.2 Writing a commit message
683 When we commit a change, Mercurial drops us into a text editor, to
684 enter a message that will describe the modifications we’ve made in
685 this changeset. This is called the commit message. It will be a record
686 for readers of what we did and why, and it will be printed by “hg log”
687 after we’ve finished committing.
691 The editor that the “hg commit” command drops us into will contain an
692 empty line, followed by a number of lines starting with “HG:”.
697 Mercurial ignores the lines that start with “HG:”; it uses them only
698 to tell us which files it’s recording changes to. Modifying or
699 deleting these lines has no effect.
701 #### 2.7.3 Writing a good commit message
703 Since “hg log” only prints the first line of a commit message by
704 default, it’s best to write a commit message whose first line stands
705 alone. Here’s a real example of a commit message that doesn’t follow
706 this guideline, and hence has a summary that is not readable.
708 changeset: 73:584af0e231be
709 user: Censored Person <censored.person@example.org>
710 date: Tue Sep 26 21:37:07 2006 -0700
711 summary: include buildmeister/commondefs. Add an exports and install
713 As far as the remainder of the contents of the commit message are
714 concerned, there are no hard-and-fast rules. Mercurial itself doesn’t
715 interpret or care about the contents of the commit message, though
716 your project may have policies that dictate a certain kind of
719 My personal preference is for short, but informative, commit messages
720 that tell me something that I can’t figure out with a quick glance at
721 the output of “hg log --patch”.
723 #### 2.7.4 Aborting a commit
725 If you decide that you don’t want to commit while in the middle of
726 editing a commit message, simply exit from your editor without saving
727 the file that it’s editing. This will cause nothing to happen to
728 either the repository or the working directory.
730 If we run the “hg commit” command without any arguments, it records
731 all of the changes we’ve made, as reported by “hg status” and “hg
734 #### 2.7.5 Admiring our new handiwork
736 Once we’ve finished the commit, we can use the “hg tip” command to
737 display the changeset we just created. This command produces output
738 that is identical to “hg log”, but it only displays the newest
739 revision in the repository.
742 changeset: 5:fa1321bf0c80
744 user: Bryan O'Sullivan <bos@serpentine.com>
745 date: Sun Jun 17 18:05:50 2007 +0000
748 Added an extra line of output
751 diff -r b57f9a090b62 -r fa1321bf0c80 hello.c
752 --- a/hello.c Tue Sep 06 15:43:07 2005 -0700
753 +++ b/hello.c Sun Jun 17 18:05:50 2007 +0000
754 @@ -8,5 +8,6 @@ int main(int argc, char ⋆⋆argv)
755 int main(int argc, char ⋆⋆argv)
757 printf("hello, world!∖");
758 + printf("hello again!∖n");
763 We refer to the newest revision in the repository as the tip revision,
766 ### 2.8 Sharing changes
768 We mentioned earlier that repositories in Mercurial are
769 self-contained. This means that the changeset we just created exists
770 only in our my-hello repository. Let’s look at a few ways that we can
771 propagate this change into other repositories.
773 #### 2.8.1 Pulling changes from another repository
775 To get started, let’s clone our original hello repository, which does
776 not contain the change we just committed. We’ll call our temporary
777 repository hello-pull.
780 $ hg clone hello hello-pull
781 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
783 We’ll use the “hg pull” command to bring changes from my-hello into
784 hello-pull. However, blindly pulling unknown changes into a repository
785 is a somewhat scary prospect. Mercurial provides the “hg incoming”
786 command to tell us what changes the “hg pull” command would pull into
787 the repository, without actually pulling the changes in.
790 $ hg incoming ../my-hello
791 comparing with ../my-hello
792 searching for changes
793 changeset: 5:fa1321bf0c80
795 user: Bryan O'Sullivan <bos@serpentine.com>
796 date: Sun Jun 17 18:05:50 2007 +0000
797 summary: Added an extra line of output
800 (Of course, someone could cause more changesets to appear in the
801 repository that we ran “hg incoming” in, before we get a chance to “hg
802 pull” the changes, so that we could end up pulling changes that we
805 Bringing changes into a repository is a simple matter of running the
806 “hg pull” command, and telling it which repository to pull from.
809 changeset: 4:b57f9a090b62
811 user: Bryan O'Sullivan <bos@serpentine.com>
812 date: Tue Sep 06 15:43:07 2005 -0700
813 summary: Trim comments.
815 $ hg pull ../my-hello
816 pulling from ../my-hello
817 searching for changes
821 added 1 changesets with 1 changes to 1 files
822 (run 'hg update' to get a working copy)
824 changeset: 5:fa1321bf0c80
826 user: Bryan O'Sullivan <bos@serpentine.com>
827 date: Sun Jun 17 18:05:50 2007 +0000
828 summary: Added an extra line of output
831 As you can see from the before-and-after output of “hg tip”, we have
832 successfully pulled changes into our repository. There remains one
833 step before we can see these changes in the working directory.
835 #### 2.8.2 Updating the working directory
837 We have so far glossed over the relationship between a repository and
838 its working directory. The “hg pull” command that we ran in
839 section [2.8.1][12] brought changes into the repository, but if we
840 check, there’s no sign of those changes in the working directory. This
841 is because “hg pull” does not (by default) touch the working
842 directory. Instead, we use the “hg update” command to do this.
844 $ grep printf hello.c
845 printf("hello, world!∖");
847 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
848 $ grep printf hello.c
849 printf("hello, world!∖");
850 printf("hello again!∖n");
852 It might seem a bit strange that “hg pull” doesn’t update the working
853 directory automatically. There’s actually a good reason for this: you
854 can use “hg update” to update the working directory to the state it
855 was in at any revision in the history of the repository. If you had
856 the working directory updated to an old revision—to hunt down the
857 origin of a bug, say—and ran a “hg pull” which automatically updated
858 the working directory to a new revision, you might not be terribly
861 However, since pull-then-update is such a common thing to do,
862 Mercurial lets you combine the two by passing the -u option to “hg
867 If you look back at the output of “hg pull” in section [2.8.1][12]
868 when we ran it without -u, you can see that it printed a helpful
869 reminder that we’d have to take an explicit step to update the working
872 (run 'hg update' to get a working copy)
874 To find out what revision the working directory is at, use the “hg
878 changeset: 5:fa1321bf0c80
880 user: Bryan O'Sullivan <bos@serpentine.com>
881 date: Sun Jun 17 18:05:50 2007 +0000
882 summary: Added an extra line of output
885 If you look back at figure [2.1][8], you’ll see arrows connecting each
886 changeset. The node that the arrow leads from in each case is a
887 parent, and the node that the arrow leads to is its child. The working
888 directory has a parent in just the same way; this is the changeset
889 that the working directory currently contains.
891 To update the working directory to a particular revision, give a
892 revision number or changeset ID to the “hg update” command.
895 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
897 changeset: 2:057d3c2d823c
898 user: Bryan O'Sullivan <bos@serpentine.com>
899 date: Tue Sep 06 13:15:43 2005 -0700
900 summary: Introduce a typo into hello.c.
903 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
905 If you omit an explicit revision, “hg update” will update to the tip
906 revision, as shown by the second call to “hg update” in the example
909 #### 2.8.3 Pushing changes to another repository
911 Mercurial lets us push changes to another repository, from the
912 repository we’re currently visiting. As with the example of “hg pull”
913 above, we’ll create a temporary repository to push our changes into.
916 $ hg clone hello hello-push
917 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
919 The “hg outgoing” command tells us what changes would be pushed into
923 $ hg outgoing ../hello-push
924 comparing with ../hello-push
925 searching for changes
926 changeset: 5:fa1321bf0c80
928 user: Bryan O'Sullivan <bos@serpentine.com>
929 date: Sun Jun 17 18:05:50 2007 +0000
930 summary: Added an extra line of output
933 And the “hg push” command does the actual push.
935 $ hg push ../hello-push
936 pushing to ../hello-push
937 searching for changes
941 added 1 changesets with 1 changes to 1 files
943 As with “hg pull”, the “hg push” command does not update the working
944 directory in the repository that it’s pushing changes into. (Unlike
945 “hg pull”, “hg push” does not provide a -u option that updates the
946 other repository’s working directory.)
948 What happens if we try to pull or push changes and the receiving
949 repository already has those changes? Nothing too exciting.
951 $ hg push ../hello-push
952 pushing to ../hello-push
953 searching for changes
956 #### 2.8.4 Sharing changes over a network
958 The commands we have covered in the previous few sections are not
959 limited to working with local repositories. Each works in exactly the
960 same fashion over a network connection; simply pass in a URL instead
963 $ hg outgoing http://hg.serpentine.com/tutorial/hello
964 comparing with http://hg.serpentine.com/tutorial/hello
965 searching for changes
966 changeset: 5:fa1321bf0c80
968 user: Bryan O'Sullivan <bos@serpentine.com>
969 date: Sun Jun 17 18:05:50 2007 +0000
970 summary: Added an extra line of output
973 In this example, we can see what changes we could push to the remote
974 repository, but the repository is understandably not set up to let
975 anonymous users push to it.
977 $ hg push http://hg.serpentine.com/tutorial/hello
978 pushing to http://hg.serpentine.com/tutorial/hello
979 searching for changes
982 [1]: http://hgbook.red-bean.com/hgbookch3.html
983 [2]: http://hgbook.red-bean.com/hgbookch1.html
984 [3]: http://hgbook.red-bean.com/hgbookch1.html#tailhgbookch1.html
985 [4]: #tailhgbookch2.html
986 [5]: http://hgbook.red-bean.com/hgbook.html#hgbookch2.html
987 [6]: http://mercurial.berkwood.com/
988 [7]: http://hgbook.red-bean.com/hgbookli4.html#Xweb:macpython
990 [9]: hgbookch2_files/tour-history.png
991 [10]: http://hgbook.red-bean.com/hgbookch12.html#x16-27100012.4
994 [13]: http://hgbook.red-bean.com/hgbookch2.html
997 Open Publication License
999 Version 1.0, 8 June 1999
1001 ### D.1 Requirements on both unmodified and modified versions
1003 The Open Publication works may be reproduced and distributed in whole
1004 or in part, in any medium physical or electronic, provided that the
1005 terms of this license are adhered to, and that this license or an
1006 incorporation of it by reference (with any options elected by the
1007 author(s) and/or publisher) is displayed in the reproduction.
1009 Proper form for an incorporation by reference is as follows:
1011 Copyright (c) year by author’s name or designee. This material may be
1012 distributed only subject to the terms and conditions set forth in the
1013 Open Publication License, vx.y or later (the latest version is
1014 presently available at
1015 [http://www.opencontent.org/openpub/][http://www.opencontent.org/openpub/]).
1017 The reference must be immediately followed with any options elected by
1018 the author(s) and/or publisher of the document (see section D.6).
1020 Commercial redistribution of Open Publication-licensed material is
1023 Any publication in standard (paper) book form shall require the
1024 citation of the original publisher and author. The publisher and
1025 author’s names shall appear on all outer surfaces of the book. On all
1026 outer surfaces of the book the original publisher’s name shall be as
1027 large as the title of the work and cited as possessive with respect to
1032 The copyright to each Open Publication is owned by its author(s) or
1035 ### D.3 Scope of license
1037 The following license terms apply to all Open Publication works,
1038 unless otherwise explicitly stated in the document.
1040 Mere aggregation of Open Publication works or a portion of an Open
1041 Publication work with other works or programs on the same media shall
1042 not cause this license to apply to those other works. The aggregate
1043 work shall contain a notice specifying the inclusion of the Open
1044 Publication material and appropriate copyright notice.
1046 Severability. If any part of this license is found to be unenforceable
1047 in any jurisdiction, the remaining portions of the license remain in
1050 No warranty. Open Publication works are licensed and provided “as is”
1051 without warranty of any kind, express or implied, including, but not
1052 limited to, the implied warranties of merchantability and fitness for
1053 a particular purpose or a warranty of non-infringement.
1055 ### D.4 Requirements on modified works
1057 All modified versions of documents covered by this license, including
1058 translations, anthologies, compilations and partial documents, must
1059 meet the following requirements:
1061 1. The modified version must be labeled as such.
1062 2. The person making the modifications must be identified and the
1063 modifications dated.
1064 3. Acknowledgement of the original author and publisher if
1065 applicable must be retained according to normal academic citation
1067 4. The location of the original unmodified document must be identified.
1068 5. The original author’s (or authors’) name(s) may not be used to
1069 assert or imply endorsement of the resulting document without the
1070 original author’s (or authors’) permission.
1072 ### D.5 Good-practice recommendations
1074 In addition to the requirements of this license, it is requested from
1075 and strongly recommended of redistributors that:
1077 1. If you are distributing Open Publication works on hardcopy or
1078 CD-ROM, you provide email notification to the authors of your
1079 intent to redistribute at least thirty days before your
1080 manuscript or media freeze, to give the authors time to provide
1081 updated documents. This notification should describe
1082 modifications, if any, made to the document.
1083 2. All substantive modifications (including deletions) be either
1084 clearly marked up in the document or else described in an
1085 attachment to the document.
1086 3. Finally, while it is not mandatory under this license, it is
1087 considered good form to offer a free copy of any hardcopy and
1088 CD-ROM expression of an Open Publication-licensed work to its
1091 ### D.6 License options
1093 The author(s) and/or publisher of an Open Publication-licensed
1094 document may elect certain options by appending language to the
1095 reference to or copy of the license. These options are considered part
1096 of the license instance and must be included with the license (or its
1097 incorporation by reference) in derived works.
1099 1. To prohibit distribution of substantively modified versions
1100 without the explicit permission of the author(s). “Substantive
1101 modification” is defined as a change to the semantic content of
1102 the document, and excludes mere changes in format or
1103 typographical corrections.
1105 To accomplish this, add the phrase “Distribution of substantively
1106 modified versions of this document is prohibited without the
1107 explicit permission of the copyright holder.” to the license
1110 2. To prohibit any publication of this work or derivative works in
1111 whole or in part in standard (paper) book form for commercial
1112 purposes is prohibited unless prior permission is obtained from
1113 the copyright holder.
1115 To accomplish this, add the phrase “Distribution of the work or
1116 derivative of the work in any standard (paper) book form is
1117 prohibited unless prior permission is obtained from the copyright
1118 holder.” to the license reference or copy.