2 A tour of Mercurial: the basics
6 Distributed revision control with Mercurial
9 Copyright © 2006, 2007 Bryan O’Sullivan.
11 This material may be distributed only subject to the terms and
12 conditions set forth in version 1.0 of the Open Publication
13 License. Please refer to Appendix D for the license text.
15 ### 2.1 Installing Mercurial on your system
17 Prebuilt binary packages of Mercurial are available for every popular
18 operating system. These make it easy to start using Mercurial on your
23 Because each Linux distribution has its own packaging tools, policies,
24 and rate of development, it’s difficult to give a comprehensive set of
25 instructions on how to install Mercurial binaries. The version of
26 Mercurial that you will end up with can vary depending on how active
27 the person is who maintains the package for your distribution.
29 To keep things simple, I will focus on installing Mercurial from the
30 command line under the most popular Linux distributions. Most of these
31 distributions provide graphical package managers that will let you
32 install Mercurial with a single click; the package name to look for is
37 1 apt-get install mercurial
41 1 yum install mercurial
49 1 yum install mercurial
51 * Ubuntu Ubuntu’s Mercurial package is based on Debian’s. To install
52 it, run the following command.
54 1 apt-get install mercurial
56 The Ubuntu package for Mercurial tends to lag behind the Debian
57 version by a considerable time margin (at the time of writing, seven
58 months), which in some cases will mean that on Ubuntu, you may run
59 into problems that have since been fixed in the Debian package.
67 Lee Cantey publishes an installer of Mercurial for Mac OS X at
68 [http://mercurial.berkwood.com][6]. This package works on both
69 Intel- and Power-based Macs. Before you can use it, you must install a
70 compatible version of Universal MacPython [[BI][7]]. This is easy to
71 do; simply follow the instructions on Lee’s site.
75 Lee Cantey also publishes an installer of Mercurial for Windows at
76 [http://mercurial.berkwood.com][6]. This package has no external
77 dependencies; it “just works”.
79 Note: The Windows version of Mercurial does not automatically convert
80 line endings between Windows and Unix styles. If you want to share
81 work with Unix users, you must do a little additional configuration
82 work. XXX Flesh this out.
84 ### 2.2 Getting started
86 To begin, we’ll use the “hg version” command to find out whether
87 Mercurial is actually installed properly. The actual version
88 information that it prints isn’t so important; it’s whether it prints
89 anything at all that we care about.
92 2 Mercurial Distributed SCM (version 2937d0dbfab0)
94 4 Copyright (C) 2005, 2006 Matt Mackall <mpm@selenic.com>
95 5 This is free software; see the source for copying conditions. There is NO
96 6 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
98 #### 2.2.1 Built-in help
100 Mercurial provides a built-in help system. This is invaluable for
101 those times when you find yourself stuck trying to remember how to run
102 a command. If you are completely stuck, simply run “hg help”; it will
103 print a brief list of commands, along with a description of what each
104 does. If you ask for help on a specific command (as below), it prints
105 more detailed information.
108 2 hg init [-e CMD] [--remotecmd CMD] [DEST]
110 4 create a new repository in the given directory
112 6 Initialize a new repository in the given directory. If the given
113 7 directory does not exist, it is created.
115 9 If no directory is given, the current directory is used.
117 11 It is possible to specify an ssh:// URL as the destination.
118 12 Look at the help text for the pull command for important details
119 13 about ssh:// URLs.
123 17 -e --ssh specify ssh command to use
124 18 --remotecmd specify hg command to run on the remote side
126 20 use "hg -v help init" to show global options
128 For a more impressive level of detail (which you won’t usually need)
129 run “hg help -v”. The -v option is short for --verbose, and tells
130 Mercurial to print more information than it usually would.
132 ### 2.3 Working with a repository
134 In Mercurial, everything happens inside a repository. The repository
135 for a project contains all of the files that “belong to” that project,
136 along with a historical record of the project’s files.
138 There’s nothing particularly magical about a repository; it is simply
139 a directory tree in your filesystem that Mercurial treats as
140 special. You can rename or delete a repository any time you like,
141 using either the command line or your file browser.
143 #### 2.3.1 Making a local copy of a repository
145 Copying a repository is just a little bit special. While you could use
146 a normal file copying command to make a copy of a repository, it’s
147 best to use a built-in command that Mercurial provides. This command
148 is called “hg clone”, because it creates an identical copy of an
151 1 $ hg clone http://hg.serpentine.com/tutorial/hello
152 2 destination directory: hello
153 3 requesting all changes
156 6 adding file changes
157 7 added 5 changesets with 5 changes to 2 files
158 8 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
160 If our clone succeeded, we should now have a local directory called
161 hello. This directory will contain some files.
165 3 drwxrwxr-x 3 bos bos 4096 Jun 17 18:05 hello
169 These files have the same contents and history in our repository as
170 they do in the repository we cloned.
172 Every Mercurial repository is complete, self-contained, and
173 independent. It contains its own private copy of a project’s files and
174 history. A cloned repository remembers the location of the repository
175 it was cloned from, but it does not communicate with that repository,
176 or any other, unless you tell it to.
178 What this means for now is that we’re free to experiment with our
179 repository, safe in the knowledge that it’s a private “sandbox” that
180 won’t affect anyone else.
182 #### 2.3.2 What’s in a repository?
184 When we take a more detailed look inside a repository, we can see that
185 it contains a directory named .hg. This is where Mercurial keeps all
186 of its metadata for the repository.
190 3 . .. .hg Makefile hello.c
192 The contents of the .hg directory and its subdirectories are private
193 to Mercurial. Every other file and directory in the repository is
194 yours to do with as you please.
196 To introduce a little terminology, the .hg directory is the “real”
197 repository, and all of the files and directories that coexist with it
198 are said to live in the working directory. An easy way to remember the
199 distinction is that the repository contains the history of your
200 project, while the working directory contains a snapshot of your
201 project at a particular point in history.
203 ### 2.4 A tour through history
205 One of the first things we might want to do with a new, unfamiliar
206 repository is understand its history. The “hg log” command gives us a
210 2 changeset: 4:b57f9a090b62
212 4 user: Bryan O'Sullivan <bos@serpentine.com>
213 5 date: Tue Sep 06 15:43:07 2005 -0700
214 6 summary: Trim comments.
216 8 changeset: 3:ff5d7b70a2a9
217 9 user: Bryan O'Sullivan <bos@serpentine.com>
218 10 date: Tue Sep 06 13:15:58 2005 -0700
219 11 summary: Get make to generate the final binary from a .o file.
221 13 changeset: 2:057d3c2d823c
222 14 user: Bryan O'Sullivan <bos@serpentine.com>
223 15 date: Tue Sep 06 13:15:43 2005 -0700
224 16 summary: Introduce a typo into hello.c.
226 18 changeset: 1:82e55d328c8c
227 19 user: mpm@selenic.com
228 20 date: Fri Aug 26 01:21:28 2005 -0700
229 21 summary: Create a makefile
231 23 changeset: 0:0a04b987be5a
232 24 user: mpm@selenic.com
233 25 date: Fri Aug 26 01:20:50 2005 -0700
234 26 summary: Create a standard "hello, world" program
237 By default, this command prints a brief paragraph of output for each
238 change to the project that was recorded. In Mercurial terminology, we
239 call each of these recorded events a changeset, because it can contain
240 a record of changes to several files.
242 The fields in a record of output from “hg log” are as follows.
244 * changeset This field has the format of a number, followed by a
245 colon, followed by a hexadecimal string. These are identifiers for
246 the changeset. There are two identifiers because the number is
247 shorter and easier to type than the hex string.
248 * user The identity of the person who created the changeset. This is
249 a free-form field, but it most often contains a person’s name and
251 * date The date and time on which the changeset was created, and the
252 timezone in which it was created. (The date and time are local to
253 that timezone; they display what time and date it was for the
254 person who created the changeset.)
255 * summary The first line of the text message that the creator of the
256 changeset entered to describe the changeset.
258 The default output printed by “hg log” is purely a summary; it is
259 missing a lot of detail.
261 Figure [2.1][8] provides a graphical representation of the history of
262 the hello repository, to make it a little easier to see which
263 direction history is “flowing” in. We’ll be returning to this figure
264 several times in this chapter and the chapter that follows.
271 Graphical history of the hello repository
275 #### 2.4.1 Changesets, revisions, and talking to other people
277 As English is a notoriously sloppy language, and computer science has
278 a hallowed history of terminological confusion (why use one term when
279 four will do?), revision control has a variety of words and phrases
280 that mean the same thing. If you are talking about Mercurial history
281 with other people, you will find that the word “changeset” is often
282 compressed to “change” or (when written) “cset”, and sometimes a
283 changeset is referred to as a “revision” or a “rev”.
285 While it doesn’t matter what word you use to refer to the concept of
286 “a changeset”, the identifier that you use to refer to “a specific
287 changeset” is of great importance. Recall that the changeset field in
288 the output from “hg log” identifies a changeset using both a number
289 and a hexadecimal string.
291 * The revision number is only valid in that repository,
292 * while the hex string is the permanent, unchanging identifier that
293 will always identify that exact changeset in every copy of the
296 This distinction is important. If you send someone an email talking
297 about “revision 33”, there’s a high likelihood that their revision 33
298 will not be the same as yours. The reason for this is that a revision
299 number depends on the order in which changes arrived in a repository,
300 and there is no guarantee that the same changes will happen in the
301 same order in different repositories. Three changes a,b,c can easily
302 appear in one repository as 0,1,2, while in another as 1,0,2.
304 Mercurial uses revision numbers purely as a convenient shorthand. If
305 you need to discuss a changeset with someone, or make a record of a
306 changeset for some other reason (for example, in a bug report), use
307 the hexadecimal identifier.
309 #### 2.4.2 Viewing specific revisions
311 To narrow the output of “hg log” down to a single revision, use the -r
312 (or --rev) option. You can use either a revision number or a long-form
313 changeset identifier, and you can provide as many revisions as you
317 2 changeset: 3:ff5d7b70a2a9
318 3 user: Bryan O'Sullivan <bos@serpentine.com>
319 4 date: Tue Sep 06 13:15:58 2005 -0700
320 5 summary: Get make to generate the final binary from a .o file.
322 7 $ hg log -r ff5d7b70a2a9
323 8 changeset: 3:ff5d7b70a2a9
324 9 user: Bryan O'Sullivan <bos@serpentine.com>
325 10 date: Tue Sep 06 13:15:58 2005 -0700
326 11 summary: Get make to generate the final binary from a .o file.
328 13 $ hg log -r 1 -r 4
329 14 changeset: 1:82e55d328c8c
330 15 user: mpm@selenic.com
331 16 date: Fri Aug 26 01:21:28 2005 -0700
332 17 summary: Create a makefile
334 19 changeset: 4:b57f9a090b62
336 21 user: Bryan O'Sullivan <bos@serpentine.com>
337 22 date: Tue Sep 06 15:43:07 2005 -0700
338 23 summary: Trim comments.
341 If you want to see the history of several revisions without having to
342 list each one, you can use range notation; this lets you express the
343 idea “I want all revisions between a and b, inclusive”.
346 2 changeset: 2:057d3c2d823c
347 3 user: Bryan O'Sullivan <bos@serpentine.com>
348 4 date: Tue Sep 06 13:15:43 2005 -0700
349 5 summary: Introduce a typo into hello.c.
351 7 changeset: 3:ff5d7b70a2a9
352 8 user: Bryan O'Sullivan <bos@serpentine.com>
353 9 date: Tue Sep 06 13:15:58 2005 -0700
354 10 summary: Get make to generate the final binary from a .o file.
356 12 changeset: 4:b57f9a090b62
358 14 user: Bryan O'Sullivan <bos@serpentine.com>
359 15 date: Tue Sep 06 15:43:07 2005 -0700
360 16 summary: Trim comments.
363 Mercurial also honours the order in which you specify revisions, so
364 “hg log -r 2:4” prints 2,3,4 while “hg log -r 4:2” prints 4,3,2.
366 #### 2.4.3 More detailed information
368 While the summary information printed by “hg log” is useful if you
369 already know what you’re looking for, you may need to see a complete
370 description of the change, or a list of the files changed, if you’re
371 trying to decide whether a changeset is the one you’re looking
372 for. The “hg log” command’s -v (or --verbose) option gives you this
376 2 changeset: 3:ff5d7b70a2a9
377 3 user: Bryan O'Sullivan <bos@serpentine.com>
378 4 date: Tue Sep 06 13:15:58 2005 -0700
381 7 Get make to generate the final binary from a .o file.
385 If you want to see both the description and content of a change, add
386 the -p (or --patch) option. This displays the content of a change as a
387 unified diff (if you’ve never seen a unified diff before, see
388 section [12.4][10] for an overview).
390 1 $ hg log -v -p -r 2
391 2 changeset: 2:057d3c2d823c
392 3 user: Bryan O'Sullivan <bos@serpentine.com>
393 4 date: Tue Sep 06 13:15:43 2005 -0700
396 7 Introduce a typo into hello.c.
399 10 diff -r 82e55d328c8c -r 057d3c2d823c hello.c
400 11 --- a/hello.c Fri Aug 26 01:21:28 2005 -0700
401 12 +++ b/hello.c Tue Sep 06 13:15:43 2005 -0700
404 15 int main(int argc, char ⋆⋆argv)
406 17 - printf("hello, world!∖n");
407 18 + printf("hello, world!∖");
412 ### 2.5 All about command options
414 Let’s take a brief break from exploring Mercurial commands to discuss
415 a pattern in the way that they work; you may find this useful to keep
416 in mind as we continue our tour.
418 Mercurial has a consistent and straightforward approach to dealing
419 with the options that you can pass to commands. It follows the
420 conventions for options that are common to modern Linux and Unix
423 * Every option has a long name. For example, as we’ve already seen,
424 the “hg log” command accepts a --rev option.
425 * Most options have short names, too. Instead of --rev, we can use
426 -r. (The reason that some options don’t have short names is that
427 the options in question are rarely used.)
428 * Long options start with two dashes (e.g. --rev), while short
429 options start with one (e.g. -r).
430 * Option naming and usage is consistent across commands. For
431 example, every command that lets you specify a changeset ID or
432 revision number accepts both -r and --rev arguments.
434 In the examples throughout this book, I use short options instead of
435 long. This just reflects my own preference, so don’t read anything
438 Most commands that print output of some kind will print more output
439 when passed a -v (or --verbose) option, and less when passed -q (or
442 ### 2.6 Making and reviewing changes
444 Now that we have a grasp of viewing history in Mercurial, let’s take a
445 look at making some changes and examining them.
447 The first thing we’ll do is isolate our experiment in a repository of
448 its own. We use the “hg clone” command, but we don’t need to clone a
449 copy of the remote repository. Since we already have a copy of it
450 locally, we can just clone that instead. This is much faster than
451 cloning over the network, and cloning a local repository uses less
452 disk space in most cases, too.
455 2 $ hg clone hello my-hello
456 3 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
459 As an aside, it’s often good practice to keep a “pristine” copy of a
460 remote repository around, which you can then make temporary clones of
461 to create sandboxes for each task you want to work on. This lets you
462 work on multiple tasks in parallel, each isolated from the others
463 until it’s complete and you’re ready to integrate it back. Because
464 local clones are so cheap, there’s almost no overhead to cloning and
465 destroying repositories whenever you want.
467 In our my-hello repository, we have a file hello.c that contains the
468 classic “hello, world” program. Let’s use the ancient and venerable
469 sed command to edit this file so that it prints a second line of
470 output. (I’m only using sed to do this because it’s easy to write a
471 scripted example this way. Since you’re not under the same constraint,
472 you probably won’t want to use sed; simply use your preferred text
473 editor to do the same thing.)
475 1 $ sed -i '/printf/a∖∖tprintf("hello again!∖∖n");' hello.c
477 Mercurial’s “hg status” command will tell us what Mercurial knows
478 about the files in the repository.
485 The “hg status” command prints no output for some files, but a line
486 starting with “M” for hello.c. Unless you tell it to, “hg status” will
487 not print any output for files that have not been modified.
489 The “M” indicates that Mercurial has noticed that we modified
490 hello.c. We didn’t need to inform Mercurial that we were going to
491 modify the file before we started, or that we had modified the file
492 after we were done; it was able to figure this out itself.
494 It’s a little bit helpful to know that we’ve modified hello.c, but we
495 might prefer to know exactly what changes we’ve made to it. To do
496 this, we use the “hg diff” command.
499 2 diff -r b57f9a090b62 hello.c
500 3 --- a/hello.c Tue Sep 06 15:43:07 2005 -0700
501 4 +++ b/hello.c Sun Jun 17 18:05:50 2007 +0000
502 5 @@ -8,5 +8,6 @@ int main(int argc, char ⋆⋆argv)
503 6 int main(int argc, char ⋆⋆argv)
505 8 printf("hello, world!∖");
506 9 + printf("hello again!∖n");
510 ### 2.7 Recording changes in a new changeset
512 We can modify files, build and test our changes, and use “hg status”
513 and “hg diff” to review our changes, until we’re satisfied with what
514 we’ve done and arrive at a natural stopping point where we want to
515 record our work in a new changeset.
517 The “hg commit” command lets us create a new changeset; we’ll usually
518 refer to this as “making a commit” or “committing”.
520 #### 2.7.1 Setting up a username
522 When you try to run “hg commit” for the first time, it is not
523 guaranteed to succeed. Mercurial records your name and address with
524 each change that you commit, so that you and others will later be able
525 to tell who made each change. Mercurial tries to automatically figure
526 out a sensible username to commit the change with. It will attempt
527 each of the following methods, in order:
529 1. If you specify a -u option to the “hg commit” command on the
530 command line, followed by a username, this is always given the
532 2. If you have set the HGUSER environment variable, this is checked next.
533 3. If you create a file in your home directory called .hgrc, with a
534 username entry, that will be used next. To see what the contents
535 of this file should look like, refer to section [2.7.1][11]
537 4. If you have set the EMAIL environment variable, this will be used
539 5. Mercurial will query your system to find out your local user name
540 and host name, and construct a username from these
541 components. Since this often results in a username that is not
542 very useful, it will print a warning if it has to do this.
544 If all of these mechanisms fail, Mercurial will fail, printing an
545 error message. In this case, it will not let you commit until you set
548 You should think of the HGUSER environment variable and the -u option
549 to the “hg commit” command as ways to override Mercurial’s default
550 selection of username. For normal use, the simplest and most robust
551 way to set a username for yourself is by creating a .hgrc file; see
554 ##### Creating a Mercurial configuration file
556 To set a user name, use your favourite editor to create a file called
557 .hgrc in your home directory. Mercurial will use this file to look up
558 your personalised configuration settings. The initial contents of your
559 .hgrc should look like this.
561 1 # This is a Mercurial configuration file.
563 3 username = Firstname Lastname <email.address@domain.net>
565 The “[ui]” line begins a section of the config file, so you can read
566 the “username = ...” line as meaning “set the value of the username
567 item in the ui section”. A section continues until a new section
568 begins, or the end of the file. Mercurial ignores empty lines and
569 treats any text from “#” to the end of a line as a comment.
571 ##### Choosing a user name
573 You can use any text you like as the value of the username config
574 item, since this information is for reading by other people, but for
575 interpreting by Mercurial. The convention that most people follow is
576 to use their name and email address, as in the example above.
578 Note: Mercurial’s built-in web server obfuscates email addresses, to
579 make it more difficult for the email harvesting tools that spammers
580 use. This reduces the likelihood that you’ll start receiving more junk
581 email if you publish a Mercurial repository on the web.
583 #### 2.7.2 Writing a commit message
585 When we commit a change, Mercurial drops us into a text editor, to
586 enter a message that will describe the modifications we’ve made in
587 this changeset. This is called the commit message. It will be a record
588 for readers of what we did and why, and it will be printed by “hg log”
589 after we’ve finished committing.
593 The editor that the “hg commit” command drops us into will contain an
594 empty line, followed by a number of lines starting with “HG:”.
597 2 HG: changed hello.c
599 Mercurial ignores the lines that start with “HG:”; it uses them only
600 to tell us which files it’s recording changes to. Modifying or
601 deleting these lines has no effect.
603 #### 2.7.3 Writing a good commit message
605 Since “hg log” only prints the first line of a commit message by
606 default, it’s best to write a commit message whose first line stands
607 alone. Here’s a real example of a commit message that doesn’t follow
608 this guideline, and hence has a summary that is not readable.
610 1 changeset: 73:584af0e231be
611 2 user: Censored Person <censored.person@example.org>
612 3 date: Tue Sep 26 21:37:07 2006 -0700
613 4 summary: include buildmeister/commondefs. Add an exports and install
615 As far as the remainder of the contents of the commit message are
616 concerned, there are no hard-and-fast rules. Mercurial itself doesn’t
617 interpret or care about the contents of the commit message, though
618 your project may have policies that dictate a certain kind of
621 My personal preference is for short, but informative, commit messages
622 that tell me something that I can’t figure out with a quick glance at
623 the output of “hg log --patch”.
625 #### 2.7.4 Aborting a commit
627 If you decide that you don’t want to commit while in the middle of
628 editing a commit message, simply exit from your editor without saving
629 the file that it’s editing. This will cause nothing to happen to
630 either the repository or the working directory.
632 If we run the “hg commit” command without any arguments, it records
633 all of the changes we’ve made, as reported by “hg status” and “hg
636 #### 2.7.5 Admiring our new handiwork
638 Once we’ve finished the commit, we can use the “hg tip” command to
639 display the changeset we just created. This command produces output
640 that is identical to “hg log”, but it only displays the newest
641 revision in the repository.
644 2 changeset: 5:fa1321bf0c80
646 4 user: Bryan O'Sullivan <bos@serpentine.com>
647 5 date: Sun Jun 17 18:05:50 2007 +0000
650 8 Added an extra line of output
653 11 diff -r b57f9a090b62 -r fa1321bf0c80 hello.c
654 12 --- a/hello.c Tue Sep 06 15:43:07 2005 -0700
655 13 +++ b/hello.c Sun Jun 17 18:05:50 2007 +0000
656 14 @@ -8,5 +8,6 @@ int main(int argc, char ⋆⋆argv)
657 15 int main(int argc, char ⋆⋆argv)
659 17 printf("hello, world!∖");
660 18 + printf("hello again!∖n");
665 We refer to the newest revision in the repository as the tip revision,
668 ### 2.8 Sharing changes
670 We mentioned earlier that repositories in Mercurial are
671 self-contained. This means that the changeset we just created exists
672 only in our my-hello repository. Let’s look at a few ways that we can
673 propagate this change into other repositories.
675 #### 2.8.1 Pulling changes from another repository
677 To get started, let’s clone our original hello repository, which does
678 not contain the change we just committed. We’ll call our temporary
679 repository hello-pull.
682 2 $ hg clone hello hello-pull
683 3 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
685 We’ll use the “hg pull” command to bring changes from my-hello into
686 hello-pull. However, blindly pulling unknown changes into a repository
687 is a somewhat scary prospect. Mercurial provides the “hg incoming”
688 command to tell us what changes the “hg pull” command would pull into
689 the repository, without actually pulling the changes in.
692 2 $ hg incoming ../my-hello
693 3 comparing with ../my-hello
694 4 searching for changes
695 5 changeset: 5:fa1321bf0c80
697 7 user: Bryan O'Sullivan <bos@serpentine.com>
698 8 date: Sun Jun 17 18:05:50 2007 +0000
699 9 summary: Added an extra line of output
702 (Of course, someone could cause more changesets to appear in the
703 repository that we ran “hg incoming” in, before we get a chance to “hg
704 pull” the changes, so that we could end up pulling changes that we
707 Bringing changes into a repository is a simple matter of running the
708 “hg pull” command, and telling it which repository to pull from.
711 2 changeset: 4:b57f9a090b62
713 4 user: Bryan O'Sullivan <bos@serpentine.com>
714 5 date: Tue Sep 06 15:43:07 2005 -0700
715 6 summary: Trim comments.
717 8 $ hg pull ../my-hello
718 9 pulling from ../my-hello
719 10 searching for changes
722 13 adding file changes
723 14 added 1 changesets with 1 changes to 1 files
724 15 (run 'hg update' to get a working copy)
726 17 changeset: 5:fa1321bf0c80
728 19 user: Bryan O'Sullivan <bos@serpentine.com>
729 20 date: Sun Jun 17 18:05:50 2007 +0000
730 21 summary: Added an extra line of output
733 As you can see from the before-and-after output of “hg tip”, we have
734 successfully pulled changes into our repository. There remains one
735 step before we can see these changes in the working directory.
737 #### 2.8.2 Updating the working directory
739 We have so far glossed over the relationship between a repository and
740 its working directory. The “hg pull” command that we ran in
741 section [2.8.1][12] brought changes into the repository, but if we
742 check, there’s no sign of those changes in the working directory. This
743 is because “hg pull” does not (by default) touch the working
744 directory. Instead, we use the “hg update” command to do this.
746 1 $ grep printf hello.c
747 2 printf("hello, world!∖");
749 4 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
750 5 $ grep printf hello.c
751 6 printf("hello, world!∖");
752 7 printf("hello again!∖n");
754 It might seem a bit strange that “hg pull” doesn’t update the working
755 directory automatically. There’s actually a good reason for this: you
756 can use “hg update” to update the working directory to the state it
757 was in at any revision in the history of the repository. If you had
758 the working directory updated to an old revision—to hunt down the
759 origin of a bug, say—and ran a “hg pull” which automatically updated
760 the working directory to a new revision, you might not be terribly
763 However, since pull-then-update is such a common thing to do,
764 Mercurial lets you combine the two by passing the -u option to “hg
769 If you look back at the output of “hg pull” in section [2.8.1][12]
770 when we ran it without -u, you can see that it printed a helpful
771 reminder that we’d have to take an explicit step to update the working
774 1 (run 'hg update' to get a working copy)
776 To find out what revision the working directory is at, use the “hg
780 2 changeset: 5:fa1321bf0c80
782 4 user: Bryan O'Sullivan <bos@serpentine.com>
783 5 date: Sun Jun 17 18:05:50 2007 +0000
784 6 summary: Added an extra line of output
787 If you look back at figure [2.1][8], you’ll see arrows connecting each
788 changeset. The node that the arrow leads from in each case is a
789 parent, and the node that the arrow leads to is its child. The working
790 directory has a parent in just the same way; this is the changeset
791 that the working directory currently contains.
793 To update the working directory to a particular revision, give a
794 revision number or changeset ID to the “hg update” command.
797 2 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
799 4 changeset: 2:057d3c2d823c
800 5 user: Bryan O'Sullivan <bos@serpentine.com>
801 6 date: Tue Sep 06 13:15:43 2005 -0700
802 7 summary: Introduce a typo into hello.c.
805 10 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
807 If you omit an explicit revision, “hg update” will update to the tip
808 revision, as shown by the second call to “hg update” in the example
811 #### 2.8.3 Pushing changes to another repository
813 Mercurial lets us push changes to another repository, from the
814 repository we’re currently visiting. As with the example of “hg pull”
815 above, we’ll create a temporary repository to push our changes into.
818 2 $ hg clone hello hello-push
819 3 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
821 The “hg outgoing” command tells us what changes would be pushed into
825 2 $ hg outgoing ../hello-push
826 3 comparing with ../hello-push
827 4 searching for changes
828 5 changeset: 5:fa1321bf0c80
830 7 user: Bryan O'Sullivan <bos@serpentine.com>
831 8 date: Sun Jun 17 18:05:50 2007 +0000
832 9 summary: Added an extra line of output
835 And the “hg push” command does the actual push.
837 1 $ hg push ../hello-push
838 2 pushing to ../hello-push
839 3 searching for changes
842 6 adding file changes
843 7 added 1 changesets with 1 changes to 1 files
845 As with “hg pull”, the “hg push” command does not update the working
846 directory in the repository that it’s pushing changes into. (Unlike
847 “hg pull”, “hg push” does not provide a -u option that updates the
848 other repository’s working directory.)
850 What happens if we try to pull or push changes and the receiving
851 repository already has those changes? Nothing too exciting.
853 1 $ hg push ../hello-push
854 2 pushing to ../hello-push
855 3 searching for changes
858 #### 2.8.4 Sharing changes over a network
860 The commands we have covered in the previous few sections are not
861 limited to working with local repositories. Each works in exactly the
862 same fashion over a network connection; simply pass in a URL instead
865 1 $ hg outgoing http://hg.serpentine.com/tutorial/hello
866 2 comparing with http://hg.serpentine.com/tutorial/hello
867 3 searching for changes
868 4 changeset: 5:fa1321bf0c80
870 6 user: Bryan O'Sullivan <bos@serpentine.com>
871 7 date: Sun Jun 17 18:05:50 2007 +0000
872 8 summary: Added an extra line of output
875 In this example, we can see what changes we could push to the remote
876 repository, but the repository is understandably not set up to let
877 anonymous users push to it.
879 1 $ hg push http://hg.serpentine.com/tutorial/hello
880 2 pushing to http://hg.serpentine.com/tutorial/hello
881 3 searching for changes
884 [1]: http://hgbook.red-bean.com/hgbookch3.html
885 [2]: http://hgbook.red-bean.com/hgbookch1.html
886 [3]: http://hgbook.red-bean.com/hgbookch1.html#tailhgbookch1.html
887 [4]: #tailhgbookch2.html
888 [5]: http://hgbook.red-bean.com/hgbook.html#hgbookch2.html
889 [6]: http://mercurial.berkwood.com/
890 [7]: http://hgbook.red-bean.com/hgbookli4.html#Xweb:macpython
892 [9]: hgbookch2_files/tour-history.png
893 [10]: http://hgbook.red-bean.com/hgbookch12.html#x16-27100012.4
896 [13]: http://hgbook.red-bean.com/hgbookch2.html
899 Open Publication License
901 Version 1.0, 8 June 1999
903 ### D.1 Requirements on both unmodified and modified versions
905 The Open Publication works may be reproduced and distributed in whole
906 or in part, in any medium physical or electronic, provided that the
907 terms of this license are adhered to, and that this license or an
908 incorporation of it by reference (with any options elected by the
909 author(s) and/or publisher) is displayed in the reproduction.
911 Proper form for an incorporation by reference is as follows:
913 Copyright (c) year by author’s name or designee. This material may be
914 distributed only subject to the terms and conditions set forth in the
915 Open Publication License, vx.y or later (the latest version is
916 presently available at
917 [http://www.opencontent.org/openpub/][http://www.opencontent.org/openpub/]).
919 The reference must be immediately followed with any options elected by
920 the author(s) and/or publisher of the document (see section D.6).
922 Commercial redistribution of Open Publication-licensed material is
925 Any publication in standard (paper) book form shall require the
926 citation of the original publisher and author. The publisher and
927 author’s names shall appear on all outer surfaces of the book. On all
928 outer surfaces of the book the original publisher’s name shall be as
929 large as the title of the work and cited as possessive with respect to
934 The copyright to each Open Publication is owned by its author(s) or
937 ### D.3 Scope of license
939 The following license terms apply to all Open Publication works,
940 unless otherwise explicitly stated in the document.
942 Mere aggregation of Open Publication works or a portion of an Open
943 Publication work with other works or programs on the same media shall
944 not cause this license to apply to those other works. The aggregate
945 work shall contain a notice specifying the inclusion of the Open
946 Publication material and appropriate copyright notice.
948 Severability. If any part of this license is found to be unenforceable
949 in any jurisdiction, the remaining portions of the license remain in
952 No warranty. Open Publication works are licensed and provided “as is”
953 without warranty of any kind, express or implied, including, but not
954 limited to, the implied warranties of merchantability and fitness for
955 a particular purpose or a warranty of non-infringement.
957 ### D.4 Requirements on modified works
959 All modified versions of documents covered by this license, including
960 translations, anthologies, compilations and partial documents, must
961 meet the following requirements:
963 1. The modified version must be labeled as such.
964 2. The person making the modifications must be identified and the
966 3. Acknowledgement of the original author and publisher if
967 applicable must be retained according to normal academic citation
969 4. The location of the original unmodified document must be identified.
970 5. The original author’s (or authors’) name(s) may not be used to
971 assert or imply endorsement of the resulting document without the
972 original author’s (or authors’) permission.
974 ### D.5 Good-practice recommendations
976 In addition to the requirements of this license, it is requested from
977 and strongly recommended of redistributors that:
979 1. If you are distributing Open Publication works on hardcopy or
980 CD-ROM, you provide email notification to the authors of your
981 intent to redistribute at least thirty days before your
982 manuscript or media freeze, to give the authors time to provide
983 updated documents. This notification should describe
984 modifications, if any, made to the document.
985 2. All substantive modifications (including deletions) be either
986 clearly marked up in the document or else described in an
987 attachment to the document.
988 3. Finally, while it is not mandatory under this license, it is
989 considered good form to offer a free copy of any hardcopy and
990 CD-ROM expression of an Open Publication-licensed work to its
993 ### D.6 License options
995 The author(s) and/or publisher of an Open Publication-licensed
996 document may elect certain options by appending language to the
997 reference to or copy of the license. These options are considered part
998 of the license instance and must be included with the license (or its
999 incorporation by reference) in derived works.
1001 1. To prohibit distribution of substantively modified versions
1002 without the explicit permission of the author(s). “Substantive
1003 modification” is defined as a change to the semantic content of
1004 the document, and excludes mere changes in format or
1005 typographical corrections.
1007 To accomplish this, add the phrase “Distribution of substantively
1008 modified versions of this document is prohibited without the
1009 explicit permission of the copyright holder.” to the license
1012 2. To prohibit any publication of this work or derivative works in
1013 whole or in part in standard (paper) book form for commercial
1014 purposes is prohibited unless prior permission is obtained from
1015 the copyright holder.
1017 To accomplish this, add the phrase “Distribution of the work or
1018 derivative of the work in any standard (paper) book form is
1019 prohibited unless prior permission is obtained from the copyright
1020 holder.” to the license reference or copy.