hgbook
view en/tour-basic.tex @ 320:97e929385442
Small typos, plus a perl regexp match. It was stripping newlines!
| author | Taavi Burns <taavi@taaviburns.ca> |
|---|---|
| date | Sun Aug 31 12:14:23 2008 -0400 (2008-08-31) |
| parents | cd595464fea9 a168daed199b |
| children | 71e726b7f70d |
line source
1 \chapter{A tour of Mercurial: the basics}
2 \label{chap:tour-basic}
4 \section{Installing Mercurial on your system}
5 \label{sec:tour:install}
7 Prebuilt binary packages of Mercurial are available for every popular
8 operating system. These make it easy to start using Mercurial on your
9 computer immediately.
11 \subsection{Linux}
13 Because each Linux distribution has its own packaging tools, policies,
14 and rate of development, it's difficult to give a comprehensive set of
15 instructions on how to install Mercurial binaries. The version of
16 Mercurial that you will end up with can vary depending on how active
17 the person is who maintains the package for your distribution.
19 To keep things simple, I will focus on installing Mercurial from the
20 command line under the most popular Linux distributions. Most of
21 these distributions provide graphical package managers that will let
22 you install Mercurial with a single click; the package name to look
23 for is \texttt{mercurial}.
25 \begin{itemize}
26 \item[Debian]
27 \begin{codesample4}
28 apt-get install mercurial
29 \end{codesample4}
31 \item[Fedora Core]
32 \begin{codesample4}
33 yum install mercurial
34 \end{codesample4}
36 \item[Gentoo]
37 \begin{codesample4}
38 emerge mercurial
39 \end{codesample4}
41 \item[OpenSUSE]
42 \begin{codesample4}
43 yum install mercurial
44 \end{codesample4}
46 \item[Ubuntu] Ubuntu's Mercurial package is based on Debian's. To
47 install it, run the following command.
48 \begin{codesample4}
49 apt-get install mercurial
50 \end{codesample4}
51 The Ubuntu package for Mercurial tends to lag behind the Debian
52 version by a considerable time margin (at the time of writing, seven
53 months), which in some cases will mean that on Ubuntu, you may run
54 into problems that have since been fixed in the Debian package.
55 \end{itemize}
57 \subsection{Solaris}
59 SunFreeWare, at \url{http://www.sunfreeware.com}, is a good source for a
60 large number of pre-built Solaris packages for 32 and 64 bit Intel and
61 Sparc architectures, including current versions of Mercurial.
63 \subsection{Mac OS X}
65 Lee Cantey publishes an installer of Mercurial for Mac OS~X at
66 \url{http://mercurial.berkwood.com}. This package works on both
67 Intel-~and Power-based Macs. Before you can use it, you must install
68 a compatible version of Universal MacPython~\cite{web:macpython}. This
69 is easy to do; simply follow the instructions on Lee's site.
71 It's also possible to install Mercurial using Fink or MacPorts,
72 two popular free package managers for Mac OS X. If you have Fink,
73 use \command{sudo apt-get install mercurial-py25}. If MacPorts,
74 \command{sudo port install mercurial}.
76 \subsection{Windows}
78 Lee Cantey publishes an installer of Mercurial for Windows at
79 \url{http://mercurial.berkwood.com}. This package has no external
80 dependencies; it ``just works''.
82 \begin{note}
83 The Windows version of Mercurial does not automatically convert line
84 endings between Windows and Unix styles. If you want to share work
85 with Unix users, you must do a little additional configuration
86 work. XXX Flesh this out.
87 \end{note}
89 \section{Getting started}
91 To begin, we'll use the \hgcmd{version} command to find out whether
92 Mercurial is actually installed properly. The actual version
93 information that it prints isn't so important; it's whether it prints
94 anything at all that we care about.
95 \interaction{tour.version}
97 \subsection{Built-in help}
99 Mercurial provides a built-in help system. This is invaluable for those
100 times when you find yourself stuck trying to remember how to run a
101 command. If you are completely stuck, simply run \hgcmd{help}; it
102 will print a brief list of commands, along with a description of what
103 each does. If you ask for help on a specific command (as below), it
104 prints more detailed information.
105 \interaction{tour.help}
106 For a more impressive level of detail (which you won't usually need)
107 run \hgcmdargs{help}{\hggopt{-v}}. The \hggopt{-v} option is short
108 for \hggopt{--verbose}, and tells Mercurial to print more information
109 than it usually would.
111 \section{Working with a repository}
113 In Mercurial, everything happens inside a \emph{repository}. The
114 repository for a project contains all of the files that ``belong to''
115 that project, along with a historical record of the project's files.
117 There's nothing particularly magical about a repository; it is simply
118 a directory tree in your filesystem that Mercurial treats as special.
119 You can rename or delete a repository any time you like, using either the
120 command line or your file browser.
122 \subsection{Making a local copy of a repository}
124 \emph{Copying} a repository is just a little bit special. While you
125 could use a normal file copying command to make a copy of a
126 repository, it's best to use a built-in command that Mercurial
127 provides. This command is called \hgcmd{clone}, because it creates an
128 identical copy of an existing repository.
129 \interaction{tour.clone}
130 If our clone succeeded, we should now have a local directory called
131 \dirname{hello}. This directory will contain some files.
132 \interaction{tour.ls}
133 These files have the same contents and history in our repository as
134 they do in the repository we cloned.
136 Every Mercurial repository is complete, self-contained, and
137 independent. It contains its own private copy of a project's files
138 and history. A cloned repository remembers the location of the
139 repository it was cloned from, but it does not communicate with that
140 repository, or any other, unless you tell it to.
142 What this means for now is that we're free to experiment with our
143 repository, safe in the knowledge that it's a private ``sandbox'' that
144 won't affect anyone else.
146 \subsection{What's in a repository?}
148 When we take a more detailed look inside a repository, we can see that
149 it contains a directory named \dirname{.hg}. This is where Mercurial
150 keeps all of its metadata for the repository.
151 \interaction{tour.ls-a}
153 The contents of the \dirname{.hg} directory and its subdirectories are
154 private to Mercurial. Every other file and directory in the
155 repository is yours to do with as you please.
157 To introduce a little terminology, the \dirname{.hg} directory is the
158 ``real'' repository, and all of the files and directories that coexist
159 with it are said to live in the \emph{working directory}. An easy way
160 to remember the distinction is that the \emph{repository} contains the
161 \emph{history} of your project, while the \emph{working directory}
162 contains a \emph{snapshot} of your project at a particular point in
163 history.
165 \section{A tour through history}
167 One of the first things we might want to do with a new, unfamiliar
168 repository is understand its history. The \hgcmd{log} command gives
169 us a view of history.
170 \interaction{tour.log}
171 By default, this command prints a brief paragraph of output for each
172 change to the project that was recorded. In Mercurial terminology, we
173 call each of these recorded events a \emph{changeset}, because it can
174 contain a record of changes to several files.
176 The fields in a record of output from \hgcmd{log} are as follows.
177 \begin{itemize}
178 \item[\texttt{changeset}] This field has the format of a number,
179 followed by a colon, followed by a hexadecimal string. These are
180 \emph{identifiers} for the changeset. There are two identifiers
181 because the number is shorter and easier to type than the hex
182 string.
183 \item[\texttt{user}] The identity of the person who created the
184 changeset. This is a free-form field, but it most often contains a
185 person's name and email address.
186 \item[\texttt{date}] The date and time on which the changeset was
187 created, and the timezone in which it was created. (The date and
188 time are local to that timezone; they display what time and date it
189 was for the person who created the changeset.)
190 \item[\texttt{summary}] The first line of the text message that the
191 creator of the changeset entered to describe the changeset.
192 \end{itemize}
193 The default output printed by \hgcmd{log} is purely a summary; it is
194 missing a lot of detail.
196 Figure~\ref{fig:tour-basic:history} provides a graphical representation of
197 the history of the \dirname{hello} repository, to make it a little
198 easier to see which direction history is ``flowing'' in. We'll be
199 returning to this figure several times in this chapter and the chapter
200 that follows.
202 \begin{figure}[ht]
203 \centering
204 \grafix{tour-history}
205 \caption{Graphical history of the \dirname{hello} repository}
206 \label{fig:tour-basic:history}
207 \end{figure}
209 \subsection{Changesets, revisions, and talking to other
210 people}
212 As English is a notoriously sloppy language, and computer science has
213 a hallowed history of terminological confusion (why use one term when
214 four will do?), revision control has a variety of words and phrases
215 that mean the same thing. If you are talking about Mercurial history
216 with other people, you will find that the word ``changeset'' is often
217 compressed to ``change'' or (when written) ``cset'', and sometimes a
218 changeset is referred to as a ``revision'' or a ``rev''.
220 While it doesn't matter what \emph{word} you use to refer to the
221 concept of ``a~changeset'', the \emph{identifier} that you use to
222 refer to ``a~\emph{specific} changeset'' is of great importance.
223 Recall that the \texttt{changeset} field in the output from
224 \hgcmd{log} identifies a changeset using both a number and a
225 hexadecimal string.
226 \begin{itemize}
227 \item The revision number is \emph{only valid in that repository},
228 \item while the hex string is the \emph{permanent, unchanging
229 identifier} that will always identify that exact changeset in
230 \emph{every} copy of the repository.
231 \end{itemize}
232 This distinction is important. If you send someone an email talking
233 about ``revision~33'', there's a high likelihood that their
234 revision~33 will \emph{not be the same} as yours. The reason for this
235 is that a revision number depends on the order in which changes
236 arrived in a repository, and there is no guarantee that the same
237 changes will happen in the same order in different repositories.
238 Three changes $a,b,c$ can easily appear in one repository as $0,1,2$,
239 while in another as $1,0,2$.
241 Mercurial uses revision numbers purely as a convenient shorthand. If
242 you need to discuss a changeset with someone, or make a record of a
243 changeset for some other reason (for example, in a bug report), use
244 the hexadecimal identifier.
246 \subsection{Viewing specific revisions}
248 To narrow the output of \hgcmd{log} down to a single revision, use the
249 \hgopt{log}{-r} (or \hgopt{log}{--rev}) option. You can use either a
250 revision number or a long-form changeset identifier, and you can
251 provide as many revisions as you want. \interaction{tour.log-r}
253 If you want to see the history of several revisions without having to
254 list each one, you can use \emph{range notation}; this lets you
255 express the idea ``I want all revisions between $a$ and $b$,
256 inclusive''.
257 \interaction{tour.log.range}
258 Mercurial also honours the order in which you specify revisions, so
259 \hgcmdargs{log}{-r 2:4} prints $2,3,4$ while \hgcmdargs{log}{-r 4:2}
260 prints $4,3,2$.
262 \subsection{More detailed information}
264 While the summary information printed by \hgcmd{log} is useful if you
265 already know what you're looking for, you may need to see a complete
266 description of the change, or a list of the files changed, if you're
267 trying to decide whether a changeset is the one you're looking for.
268 The \hgcmd{log} command's \hggopt{-v} (or \hggopt{--verbose})
269 option gives you this extra detail.
270 \interaction{tour.log-v}
272 If you want to see both the description and content of a change, add
273 the \hgopt{log}{-p} (or \hgopt{log}{--patch}) option. This displays
274 the content of a change as a \emph{unified diff} (if you've never seen
275 a unified diff before, see section~\ref{sec:mq:patch} for an overview).
276 \interaction{tour.log-vp}
278 \section{All about command options}
280 Let's take a brief break from exploring Mercurial commands to discuss
281 a pattern in the way that they work; you may find this useful to keep
282 in mind as we continue our tour.
284 Mercurial has a consistent and straightforward approach to dealing
285 with the options that you can pass to commands. It follows the
286 conventions for options that are common to modern Linux and Unix
287 systems.
288 \begin{itemize}
289 \item Every option has a long name. For example, as we've already
290 seen, the \hgcmd{log} command accepts a \hgopt{log}{--rev} option.
291 \item Most options have short names, too. Instead of
292 \hgopt{log}{--rev}, we can use \hgopt{log}{-r}. (The reason that
293 some options don't have short names is that the options in question
294 are rarely used.)
295 \item Long options start with two dashes (e.g.~\hgopt{log}{--rev}),
296 while short options start with one (e.g.~\hgopt{log}{-r}).
297 \item Option naming and usage is consistent across commands. For
298 example, every command that lets you specify a changeset~ID or
299 revision number accepts both \hgopt{log}{-r} and \hgopt{log}{--rev}
300 arguments.
301 \end{itemize}
302 In the examples throughout this book, I use short options instead of
303 long. This just reflects my own preference, so don't read anything
304 significant into it.
306 Most commands that print output of some kind will print more output
307 when passed a \hggopt{-v} (or \hggopt{--verbose}) option, and less
308 when passed \hggopt{-q} (or \hggopt{--quiet}).
310 \section{Making and reviewing changes}
312 Now that we have a grasp of viewing history in Mercurial, let's take a
313 look at making some changes and examining them.
315 The first thing we'll do is isolate our experiment in a repository of
316 its own. We use the \hgcmd{clone} command, but we don't need to
317 clone a copy of the remote repository. Since we already have a copy
318 of it locally, we can just clone that instead. This is much faster
319 than cloning over the network, and cloning a local repository uses
320 less disk space in most cases, too.
321 \interaction{tour.reclone}
322 As an aside, it's often good practice to keep a ``pristine'' copy of a
323 remote repository around, which you can then make temporary clones of
324 to create sandboxes for each task you want to work on. This lets you
325 work on multiple tasks in parallel, each isolated from the others
326 until it's complete and you're ready to integrate it back. Because
327 local clones are so cheap, there's almost no overhead to cloning and
328 destroying repositories whenever you want.
330 In our \dirname{my-hello} repository, we have a file
331 \filename{hello.c} that contains the classic ``hello, world'' program.
332 Let's use the ancient and venerable \command{sed} command to edit this
333 file so that it prints a second line of output. (I'm only using
334 \command{sed} to do this because it's easy to write a scripted example
335 this way. Since you're not under the same constraint, you probably
336 won't want to use \command{sed}; simply use your preferred text editor to
337 do the same thing.)
338 \interaction{tour.sed}
340 Mercurial's \hgcmd{status} command will tell us what Mercurial knows
341 about the files in the repository.
342 \interaction{tour.status}
343 The \hgcmd{status} command prints no output for some files, but a line
344 starting with ``\texttt{M}'' for \filename{hello.c}. Unless you tell
345 it to, \hgcmd{status} will not print any output for files that have
346 not been modified.
348 The ``\texttt{M}'' indicates that Mercurial has noticed that we
349 modified \filename{hello.c}. We didn't need to \emph{inform}
350 Mercurial that we were going to modify the file before we started, or
351 that we had modified the file after we were done; it was able to
352 figure this out itself.
354 It's a little bit helpful to know that we've modified
355 \filename{hello.c}, but we might prefer to know exactly \emph{what}
356 changes we've made to it. To do this, we use the \hgcmd{diff}
357 command.
358 \interaction{tour.diff}
360 \section{Recording changes in a new changeset}
362 We can modify files, build and test our changes, and use
363 \hgcmd{status} and \hgcmd{diff} to review our changes, until we're
364 satisfied with what we've done and arrive at a natural stopping point
365 where we want to record our work in a new changeset.
367 The \hgcmd{commit} command lets us create a new changeset; we'll
368 usually refer to this as ``making a commit'' or ``committing''.
370 \subsection{Setting up a username}
372 When you try to run \hgcmd{commit} for the first time, it is not
373 guaranteed to succeed. Mercurial records your name and address with
374 each change that you commit, so that you and others will later be able
375 to tell who made each change. Mercurial tries to automatically figure
376 out a sensible username to commit the change with. It will attempt
377 each of the following methods, in order:
378 \begin{enumerate}
379 \item If you specify a \hgopt{commit}{-u} option to the \hgcmd{commit}
380 command on the command line, followed by a username, this is always
381 given the highest precedence.
382 \item If you have set the \envar{HGUSER} environment variable, this is
383 checked next.
384 \item If you create a file in your home directory called
385 \sfilename{.hgrc}, with a \rcitem{ui}{username} entry, that will be
386 used next. To see what the contents of this file should look like,
387 refer to section~\ref{sec:tour-basic:username} below.
388 \item If you have set the \envar{EMAIL} environment variable, this
389 will be used next.
390 \item Mercurial will query your system to find out your local user
391 name and host name, and construct a username from these components.
392 Since this often results in a username that is not very useful, it
393 will print a warning if it has to do this.
394 \end{enumerate}
395 If all of these mechanisms fail, Mercurial will fail, printing an
396 error message. In this case, it will not let you commit until you set
397 up a username.
399 You should think of the \envar{HGUSER} environment variable and the
400 \hgopt{commit}{-u} option to the \hgcmd{commit} command as ways to
401 \emph{override} Mercurial's default selection of username. For normal
402 use, the simplest and most robust way to set a username for yourself
403 is by creating a \sfilename{.hgrc} file; see below for details.
405 \subsubsection{Creating a Mercurial configuration file}
406 \label{sec:tour-basic:username}
408 To set a user name, use your favourite editor to create a file called
409 \sfilename{.hgrc} in your home directory. Mercurial will use this
410 file to look up your personalised configuration settings. The initial
411 contents of your \sfilename{.hgrc} should look like this.
412 \begin{codesample2}
413 # This is a Mercurial configuration file.
414 [ui]
415 username = Firstname Lastname <email.address@domain.net>
416 \end{codesample2}
417 The ``\texttt{[ui]}'' line begins a \emph{section} of the config file,
418 so you can read the ``\texttt{username = ...}'' line as meaning ``set
419 the value of the \texttt{username} item in the \texttt{ui} section''.
420 A section continues until a new section begins, or the end of the
421 file. Mercurial ignores empty lines and treats any text from
422 ``\texttt{\#}'' to the end of a line as a comment.
424 \subsubsection{Choosing a user name}
426 You can use any text you like as the value of the \texttt{username}
427 config item, since this information is for reading by other people,
428 but for interpreting by Mercurial. The convention that most people
429 follow is to use their name and email address, as in the example
430 above.
432 \begin{note}
433 Mercurial's built-in web server obfuscates email addresses, to make
434 it more difficult for the email harvesting tools that spammers use.
435 This reduces the likelihood that you'll start receiving more junk
436 email if you publish a Mercurial repository on the web.
437 \end{note}
439 \subsection{Writing a commit message}
441 When we commit a change, Mercurial drops us into a text editor, to
442 enter a message that will describe the modifications we've made in
443 this changeset. This is called the \emph{commit message}. It will be
444 a record for readers of what we did and why, and it will be printed by
445 \hgcmd{log} after we've finished committing.
446 \interaction{tour.commit}
448 The editor that the \hgcmd{commit} command drops us into will contain
449 an empty line, followed by a number of lines starting with
450 ``\texttt{HG:}''.
451 \begin{codesample2}
452 \emph{empty line}
453 HG: changed hello.c
454 \end{codesample2}
455 Mercurial ignores the lines that start with ``\texttt{HG:}''; it uses
456 them only to tell us which files it's recording changes to. Modifying
457 or deleting these lines has no effect.
459 \subsection{Writing a good commit message}
461 Since \hgcmd{log} only prints the first line of a commit message by
462 default, it's best to write a commit message whose first line stands
463 alone. Here's a real example of a commit message that \emph{doesn't}
464 follow this guideline, and hence has a summary that is not readable.
465 \begin{codesample2}
466 changeset: 73:584af0e231be
467 user: Censored Person <censored.person@example.org>
468 date: Tue Sep 26 21:37:07 2006 -0700
469 summary: include buildmeister/commondefs. Add an exports and install
470 \end{codesample2}
472 As far as the remainder of the contents of the commit message are
473 concerned, there are no hard-and-fast rules. Mercurial itself doesn't
474 interpret or care about the contents of the commit message, though
475 your project may have policies that dictate a certain kind of
476 formatting.
478 My personal preference is for short, but informative, commit messages
479 that tell me something that I can't figure out with a quick glance at
480 the output of \hgcmdargs{log}{--patch}.
482 \subsection{Aborting a commit}
484 If you decide that you don't want to commit while in the middle of
485 editing a commit message, simply exit from your editor without saving
486 the file that it's editing. This will cause nothing to happen to
487 either the repository or the working directory.
489 If we run the \hgcmd{commit} command without any arguments, it records
490 all of the changes we've made, as reported by \hgcmd{status} and
491 \hgcmd{diff}.
493 \subsection{Admiring our new handiwork}
495 Once we've finished the commit, we can use the \hgcmd{tip} command to
496 display the changeset we just created. This command produces output
497 that is identical to \hgcmd{log}, but it only displays the newest
498 revision in the repository.
499 \interaction{tour.tip}
500 We refer to the newest revision in the repository as the tip revision,
501 or simply the tip.
503 \section{Sharing changes}
505 We mentioned earlier that repositories in Mercurial are
506 self-contained. This means that the changeset we just created exists
507 only in our \dirname{my-hello} repository. Let's look at a few ways
508 that we can propagate this change into other repositories.
510 \subsection{Pulling changes from another repository}
511 \label{sec:tour:pull}
513 To get started, let's clone our original \dirname{hello} repository,
514 which does not contain the change we just committed. We'll call our
515 temporary repository \dirname{hello-pull}.
516 \interaction{tour.clone-pull}
518 We'll use the \hgcmd{pull} command to bring changes from
519 \dirname{my-hello} into \dirname{hello-pull}. However, blindly
520 pulling unknown changes into a repository is a somewhat scary
521 prospect. Mercurial provides the \hgcmd{incoming} command to tell us
522 what changes the \hgcmd{pull} command \emph{would} pull into the
523 repository, without actually pulling the changes in.
524 \interaction{tour.incoming}
525 (Of course, someone could cause more changesets to appear in the
526 repository that we ran \hgcmd{incoming} in, before we get a chance to
527 \hgcmd{pull} the changes, so that we could end up pulling changes that we
528 didn't expect.)
530 Bringing changes into a repository is a simple matter of running the
531 \hgcmd{pull} command, and telling it which repository to pull from.
532 \interaction{tour.pull}
533 As you can see from the before-and-after output of \hgcmd{tip}, we
534 have successfully pulled changes into our repository. There remains
535 one step before we can see these changes in the working directory.
537 \subsection{Updating the working directory}
539 We have so far glossed over the relationship between a repository and
540 its working directory. The \hgcmd{pull} command that we ran in
541 section~\ref{sec:tour:pull} brought changes into the repository, but
542 if we check, there's no sign of those changes in the working
543 directory. This is because \hgcmd{pull} does not (by default) touch
544 the working directory. Instead, we use the \hgcmd{update} command to
545 do this.
546 \interaction{tour.update}
548 It might seem a bit strange that \hgcmd{pull} doesn't update the
549 working directory automatically. There's actually a good reason for
550 this: you can use \hgcmd{update} to update the working directory to
551 the state it was in at \emph{any revision} in the history of the
552 repository. If you had the working directory updated to an old
553 revision---to hunt down the origin of a bug, say---and ran a
554 \hgcmd{pull} which automatically updated the working directory to a
555 new revision, you might not be terribly happy.
557 However, since pull-then-update is such a common thing to do,
558 Mercurial lets you combine the two by passing the \hgopt{pull}{-u}
559 option to \hgcmd{pull}.
560 \begin{codesample2}
561 hg pull -u
562 \end{codesample2}
563 If you look back at the output of \hgcmd{pull} in
564 section~\ref{sec:tour:pull} when we ran it without \hgopt{pull}{-u},
565 you can see that it printed a helpful reminder that we'd have to take
566 an explicit step to update the working directory:
567 \begin{codesample2}
568 (run 'hg update' to get a working copy)
569 \end{codesample2}
571 To find out what revision the working directory is at, use the
572 \hgcmd{parents} command.
573 \interaction{tour.parents}
574 If you look back at figure~\ref{fig:tour-basic:history}, you'll see
575 arrows connecting each changeset. The node that the arrow leads
576 \emph{from} in each case is a parent, and the node that the arrow
577 leads \emph{to} is its child. The working directory has a parent in
578 just the same way; this is the changeset that the working directory
579 currently contains.
581 To update the working directory to a particular revision, give a
582 revision number or changeset~ID to the \hgcmd{update} command.
583 \interaction{tour.older}
584 If you omit an explicit revision, \hgcmd{update} will update to the
585 tip revision, as shown by the second call to \hgcmd{update} in the
586 example above.
588 \subsection{Pushing changes to another repository}
590 Mercurial lets us push changes to another repository, from the
591 repository we're currently visiting. As with the example of
592 \hgcmd{pull} above, we'll create a temporary repository to push our
593 changes into.
594 \interaction{tour.clone-push}
595 The \hgcmd{outgoing} command tells us what changes would be pushed
596 into another repository.
597 \interaction{tour.outgoing}
598 And the \hgcmd{push} command does the actual push.
599 \interaction{tour.push}
600 As with \hgcmd{pull}, the \hgcmd{push} command does not update the
601 working directory in the repository that it's pushing changes into.
602 (Unlike \hgcmd{pull}, \hgcmd{push} does not provide a \texttt{-u}
603 option that updates the other repository's working directory.)
605 What happens if we try to pull or push changes and the receiving
606 repository already has those changes? Nothing too exciting.
607 \interaction{tour.push.nothing}
609 \subsection{Sharing changes over a network}
611 The commands we have covered in the previous few sections are not
612 limited to working with local repositories. Each works in exactly the
613 same fashion over a network connection; simply pass in a URL instead
614 of a local path.
615 \interaction{tour.outgoing.net}
616 In this example, we can see what changes we could push to the remote
617 repository, but the repository is understandably not set up to let
618 anonymous users push to it.
619 \interaction{tour.push.net}
621 %%% Local Variables:
622 %%% mode: latex
623 %%% TeX-master: "00book"
624 %%% End: