%\chapter{A tour of Mercurial: the basics}
\chapter{Mercurial$B%D%"!<(B: $B4pK\(B}
\label{chap:tour-basic}

%\section{Installing Mercurial on your system}
\section{$B%7%9%F%`$X$N(BMercurial$B$N%$%s%9%H!<%k(B}
\label{sec:tour:install}

%Prebuilt binary packages of Mercurial are available for every popular
%operating system.  These make it easy to start using Mercurial on your
%computer immediately.

$B?M5$$N9b$$%*%Z%l!<%F%#%s%0%7%9%F%`$G$O(BMercurial$B$N%S%k%I:Q$_%P%$%J%j%Q%C(B
$B%1!<%8$,Ds6!$5$l$F$$$k!%$3$l$rMQ$$$l$PFI<T$N7W;;5!$N>e$GD>$A$K(BMercurial
$B$r;H$&$3$H$,$G$-$k!%(B

\subsection{Windows}

%The best version of Mercurial for Windows is TortoiseHg, which can be
%found at \url{http://bitbucket.org/tortoisehg/stable/wiki/Home}. This
%package has no external dependencies; it ``just works''. It
%provides both command line and graphical user interfaces.

Windows$B8~$1(BMercurial$B$N:G$bM%$l$?%P!<%8%g%s$G$"$k(BTortoiseHg$B$O!$(B
\url{http://bitbucket.org/tortoisehg/stable/wiki/Home}$B$GF~<j$G$-$k!%(B
$B$3$N%Q%C%1!<%8$O30It$N%Q%C%1!<%8$X0MB8$;$:!$$9$0$KF0:n$9$k!%%3%^%s%I%i%$(B
$B%s%$%s%?%U%'!<%9$H%0%i%U%#%+%k%f!<%6%$%s%?%U%'!<%9$NN>J}$,MxMQ$G$-$k!%(B

\subsection{Mac OS X}

%Lee Cantey publishes an installer of Mercurial for Mac OS X at
%       \url{http://mercurial.berkwood.com}.

Lee Cantey$B$O(BMac OS~X$B8~$1$N(BMercurial$B%$%s%9%H!<%i$r(B
\url{http://mercurial.berkwood.com}$B$GG[I[$7$F$$$k!%(B

\subsection{Linux}
%Because each Linux distribution has its own packaging tools, policies,
%and rate of development, it's difficult to give a comprehensive set of
%instructions on how to install Mercurial binaries.  The version of
%Mercurial that you will end up with can vary depending on how active
%the person is who maintains the package for your distribution.

Linux$B$N3F%G%#%9%H%j%S%e!<%7%g%s$O$=$l$>$lFH<+$N%Q%C%1!<%8%D!<%k!$%]%j(B
$B%7!<!$3+H/%Z!<%9$r;}$C$F$$$k$?$a!$A4$F$rLVMe$7$F(BMercurial$B%P%$%J%j$N%$%s%9(B
$B%H!<%k<j=g$r=R$Y$k$3$H$O:$Fq$G$"$k!%$=$l$>$l$N%G%#%9%H%j%S%e!<%7%g%s$GMx(B
$BMQ2DG=$J(BMercurial$B$N%P!<%8%g%s$O!$%Q%C%1!<%8%a%s%F%J$N3hF0$K0MB8$9$k!%(B

%To keep things simple, I will focus on installing Mercurial from the
%command line under the most popular Linux distributions.  Most of
%these distributions provide graphical package managers that will let
%you install Mercurial with a single click; the package name to look
%for is \texttt{mercurial}.

$BC1=c2=$N$?$a$K!$BgB??t$N(BLinux$B%G%#%9%H%j%S%e!<%7%g%s$G%3%^%s%I%i%$%s$+$i(B
Mercurial$B$r%$%s%9%H!<%k$9$kJ}K!$K8BDj$7$F@bL@$9$k$3$H$K$9$k!%$3$l$i$NBgH>(B
$B$N%G%#%9%H%j%S%e!<%7%g%s$G$O!$(BMercurial$B$r%/%j%C%/(B1$B2s$G%$%s%9%H!<%k$G$-$k(B
$B$h$&$J%0%i%U%#%+%k$J%Q%C%1!<%8%^%M!<%8%c$rMQ0U$7$F$$$k!%(B

\begin{itemize}
\item[Debian and Ubuntu]
  \begin{codesample4}
    apt-get install mercurial
  \end{codesample4}

\item[Fedora and OpenSUSE]
  \begin{codesample4}
    yum install mercurial
  \end{codesample4}

\item[Gentoo]
  \begin{codesample4}
    emerge mercurial
  \end{codesample4}

%  The Ubuntu package for Mercurial tends to lag behind the Debian
%  version by a considerable time margin (at the time of writing, seven
%  months), which in some cases will mean that on Ubuntu, you may run
%  into problems that have since been fixed in the Debian package.
Ubuntu$B$N(BMercurial$B%Q%C%1!<%8$O(BDebian$B$N$b$N$KHf$Y$FL5;k$G$-$J$$$[$I$NCY$l(B
	     $B$,$"$k!J$3$l$r=q$$$F$$$k;~E@$G$O(B7$B%+7n!K!%$3$N$?$a!$(BUbuntu$B$G(B
	     $B$O(BDebian$B$G$O$9$G$K2r7h$5$l$?LdBj$KD>LL$9$k$+$b$7$l$J$$!%(B
\end{itemize}

\subsection{Solaris}

%SunFreeWare, at \url{http://www.sunfreeware.com}, provides prebuilt
%packages of Mercurial.
\url{http://www.sunfreeware.com}$B$+$i%S%k%I:Q$_$N(BMercurial$B%Q%C%1!<%8$,F~(B
$B<j$G$-$k!%(B

%\section{Getting started}
\section{Mercurial$B$r;H$&(B}

%To begin, we'll use the \hgcmd{version} command to find out whether
%Mercurial is actually installed properly.  The actual version
%information that it prints isn't so important; it's whether it prints
%anything at all that we care about.
%\interaction{tour.version}

$B$^$:(B\hgcmd{version}$B%3%^%s%I$G(BMercurial$B$,<B:]$K@5$7$/%$%s%9%H!<%k$5$l$?$+(B
$B$r3NG'$7$F$_$h$&!%I=<($5$l$k$+$I$&$+$,LdBj$G$"$C$F!$I=<($5$l$k%P!<%8%g%s(B
$B>pJs$OFC$K=EMW$G$O$J$$!%(B
\interaction{tour.version}

%\subsection{Built-in help}
\subsection{$BAH$_9~$_%X%k%W(B}

%Mercurial provides a built-in help system.  This is invaluable for those
%times when you find yourself stuck trying to remember how to run a
%command.  If you are completely stuck, simply run \hgcmd{help}; it
%will print a brief list of commands, along with a description of what
%each does.  If you ask for help on a specific command (as below), it
%prints more detailed information.
%\interaction{tour.help}
%For a more impressive level of detail (which you won't usually need)
%run \hgcmdargs{help}{\hggopt{-v}}.  The \hggopt{-v} option is short
%for \hggopt{--verbose}, and tells Mercurial to print more information
%than it usually would.

Mercurial$B$OAH$_9~$_$N%X%k%W%7%9%F%`$rHw$($F$$$k!%$3$l$O%3%^%s%I$N;H$$J}$K(B
$B5M$^$C$?;~$KLr$KN)$D!%2?$r<B9T$7$?$iNI$$$N$+A4$/J,$+$i$J$$>l9g$OC1$K(B
\hgcmd{help}$B$r<B9T$9$k!%$3$l$O%3%^%s%I$N0lIt$r@bL@$H6&$K%j%9%HI=<($9$k!%(B
$BFCDj$N%3%^%s%I$K$D$$$F%X%k%W$,8+$?$$>l9g$O!$2<5-$N$h$&$K$9$k$H$h$j>\:Y$J(B
$B>pJs$,F@$i$l$k!%(B
\interaction{tour.help}
$BDL>oI,MW$H$7$J$$$h$&$J6K$a$F>\$7$$@bL@$,I,MW$J>l9g$O(B
\hgcmdargs{help}{\hggopt{-v}}$B$r<B9T$9$k!%(B\hggopt{-v}$B$O(B\hggopt{--verbose}
$B%*%W%7%g%s$NC;=L7A$G!$$h$j>\:Y$J>pJs$rI=<($9$k%*%W%7%g%s$G$"$k!%(B

%\section{Working with a repository}
\section{$B%j%]%8%H%j$r;H$C$?:n6H(B}

%In Mercurial, everything happens inside a \emph{repository}.  The
%repository for a project contains all of the files that ``belong to''
%that project, along with a historical record of the project's files.

Mercurial$B$G$O(B\emph{$B%j%]%8%H%jFb(B}$B$G0l@Z$,5/$-$k!%%W%m%8%'%/%H$N%j%]%8%H%j(B
$B$O=jB0$9$kA4$F$N%U%!%$%k$H$=$l$i$NMzNr>pJs$r;}$D!%(B

%There's nothing particularly magical about a repository; it is simply
%a directory tree in your filesystem that Mercurial treats as special.
%You can rename or delete a repository any time you like, using either the
%command line or your file browser.

$B%j%]%8%H%j$K$OFC$KIT;W5D$J$H$3$m$O$J$$!%%j%]%8%H%j$O(BMercurial$B$,FCJL$N07$$(B
$B$r$9$k$@$1$N%U%!%$%k%7%9%F%`>e$NC1$J$k%G%#%l%/%H%j%D%j!<$K$9$.$J$$!%(B
$B%j%]%8%H%j$O%3%^%s%I%i%$%s$d%U%!%$%k%V%i%&%6$+$i$$$D$G$bL>A0$rJQ$($?$j>C(B
$B5n$9$k$3$H$,$G$-$k!%(B

%\subsection{Making a local copy of a repository}
\subsection{$B%j%]%8%H%j$N%m!<%+%k%3%T!<$r:n$k(B}

%\emph{Copying} a repository is just a little bit special.  While you
%could use a normal file copying command to make a copy of a
%repository, it's best to use a built-in command that Mercurial
%provides.  This command is called \hgcmd{clone}, because it makes an
%identical copy of an existing repository.
%\interaction{tour.clone}

$B%j%]%8%H%j$N(B\emph{$B%3%T!<(B}$B$O$d$dFC<l$G$"$k!%DL>o$N%U%!%$%k%3%T!<%3%^%s%I$r(B
$B;H$C$F%j%]%8%H%j$N%3%T!<$r:n@.$9$k$3$H$b$G$-$k$,!$(BMercurial$B$NAH$_9~$_%3%^(B
$B%s%I$r;H$C$F%3%T!<$9$k$N$,0lHVNI$$!%$3$N%3%^%s%I$O(B\hgcmd{clone}$B$H8F$P$l!$(B
$B4{B8$N%j%]%8%H%j$N40A4$J%3%T!<$r:n@.$9$k!%(B
\interaction{tour.clone}

%One advantage of using \hgcmd{clone} is that, as we can see above, it
%lets us clone repositories over the network.  Another is that it
%remembers where we cloned from, which we'll find useful soon when we
%want to fetch new changes from another repository.

\hgcmd{clone}$B%3%^%s%I$r;H$&MxE@$N0l$D$O!$>e$G8+$?$h$&$K%j%]%8%H%j$r%M%C%H(B
$B%o!<%/1[$7$K%/%m!<%s$G$-$kE@$G$"$k!%$^$?$b$&0lE@!$$3$N%3%^%s%I$O$I$3$+$i(B
$B%/%m!<%s$7$?$N$+$r5-O?$9$k$?$a!$?7$?$JJQ99$rJL$N%j%]%8%H%j$+$i<hF@$7$h$&(B
$B$H$9$k:]$KJXMx$G$"$k!%(B

%If our clone succeeded, we should now have a local directory called
%\dirname{hello}.  This directory will contain some files.
%\interaction{tour.ls}
%These files have the same contents and history in our repository as
%they do in the repository we cloned.

$B%/%m!<%s$,@.8y$9$k$H(B\dirname{hello}$B$H$$$&%m!<%+%k%G%#%l%/%H%j$,$G$-$k!%(B
$B$3$N%G%#%l%/%H%j$K$O%*%j%8%J%k$HF10l$N%U%!%$%k$,4^$^$l$k!%(B
\interaction{tour.ls}
$B$3$l$i$N%U%!%$%k$O%/%m!<%s$7$?%j%]%8%H%jFb$HA4$/F1$8FbMF$HMzNr$r;}$C$F$$(B
$B$k!%(B

%Every Mercurial repository is complete, self-contained, and independent.
%It contains its own private copy of a project's files and history. As we
%just mentioned, A cloned repository remembers the location of the
%repository it was cloned from, but it does not communicate with that
%repository, or any other, unless you tell it to.

$BA4$F$N(BMercurial$B%j%]%8%H%j$O40A4$+$D<+8J=<B-E*$GFHN)$G$"$k!%%j%]%8%H%j$O%W(B
$B%m%8%'%/%H$KB0$9%U%!%$%k$N%W%i%$%Y!<%H%3%T!<$HMzNr$r;}$D!%:#=R$Y$?$h$&(B
$B$K!$%/%m!<%s$5$l$?%j%]%8%H%j$O%/%m!<%s85$N%j%]%8%H%j$N>l=j$r5-21$7$F$$$k(B
$B$,!$%f!<%6$,;X<($7$J$$8B$j!$$=$N%j%]%8%H%j$dB>$N%j%]%8%H%j$HDL?.$r9T$&$3(B
$B$H$O$J$$!%(B

%What this means for now is that we're free to experiment with our
%repository, safe in the knowledge that it's a private ``sandbox'' that
%won't affect anyone else.

$B:#$NCJ3,$G$O%m!<%+%k$J%j%]%8%H%j$H$O30It$X2?$N1F6A$b5Z$\$5$J$$%W%i%$%Y!<(B
$B%H$J(B``$B%5%s%I%\%C%/%9(B''$B$G!$$3$NCf$G$I$s$J$3$H$G$b;n$9$3$H$,$G$-$k$H2r<a$7(B
$B$F$*$1$P==J,$G$"$k!%(B

%\subsection{What's in a repository?}
\subsection{$B%j%]%8%H%j$K$O2?$,4^$^$l$k$+!)(B}

%When we take a more detailed look inside a repository, we can see that
%it contains a directory named \dirname{.hg}.  This is where Mercurial
%keeps all of its metadata for the repository.
%\interaction{tour.ls-a}

$B%j%]%8%H%j$NFbIt$r$h$j>\$7$/8+$F$_$k$H!$(B\dirname{.hg}$B$H$$$&%G%#%l%/%H%j(B
$B$,$"$k$N$K5$$E$/!%(BMercurial$B$O$3$3$K%j%]%8%H%j$N$?$a$N%a%?%G!<%?$rJ]4I$7(B
$B$F$$$k!%(B
\interaction{tour.ls-a}

%The contents of the \dirname{.hg} directory and its subdirectories are
%private to Mercurial.  Every other file and directory in the
%repository is yours to do with as you please.

\dirname{.hg}$B%G%#%l%/%H%j$NCf?H$H!$$3$N%G%#%l%/%H%j$N%5%V%G%#%l%/%H%j$O(B
Mercurial$B@lMQ$N$b$N$G$"$k!%%j%]%8%H%j$N$=$l0J30$N%U%!%$%k$H%G%#%l%/%H%j(B
$B$O%f!<%6$KB0$9!%(B

%To introduce a little terminology, the \dirname{.hg} directory is the
%``real'' repository, and all of the files and directories that coexist
%with it are said to live in the \emph{working directory}.  An easy way
%to remember the distinction is that the \emph{repository} contains the
%\emph{history} of your project, while the \emph{working directory}
%contains a \emph{snapshot} of your project at a particular point in
%history.

$B$3$3$G>/!9MQ8l$rDj5A$7$h$&$H;W$&!%(B\dirname{.hg}$B%G%#%l%/%H%j$r(B``$B%j%"%k(B''$B%j(B
$B%]%8%H%j!$$3$N%G%#%l%/%H%j$H0l=o$K07$o$l$k%U%!%$%k$d%G%#%l%/%H%j$r(B
\emph{$B%o!<%-%s%0%G%#%l%/%H%j(B}$B$H8F$V$3$H$K$9$k!%$3$l$i$r4JC1$K6hJL$9$k$?$a(B
$B$K!$(B\emph{$B%j%]%8%H%j(B}$B$O%W%m%8%'%/%H$N(B\emph{$BMzNr(B}$B$rJ]B8$7!$(B\emph{$B%o!<%-%s(B
$B%0%G%#%l%/%H%j(B}$B$O%W%m%8%'%/%H$NMzNr$NCf$N$"$k;~E@$N(B\emph{$B%9%J%C%W%7%g%C(B
$B%H(B}$B$r;}$D$H3P$($k$HNI$$!%(B

%\section{A tour through history}
\section{$BMzNr$rC)$k(B}

%One of the first things we might want to do with a new, unfamiliar
%repository is understand its history.  The \hgcmd{log} command gives
%us a view of the history of changes in the repository.
%\interaction{tour.log}
%By default, this command prints a brief paragraph of output for each
%change to the project that was recorded.  In Mercurial terminology, we
%call each of these recorded events a \emph{changeset}, because it can
%contain a record of changes to several files.

$BL$CN$N%j%]%8%H%j$KBP$7$F$^$:$7$h$&$H;W$&$3$H$O!$$=$N%j%]%8%H%j$G$NJQ99$N(B
$BMzNr$rCN$k$3$H$@$m$&!%MzNr$O(B\hgcmd{log}$B%3%^%s%I$G8+$k$3$H$,$G$-$k!%(B
\interaction{tour.log}
$B%G%U%)%k%H$G$O!$$3$N%3%^%s%I$O%W%m%8%'%/%H$KBP$7$F9T$o$l$?JQ99$N3F!9$K$D(B
$B$$$F4J7i$J%Q%i%0%i%U$rI=<($9$k!%(B Mercurial$B$NMQ8l$G$O!$MzNrCf$NJQ99$N%$%Y(B
$B%s%H$r(B\emph{$B%A%'%s%8%;%C%H(B}$B$H8F$V!%$=$NM}M3$O!$J#?t$N%U%!%$%k$KBP$9$kJQ99(B
$B$N5-O?$r;}$AF@$k$+$i$G$"$k!%(B

%The fields in a record of output from \hgcmd{log} are as follows.
\hgcmd{log}$B$+$i=PNO$5$l$k5-O?$N3F%U%#!<%k%I$O<!$N$h$&$K$J$C$F$$$k!%(B
\begin{itemize}
%\item[\texttt{changeset}] This field has the format of a number,
%	     followed by a colon, followed by a hexadecimal (or
%	     \emph{hex}) string.  These are \emph{identifiers} for the
%	     changeset.  The hex string is a unique identifier: the same
%	     hex string will always refer to the same changeset. The
%	     number is shorter and easier to type than the hex string,
%	     but it isn't unique: the same number in two different
%	     clones of a repository may identify different changesets.
%	     Why provide the number at all, then?  For local
%	     convenience.
\item[\texttt{changeset}] $BHV9f!$$=$l$KB3$/%3%m%s$*$h$S(B16$B?JJ8;zNs!%$3$l$O(B
	     $B%A%'%s%8%;%C%H$N(B\emph{$B<1JL;R(B}$B$G$"$k!%(B16$B?JJ8;zNs$O8GM-$N<1JL(B
	     $B;R$G!$F10l$N<1JL;R$O>o$KF1$8%A%'%s%8%;%C%H$r;X$9!%HV9f$OC;$/(B
	     $BF~NO$b(B16$B?JJ8;zNs$h$jMF0W$G$"$k$,!$%A%'%s%8%;%C%H$K8GM-$G$O$J(B
	     $B$$!%F1$8HV9f$G$b%j%]%8%H%j$NJL$N%/%m!<%s$G$O!$0c$&%A%'%s%8%;%C(B
	     $B%H$r;X$92DG=@-$,$"$k!%HV9f$OC1$K%m!<%+%k$JMxJX$N$?$a$KDs6!$5(B
	     $B$l$F$$$k!%(B
%\item[\texttt{user}] The identity of the person who created the
%  changeset.  This is a free-form field, but it most often contains a
%  person's name and email address.
 \item[\texttt{user}] $B%A%'%s%8%;%C%H:n@.<T!%$3$N%U%#!<%k%I$N=q<0$O<+M3$@(B
	      $B$,!$$[$H$s$I$N>l9g;aL>$H(Bemail$B%"%I%l%9$G$"$k!%(B
%\item[\texttt{date}] The date and time on which the changeset was
%  created, and the timezone in which it was created.  (The date and
%  time are local to that timezone; they display what time and date it
%  was for the person who created the changeset.)
 \item[\texttt{date}] $B%A%'%s%8%;%C%H$,:n@.$5$l$?F|IU$H;~9o$*$h$S%?%$%`%>!<(B
	      $B%s!%(B $B!JF|;~$O%A%'%s%8%;%C%H$N:n@.<T$NB0$9%?%$%`%>!<%s$K%m!<(B
	      $B%+%k$G$"$k!%!K(B
%\item[\texttt{summary}] The first line of the text message that the
%  creator of the changeset entered to describe the changeset.
 \item[\texttt{summary}] $B%F%-%9%H%a%C%;!<%8$N:G=i$N9T$O%A%'%s%8%;%C%H$N@b(B
	     $BL@$KF~NO$5$l$?%A%'%s%8%;%C%H$N:n@.<T$G$"$k!%(B
% \item Some changesets, such as the first in the list above, have a
%	     \texttt{tag} field.  A tag is another way to identify a
%	     changeset, by giving it an easy-to-remember name. (The tag
%	     named \texttt{tip} is special: it always refers to the
%	     newest change in a repository.)
 \item $B>e$N%j%9%H$N:G=i$N%A%'%s%8%;%C%H$N$h$&$K(B\texttt{tag}$B%U%#!<%k%I$r;}(B
       $B$D%A%'%s%8%;%C%H$b$"$k!%%?%0$O%A%'%s%8%;%C%H$r<1JL$9$k$?$a$N$b$&(B
       $B0l$D$NJ}K!$G!$3P$($d$9$$L>A0$r<+M3$KIU$1$k$3$H$,$G$-$k!%!J%?%0(B
       \texttt{tip}$B$OFCJL$G!$>o$K%j%]%8%H%j$N:G?7$N%A%'%s%8%;%C%H$r;X$9!%!K(B
\end{itemize}
%The default output printed by \hgcmd{log} is purely a summary; it is
%missing a lot of detail.
\hgcmd{log}$B$N%G%U%)%k%H=PNO$OMWLs$K$9$.$:!$B?$/$N>\:Y>pJs$r7g$$$F$$$k!%(B

%Figure~\ref{fig:tour-basic:history} provides a graphical representation of
%the history of the \dirname{hello} repository, to make it a little
%easier to see which direction history is ``flowing'' in.  We'll be
%returning to this figure several times in this chapter and the chapter
%that follows.

$B?^(B~\ref{fig:tour-basic:history}$B$O(B\dirname{hello}$B%j%]%8%H%j$NMzNr$r%0%i%UI=(B
$B<($7$?$b$N$G$"$k!%$3$NI=<($K$h$C$F$I$NJ}8~$NMzNr$,=gJ}8~$J$N$+M}2r$7$d$9(B
$B$/$J$C$F$$$k!%:#8e!$$3$N?^$r2?EY$+;2>H$9$k!%(B

\begin{figure}[ht]
  \centering
  \grafix{tour-history}
%  \caption{Graphical history of the \dirname{hello} repository}
  \caption{\dirname{hello}$B%j%]%8%H%j$NMzNr%0%i%U(B}
 \label{fig:tour-basic:history}
\end{figure}

%\subsection{Changesets, revisions, and talking to other people}
\subsection{$B%A%'%s%8%;%C%H(B, $B%j%S%8%g%s(B, $BB>$N%f!<%6$H$N$d$j$H$j(B}

%As English is a notoriously sloppy language, and computer science has
%a hallowed history of terminological confusion (why use one term when
%four will do?), revision control has a variety of words and phrases
%that mean the same thing.  If you are talking about Mercurial history
%with other people, you will find that the word ``changeset'' is often
%compressed to ``change'' or (when written) ``cset'', and sometimes a
%changeset is referred to as a ``revision'' or a ``rev''.

$B1Q8l$O$$$$2C8:$J$3$H$G0-L>$N9b$$8@8l$G$"$j!$%3%s%T%e!<%?%5%$%(%s%9$G$O@l(B
$BLgMQ8l$N:.Mp$,?S$@$7$$!%!J(B4$B?M$,(B1$B$D$NMQ8l$r;H$&$3$H$J$IM-$jF@$J$$!%!K%j%S(B
$B%8%g%s%3%s%H%m!<%k$OBt;3$NF15A8l$r;}$C$F$$$k!%B>$N?M$H(BMercurial$B$NMzNr$K$D(B
$B$$$FOC$9$H$-!$(B``$B%A%'%s%8%;%C%H(B''$B$,$7$P$7$P(B``$B%A%'%s%8(B''$B$KN,$5$l$?$j!$=q$-(B
$B8@MU$G$O(B``cset''$B$J$I$H$5$l$?$j!$;~$K$O%A%'%s%8%;%C%H$,(B``$B%j%S%8%g%s(B''$B$d(B
``rev''$B$HI=$5$l$?$j$9$k$3$H$K5$$E$/$@$m$&!%(B

%While it doesn't matter what \emph{word} you use to refer to the
%concept of ``a~changeset'', the \emph{identifier} that you use to
%refer to ``a~\emph{specific} changeset'' is of great importance.
%Recall that the \texttt{changeset} field in the output from
%\hgcmd{log} identifies a changeset using both a number and a
%hexadecimal string.

``a~changeset''$B$H$$$&%A%'%s%8%;%C%H$N(B\emph{$B8F$SL>(B}$B$O<+M3$@$,!$(B
``a~\emph{specific} changeset''$B$r;2>H$9$k(B\emph{$B<1JL;R(B}$B$OHs>o$K=EMW$G$"$k!%(B
\hgcmd{log}$B%3%^%s%I$N=PNO$K4^$^$l$k(B\texttt{changeset}$B%U%#!<%k%I$O!$$"$k%A%'(B
$B%s%8%;%C%H$rHV9f$H(B16$B?JJ8;zNs$GI=$7$F$$$?$3$H$r;W$$=P$7$FM_$7$$!%(B

%\begin{itemize}
%\item The revision number is a handy notation that \emph{only valid in
%      that repository}.
%\item The hexadecimal string is the \emph{permanent, unchanging
%    identifier} that will always identify that exact changeset in
%  \emph{every} copy of the repository.
%\end{itemize}
\begin{itemize}
\item $B%j%S%8%g%sHV9f$O(B\emph{$B$=$N%j%]%8%H%j$K8B$C$FM-8z(B}$B$J4JJX5-K!$G$"$k!%(B
\item 16$B?JJ8;zNs$O(B\emph{$B1JB3E*$+$DITJQ$N<1JL;R(B}$B$G!$%j%]%8%H%j$N%3%T!<(B
      \emph{$BA4$F(B}$B$G>o$KFCDj$N%A%'%s%8%;%C%H$r<($9!%(B
\end{itemize}

%This distinction is important.  If you send someone an email talking
%about ``revision~33'', there's a high likelihood that their
%revision~33 will \emph{not be the same} as yours.  The reason for this
%is that a revision number depends on the order in which changes
%arrived in a repository, and there is no guarantee that the same
%changes will happen in the same order in different repositories.
%Three changes $a,b,c$ can easily appear in one repository as $0,1,2$,
%while in another as $0,2,1$.

$B$3$N6hJL$O=EMW$G$"$k!%C/$+$K(B``revision~33''$B$H8@$C$?;~!$$=$N%j%S%8%g%s(B33$B$,(B
$B<+J,$N%j%]%8%H%j$N%j%]%8%H%j$N$b$N$H$O(B\emph{$B0c$&$b$N$G$"$k(B}$B2DG=@-$O9b$$!%(B
$B$=$NM}M3$O!$%j%S%8%g%sHV9f$O%j%]%8%H%j$KJQ99$,8=$l$?=g=x$K$h$C$F7h$^(B
$B$j!$(BMercurial$B$G$OJL$N%j%]%8%H%j$GF1$8JQ99$,F1$8=g=x$G5/$3$kJ]>Z$O$J$$$?$a(B
$B$G$"$k!%(B 3$B$D$NJQ99(B$a,b,c$$B$O!$$"$k%j%]%8%H%j$G(B$0,1,2$$B$N=g$G5/$3$j!$JL$N%j(B
$B%]%8%H%j$G$O(B$0,2,1$$B$N=g=x$G5/$3$jF@$k!%(B

%Mercurial uses revision numbers purely as a convenient shorthand.  If
%you need to discuss a changeset with someone, or make a record of a
%changeset for some other reason (for example, in a bug report), use
%the hexadecimal identifier.

Mercurial$B$O%j%S%8%g%sHV9f$rC1$KJXMx$N$?$a$NN,5-K!$H$7$FMQ$$$k!%C/$+$H%A%'(B
$B%s%8%;%C%H$K$D$$$F5DO@$7$?$j!$!J%P%0Js9p$J$I$N$?$a$K!K%A%'%s%8%;%C%H$r5-(B
$BO?$7$?$$>l9g$O(B16$B?J$N<1JL;R$rMxMQ$9$Y$-$G$"$k!%(B

%\subsection{Viewing specific revisions}
\subsection{$BFCDj$N%j%S%8%g%s$r8+$k(B}

%To narrow the output of \hgcmd{log} down to a single revision, use the
%\hgopt{log}{-r} (or \hgopt{log}{--rev}) option.  You can use either a
%revision number or a hexadecimal changeset identifier, and you can
%provide as many revisions as you want.  \interaction{tour.log-r}

\hgcmd{log}$B$N=PNO$r$"$k(B1$B$D$N%j%S%8%g%s$K@)8B$9$k$?$a$K$O!$(B
\hgopt{log}{-r}$B!J$^$?$O(B \hgopt{log}{--rev}$B!K%*%W%7%g%s$rMQ$$$k!%%j%S%8%g(B
$B%sHV9f$b(B16$B?JJ8;zNs$N%A%'%s%8%;%C%H<1JL;R$bMxMQ2DG=$G$"$j!$;XDj$G$-$k%j%S(B
$B%8%g%s$N?t$K@)8B$O$J$$!%(B
\interaction{tour.log-r}

%If you want to see the history of several revisions without having to
%list each one, you can use \emph{range notation}; this lets you
%express the idea ``I want all revisions between $a$ and $b$,
%inclusive''.
%\interaction{tour.log.range}
%Mercurial also honours the order in which you specify revisions, so
%\hgcmdargs{log}{-r 2:4} prints $2,3,4$ while \hgcmdargs{log}{-r 4:2}
%prints $4,3,2$.

$B$$$/$D$+$N%j%S%8%g%s$NMzNr$r!$$$$A$$$A%j%S%8%g%s$r;XDj$9$k$3$H$J$/8+$?$$(B
$B;~$O!$(B\emph{$BHO0O5-K!(B}$B$,;H$($k!%$3$l$K$h$j(B``$a$$B$+$i(B$b$$B$^$G$K4^$^$l$kA4$F$N(B
$B%j%S%8%g%s(B''$B$r;XDj$9$k$3$H$,$G$-$k!%(B
\interaction{tour.log.range}
Mercurial$B$O%j%S%8%g%s$,;XDj$5$l$?=g=x$r9MN8$9$k!%(B\hgcmdargs{log}{-r 2:4}
$B$O(B$2,3,4$$B$N=g$KI=<($7!$(B\hgcmdargs{log}{-r 4:2}$B$O(B$4,3,2$$B$N=g$KI=<($r9T$&!%(B

%\subsection{More detailed information}
\subsection{$B$h$j>\:Y$J>pJs(B}

%While the summary information printed by \hgcmd{log} is useful if you
%already know what you're looking for, you may need to see a complete
%description of the change, or a list of the files changed, if you're
%trying to decide whether a changeset is the one you're looking for.
%The \hgcmd{log} command's \hggopt{-v} (or \hggopt{--verbose})
%option gives you this extra detail.
%\interaction{tour.log-v}

$BC5$7$F$$$k$b$N$,$O$C$-$j$7$F$$$k>l9g$O(B\hgcmd{log}$B%3%^%s%I$K$h$k%5%^%j!<>p(B
$BJs$OM-MQ$@$,!$$I$N%A%'%s%8%;%C%H$,8+$D$1$h$&$H$9$k%A%'%s%8%;%C%H$J$N$+7h(B
$B$a$k;~$K$OJQ99$N40A4$J5-=R$dJQ99$5$l$?%U%!%$%k$N%j%9%H$,I,MW$K$J$k$+$b$7(B
$B$l$J$$!%(B\hgcmd{log}$B%3%^%s%I$N(B\hggopt{-v}$B!J$^$?$O(B\hggopt{--verbose}$B!K%*%W(B
$B%7%g%s$G$h$j>\:Y$J>pJs$r8+$k$3$H$,$G$-$k!%(B
\interaction{tour.log-v}

%If you want to see both the description and content of a change, add
%the \hgopt{log}{-p} (or \hgopt{log}{--patch}) option.  This displays
%the content of a change as a \emph{unified diff} (if you've never seen
%a unified diff before, see section~\ref{sec:mq:patch} for an overview).
%\interaction{tour.log-vp}

$B@bL@$HJQ99$NFbMF$NN>J}$r8+$?$$>l9g$O(B\hgopt{log}{-p}$B!J$^$?$O(B
\hgopt{log}{--patch}$B!K%*%W%7%g%s$rDI2C$9$k!%$3$N%*%W%7%g%s$OJQ99$NFbMF$r(B
\emph{unified diff}$B7A<0$GI=<($9$k!%!J(Bunified diff$B7A<0$r8+$?$3$H$,$J$1$l(B
$B$P35N,$r(B\ref{sec:mq:patch}$B@a$G8+$k$3$H$,$G$-$k!%!K(B
\interaction{tour.log-vp}

%The \hgopt{log}{-p} option is tremendously useful, so it's well worth
%remembering.

\hgopt{log}{-p}$B%*%W%7%g%s$O6C0[E*$KJXMx$J$N$G3P$($F$*$/$HNI$$!%(B

%\section{All about command options}
\section{$B%3%^%s%I%*%W%7%g%s$N$9$Y$F(B}

%Let's take a brief break from exploring Mercurial commands to discuss
%a pattern in the way that they work; you may find this useful to keep
%in mind as we continue our tour.

Mercurial$B%3%^%s%I$r;n$9$N$r0l5Y$_$7$F!$%3%^%s%I$NF0:n%Q%?!<%s$K$D$$$F5D(B
$BO@$7$F$_$h$&!%$3$l$O$3$N%D%"!<$rB3$1$k>e$GLr$KN)$D$@$m$&!%(B

%Mercurial has a consistent and straightforward approach to dealing
%with the options that you can pass to commands.  It follows the
%conventions for options that are common to modern Linux and Unix
%systems.
Mercurial$B$O%3%^%s%I$K%*%W%7%g%s$rEO$9:]$K0l4S@-$N$"$kD>@\E*$J%"%W%m!<%A$r(B
$B<h$C$F$$$k!%$3$l$O8=Be$N(BLinux$B$*$h$S(BUnix$B$K6&DL$N%*%W%7%g%s$K4X$9$k=,47$K4p(B
$B$E$$$F$$$k!%(B
\begin{itemize}
%\item Every option has a long name.  For example, as we've already
%  seen, the \hgcmd{log} command accepts a \hgopt{log}{--rev} option.
 \item $BA4$F$N%*%W%7%g%s$OD97A<0$N%*%W%7%g%s$r;}$D!%Nc$($P!$$9$G$K8+$F$$$k(B
       $B$h$&$K(B\hgcmd{log}$B%3%^%s%I$O(B\hgopt{log}{--rev}$B%*%W%7%g%s$r<u$1IU$1(B
       $B$k!%(B
%\item Most options have short names, too.  Instead of
%  \hgopt{log}{--rev}, we can use \hgopt{log}{-r}.  (The reason that
%  some options don't have short names is that the options in question
%  are rarely used.)
 \item $B$[$H$s$I$N%*%W%7%g%s$OC;=LL>$r;}$D!%(B\hgopt{log}{--rev}$B%*%W%7%g%s$N(B
       $BBe$o$j$K(B\hgopt{log}{-r}$B$,;H$($k!%!J$$$/$D$+$N%*%W%7%g%s$GC;=LL>$,(B
       $B;H$($J$$M}M3$O!$$=$N%*%W%7%g%s$,$[$H$s$I;HMQ$5$l$J$$$?$a$G$"$k!%!K(B
%\item Long options start with two dashes (e.g.~\hgopt{log}{--rev}),
%  while short options start with one (e.g.~\hgopt{log}{-r}).
 \item $BD97A<0$N%*%W%7%g%s$O(B2$B$D$N%@%C%7%e$G;O$^$k!JNc(B
       ~\hgopt{log}{--rev}$B!K!%0lJ}C;7A<0$N%*%W%7%g%s$O(B1$B$D$N%@%C%7%e$G;O$^(B
       $B$k!JNc(B ~\hgopt{log}{-r}$B!K!%(B
%\item Option naming and usage is consistent across commands.  For
%  example, every command that lets you specify a changeset~ID or
%  revision number accepts both \hgopt{log}{-r} and \hgopt{log}{--rev}
%  arguments.
 \item $B%*%W%7%g%s$NL?L>$H;HMQK!$O%3%^%s%I4V$G0l4S$7$F$$$k!%Nc$r5s$2$k$H!$(B
       $B%A%'%s%8%;%C%H(BID$B$^$?$O%j%S%8%g%sHV9f$r;XDj$5$;$k%3%^%s%I$NA4$F$G(B
       \hgopt{log}{-r}$B$H(B\hgopt{log}{--rev}$B$NN>J}$r<u$1IU$1$k!%(B
% \item If you are using short options, you can save typing by running
%       them together. For example, the command \hgopt{log}{-v -p -r 2}
%       can be written as \hgopt{log}{-vpr2}
 \item $BC;7A<0$N%*%W%7%g%s$r;H$C$F$$$k;~$O$"!$J#?t$N%*%W%7%g%s$rAH$_9g$o$;(B
       $B$FF~NO$N<j4V$r>J$/$3$H$,$G$-$k!%Nc$($P(B\hgopt{log}{-v -p -r 2}$B$O(B
       \hgopt{log}{-vpr2}$B$H=q$/$3$H$,$G$-$k!%(B
\end{itemize}
%In the examples throughout this book, I use short options instead of
%long.  This just reflects my own preference, so don't read anything
%significant into it.
$B$3$NK\$NNc$NA4$F$GC;7A<0$N%*%W%7%g%s$rMQ$$$k!%$3$l$OC1$KI.<T$N9%$_$N$?$a(B
$B$G!$?<$$0UL#$O$J$$!%(B

%Most commands that print output of some kind will print more output
%when passed a \hggopt{-v} (or \hggopt{--verbose}) option, and less
%when passed \hggopt{-q} (or \hggopt{--quiet}).
$BI=<(=PNO$r9T$&$[$H$s$I$N%3%^%s%I$G(B\hggopt{-v}$B!J$^$?$O(B\hggopt{--verbose}$B!K(B
$B%*%W%7%g%s$rIU$1$k$H$h$j>\:Y$J=PNO$r9T$$!$(B\hggopt{-q}$B!J$^$?$O(B
\hggopt{--quiet}$B!K%*%W%7%g%s$rIU$1$k$H$h$j4J7i$J=PNO$H$J$k!%(B

%\begin{note}
%Option naming consistency
%
%Almost always, Mercurial commands use consistent option names to refer
%to the same concepts.  For instance, if a command deals with changesets,
%you'll always identify them with \hgopt{log}{--rev} or \hgopt{log}{-r}

%This consistent use of option names makes it easier to remember what
%options a particular command takes.
%\end{note}

\begin{note}
$B%*%W%7%g%sL>$N0l4S@-(B

Mercurial$B%3%^%s%I$G$O!$F1$8BP>]$r07$&:]!$$[$H$s$I>o$KF1$8%*%W%7%g%sL>$r;H(B
$B$&$h$&$K$J$C$F$$$k!%Nc$r5s$2$k$H!$%A%'%s%8%;%C%H$r07$&%3%^%s%I$N>l9g$O>o(B
$B$K(B\hgopt{log}{--rev}$B$d(B\hgopt{log}{-r}$B$G%A%'%s%8%;%C%H$N;XDj$,$G$-$k!%$3$N(B
$B0l4S@-$K$h$j!$AH$^$s$I$N%*%W%7%g%s$,3P$($d$9$/$J$C$F$$$k!%(B
\end{note}

%\section{Making and reviewing changes}
\section{$BJQ99$N;EJ}!$JQ99$N%l%S%e!<(B}

%Now that we have a grasp of viewing history in Mercurial, let's take a
%look at making some changes and examining them.

Mercurial$B$GMzNr$r8+$kJ}K!$K$D$$$F$OM}2r$7$?!%$3$3$G$O2?$+JQ99$r9T$C$F!$(B
$B$3$l$r8+$F$_$h$&!%(B

%The first thing we'll do is isolate our experiment in a repository of
%its own.  We use the \hgcmd{clone} command, but we don't need to
%clone a copy of the remote repository.  Since we already have a copy
%of it locally, we can just clone that instead.  This is much faster
%than cloning over the network, and cloning a local repository uses
%less disk space in most cases, too.
%\begin{footnote}
%The saving of space arises when source and destination repositories are
%on the same filesystem, in which case Mercurial will use hardlinks to do
%copy-on-write sharing of its internal metadata.  If that explanation
%meant nothing to you, don't worry: everything happens transparently and
%automatically, and you don't need to understand it.
%\end{footnote}
%\interaction{tour.reclone}
%As an aside, it's often good practice to keep a ``pristine'' copy of a
%remote repository around, which you can then make temporary clones of
%to create sandboxes for each task you want to work on.  This lets you
%work on multiple tasks in parallel, each isolated from the others
%until it's complete and you're ready to integrate it back.  Because
%local clones are so cheap, there's almost no overhead to cloning and
%destroying repositories whenever you want.

$B$^$::G=i$K$3$N<B83$rK\Mh$N%j%]%8%H%j$+$i3VN%$9$k$?$a$K(B\hgcmd{clone}$B$r9T(B
$B$&!%$9$G$K%m!<%+%k$J%j%]%8%H%j$r;}$C$F$$$k$N$G!$$3$l$r%/%m!<%s$9$k$@$1$G(B
$B$h$/!$%j%b!<%H$N%j%]%8%H%j$r%3%T!<$9$kI,MW$O$J$$!%%m!<%+%k$J%/%m!<%s$O%M%C(B
$B%H%o!<%/1[$7$K9T$&%/%m!<%s$h$j$b$:$C$HB.$/!$B?$/$N>l9g;HMQ$9$k%G%#%9%/MF(B
$BNL$b>/$J$$!%(B
\begin{footnote}
$BF10l%U%!%$%k%7%9%F%`>e$G%j%]%8%H%j$N%/%m!<%s$r9T$&>l9g!$(B Mercurial$B$O%O!<(B
$B%I%j%s%/$r;H$$!$FbIt%a%?%G!<%?$r%3%T!<%*%s%i%$%H$G6&M-$7!$%G%#%9%/;HMQNL(B
$B$N@aLs$r9T$&!%$3$N@bL@$,$h$/$o$+$i$J$/$F$b?4G[$9$kI,MW$O$J$$!%$3$NF0:n$O(B
$B$9$Y$FF)2aE*$+$D<+F0E*$K9T$o$l$k$?$a!$5$$K$9$kI,MW$O$J$$!%(B
\end{footnote}
\interaction{tour.reclone}
$B$^$?!$2?$+:n6H$r$7$?$$;~$K%5%s%I%\%C%/%9$H$9$k$?$a$K0l;~E*$J%/%m!<%s$r:n(B
$B@.$7!$%j%b!<%H%j%]%8%H%j$N%3%T!<$r(B``$B@67i(B''$B$KJ]$D$3$H$O$7$P$7$PLr$KN)$D!%(B
$B$3$l$K$h$jJ#?t$N:n6H$rJB9T$7$F9T$&$3$H$,$G$-!$$+$D!$:n6H$,40N;$7!$:F$SE}(B
$B9g$9$k$^$GB>$N:n6H$+$i3VN%$5$l$?$^$^$K$7$F$*$/$3$H$,$G$-$k!%%j%]%8%H%j$N(B
$B%m!<%+%k%/%m!<%s$O$H$F$b<j7Z$G!$%/%m!<%s$HGQ4~$K$[$H$s$I%*!<%P%X%C%I$,$J(B
$B$$!%(B

%In our \dirname{my-hello} repository, we have a file
%\filename{hello.c} that contains the classic ``hello, world'' program.
%\interaction{tour.cat1}
\dirname{my-hello}$B%j%]%8%H%jFb$K$O%/%i%7%C%/$J(B``hello, world''$B%W%m%0%i%`(B
$B$G$"$k(B\filename{hello.c}$B$,$"$k!%(B
\interaction{tour.cat1}

%Let's edit this file so that it prints a second line of output.
%\interaction{tour.cat2}
$B$3$N%U%!%$%k$r(B2$B9TL\$,=PNO$5$l$k$h$&$KJT=8$9$k!%(B
\interaction{tour.cat2}

%Mercurial's \hgcmd{status} command will tell us what Mercurial knows
%about the files in the repository.
%\interaction{tour.status}
%The \hgcmd{status} command prints no output for some files, but a line
%starting with ``\texttt{M}'' for \filename{hello.c}.  Unless you tell
%it to, \hgcmd{status} will not print any output for files that have
%not been modified.
$B%j%]%8%H%jFb$N%U%!%$%k$KBP$7$F(BMercurial$B$,GD0.$7$F$$$kFbMF$r(B
\hgcmd{status}$B%3%^%s%I$G8+$k$3$H$,$G$-$k!%(B
\interaction{tour.status}
\hgcmd{status}$B%3%^%s%I$O$$$/$D$+$N%U%!%$%k$KBP$7$F$O=PNO$r9T$o$J$$$,!$(B
\filename{hello.c}$B$KBP$7$F(B``\texttt{M}''$B$rI=<($9$k!%FC$K;X<($r$7$J$$>l(B
$B9g!$(B\hgcmd{status}$B%3%^%s%I$OJQ99$5$l$F$$$J$$%U%!%$%k$KBP$7$F$O2?$b=PNO$7(B
$B$J$$!%(B

%The ``\texttt{M}'' indicates that Mercurial has noticed that we
%modified \filename{hello.c}.  We didn't need to \emph{inform}
%Mercurial that we were going to modify the file before we started, or
%that we had modified the file after we were done; it was able to
%figure this out itself.

``\texttt{M}''$B$N0UL#$O!$(B\filename{hello.c}$B$KBP$7$F9T$o$l$?JQ99$r(B
Mercurial$B$,GD0.$7$?$H$$$&$3$H$G$"$k!%%U%!%$%k$NJQ99A0$K(BMercurial$B$K$3$l$+(B
$B$iJQ99$9$k%U%!%$%k$rEPO?$9$kI,MW$O$J$$$7!$JQ998e$K9T$&I,MW$b$J$$!%JQ99$5(B
$B$l$?%U%!%$%k$NH/8+$O<+F0E*$K9T$o$l$k!%(B

%It's a somewhat helpful to know that we've modified
%\filename{hello.c}, but we might prefer to know exactly \emph{what}
%changes we've made to it.  To do this, we use the \hgcmd{diff}
%command.
%\interaction{tour.diff}

\filename{hello.c}$B$rJT=8$7$?$3$H$,J,$+$k$N$OB?>/Lr$KN)$D$,!$CN$j$?$$$N$O(B
$B$`$7$m(B\emph{$B2?$r(B}$BJQ99$7$?$N$+$G$"$k!%(B\hgcmd{diff}$B%3%^%s%I$r;H$($P$3$l$rCN(B
$B$k$3$H$,$G$-$k!%(B \interaction{tour.diff}

%\begin{note}
%Understanding patches
%
%Remember to take a look at section~\ref{sec:mq:patch} if you don't know
%how to read output above.
%\end{note}

\begin{note}
$B%Q%C%A$K$D$$$F(B

$B>e$N=PNO$NFI$_J}$,J,$+$i$J$$>l9g$O!$(B\ref{sec:mq:patch}$B@a$r;2>H$5$l$?$$!%(B
\end{note}

%\section{Recording changes in a new changeset}
\section{$B?7$?$J%A%'%s%8%;%C%H$XJQ99$r5-O?$9$k(B}

%We can modify files, build and test our changes, and use
%\hgcmd{status} and \hgcmd{diff} to review our changes, until we're
%satisfied with what we've done and arrive at a natural stopping point
%where we want to record our work in a new changeset.

$B%U%!%$%k$rJQ99$7!$%S%k%I$H%F%9%H$r9T$$!$(B\hgcmd{status}$B$H(B\hgcmd{diff}$B$r;H$C(B
$B$FJQ99$N%l%S%e!<$r9T$$!$5$$N:Q$`$H$3$m$^$G$3$l$r7+JV$7!$;E;v$N7k2L$r?7$?(B
$B$J%A%'%s%8%;%C%H$K5-O?$9$k!%(B

%The \hgcmd{commit} command lets us create a new changeset; we'll
%usually refer to this as ``making a commit'' or ``committing''.

$B?7$?$J%A%'%s%8%;%C%H$r:n@.$9$k$K$O(B\hgcmd{commit}$B%3%^%s%I$r;H$&!%(B
$B$3$NA`:n$r$h$/(B``$B%3%_%C%H$9$k(B''$B$H$+(B``$B%3%_%C%H(B''$B$H8F$V!%(B

%\subsection{Setting up a username}
\subsection{$B%f!<%6L>$r@_Dj$9$k(B}

%When you try to run \hgcmd{commit} for the first time, it is not
%guaranteed to succeed.  Mercurial records your name and address with
%each change that you commit, so that you and others will later be able
%to tell who made each change.  Mercurial tries to automatically figure
%out a sensible username to commit the change with.  It will attempt
%each of the following methods, in order:

$B:G=i$K(B\hgcmd{commit}$B$r<B9T$9$k>l9g!$<B9T$,@.8y$9$k$+$I$&$+$OJ]>Z$5$l$F$$(B
$B$J$$!%$9$Y$F$N%3%_%C%H$G(BMercurial$B$O%f!<%6$NL>A0$H%"%I%l%9$r5-O?$7!$8e$GC/(B
$B$,$=$NJQ99$r9T$C$?$N$+J,$+$k$h$&$K$7$F$$$k!%(B Mercurial$B$OJQ99$r%3%_%C%H$9(B
$B$k:]$K<+F0E*$KBEEv$J%f!<%6L>$rIU$1$h$&$H$9$k!%(B
$B%f!<%6L>$N?dB,$O0J2<$N$h$&$J=g=x$G9T$o$l$k!'(B
\begin{enumerate}
%\item If you specify a \hgopt{commit}{-u} option to the \hgcmd{commit}
%  command on the command line, followed by a username, this is always
%  given the highest precedence.
 \item \hgcmd{commit}$B%3%^%s%I$K(B\hgopt{commit}{-u}$B%*%W%7%g%s$H%f!<%6L>$rIU(B
       $B$1$?>l9g!$$3$l$,:G$bM%@h$5$l$k!%(B
%\item If you have set the \envar{HGUSER} environment variable, this is
%  checked next.
 \item $B4D6-JQ?t(B\envar{HGUSER}$B$r@_Dj$7$F$$$k>l9g$O<!$K$3$l$,;2>H$5$l$k!%(B
%\item If you create a file in your home directory called
%  \sfilename{.hgrc}, with a \rcitem{ui}{username} entry, that will be
%  used next.  To see what the contents of this file should look like,
%  refer to section~\ref{sec:tour-basic:username} below.
 \item $B%[!<%`%G%#%l%/%H%j$K(B\sfilename{.hgrc}$B%U%!%$%k$r:n$C$F$$$k>l(B
       $B9g!$(B\rcitem{ui}{username}$B%(%s%H%j$,<!$K;2>H$5$l$k!%$3$N%U%!%$%k$N(B
       $BFbMF$O(B\ref{sec:tour-basic:username}$B@a$G@bL@$7$F$$$k!%(B
%\item If you have set the \envar{EMAIL} environment variable, this
%  will be used next.
 \item $B4D6-JQ?t(B\envar{EMAIL}$B$r@_Dj$7$F$$$k$J$i<!$K$3$l$,;2>H$5$l$k!%(B
%\item Mercurial will query your system to find out your local user
%  name and host name, and construct a username from these components.
%  Since this often results in a username that is not very useful, it
%  will print a warning if it has to do this.
 \item Mercurial$B$O%7%9%F%`$K%m!<%+%k%f!<%6L>$H%[%9%HL>$rLd$$9g$o$;!$$3$l(B
       $B$i$+$i%3%_%C%H%f!<%6L>$r9=@.$9$k!%$3$N%f!<%6L>$OLr$KN)$?$J$$$3$H$,(B
       $BB?$$$?$a!$$3$NJ}K!$r;H$C$?>l9g$O7Y9p%a%C%;!<%8$,I=<($5$l$k!%(B
\end{enumerate}
%If all of these mechanisms fail, Mercurial will fail, printing an
%error message.  In this case, it will not let you commit until you set
%up a username.
$B$3$l$i$N%a%+%K%:%`$N$9$Y$F$,<:GT$7$?>l9g!$(BMercurial$B$O%(%i!<%a%C%;!<%8$r(B
$BI=<($7$F<B9T$rCGG0$9$k!%$3$N>l9g!$%f!<%6L>$r@_Dj$9$k$^$G%3%_%C%H$9$k$3$H(B
$B$O$G$-$J$$!%(B

%You should think of the \envar{HGUSER} environment variable and the
%\hgopt{commit}{-u} option to the \hgcmd{commit} command as ways to
%\emph{override} Mercurial's default selection of username.  For normal
%use, the simplest and most robust way to set a username for yourself
%is by creating a \sfilename{.hgrc} file; see below for details.

$B4D6-JQ?t(B\envar{HGUSER}$B$H(B\hgcmd{commit}$B%3%^%s%I$N(B\hgopt{commit}{-u}$B%*%W%7%g(B
$B%s$O!$(BMercurial$B$,%G%U%)%k%H$G@_Dj$9$k%f!<%6L>$r(B\emph{$B%*!<%P%i%$%I(B}$B$9$kJ}(B
$BK!$@$H9M$($k$H$h$$!%DL>o$NMxMQK!$G%f!<%6L>$r@_Dj$9$k:G$b4JC1$G:G$b4h6/$J(B
$BJ}K!$O(B\sfilename{.hgrc}$B%U%!%$%k$r:n@.$9$k$3$H$G$"$k!%$3$N$d$jJ}$K$D$$$F<!(B
$B$K=R$Y$k!%(B

%\subsubsection{Creating a Mercurial configuration file}
\subsubsection{Mercurial$B$N@_Dj%U%!%$%k$r:n@.$9$k(B}
\label{sec:tour-basic:username}

%To set a user name, use your favorite editor to create a file called
%\sfilename{.hgrc} in your home directory.  Mercurial will use this
%file to look up your personalised configuration settings.  The initial
%contents of your \sfilename{.hgrc} should look like this.
%\begin{footnote}
%Figure out what the appropriate directory is on Windows.
%\end{footnote}
%\begin{codesample2}
%  # This is a Mercurial configuration file.
%  [ui]
%  username = Firstname Lastname <email.address@domain.net>
%\end{codesample2}
%The ``\texttt{[ui]}'' line begins a \emph{section} of the config file,
%so you can read the ``\texttt{username = ...}'' line as meaning ``set
%the value of the \texttt{username} item in the \texttt{ui} section''.
%A section continues until a new section begins, or the end of the
%file.  Mercurial ignores empty lines and treats any text from
%``\texttt{\#}'' to the end of a line as a comment.

$B%f!<%6L>$r@_Dj$9$k$K$O9%$_$N%(%G%#%?$G%[!<%`%G%#%l%/%H%j$K(B
\sfilename{.hgrc}$B$H$$$&%U%!%$%k$r:n@.$9$k!%(B Mercurial$B$O$3$N%U%!%$%k$+$i8D(B
$B?M@_Dj$r<hF@$7!$;HMQ$9$k!%(B\sfilename{.hgrc}$B%U%!%$%k$N:G=i$NFbMF$O0J2<$N$h(B
$B$&$J=q<0$K$9$k!%(B
\footnote{Windows$B$G$NE,@Z$J%G%#%l%/%H%j$r<($9$3$H!%(B}
\begin{codesample2}
  # This is a Mercurial configuration file.
  [ui]
  username = Firstname Lastname <email.address@domain.net>
\end{codesample2}
``\texttt{[ui]}''$B$N9T$G@_Dj%U%!%$%k$N(B\emph{$B%;%/%7%g%s(B}$B$,;O$^$k!%(B
``\texttt{username = ...}''$B$N9T$O(B``\texttt{ui}$B%;%/%7%g%s$N(B
\texttt{username}$B9`L\$NCM$r@_Dj$9$k(B''$B$HFI$`$3$H$,$G$-$k!%(B
$B%;%/%7%g%s$O?7$?$JJL$N%;%/%7%g%s$,;O$^$k$+!$%U%!%$%k$,=*N;$9$k$^$GB3(B
$B$/!%(BMercurial$B$O6u9T$rL5;k$7!$(B``\texttt{\#}''$B$+$i9TKv$^$G$r%3%a%s%H$H$7$F(B
$B07$&!%(B

%\subsubsection{Choosing a user name}
\subsubsection{$B%f!<%6L>$rA*$V(B}

%You can use any text you like as the value of the \texttt{username}
%config item, since this information is for reading by other people,
%but will not be interpreted by Mercurial.  The convention that most
%people follow is to use their name and email address, as in the example
%above.

\texttt{username}$B$N@_Dj$K;HMQ$9$kJ8;zNs$O!$B>$N%f!<%6$,FI$`>pJs$G$"$k$K2a(B
$B$.$:!$(BMercurial$B$K$h$C$F=hM}$5$l$k$b$N$G$O$J$$$?$a!$$I$N$h$&$JJ8;zNs$G$b9=(B
$B$o$J$$!%B?$/$N%f!<%6$,=>$&=,47$O!$>e$NNc$N$h$&$KL>A0$H(Bemail$B%"%I%l%9$r;H$&(B
$B$b$N$G$"$k!%(B

\begin{note}
%  Mercurial's built-in web server obfuscates email addresses, to make
%  it more difficult for the email harvesting tools that spammers use.
%  This reduces the likelihood that you'll start receiving more junk
%  email if you publish a Mercurial repository on the web.
Mercurial$B$NAH$_9~$_%&%'%V%5!<%P$O(Bemail$B%"%I%l%9$r%9%Q%^!<$,;H$&(Bemail$B<}=&%D!<(B
$B%k$K=&$o$lFq$/$9$k$h$&$K2~JQ$7!$(BMercurial$B%j%]%8%H%j$r%&%'%V$G8x3+$7$F$b%9(B
$B%Q%`$r<u$1<h$jFq$/$7$F$$$k!%(B
\end{note}

%\subsection{Writing a commit message}
\subsection{$B%3%_%C%H%a%C%;!<%8$r=q$/(B}

%When we commit a change, Mercurial drops us into a text editor, to
%enter a message that will describe the modifications we've made in
%this changeset.  This is called the \emph{commit message}.  It will be
%a record for readers of what we did and why, and it will be printed by
%\hgcmd{log} after we've finished committing.
%\interaction{tour.commit}

$BJQ99$r%3%_%C%H$9$k;~!$(BMercurial$B$O%A%'%s%8%;%C%H$G9T$C$?JQ99$K$D$$$F@bL@$9(B
$B$k%a%C%;!<%8$rF~NO$5$;$k$?$a$K%F%-%9%H%(%G%#%?$r5/F0$9$k!%(B
$B$3$l$O(B\emph{$B%3%_%C%H%a%C%;!<%8(B}$B$H8F$P$l$k!%(B
$B$3$l$O2?$r$J$<JQ99$7$?$N$+FI$_<j$KEA$($k$b$N$G!$%3%_%C%H40N;8e$K(B
\hgcmd{log}$B$GI=<($9$k$3$H$,$G$-$k!%(B
\interaction{tour.commit}

%The editor that the \hgcmd{commit} command drops us into will contain
%an empty line or two, followed by a number of lines starting with
%``\texttt{HG:}''.
%%\begin{codesample2}
%This is where I type my commit comment.
%
%HG: Enter commit message.  Lines beginning with 'HG:' are removed.
%HG: --
%HG: user: Bryan O'Sullivan <bos@serpentine.com>
%HG: branch 'default'
%HG: changed hello.c</programlisting>
%\end{codesample2}
%Mercurial ignores the lines that start with ``\texttt{HG:}''; it uses
%them only to tell us which files it's recording changes to.  Modifying
%or deleting these lines has no effect.

\hgcmd{commit}$B%3%^%s%I$,5/F0$9$k%(%G%#%?$O!$6u9T$H(B``\texttt{HG:}''$B$G;O$^(B
$B$k?t9T$r$9$G$K4^$s$G$$$k!%(B
\begin{codesample2}
This is where I type my commit comment.

HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: --
HG: user: Bryan O'Sullivan <bos@serpentine.com>
HG: branch 'default'
HG: changed hello.c</programlisting>
\end{codesample2}
Mercurial$B$O(B``\texttt{HG:}''$B$G;O$^$k9T$rL5;k$9$k!%$3$l$i$N9T$O$I$N%U%!%$%k(B
$B$X$NJQ99$J$N$+$r%f!<%6$KEA$($k$@$1$NL\E*$GB8:_$9$k!%$3$l$i$N9T$rJQ99$7$?(B
$B$j>C5n$7$?$j$7$F$b2?$N1F6A$bM?$($J$$!%(B

%\subsection{Writing a good commit message}
\subsection{$B$h$$%3%_%C%H%a%C%;!<%8$N=q$-J}(B}

%Since \hgcmd{log} only prints the first line of a commit message by
%default, it's best to write a commit message whose first line stands
%alone.  Here's a real example of a commit message that \emph{doesn't}
%follow this guideline, and hence has a summary that is not readable.
%\begin{codesample2}
%  changeset:   73:584af0e231be
%  user:        Censored Person <censored.person@example.org>
%  date:        Tue Sep 26 21:37:07 2006 -0700
%  summary:     include buildmeister/commondefs.   Add an exports and install
%\end{codesample2}

$B%G%U%)%k%H$G$O(B\hgcmd{log}$B$O%3%_%C%H%a%C%;!<%8$N:G=i$N9T$7$+I=<($7$J$$$?$a(B
$B%3%_%C%H%a%C%;!<%8$N:G=i$N9T$O(B1$B9T$G407k$9$k$h$&$K=q$/$H$h$$!%(B
$B%,%$%I%i%$%s$K(B\emph{$B=>$o$J$$(B}$B$?$aFI$a$J$$%3%_%C%H%a%C%;!<%8$NNc$r<($9!%(B
\begin{codesample2}
  changeset:   73:584af0e231be
  user:        Censored Person <censored.person@example.org>
  date:        Tue Sep 26 21:37:07 2006 -0700
  summary:     include buildmeister/commondefs.   Add an exports and install
\end{codesample2}

%As far as the remainder of the contents of the commit message are
%concerned, there are no hard-and-fast rules.  Mercurial itself doesn't
%interpret or care about the contents of the commit message, though
%your project may have policies that dictate a certain kind of
%formatting.

$B%3%_%C%H%a%C%;!<%8$N;D$j$NItJ,$K$O873J$J%k!<%k$O$J$$!%%W%m%8%'%/%H$G%U%)!<(B
$B%^%C%H$K4X$7$FMW5a$9$k%]%j%7!<$,$"$C$?$H$7$F$b!$(BMercurial$B$O%3%_%C%H%a%C%;!<(B
$B%8$rCfCG$7$?$j!$FCJL$NG[N8$r$9$k$3$H$O$J$$!%(B

%My personal preference is for short, but informative, commit messages
%that tell me something that I can't figure out with a quick glance at
%the output of \hgcmdargs{log}{--patch}.

$B8D?ME*$K$O!$4J7i$+$D>pJs$,$"$j!$(B \hgcmdargs{log}{--patch}$B$r0l8+$7$?$@$1$G(B
$B$O$o$+$i$J$$ItJ,$K$D$$$F@bL@$7$?%3%_%C%H%a%C%;!<%8$,9%$_$G$"$k!%(B

%\subsection{Aborting a commit}
\subsection{$B%3%_%C%H$rCf;_$9$k(B}

%If you decide that you don't want to commit while in the middle of
%editing a commit message, simply exit from your editor without saving
%the file that it's editing.  This will cause nothing to happen to
%either the repository or the working directory.

$B%3%_%C%H%a%C%;!<%8$rJT=8Cf$K%3%_%C%H$r<h$j;_$a$?$/$J$C$?;~$O!$JT=8Cf$N%U%!(B
$B%$%k$r%;!<%V$;$:$K%(%G%#%?$r=*N;$9$l$P$h$$!%$3$&$9$k$H%j%]%8%H%j$K$b%o!<(B
$B%-%s%0%G%#%l%/%H%j$K$b2?$b5/$-$J$$!%(B

%If we run the \hgcmd{commit} command without any arguments, it records
%all of the changes we've made, as reported by \hgcmd{status} and
%\hgcmd{diff}.

\hgcmd{commit}$B%3%^%s%I$r0z?t$J$7$G<B9T$7$F$$$k>l9g!$(B\hgcmd{status}$B%3%^%s(B
$B%I$d(B\hgcmd{diff}$B%3%^%s%I$K8=$l$k$=$l$^$G$K9T$C$?JQ99$OJ]B8$5$l$k!%(B

%\subsection{Admiring our new handiwork}
\subsection{$B?7$?$J:n6H$r>N;?$9$k(B}

%Once we've finished the commit, we can use the \hgcmd{tip} command to
%display the changeset we just created.  This command produces output
%that is identical to \hgcmd{log}, but it only displays the newest
%revision in the repository.
%\interaction{tour.tip}
%We refer to the newest revision in the repository as the \emph{tip revision},
%or simply the \emph{tip}.

$B%3%_%C%H$N40N;8e!$(B\hgcmd{tip}$B%3%^%s%I$G:#:n@.$7$?%A%'%s%8%;%C%H$rCN$k$3$H(B
$B$,$G$-$k!%$3$N%3%^%s%I$N=PNO$O%j%]%8%H%j$N:G?7%j%S%8%g%s$N$_$rI=<($9$k$H(B
$B$$$&E@$r=|$1$P(B\hgcmd{log}$B$HA4$/F1$8$G$"$k!%(B
\interaction{tour.tip}
$B%j%]%8%H%j$N:G?7%j%S%8%g%s$O(B\emph{tip$B%j%S%8%g%s(B}$B$^$?$OC1$K(B\emph{tip}$B$H8F(B
$B$P$l$k!%(B

%By the way, the \hgcmpd{tip} command accepts many of the same options as
%\hgcmd{log}, so \hgopt{log}{-v} above indicates ``be verbose'',
%\hgopt{log}{-p} specifies ``print a patch''. The use of \hgopt{log}{-p}
%to print patches is another example of the consistent naming we
%mentioned earlier.

\hgcmd{tip}$B%3%^%s%I$G$O(B\hgcmd{log}$B%3%^%s%I$N%*%W%7%g%s$NB?$/$,;H$($k!%>e(B
$B5-$N(B\hgopt{log}{-v}$B$O(B``$B>iD9(B''$B$JI=<($r9T$&$7!$(B\hgopt{log}{-p}$B$O(B``$B%Q%C%A$N(B
$BI=<((B''$B$r9T$&!%(B\hgopt{log}{-p}$B$G%Q%C%A$,I=<($5$l$k$N$O!$A0=R$N%*%W%7%g%sL>(B
$B$N0l4S@-$r<($9$b$&0l$D$NNc$G$"$k!%(B

%\section{Sharing changes}
\section{$BJQ99$r6&M-$9$k(B}

%We mentioned earlier that repositories in Mercurial are
%self-contained.  This means that the changeset we just created exists
%only in our \dirname{my-hello} repository.  Let's look at a few ways
%that we can propagate this change into other repositories.

Mercurial$B$N%j%]%8%H%j$O<+8J=<B-E*$G$"$k$H$9$G$K=R$Y$?!%$D$^$j!$:#:n@.$7$?(B
$B%A%'%s%8%;%C%H$O(B\dirname{my-hello}$B%j%]%8%H%j$K$N$_B8:_$7$F$$$k!%$3$NJQ99(B
$B$rB>$N%j%]%8%H%j$KGH5Z$5$;$k$$$/$D$+$NJ}K!$r8+$F$_$h$&!%(B

%\subsection{Pulling changes from another repository}
\subsection{$BB>$N%j%]%8%H%j$+$iJQ99$r(Bpull$B$9$k(B}
\label{sec:tour:pull}

%To get started, let's clone our original \dirname{hello} repository,
%which does not contain the change we just committed.  We'll call our
%temporary repository \dirname{hello-pull}.
%\interaction{tour.clone-pull}

$B;O$a$k$KEv$?$C$F!$:#%3%_%C%H$7$?JQ99$r4^$^$J$$%*%j%8%J%k$N(B
\dirname{hello}$B%j%]%8%H%j$r%/%m!<%s$9$k!%$3$N0l;~E*$J%j%]%8%H%j$r(B
\dirname{hello-pull}$B$H8F$V$3$H$K$9$k!%(B
\interaction{tour.clone-pull}

%We'll use the \hgcmd{pull} command to bring changes from
%\dirname{my-hello} into \dirname{hello-pull}.  However, blindly
%pulling unknown changes into a repository is a somewhat scary
%prospect.  Mercurial provides the \hgcmd{incoming} command to tell us
%what changes the \hgcmd{pull} command \emph{would} pull into the
%repository, without actually pulling the changes in.
%\interaction{tour.incoming}

\hgcmd{pull}$B%3%^%s%I$GJQ99$r(B\dirname{my-hello}$B$+$i(B\dirname{hello-pull}$B$K(B
$B<h$j9~$`!%L$CN$NJQ99$rLUL\E*$K%j%]%8%H%j$K(Bpull$B$9$k$3$H$O>/!962$m$7(B
$B$$!%(BMercurial$B$K$O(B\hgcmd{pull}$B%3%^%s%I$G$I$N$h$&$JJQ99$,%j%]%8%H%j$K<h$j9~(B
$B$^$l$k$N$+$r<B:]$K$O(Bpull$B$9$k$3$H$J$/I=<($9$k(B\hgcmd{incoming}$B%3%^%s%I$,$"(B
$B$k!%(B
\interaction{tour.incoming}

%Suppose you're pulling changes from a repository on the network
%somewhere. While you are looking at the \hgcmd{incoming} output, and
%before you pull those changes, someone might have committed something in
%the remote repository. This means that it's possible to pull more
%changes than you saw when using \hgcmd{incoming}.

$B$*$=$i$/FI<T$O%M%C%H%o!<%/>e$N$I$3$+$+$i%j%]%8%H%j$r(Bpull$B$9$k$K0c$$$J$$!%(B
$BJQ99$r(Bpull$B$9$kA0!$(B\hgcmd{incoming}$B$N=PNO$r8+$F$$$k4V$KC/$+$,%j%b!<%H%j%](B
$B%8%H%j$K2?$+%3%_%C%H$9$k$3$H$bM-$jF@$k!%$3$N>l9g!$(B\hgcmd{incoming}$B$G8+$?(B
$B$b$N$h$j$bB?$/$NJQ99$,(Bpull$B$5$l$k$3$H$K$J$k!%(B

%Bringing changes into a repository is a simple matter of running the
%\hgcmd{pull} command, and telling it which repository to pull from.
%\interaction{tour.pull}
%As you can see from the before-and-after output of \hgcmd{tip}, we
%have successfully pulled changes into our repository.  There remains
%one step before we can see these changes in the working directory.

$BJQ99$r%j%]%8%H%j$K<h$j9~$`$N$O!$<h$j9~$_85$N%j%]%8%H%j$r;XDj$7$F(B
\hgcmd{pull}$B%3%^%s%I$r<B9T$9$k$@$1$N%7%s%W%k$JA`:n$G$"$k!%(B
\interaction{tour.pull}
pull$B$NA08e$N(B\hgcmd{tip}$B=PNO$G%j%]%8%H%j$X$NJQ99$N<h$j9~$_$K@.8y$7$?$+$I$&(B
$B$+$,$o$+$k!%%o!<%-%s%0%G%#%l%/%H%j$KJQ99$rH?1G$5$;$k$K$O$b$&(B1$B%9%F%C%W$,I,(B
$BMW$G$"$k!%(B

%\subsection{Updating the working directory}
\subsection{$B%o!<%-%s%0%G%#%l%/%H%j$r99?7$9$k(B}

%We have so far glossed over the relationship between a repository and
%its working directory.  The \hgcmd{pull} command that we ran in
%section~\ref{sec:tour:pull} brought changes into the repository, but
%if we check, there's no sign of those changes in the working
%directory.  This is because \hgcmd{pull} does not (by default) touch
%the working directory.  Instead, we use the \hgcmd{update} command to
%do this.
%\interaction{tour.update}

$B$3$3$^$G$O%j%]%8%H%j$H%o!<%-%s%0%G%#%l%/%H%j$N4X78$r$"$^$jL@3N$K$;$:$KMh(B
$B$?!%(B \ref{sec:tour:pull}$B@a$G(B\hgcmd{pull}$B%3%^%s%I$r;H$C$FJQ99$r%j%]%8%H%j(B
$B$K<h$j9~$s$@$,!$Cm0U?<$/8+$k$H!$$=$l$i$NJQ99$O%o!<%-%s%0%G%#%l%/%H%j$KH?(B
$B1G$5$l$F$$$J$+$C$?!%$3$l$O!$(B\hgcmd{pull}$B%3%^%s%I$O!J%G%U%)%k%H$G$O!K%o!<(B
$B%-%s%0%G%#%l%/%H%j$K<j$rIU$1$J$$$?$a$G$"$k!%%o!<%-%s%0%G%#%l%/%H%j$rA`:n(B
$B$9$k$?$a$K$O(B\hgcmd{update}$B%3%^%s%I$r;H$&!%(B
\interaction{tour.update}

%It might seem a bit strange that \hgcmd{pull} doesn't update the
%working directory automatically.  There's actually a good reason for
%this: you can use \hgcmd{update} to update the working directory to
%the state it was in at \emph{any revision} in the history of the
%repository.  If you had the working directory updated to an old
%revision---to hunt down the origin of a bug, say---and ran a
%\hgcmd{pull} which automatically updated the working directory to a
%new revision, you might not be terribly happy.

\hgcmd{pull}$B$,%o!<%-%s%0%G%#%l%/%H%j$r<+F0E*$K99?7$7$J$$$N$O$$$5$5$+4qL/(B
$B$K8+$($k$+$b$7$l$J$$!%$7$+$7$3$l$K$O$A$c$s$H$7$?M}M3$,$"$k!%%o!<%-%s%0%G%#(B
$B%l%/%H%j$O(B\hgcmd{update}$B$G%j%]%8%H%j$N$$$+$J$k%P!<%8%g%s$K$b99?7$G$-$k!%(B
$B%P%0$N860x$rC5$k$?$a$K%o!<%-%s%0%G%#%l%/%H%j$r8E$$%j%S%8%g%s$K$7$F$$$k;~!$(B
\hgcmd{pull}$B$r<B9T$7$?$?$a$K%o!<%-%s%0%G%#%l%/%H%j$,:G?7$N%j%S%8%g%s$K$J$C(B
$B$?$H$7$?$i!$<u$1$kHo32$O>/$J$/$J$$!%(B

%However, since pull-then-update is such a common thing to do,
%Mercurial lets you combine the two by passing the \hgopt{pull}{-u}
%option to \hgcmd{pull}.
%\begin{codesample2}
%  hg pull -u
%\end{codesample2}
%If you look back at the output of \hgcmd{pull} in
%section~\ref{sec:tour:pull} when we ran it without \hgopt{pull}{-u},
%you can see that it printed a helpful reminder that we'd have to take
%an explicit step to update the working directory:
%\begin{codesample2}
%  (run 'hg update' to get a working copy)
%\end{codesample2}

$B$7$+$7$J$,$i!$!V(Bpull$B8e$K99?7!W$H$$$&A`:n$O$H$F$b$h$/9T$o$l$k$?$a!$(B
\hgcmd{pull}$B%3%^%s%I$K$O$3$l$i(B2$B$D$NA`:n$r0lEY$K9T$&%*%W%7%g%s!$(B
\hgopt{pull}{-u}$B$,$"$k!%(B
\begin{codesample2}
  hg pull -u
\end{codesample2}
\ref{sec:tour:pull}$B@a$G(B\hgopt{pull}{-u}$B%*%W%7%g%s$J$7$G<B9T$5$l$F$$$k(B
\hgcmd{pull}$B%3%^%s%I$N=PNO$r2~$a$F8+$F$_$k$H!$%o!<%-%s%0%G%#%l%/%H%j$r(B
$BL@<(E*$K99?7$7$J$1$l$P$J$i$J$$$3$H$r<($9(B
\begin{codesample2}
  (run 'hg update' to get a working copy)
\end{codesample2}
$B$H$$$&Cm0U=q$-$,$"$k$N$K5$$E$/!%(B

%To find out what revision the working directory is at, use the
%\hgcmd{parents} command.
%\interaction{tour.parents}
%If you look back at figure~\ref{fig:tour-basic:history}, you'll see
%arrows connecting each changeset.  The node that the arrow leads
%\emph{from} in each case is a parent, and the node that the arrow
%leads \emph{to} is its child.  The working directory has a parent in
%just the same way; this is the changeset that the working directory
%currently contains.

$B%o!<%-%s%0%G%#%l%/%H%j$N8=:_$N%j%S%8%g%s$rD4$Y$k$K$O(B\hgcmd{parents}$B%3%^(B
$B%s%I$r;H$&!%(B
\interaction{tour.parents}
$B?^(B~\ref{fig:tour-basic:history}$B$r8+D>$9$H!$3F!9$N%A%'%s%8%;%C%H$r7k$VLp0u(B
$B$,$"$k!%Lp0u$N=P$F$$$k$H$3$m$,?F$G!$Lp0u$,<($7$F$$$k$H$3$m$,;R$G$"$k!%%o!<(B
$B%-%s%0%G%#%l%/%H%j$OF1MM$K(B1$B$D$N?F$r;}$A!$$3$l$,%o!<%-%s%0%G%#%l%/%H%j$,8=(B
$B:_99?7$5$l$F$$$k%A%'%s%8%;%C%H$G$"$k!%(B

%To update the working directory to a particular revision, give a
%revision number or changeset~ID to the \hgcmd{update} command.
%\interaction{tour.older}
%If you omit an explicit revision, \hgcmd{update} will update to the
%tip revision, as shown by the second call to \hgcmd{update} in the
%example above.

$BFCDj$N%j%S%8%g%s$K%o!<%-%s%0%G%#%l%/%H%j$r99?7$9$k$?$a$K(B
$B$O!$(B\hgcmd{update}$B%3%^%s%I$K%j%S%8%g%sHV9f$^$?$O%A%'%s%8%;%C%H(BID$B$rEO$9!%(B
\interaction{tour.older}
$BL@<(E*$K%j%S%8%g%s$rEO$5$J$+$C$?>l9g!$>e$NNc$G(B2$B2sL\$N(B\hgcmd{update}$B$N<B9T(B
$B$N$h$&$K(B\hgcmd{update}$B%3%^%s%I$O%o!<%-%s%0%G%#%l%/%H%j$r(Btip$B%j%S%8%g%s$X99(B
$B?7$9$k!%(B

%\subsection{Pushing changes to another repository}
\subsection{$BB>$N%j%]%8%H%j$KJQ99$r(Bpush$B$9$k(B}

%Mercurial lets us push changes to another repository, from the
%repository we're currently visiting.  As with the example of
%\hgcmd{pull} above, we'll create a temporary repository to push our
%changes into.
%\interaction{tour.clone-push}
%The \hgcmd{outgoing} command tells us what changes would be pushed
%into another repository.
%\interaction{tour.outgoing}
%And the \hgcmd{push} command does the actual push.
%\interaction{tour.push}

Mercurial$B$G$O8=:_;HMQ$7$F$$$k%j%]%8%H%j$+$iB>$N%j%]%8%H%j$KJQ99$r(Bpush$B$9$k(B
$B$3$H$,$G$-$k!%A0=R$N(B\hgcmd{pull}$B%3%^%s%I$N$h$&$K!$0l;~E*$J%j%]%8%H%j$r:n$C(B
$B$F$=$3$KJQ99$r(Bpush$B$7$F$_$h$&!%(B
\interaction{tour.clone-push}
$BB>$N%j%]%8%H%j$K(Bpush$B$5$l$kJQ99$O(B\hgcmd{outgoing}$B%3%^%s%I$GCN$k$3$H$,$G$-(B
$B$k!%(B
\interaction{tour.outgoing}
\hgcmd{push}$B%3%^%s%I$G<B:]$K(Bpush$B$r9T$&!%(B
\interaction{tour.push}

%As with \hgcmd{pull}, the \hgcmd{push} command does not update the
%working directory in the repository that it's pushing changes into.
%Unlike \hgcmd{pull}, \hgcmd{push} does not provide a \texttt{-u} option
%that updates the other repository's working directory.  This asymmetry
%is deliberate: the repository we're pushing to might be on a remote
%server and shared between several people. If we were to update its
%working directory while someone was working in it, their work would be
%disrupted.

\hgcmd{pull}$B%3%^%s%I$HF1MM$K!$(B\hgcmd{push}$B%3%^%s%I$O(Bpush$B@h$N%j%]%8%H%j$N(B
$B%o!<%-%s%0%G%#%l%/%H%j$N99?7$r9T$o$J$$!%(B\hgcmd{pull}$B%3%^%s%I$H0c$C$F(B
\hgcmd{push}$B%3%^%s%I$O!$%o!<%-%s%0%G%#%l%/%H%j$N99?7$r9T$&(B\texttt{-u}$B%*%W(B
$B%7%g%s$r;}$?$J$$!%$3$NHsBP>N@-$O0U?^E*$J$b$N$G!$(Bpush$B@h$N%j%]%8%H%j$O%j%b!<(B
$B%H%5!<%P>e$K$"$k$+$b$7$l$:!$J#?t$N%f!<%6$+$i6&M-$5$l$F$$$k2DG=@-$,$"$k!%(B
$B$b$7C/$+$,:n6HCf$N%o!<%-%s%0%G%#%l%/%H%j$r99?7$7$?$i!$$=$N:n6HFbMF$OBfL5(B
$B$7$K$J$C$F$7$^$&!%(B

%What happens if we try to pull or push changes and the receiving
%repository already has those changes?  Nothing too exciting.
%\interaction{tour.push.nothing}

$B%j%]%8%H%j$,$"$kJQ99$r$9$G$K;}$C$F$$$k$H$-!$F1$8JQ99$r(Bpull$B$^$?$O(Bpush$B$7$h(B
$B$&$H$9$k$H2?$,5/$-$k$@$m$&$+!)FC$K6C$/$h$&$J$3$H$O5/$-$J$$!%(B
\interaction{tour.push.nothing}

%\subsection{Sharing changes over a network}
\subsection{$BJQ99$r%M%C%H%o!<%/$rDL$8$F6&M-$9$k(B}

%The commands we have covered in the previous few sections are not
%limited to working with local repositories.  Each works in exactly the
%same fashion over a network connection; simply pass in a URL instead
%of a local path.
%\interaction{tour.outgoing.net}
%In this example, we can see what changes we could push to the remote
%repository, but the repository is understandably not set up to let
%anonymous users push to it.
%\interaction{tour.push.net}

$B$3$l$h$jA0$N$$$/$D$+$N@a$G07$C$?%3%^%s%I$O!$%m!<%+%k%j%]%8%H%j$@$1$K8BDj(B
$B$5$l$J$$!%$I$N%3%^%s%I$b%M%C%H%o!<%/7PM3$G$bA4$/F1$8$KF0:n$9$k!%0c$$$O%m!<(B
$B%+%k%Q%9$NBe$o$j$K(BURL$B$rEO$9$@$1$G$"$k!%(B
\interaction{tour.outgoing.net}
$B$3$NNc$G$O!$%j%]!<%H%j%]%8%H%j$K(Bpush$B$7$h$&$H$9$k$,!$EvA3$N$3$H$J$,$iF?L>(B
$B$N%f!<%6$K(Bpush$B$r5v2D$7$J$$$h$&$K@_Dj$5$l$F$$$k$?$a!$(Bpush$B$G$-$J$$!%(B
\interaction{tour.push.net}

%%% Local Variables:
%%% mode: yatex
%%% TeX-master: "00book"
%%% End:
