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 “hg version” command to find out whether
98 Mercurial is actually installed properly. The actual version
99 information that it prints isn’t so important; it’s whether it prints
100 anything at all that we care about.
103 Mercurial Distributed SCM (version 2937d0dbfab0)
105 Copyright (C) 2005, 2006 Matt Mackall <mpm@selenic.com>
106 This is free software; see the source for copying conditions. There is NO
107 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
109 #### 2.2.1 Built-in help
111 Mercurial provides a built-in help system. This is invaluable for
112 those times when you find yourself stuck trying to remember how to run
113 a command. If you are completely stuck, simply run “hg help”; it will
114 print a brief list of commands, along with a description of what each
115 does. If you ask for help on a specific command (as below), it prints
116 more detailed information.
119 hg init [-e CMD] [--remotecmd CMD] [DEST]
121 create a new repository in the given directory
123 Initialize a new repository in the given directory. If the given
124 directory does not exist, it is created.
126 If no directory is given, the current directory is used.
128 It is possible to specify an ssh:// URL as the destination.
129 Look at the help text for the pull command for important details
134 -e --ssh specify ssh command to use
135 --remotecmd specify hg command to run on the remote side
137 use "hg -v help init" to show global options
139 For a more impressive level of detail (which you won’t usually need)
140 run “hg help -v”. The -v option is short for --verbose, and tells
141 Mercurial to print more information than it usually would.
143 ### 2.3 Working with a repository
145 In Mercurial, everything happens inside a repository. The repository
146 for a project contains all of the files that “belong to” that project,
147 along with a historical record of the project’s files.
149 There’s nothing particularly magical about a repository; it is simply
150 a directory tree in your filesystem that Mercurial treats as
151 special. You can rename or delete a repository any time you like,
152 using either the command line or your file browser.
154 #### 2.3.1 Making a local copy of a repository
156 Copying a repository is just a little bit special. While you could use
157 a normal file copying command to make a copy of a repository, it’s
158 best to use a built-in command that Mercurial provides. This command
159 is called “hg clone”, because it creates an identical copy of an
162 $ hg clone http://hg.serpentine.com/tutorial/hello
163 destination directory: hello
164 requesting all changes
168 added 5 changesets with 5 changes to 2 files
169 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
171 If our clone succeeded, we should now have a local directory called
172 hello. This directory will contain some files.
176 drwxrwxr-x 3 bos bos 4096 Jun 17 18:05 hello
180 These files have the same contents and history in our repository as
181 they do in the repository we cloned.
183 Every Mercurial repository is complete, self-contained, and
184 independent. It contains its own private copy of a project’s files and
185 history. A cloned repository remembers the location of the repository
186 it was cloned from, but it does not communicate with that repository,
187 or any other, unless you tell it to.
189 What this means for now is that we’re free to experiment with our
190 repository, safe in the knowledge that it’s a private “sandbox” that
191 won’t affect anyone else.
193 #### 2.3.2 What’s in a repository?
195 When we take a more detailed look inside a repository, we can see that
196 it contains a directory named .hg. This is where Mercurial keeps all
197 of its metadata for the repository.
201 . .. .hg Makefile hello.c
203 The contents of the .hg directory and its subdirectories are private
204 to Mercurial. Every other file and directory in the repository is
205 yours to do with as you please.
207 To introduce a little terminology, the .hg directory is the “real”
208 repository, and all of the files and directories that coexist with it
209 are said to live in the working directory. An easy way to remember the
210 distinction is that the repository contains the history of your
211 project, while the working directory contains a snapshot of your
212 project at a particular point in history.
214 ### 2.4 A tour through history
216 One of the first things we might want to do with a new, unfamiliar
217 repository is understand its history. The “hg log” command gives us a
221 changeset: 4:b57f9a090b62
223 user: Bryan O'Sullivan <bos@serpentine.com>
224 date: Tue Sep 06 15:43:07 2005 -0700
225 summary: Trim comments.
227 changeset: 3:ff5d7b70a2a9
228 user: Bryan O'Sullivan <bos@serpentine.com>
229 date: Tue Sep 06 13:15:58 2005 -0700
230 summary: Get make to generate the final binary from a .o file.
232 changeset: 2:057d3c2d823c
233 user: Bryan O'Sullivan <bos@serpentine.com>
234 date: Tue Sep 06 13:15:43 2005 -0700
235 summary: Introduce a typo into hello.c.
237 changeset: 1:82e55d328c8c
238 user: mpm@selenic.com
239 date: Fri Aug 26 01:21:28 2005 -0700
240 summary: Create a makefile
242 changeset: 0:0a04b987be5a
243 user: mpm@selenic.com
244 date: Fri Aug 26 01:20:50 2005 -0700
245 summary: Create a standard "hello, world" program
248 By default, this command prints a brief paragraph of output for each
249 change to the project that was recorded. In Mercurial terminology, we
250 call each of these recorded events a changeset, because it can contain
251 a record of changes to several files.
253 The fields in a record of output from “hg log” are as follows.
255 * changeset This field has the format of a number, followed by a
256 colon, followed by a hexadecimal string. These are identifiers for
257 the changeset. There are two identifiers because the number is
258 shorter and easier to type than the hex string.
259 * user The identity of the person who created the changeset. This is
260 a free-form field, but it most often contains a person’s name and
262 * date The date and time on which the changeset was created, and the
263 timezone in which it was created. (The date and time are local to
264 that timezone; they display what time and date it was for the
265 person who created the changeset.)
266 * summary The first line of the text message that the creator of the
267 changeset entered to describe the changeset.
269 The default output printed by “hg log” is purely a summary; it is
270 missing a lot of detail.
272 Figure [2.1][8] provides a graphical representation of the history of
273 the hello repository, to make it a little easier to see which
274 direction history is “flowing” in. We’ll be returning to this figure
275 several times in this chapter and the chapter that follows.
282 Graphical history of the hello repository
286 #### 2.4.1 Changesets, revisions, and talking to other people
288 As English is a notoriously sloppy language, and computer science has
289 a hallowed history of terminological confusion (why use one term when
290 four will do?), revision control has a variety of words and phrases
291 that mean the same thing. If you are talking about Mercurial history
292 with other people, you will find that the word “changeset” is often
293 compressed to “change” or (when written) “cset”, and sometimes a
294 changeset is referred to as a “revision” or a “rev”.
296 While it doesn’t matter what word you use to refer to the concept of
297 “a changeset”, the identifier that you use to refer to “a specific
298 changeset” is of great importance. Recall that the changeset field in
299 the output from “hg log” identifies a changeset using both a number
300 and a hexadecimal string.
302 * The revision number is only valid in that repository,
303 * while the hex string is the permanent, unchanging identifier that
304 will always identify that exact changeset in every copy of the
307 This distinction is important. If you send someone an email talking
308 about “revision 33”, there’s a high likelihood that their revision 33
309 will not be the same as yours. The reason for this is that a revision
310 number depends on the order in which changes arrived in a repository,
311 and there is no guarantee that the same changes will happen in the
312 same order in different repositories. Three changes a,b,c can easily
313 appear in one repository as 0,1,2, while in another as 1,0,2.
315 Mercurial uses revision numbers purely as a convenient shorthand. If
316 you need to discuss a changeset with someone, or make a record of a
317 changeset for some other reason (for example, in a bug report), use
318 the hexadecimal identifier.
320 #### 2.4.2 Viewing specific revisions
322 To narrow the output of “hg log” down to a single revision, use the -r
323 (or --rev) option. You can use either a revision number or a long-form
324 changeset identifier, and you can provide as many revisions as you
328 changeset: 3:ff5d7b70a2a9
329 user: Bryan O'Sullivan <bos@serpentine.com>
330 date: Tue Sep 06 13:15:58 2005 -0700
331 summary: Get make to generate the final binary from a .o file.
333 $ hg log -r ff5d7b70a2a9
334 changeset: 3:ff5d7b70a2a9
335 user: Bryan O'Sullivan <bos@serpentine.com>
336 date: Tue Sep 06 13:15:58 2005 -0700
337 summary: Get make to generate the final binary from a .o file.
340 changeset: 1:82e55d328c8c
341 user: mpm@selenic.com
342 date: Fri Aug 26 01:21:28 2005 -0700
343 summary: Create a makefile
345 changeset: 4:b57f9a090b62
347 user: Bryan O'Sullivan <bos@serpentine.com>
348 date: Tue Sep 06 15:43:07 2005 -0700
349 summary: Trim comments.
352 If you want to see the history of several revisions without having to
353 list each one, you can use range notation; this lets you express the
354 idea “I want all revisions between a and b, inclusive”.
357 changeset: 2:057d3c2d823c
358 user: Bryan O'Sullivan <bos@serpentine.com>
359 date: Tue Sep 06 13:15:43 2005 -0700
360 summary: Introduce a typo into hello.c.
362 changeset: 3:ff5d7b70a2a9
363 user: Bryan O'Sullivan <bos@serpentine.com>
364 date: Tue Sep 06 13:15:58 2005 -0700
365 summary: Get make to generate the final binary from a .o file.
367 changeset: 4:b57f9a090b62
369 user: Bryan O'Sullivan <bos@serpentine.com>
370 date: Tue Sep 06 15:43:07 2005 -0700
371 summary: Trim comments.
374 Mercurial also honours the order in which you specify revisions, so
375 “hg log -r 2:4” prints 2,3,4 while “hg log -r 4:2” prints 4,3,2.
377 #### 2.4.3 More detailed information
379 While the summary information printed by “hg log” is useful if you
380 already know what you’re looking for, you may need to see a complete
381 description of the change, or a list of the files changed, if you’re
382 trying to decide whether a changeset is the one you’re looking
383 for. The “hg log” command’s -v (or --verbose) option gives you this
387 changeset: 3:ff5d7b70a2a9
388 user: Bryan O'Sullivan <bos@serpentine.com>
389 date: Tue Sep 06 13:15:58 2005 -0700
392 Get make to generate the final binary from a .o file.
396 If you want to see both the description and content of a change, add
397 the -p (or --patch) option. This displays the content of a change as a
398 unified diff (if you’ve never seen a unified diff before, see
399 section [12.4][10] for an overview).
402 changeset: 2:057d3c2d823c
403 user: Bryan O'Sullivan <bos@serpentine.com>
404 date: Tue Sep 06 13:15:43 2005 -0700
407 Introduce a typo into hello.c.
410 diff -r 82e55d328c8c -r 057d3c2d823c hello.c
411 --- a/hello.c Fri Aug 26 01:21:28 2005 -0700
412 +++ b/hello.c Tue Sep 06 13:15:43 2005 -0700
415 int main(int argc, char ⋆⋆argv)
417 - printf("hello, world!∖n");
418 + printf("hello, world!∖");
423 ### 2.5 All about command options
425 Let’s take a brief break from exploring Mercurial commands to discuss
426 a pattern in the way that they work; you may find this useful to keep
427 in mind as we continue our tour.
429 Mercurial has a consistent and straightforward approach to dealing
430 with the options that you can pass to commands. It follows the
431 conventions for options that are common to modern Linux and Unix
434 * Every option has a long name. For example, as we’ve already seen,
435 the “hg log” command accepts a --rev option.
436 * Most options have short names, too. Instead of --rev, we can use
437 -r. (The reason that some options don’t have short names is that
438 the options in question are rarely used.)
439 * Long options start with two dashes (e.g. --rev), while short
440 options start with one (e.g. -r).
441 * Option naming and usage is consistent across commands. For
442 example, every command that lets you specify a changeset ID or
443 revision number accepts both -r and --rev arguments.
445 In the examples throughout this book, I use short options instead of
446 long. This just reflects my own preference, so don’t read anything
449 Most commands that print output of some kind will print more output
450 when passed a -v (or --verbose) option, and less when passed -q (or
453 ### 2.6 Making and reviewing changes
455 Now that we have a grasp of viewing history in Mercurial, let’s take a
456 look at making some changes and examining them.
458 The first thing we’ll do is isolate our experiment in a repository of
459 its own. We use the “hg clone” command, but we don’t need to clone a
460 copy of the remote repository. Since we already have a copy of it
461 locally, we can just clone that instead. This is much faster than
462 cloning over the network, and cloning a local repository uses less
463 disk space in most cases, too.
466 $ hg clone hello my-hello
467 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
470 As an aside, it’s often good practice to keep a “pristine” copy of a
471 remote repository around, which you can then make temporary clones of
472 to create sandboxes for each task you want to work on. This lets you
473 work on multiple tasks in parallel, each isolated from the others
474 until it’s complete and you’re ready to integrate it back. Because
475 local clones are so cheap, there’s almost no overhead to cloning and
476 destroying repositories whenever you want.
478 In our my-hello repository, we have a file hello.c that contains the
479 classic “hello, world” program. Let’s use the ancient and venerable
480 sed command to edit this file so that it prints a second line of
481 output. (I’m only using sed to do this because it’s easy to write a
482 scripted example this way. Since you’re not under the same constraint,
483 you probably won’t want to use sed; simply use your preferred text
484 editor to do the same thing.)
486 $ sed -i '/printf/a∖∖tprintf("hello again!∖∖n");' hello.c
488 Mercurial’s “hg status” command will tell us what Mercurial knows
489 about the files in the repository.
496 The “hg status” command prints no output for some files, but a line
497 starting with “M” for hello.c. Unless you tell it to, “hg status” will
498 not print any output for files that have not been modified.
500 The “M” indicates that Mercurial has noticed that we modified
501 hello.c. We didn’t need to inform Mercurial that we were going to
502 modify the file before we started, or that we had modified the file
503 after we were done; it was able to figure this out itself.
505 It’s a little bit helpful to know that we’ve modified hello.c, but we
506 might prefer to know exactly what changes we’ve made to it. To do
507 this, we use the “hg diff” command.
510 diff -r b57f9a090b62 hello.c
511 --- a/hello.c Tue Sep 06 15:43:07 2005 -0700
512 +++ b/hello.c Sun Jun 17 18:05:50 2007 +0000
513 @@ -8,5 +8,6 @@ int main(int argc, char ⋆⋆argv)
514 int main(int argc, char ⋆⋆argv)
516 printf("hello, world!∖");
517 + printf("hello again!∖n");
521 ### 2.7 Recording changes in a new changeset
523 We can modify files, build and test our changes, and use “hg status”
524 and “hg diff” to review our changes, until we’re satisfied with what
525 we’ve done and arrive at a natural stopping point where we want to
526 record our work in a new changeset.
528 The “hg commit” command lets us create a new changeset; we’ll usually
529 refer to this as “making a commit” or “committing”.
531 #### 2.7.1 Setting up a username
533 When you try to run “hg commit” for the first time, it is not
534 guaranteed to succeed. Mercurial records your name and address with
535 each change that you commit, so that you and others will later be able
536 to tell who made each change. Mercurial tries to automatically figure
537 out a sensible username to commit the change with. It will attempt
538 each of the following methods, in order:
540 1. If you specify a -u option to the “hg commit” command on the
541 command line, followed by a username, this is always given the
543 2. If you have set the HGUSER environment variable, this is checked next.
544 3. If you create a file in your home directory called .hgrc, with a
545 username entry, that will be used next. To see what the contents
546 of this file should look like, refer to section [2.7.1][11]
548 4. If you have set the EMAIL environment variable, this will be used
550 5. Mercurial will query your system to find out your local user name
551 and host name, and construct a username from these
552 components. Since this often results in a username that is not
553 very useful, it will print a warning if it has to do this.
555 If all of these mechanisms fail, Mercurial will fail, printing an
556 error message. In this case, it will not let you commit until you set
559 You should think of the HGUSER environment variable and the -u option
560 to the “hg commit” command as ways to override Mercurial’s default
561 selection of username. For normal use, the simplest and most robust
562 way to set a username for yourself is by creating a .hgrc file; see
565 ##### Creating a Mercurial configuration file
567 To set a user name, use your favourite editor to create a file called
568 .hgrc in your home directory. Mercurial will use this file to look up
569 your personalised configuration settings. The initial contents of your
570 .hgrc should look like this.
572 # This is a Mercurial configuration file.
574 username = Firstname Lastname <email.address@domain.net>
576 The “[ui]” line begins a section of the config file, so you can read
577 the “username = ...” line as meaning “set the value of the username
578 item in the ui section”. A section continues until a new section
579 begins, or the end of the file. Mercurial ignores empty lines and
580 treats any text from “#” to the end of a line as a comment.
582 ##### Choosing a user name
584 You can use any text you like as the value of the username config
585 item, since this information is for reading by other people, but for
586 interpreting by Mercurial. The convention that most people follow is
587 to use their name and email address, as in the example above.
589 Note: Mercurial’s built-in web server obfuscates email addresses, to
590 make it more difficult for the email harvesting tools that spammers
591 use. This reduces the likelihood that you’ll start receiving more junk
592 email if you publish a Mercurial repository on the web.
594 #### 2.7.2 Writing a commit message
596 When we commit a change, Mercurial drops us into a text editor, to
597 enter a message that will describe the modifications we’ve made in
598 this changeset. This is called the commit message. It will be a record
599 for readers of what we did and why, and it will be printed by “hg log”
600 after we’ve finished committing.
604 The editor that the “hg commit” command drops us into will contain an
605 empty line, followed by a number of lines starting with “HG:”.
610 Mercurial ignores the lines that start with “HG:”; it uses them only
611 to tell us which files it’s recording changes to. Modifying or
612 deleting these lines has no effect.
614 #### 2.7.3 Writing a good commit message
616 Since “hg log” only prints the first line of a commit message by
617 default, it’s best to write a commit message whose first line stands
618 alone. Here’s a real example of a commit message that doesn’t follow
619 this guideline, and hence has a summary that is not readable.
621 changeset: 73:584af0e231be
622 user: Censored Person <censored.person@example.org>
623 date: Tue Sep 26 21:37:07 2006 -0700
624 summary: include buildmeister/commondefs. Add an exports and install
626 As far as the remainder of the contents of the commit message are
627 concerned, there are no hard-and-fast rules. Mercurial itself doesn’t
628 interpret or care about the contents of the commit message, though
629 your project may have policies that dictate a certain kind of
632 My personal preference is for short, but informative, commit messages
633 that tell me something that I can’t figure out with a quick glance at
634 the output of “hg log --patch”.
636 #### 2.7.4 Aborting a commit
638 If you decide that you don’t want to commit while in the middle of
639 editing a commit message, simply exit from your editor without saving
640 the file that it’s editing. This will cause nothing to happen to
641 either the repository or the working directory.
643 If we run the “hg commit” command without any arguments, it records
644 all of the changes we’ve made, as reported by “hg status” and “hg
647 #### 2.7.5 Admiring our new handiwork
649 Once we’ve finished the commit, we can use the “hg tip” command to
650 display the changeset we just created. This command produces output
651 that is identical to “hg log”, but it only displays the newest
652 revision in the repository.
655 changeset: 5:fa1321bf0c80
657 user: Bryan O'Sullivan <bos@serpentine.com>
658 date: Sun Jun 17 18:05:50 2007 +0000
661 Added an extra line of output
664 diff -r b57f9a090b62 -r fa1321bf0c80 hello.c
665 --- a/hello.c Tue Sep 06 15:43:07 2005 -0700
666 +++ b/hello.c Sun Jun 17 18:05:50 2007 +0000
667 @@ -8,5 +8,6 @@ int main(int argc, char ⋆⋆argv)
668 int main(int argc, char ⋆⋆argv)
670 printf("hello, world!∖");
671 + printf("hello again!∖n");
676 We refer to the newest revision in the repository as the tip revision,
679 ### 2.8 Sharing changes
681 We mentioned earlier that repositories in Mercurial are
682 self-contained. This means that the changeset we just created exists
683 only in our my-hello repository. Let’s look at a few ways that we can
684 propagate this change into other repositories.
686 #### 2.8.1 Pulling changes from another repository
688 To get started, let’s clone our original hello repository, which does
689 not contain the change we just committed. We’ll call our temporary
690 repository hello-pull.
693 $ hg clone hello hello-pull
694 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
696 We’ll use the “hg pull” command to bring changes from my-hello into
697 hello-pull. However, blindly pulling unknown changes into a repository
698 is a somewhat scary prospect. Mercurial provides the “hg incoming”
699 command to tell us what changes the “hg pull” command would pull into
700 the repository, without actually pulling the changes in.
703 $ hg incoming ../my-hello
704 comparing with ../my-hello
705 searching for changes
706 changeset: 5:fa1321bf0c80
708 user: Bryan O'Sullivan <bos@serpentine.com>
709 date: Sun Jun 17 18:05:50 2007 +0000
710 summary: Added an extra line of output
713 (Of course, someone could cause more changesets to appear in the
714 repository that we ran “hg incoming” in, before we get a chance to “hg
715 pull” the changes, so that we could end up pulling changes that we
718 Bringing changes into a repository is a simple matter of running the
719 “hg pull” command, and telling it which repository to pull from.
722 changeset: 4:b57f9a090b62
724 user: Bryan O'Sullivan <bos@serpentine.com>
725 date: Tue Sep 06 15:43:07 2005 -0700
726 summary: Trim comments.
728 $ hg pull ../my-hello
729 pulling from ../my-hello
730 searching for changes
734 added 1 changesets with 1 changes to 1 files
735 (run 'hg update' to get a working copy)
737 changeset: 5:fa1321bf0c80
739 user: Bryan O'Sullivan <bos@serpentine.com>
740 date: Sun Jun 17 18:05:50 2007 +0000
741 summary: Added an extra line of output
744 As you can see from the before-and-after output of “hg tip”, we have
745 successfully pulled changes into our repository. There remains one
746 step before we can see these changes in the working directory.
748 #### 2.8.2 Updating the working directory
750 We have so far glossed over the relationship between a repository and
751 its working directory. The “hg pull” command that we ran in
752 section [2.8.1][12] brought changes into the repository, but if we
753 check, there’s no sign of those changes in the working directory. This
754 is because “hg pull” does not (by default) touch the working
755 directory. Instead, we use the “hg update” command to do this.
757 $ grep printf hello.c
758 printf("hello, world!∖");
760 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
761 $ grep printf hello.c
762 printf("hello, world!∖");
763 printf("hello again!∖n");
765 It might seem a bit strange that “hg pull” doesn’t update the working
766 directory automatically. There’s actually a good reason for this: you
767 can use “hg update” to update the working directory to the state it
768 was in at any revision in the history of the repository. If you had
769 the working directory updated to an old revision—to hunt down the
770 origin of a bug, say—and ran a “hg pull” which automatically updated
771 the working directory to a new revision, you might not be terribly
774 However, since pull-then-update is such a common thing to do,
775 Mercurial lets you combine the two by passing the -u option to “hg
780 If you look back at the output of “hg pull” in section [2.8.1][12]
781 when we ran it without -u, you can see that it printed a helpful
782 reminder that we’d have to take an explicit step to update the working
785 (run 'hg update' to get a working copy)
787 To find out what revision the working directory is at, use the “hg
791 changeset: 5:fa1321bf0c80
793 user: Bryan O'Sullivan <bos@serpentine.com>
794 date: Sun Jun 17 18:05:50 2007 +0000
795 summary: Added an extra line of output
798 If you look back at figure [2.1][8], you’ll see arrows connecting each
799 changeset. The node that the arrow leads from in each case is a
800 parent, and the node that the arrow leads to is its child. The working
801 directory has a parent in just the same way; this is the changeset
802 that the working directory currently contains.
804 To update the working directory to a particular revision, give a
805 revision number or changeset ID to the “hg update” command.
808 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
810 changeset: 2:057d3c2d823c
811 user: Bryan O'Sullivan <bos@serpentine.com>
812 date: Tue Sep 06 13:15:43 2005 -0700
813 summary: Introduce a typo into hello.c.
816 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
818 If you omit an explicit revision, “hg update” will update to the tip
819 revision, as shown by the second call to “hg update” in the example
822 #### 2.8.3 Pushing changes to another repository
824 Mercurial lets us push changes to another repository, from the
825 repository we’re currently visiting. As with the example of “hg pull”
826 above, we’ll create a temporary repository to push our changes into.
829 $ hg clone hello hello-push
830 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
832 The “hg outgoing” command tells us what changes would be pushed into
836 $ hg outgoing ../hello-push
837 comparing with ../hello-push
838 searching for changes
839 changeset: 5:fa1321bf0c80
841 user: Bryan O'Sullivan <bos@serpentine.com>
842 date: Sun Jun 17 18:05:50 2007 +0000
843 summary: Added an extra line of output
846 And the “hg push” command does the actual push.
848 $ hg push ../hello-push
849 pushing to ../hello-push
850 searching for changes
854 added 1 changesets with 1 changes to 1 files
856 As with “hg pull”, the “hg push” command does not update the working
857 directory in the repository that it’s pushing changes into. (Unlike
858 “hg pull”, “hg push” does not provide a -u option that updates the
859 other repository’s working directory.)
861 What happens if we try to pull or push changes and the receiving
862 repository already has those changes? Nothing too exciting.
864 $ hg push ../hello-push
865 pushing to ../hello-push
866 searching for changes
869 #### 2.8.4 Sharing changes over a network
871 The commands we have covered in the previous few sections are not
872 limited to working with local repositories. Each works in exactly the
873 same fashion over a network connection; simply pass in a URL instead
876 $ hg outgoing http://hg.serpentine.com/tutorial/hello
877 comparing with http://hg.serpentine.com/tutorial/hello
878 searching for changes
879 changeset: 5:fa1321bf0c80
881 user: Bryan O'Sullivan <bos@serpentine.com>
882 date: Sun Jun 17 18:05:50 2007 +0000
883 summary: Added an extra line of output
886 In this example, we can see what changes we could push to the remote
887 repository, but the repository is understandably not set up to let
888 anonymous users push to it.
890 $ hg push http://hg.serpentine.com/tutorial/hello
891 pushing to http://hg.serpentine.com/tutorial/hello
892 searching for changes
895 [1]: http://hgbook.red-bean.com/hgbookch3.html
896 [2]: http://hgbook.red-bean.com/hgbookch1.html
897 [3]: http://hgbook.red-bean.com/hgbookch1.html#tailhgbookch1.html
898 [4]: #tailhgbookch2.html
899 [5]: http://hgbook.red-bean.com/hgbook.html#hgbookch2.html
900 [6]: http://mercurial.berkwood.com/
901 [7]: http://hgbook.red-bean.com/hgbookli4.html#Xweb:macpython
903 [9]: hgbookch2_files/tour-history.png
904 [10]: http://hgbook.red-bean.com/hgbookch12.html#x16-27100012.4
907 [13]: http://hgbook.red-bean.com/hgbookch2.html
910 Open Publication License
912 Version 1.0, 8 June 1999
914 ### D.1 Requirements on both unmodified and modified versions
916 The Open Publication works may be reproduced and distributed in whole
917 or in part, in any medium physical or electronic, provided that the
918 terms of this license are adhered to, and that this license or an
919 incorporation of it by reference (with any options elected by the
920 author(s) and/or publisher) is displayed in the reproduction.
922 Proper form for an incorporation by reference is as follows:
924 Copyright (c) year by author’s name or designee. This material may be
925 distributed only subject to the terms and conditions set forth in the
926 Open Publication License, vx.y or later (the latest version is
927 presently available at
928 [http://www.opencontent.org/openpub/][http://www.opencontent.org/openpub/]).
930 The reference must be immediately followed with any options elected by
931 the author(s) and/or publisher of the document (see section D.6).
933 Commercial redistribution of Open Publication-licensed material is
936 Any publication in standard (paper) book form shall require the
937 citation of the original publisher and author. The publisher and
938 author’s names shall appear on all outer surfaces of the book. On all
939 outer surfaces of the book the original publisher’s name shall be as
940 large as the title of the work and cited as possessive with respect to
945 The copyright to each Open Publication is owned by its author(s) or
948 ### D.3 Scope of license
950 The following license terms apply to all Open Publication works,
951 unless otherwise explicitly stated in the document.
953 Mere aggregation of Open Publication works or a portion of an Open
954 Publication work with other works or programs on the same media shall
955 not cause this license to apply to those other works. The aggregate
956 work shall contain a notice specifying the inclusion of the Open
957 Publication material and appropriate copyright notice.
959 Severability. If any part of this license is found to be unenforceable
960 in any jurisdiction, the remaining portions of the license remain in
963 No warranty. Open Publication works are licensed and provided “as is”
964 without warranty of any kind, express or implied, including, but not
965 limited to, the implied warranties of merchantability and fitness for
966 a particular purpose or a warranty of non-infringement.
968 ### D.4 Requirements on modified works
970 All modified versions of documents covered by this license, including
971 translations, anthologies, compilations and partial documents, must
972 meet the following requirements:
974 1. The modified version must be labeled as such.
975 2. The person making the modifications must be identified and the
977 3. Acknowledgement of the original author and publisher if
978 applicable must be retained according to normal academic citation
980 4. The location of the original unmodified document must be identified.
981 5. The original author’s (or authors’) name(s) may not be used to
982 assert or imply endorsement of the resulting document without the
983 original author’s (or authors’) permission.
985 ### D.5 Good-practice recommendations
987 In addition to the requirements of this license, it is requested from
988 and strongly recommended of redistributors that:
990 1. If you are distributing Open Publication works on hardcopy or
991 CD-ROM, you provide email notification to the authors of your
992 intent to redistribute at least thirty days before your
993 manuscript or media freeze, to give the authors time to provide
994 updated documents. This notification should describe
995 modifications, if any, made to the document.
996 2. All substantive modifications (including deletions) be either
997 clearly marked up in the document or else described in an
998 attachment to the document.
999 3. Finally, while it is not mandatory under this license, it is
1000 considered good form to offer a free copy of any hardcopy and
1001 CD-ROM expression of an Open Publication-licensed work to its
1004 ### D.6 License options
1006 The author(s) and/or publisher of an Open Publication-licensed
1007 document may elect certain options by appending language to the
1008 reference to or copy of the license. These options are considered part
1009 of the license instance and must be included with the license (or its
1010 incorporation by reference) in derived works.
1012 1. To prohibit distribution of substantively modified versions
1013 without the explicit permission of the author(s). “Substantive
1014 modification” is defined as a change to the semantic content of
1015 the document, and excludes mere changes in format or
1016 typographical corrections.
1018 To accomplish this, add the phrase “Distribution of substantively
1019 modified versions of this document is prohibited without the
1020 explicit permission of the copyright holder.” to the license
1023 2. To prohibit any publication of this work or derivative works in
1024 whole or in part in standard (paper) book form for commercial
1025 purposes is prohibited unless prior permission is obtained from
1026 the copyright holder.
1028 To accomplish this, add the phrase “Distribution of the work or
1029 derivative of the work in any standard (paper) book form is
1030 prohibited unless prior permission is obtained from the copyright
1031 holder.” to the license reference or copy.