hgbook
view en/mq.tex @ 28:f5ce861d6fcc
Fix description of quilt.
| author | Bryan O'Sullivan <bos@serpentine.com> |
|---|---|
| date | Thu Jul 13 14:58:31 2006 -0700 (2006-07-13) |
| parents | 535e87792eb1 |
| children | cc1e6f1d7161 |
line source
1 \chapter{Managing change with Mercurial Queues}
2 \label{chap:mq}
4 \section{The patch management problem}
5 \label{sec:mq:patch-mgmt}
7 Here is a common scenario: you need to install a software package from
8 source, but you find a bug that you must fix in the source before you
9 can start using the package. You make your changes, forget about the
10 package for a while, and a few months later you need to upgrade to a
11 newer version of the package. If the newer version of the package
12 still has the bug, you must extract your fix from the older source
13 tree and apply it against the newer version. This is a tedious task,
14 and it's easy to make mistakes.
16 This is a simple case of the ``patch management'' problem. You have
17 an ``upstream'' source tree that you can't change; you need to make
18 some local changes on top of the upstream tree; and you'd like to be
19 able to keep those changes separate, so that you can apply them to
20 newer versions of the upstream source.
22 The patch management problem arises in many situations. Probably the
23 most visible is that a user of an open source software project will
24 contribute a bug fix or new feature to the project's maintainers in the
25 form of a patch.
27 Distributors of operating systems that include open source software
28 often need to make changes to the packages they distribute so that
29 they will build properly in their environments.
31 When you have few changes to maintain, it is easy to manage a single
32 patch using the standard \texttt{diff} and \texttt{patch} programs
33 (see section~\ref{sec:mq:patch} for a discussion of these tools).
34 Once the number of changes grows, it starts to makes sense to maintain
35 patches as discrete ``chunks of work,'' so that for example a single
36 patch will contain only one bug fix (the patch might modify several
37 files, but it's doing ``only one thing''), and you may have a number
38 of such patches for different bugs you need fixed and local changes
39 you require. In this situation, if you submit a bug fix patch to the
40 upstream maintainers of a package and they include your fix in a
41 subsequent release, you can simply drop that single patch when you're
42 updating to the newer release.
44 Maintaining a single patch against an upstream tree is a little
45 tedious and error-prone, but not difficult. However, the complexity
46 of the problem grows rapidly as the number of patches you have to
47 maintain increases. With more than a tiny number of patches in hand,
48 understanding which ones you have applied and maintaining them moves
49 from messy to overwhelming.
51 Fortunately, Mercurial includes a powerful extension, Mercurial Queues
52 (or simply ``MQ''), that massively simplifies the patch management
53 problem.
55 \section{The prehistory of Mercurial Queues}
56 \label{sec:mq:history}
58 During the late 1990s, several Linux kernel developers started to
59 maintain ``patch series'' that modified the behaviour of the Linux
60 kernel. Some of these series were focused on stability, some on
61 feature coverage, and others were more speculative.
63 The sizes of these patch series grew rapidly. In 2002, Andrew Morton
64 published some shell scripts he had been using to automate the task of
65 managing his patch queues. Andrew was successfully using these
66 scripts to manage hundreds (sometimes thousands) of patches on top of
67 the Linux kernel.
69 \subsection{A patchwork quilt}
70 \label{sec:mq:quilt}
73 In early 2003, Andreas Gruenbacher and Martin Quinson borrowed the
74 approach of Andrew's scripts and published a tool called ``patchwork
75 quilt''~\cite{web:quilt}, or simply ``quilt''
76 (see~\cite{gruenbacher:2005} for a paper describing it). Because
77 quilt substantially automated patch management, it rapidly gained a
78 large following among open source software developers.
80 Quilt manages a \emph{stack of patches} on top of a directory tree.
81 To begin, you tell quilt to manage a directory tree, and tell it which
82 files you want to manage; it stores away the names and contents of
83 those files. To fix a bug, you create a new patch (using a single
84 command), edit the files you need to fix, then ``refresh'' the patch.
86 The refresh step causes quilt to scan the directory tree; it updates
87 the patch with all of the changes you have made. You can create
88 another patch on top of the first, which will track the changes
89 required to modify the tree from ``tree with one patch applied'' to
90 ``tree with two patches applied''.
92 You can \emph{change} which patches are applied to the tree. If you
93 ``pop'' a patch, the changes made by that patch will vanish from the
94 directory tree. Quilt remembers which patches you have popped,
95 though, so you can ``push'' a popped patch again, and the directory
96 tree will be restored to contain the modifications in the patch. Most
97 importantly, you can run the ``refresh'' command at any time, and the
98 topmost applied patch will be updated. This means that you can, at
99 any time, change both which patches are applied and what
100 modifications those patches make.
102 Quilt knows nothing about revision control tools, so it works equally
103 well on top of an unpacked tarball or a Subversion repository.
105 \subsection{From patchwork quilt to Mercurial Queues}
106 \label{sec:mq:quilt-mq}
108 In mid-2005, Chris Mason took the features of quilt and wrote an
109 extension that he called Mercurial Queues, which added quilt-like
110 behaviour to Mercurial.
112 The key difference between quilt and MQ is that quilt knows nothing
113 about revision control systems, while MQ is \emph{integrated} into
114 Mercurial. Each patch that you push is represented as a Mercurial
115 changeset. Pop a patch, and the changeset goes away.
117 This integration makes understanding patches and debugging their
118 effects \emph{enormously} easier. Since every applied patch has an
119 associated changeset, you can use \hgcmdargs{log}{\emph{filename}} to
120 see which changesets and patches affected a file. You can use the
121 \hgext{bisect} extension to binary-search through all changesets and
122 applied patches to see where a bug got introduced or fixed. You can
123 use the \hgcmd{annotate} command to see which changeset or patch
124 modified a particular line of a source file. And so on.
126 Because quilt does not care about revision control tools, it is still
127 a tremendously useful piece of software to know about for situations
128 where you cannot use Mercurial and MQ.
130 \section{Understanding patches}
131 \label{sec:mq:patch}
133 Because MQ doesn't hide its patch-oriented nature, it is helpful to
134 understand what patches are, and a little about the tools that work
135 with them.
137 The traditional Unix \command{diff} command compares two files, and
138 prints a list of differences between them. The \command{patch} command
139 understands these differences as \emph{modifications} to make to a
140 file. Take a look at figure~\ref{ex:mq:diff} for a simple example of
141 these commands in action.
143 \begin{figure}[ht]
144 \interaction{mq.diff.diff}
145 \caption{Simple uses of the \command{diff} and \command{patch} commands}
146 \label{ex:mq:diff}
147 \end{figure}
149 The type of file that \command{diff} generates (and \command{patch}
150 takes as input) is called a ``patch'' or a ``diff''; there is no
151 difference between a patch and a diff. (We'll use the term ``patch'',
152 since it's more commonly used.)
154 A patch file can start with arbitrary text; the \command{patch}
155 command ignores this text, but MQ uses it as the commit message when
156 creating changesets. To find the beginning of the patch content,
157 \command{patch} searches for the first line that starts with the
158 string ``\texttt{diff~-}''.
160 MQ works with \emph{unified} diffs (\command{patch} can accept several
161 other diff formats, but MQ doesn't). A unified diff contains two
162 kinds of header. The \emph{file header} describes the file being
163 modified; it contains the name of the file to modify. When
164 \command{patch} sees a new file header, it looks for a file with that
165 name to start modifying.
167 After the file header comes a series of \emph{hunks}. Each hunk
168 starts with a header; this identifies the range of line numbers within
169 the file that the hunk should modify. Following the header, a hunk
170 starts and ends with a few (usually three) lines of text from the
171 unmodified file; these are called the \emph{context} for the hunk. If
172 there's only a small amount of context between successive hunks,
173 \command{diff} doesn't print a new hunk header; it just runs the hunks
174 together, with a few lines of context between modifications.
176 Each line of context begins with a space character. Within the hunk,
177 a line that begins with ``\texttt{-}'' means ``remove this line,''
178 while a line that begins with ``\texttt{+}'' means ``insert this
179 line.'' For example, a line that is modified is represented by one
180 deletion and one insertion.
182 We will return to ome of the more subtle aspects of patches later (in
183 section~\ref{sec:mq:adv-patch}), but you should have enough information
184 now to use MQ.
186 \section{Getting started with Mercurial Queues}
187 \label{sec:mq:start}
189 Because MQ is implemented as an extension, you must explicitly enable
190 before you can use it. (You don't need to download anything; MQ ships
191 with the standard Mercurial distribution.) To enable MQ, edit your
192 \tildefile{.hgrc} file, and add the lines in figure~\ref{ex:mq:config}.
194 \begin{figure}[ht]
195 \begin{codesample4}
196 [extensions]
197 hgext.mq =
198 \end{codesample4}
199 \label{ex:mq:config}
200 \caption{Contents to add to \tildefile{.hgrc} to enable the MQ extension}
201 \end{figure}
203 Once the extension is enabled, it will make a number of new commands
204 available. To verify that the extension is working, you can use
205 \hgcmd{help} to see if the \hgcmd{qinit} command is now available; see
206 the example in figure~\ref{ex:mq:enabled}.
208 \begin{figure}[ht]
209 \interaction{mq.qinit-help.help}
210 \caption{How to verify that MQ is enabled}
211 \label{ex:mq:enabled}
212 \end{figure}
214 You can use MQ with \emph{any} Mercurial repository, and its commands
215 only operate within that repository. To get started, simply prepare
216 the repository using the \hgcmd{qinit} command (see
217 figure~\ref{ex:mq:qinit}). This command creates an empty directory
218 called \sdirname{.hg/patches}, where MQ will keep its metadata. As
219 with many Mercurial commands, the \hgcmd{qinit} command prints nothing
220 if it succeeds.
222 \begin{figure}[ht]
223 \interaction{mq.tutorial.qinit}
224 \caption{Preparing a repository for use with MQ}
225 \label{ex:mq:qinit}
226 \end{figure}
228 \begin{figure}[ht]
229 \interaction{mq.tutorial.qnew}
230 \caption{Creating a new patch}
231 \label{ex:mq:qnew}
232 \end{figure}
234 \subsection{Creating a new patch}
236 To begin work on a new patch, use the \hgcmd{qnew} command. This
237 command takes one argument, the name of the patch to create. MQ will
238 use this as the name of an actual file in the \sdirname{.hg/patches}
239 directory, as you can see in figure~\ref{ex:mq:qnew}.
241 Also newly present in the \sdirname{.hg/patches} directory are two
242 other files, \sfilename{series} and \sfilename{status}. The
243 \sfilename{series} file lists all of the patches that MQ knows about
244 for this repository, with one patch per line. Mercurial uses the
245 \sfilename{status} file for internal book-keeping; it tracks all of the
246 patches that MQ has \emph{applied} in this repository.
248 \begin{note}
249 You may sometimes want to edit the \sfilename{series} file by hand;
250 for example, to change the sequence in which some patches are
251 applied. However, manually editing the \sfilename{status} file is
252 almost always a bad idea, as it's easy to corrupt MQ's idea of what
253 is happening.
254 \end{note}
256 Once you have created your new patch, you can edit files in the
257 working directory as you usually would. All of the normal Mercurial
258 commands, such as \hgcmd{diff} and \hgcmd{annotate}, work exactly as
259 they did before.
261 \subsection{Refreshing a patch}
263 When you reach a point where you want to save your work, use the
264 \hgcmd{qrefresh} command (figure~\ref{ex:mq:qnew}) to update the patch
265 you are working on. This command folds the changes you have made in
266 the working directory into your patch, and updates its corresponding
267 changeset to contain those changes.
269 \begin{figure}[ht]
270 \interaction{mq.tutorial.qrefresh}
271 \caption{Refreshing a patch}
272 \label{ex:mq:qrefresh}
273 \end{figure}
275 You can run \hgcmd{qrefresh} as often as you like, so it's a good way
276 to ``checkpoint'' your work. Refresh your patch at an opportune
277 time; try an experiment; and if the experiment doesn't work out,
278 \hgcmd{revert} your modifications back to the last time you refreshed.
280 \begin{figure}[ht]
281 \interaction{mq.tutorial.qrefresh2}
282 \caption{Refresh a patch many times to accumulate changes}
283 \label{ex:mq:qrefresh2}
284 \end{figure}
286 \subsection{Stacking and tracking patches}
288 Once you have finished working on a patch, or need to work on another,
289 you can use the \hgcmd{qnew} command again to create a new patch.
290 Mercurial will apply this patch on top of your existing patch. See
291 figure~\ref{ex:mq:qnew2} for an example. Notice that the patch
292 contains the changes in our prior patch as part of its context (you
293 can see this more clearly in the output of \hgcmd{annotate}).
295 \begin{figure}[ht]
296 \interaction{mq.tutorial.qnew2}
297 \caption{Stacking a second patch on top of the first}
298 \label{ex:mq:qnew2}
299 \end{figure}
301 So far, with the exception of \hgcmd{qnew} and \hgcmd{qrefresh}, we've
302 been careful to only use regular Mercurial commands. However, MQ
303 provides many commands that are easier to use when you are thinking
304 about patches, as illustrated in figure~\ref{ex:mq:qseries}:
306 \begin{itemize}
307 \item The \hgcmd{qseries} command lists every patch that MQ knows
308 about in this repository, from oldest to newest (most recently
309 \emph{created}).
310 \item The \hgcmd{qapplied} command lists every patch that MQ has
311 \emph{applied} in this repository, again from oldest to newest (most
312 recently applied).
313 \end{itemize}
315 \begin{figure}[ht]
316 \interaction{mq.tutorial.qseries}
317 \caption{Understanding the patch stack with \hgcmd{qseries} and
318 \hgcmd{qapplied}}
319 \label{ex:mq:qseries}
320 \end{figure}
322 \subsection{Manipulating the patch stack}
324 The previous discussion implied that there must be a difference
325 between ``known'' and ``applied'' patches, and there is. MQ can
326 manage a patch without it being applied in the repository.
328 An \emph{applied} patch has a corresponding changeset in the
329 repository, and the effects of the patch and changeset are visible in
330 the working directory. You can undo the application of a patch using
331 the \hgcmd{qpop} command. MQ still \emph{knows about}, or manages, a
332 popped patch, but the patch no longer has a corresponding changeset in
333 the repository, and the working directory does not contain the changes
334 made by the patch. Figure~\ref{fig:mq:stack} illustrates the
335 difference between applied and tracked patches.
337 \begin{figure}[ht]
338 \centering
339 \grafix{mq-stack}
340 \caption{Applied and unapplied patches in the MQ patch stack}
341 \label{fig:mq:stack}
342 \end{figure}
344 You can reapply an unapplied, or popped, patch using the \hgcmd{qpush}
345 command. This creates a new changeset to correspond to the patch, and
346 the patch's changes once again become present in the working
347 directory. See figure~\ref{ex:mq:qpop} for examples of \hgcmd{qpop}
348 and \hgcmd{qpush} in action. Notice that once we have popped a patch
349 or two patches, the output of \hgcmd{qseries} remains the same, while
350 that of \hgcmd{qapplied} has changed.
352 \begin{figure}[ht]
353 \interaction{mq.tutorial.qpop}
354 \caption{Modifying the stack of applied patches}
355 \label{ex:mq:qpop}
356 \end{figure}
358 \subsection{Pushing and popping many patches}
360 While \hgcmd{qpush} and \hgcmd{qpop} each operate on a single patch at
361 a time by default, you can push and pop many patches in one go. The
362 \hgopt{qpush}{-a} option to \hgcmd{qpush} causes it to push all
363 unapplied patches, while the \hgopt{qpop}{-a} option to \hgcmd{qpop}
364 causes it to pop all applied patches. (For some more ways to push and
365 pop many patches, see section~\ref{sec:mq:perf} below.)
367 \begin{figure}[ht]
368 \interaction{mq.tutorial.qpush-a}
369 \caption{Pushing all unapplied patches}
370 \label{ex:mq:qpush-a}
371 \end{figure}
373 \subsection{Safety checks, and overriding them}
375 Several MQ commands check the working directory before they do
376 anything, and fail if they find any modifications. They do this to
377 ensure that you won't lose any changes that you have made, but not yet
378 incorporated into a patch. Figure~\ref{ex:mq:add} illustrates this;
379 the \hgcmd{qnew} command will not create a new patch if there are
380 outstanding changes, caused in this case by the \hgcmd{add} of
381 \filename{file3}.
383 \begin{figure}[ht]
384 \interaction{mq.tutorial.add}
385 \caption{Forcibly creating a patch}
386 \label{ex:mq:add}
387 \end{figure}
389 Commands that check the working directory all take an ``I know what
390 I'm doing'' option, which is always named \option{-f}. The exact
391 meaning of \option{-f} depends on the command. For example,
392 \hgcmdargs{qnew}{\hgopt{qnew}{-f}} will incorporate any outstanding
393 changes into the new patch it creates, but
394 \hgcmdargs{qpop}{\hgopt{qpop}{-f}} will revert modifications to any
395 files affected by the patch that it is popping. Be sure to read the
396 documentation for a command's \option{-f} option before you use it!
398 \subsection{Working on several patches at once}
400 The \hgcmd{qrefresh} command always refreshes the \emph{topmost}
401 applied patch. This means that you can suspend work on one patch (by
402 refreshing it), pop or push to make a different patch the top, and
403 work on \emph{that} patch for a while.
405 Here's an example that illustrates how you can use this ability.
406 Let's say you're developing a new feature as two patches. The first
407 is a change to the core of your software, and the second---layered on
408 top of the first---changes the user interface to use the code you just
409 added to the core. If you notice a bug in the core while you're
410 working on the UI patch, it's easy to fix the core. Simply
411 \hgcmd{qrefresh} the UI patch to save your in-progress changes, and
412 \hgcmd{qpop} down to the core patch. Fix the core bug,
413 \hgcmd{qrefresh} the core patch, and \hgcmd{qpush} back to the UI
414 patch to continue where you left off.
416 \section{More about patches}
417 \label{sec:mq:adv-patch}
419 MQ uses the GNU \command{patch} command to apply patches, so it's
420 helpful to know a few more detailed aspects of how \command{patch}
421 works, and about patches themselves.
423 \subsection{The strip count}
425 If you look at the file headers in a patch, you will notice that the
426 pathnames usually have an extra component on the front that isn't
427 present in the actual path name. This is a holdover from the way that
428 people used to generate patches (people still do this, but it's
429 somewhat rare with modern revision control tools).
431 Alice would unpack a tarball, edit her files, then decide that she
432 wanted to create a patch. So she'd rename her working directory,
433 unpack the tarball again (hence the need for the rename), and use the
434 \cmdopt{diff}{-r} and \cmdopt{diff}{-N} options to \command{diff} to
435 recursively generate a patch between the unmodified directory and the
436 modified one. The result would be that the name of the unmodified
437 directory would be at the front of the left-hand path in every file
438 header, and the name of the modified directory would be at the front
439 of the right-hand path.
441 Since someone receiving a patch from the Alices of the net would be
442 unlikely to have unmodified and modified directories with exactly the
443 same names, the \command{patch} command has a \cmdopt{patch}{-p}
444 option that indicates the number of leading path name components to
445 strip when trying to apply a patch. This number is called the
446 \emph{strip count}.
448 An option of ``\texttt{-p1}'' means ``use a strip count of one''. If
449 \command{patch} sees a file name \filename{foo/bar/baz} in a file
450 header, it will strip \filename{foo} and try to patch a file named
451 \filename{bar/baz}. (Strictly speaking, the strip count refers to the
452 number of \emph{path separators} (and the components that go with them
453 ) to strip. A strip count of one will turn \filename{foo/bar} into
454 \filename{bar}, but \filename{/foo/bar} (notice the extra leading
455 slash) into \filename{foo/bar}.)
457 The ``standard'' strip count for patches is one; almost all patches
458 contain one leading path name component that needs to be stripped.
459 Mercurial's \hgcmd{diff} command generates path names in this form,
460 and the \hgcmd{import} command and MQ expect patches to have a strip
461 count of one.
463 If you receive a patch from someone that you want to add to your patch
464 queue, and the patch needs a strip count other than one, you cannot
465 just \hgcmd{qimport} the patch, because \hgcmd{qimport} does not yet
466 have a \texttt{-p} option (see~\bug{311}). Your best bet is to
467 \hgcmd{qnew} a patch of your own, then use \cmdargs{patch}{-p\emph{N}}
468 to apply their patch, followed by \hgcmd{addremove} to pick up any
469 files added or removed by the patch, followed by \hgcmd{qrefresh}.
470 This complexity may become unnecessary; see~\bug{311} for details.
471 \subsection{Strategies for applying a patch}
473 When \command{patch} applies a hunk, it tries a handful of
474 successively less accurate strategies to try to make the hunk apply.
475 This falling-back technique often makes it possible to take a patch
476 that was generated against an old version of a file, and apply it
477 against a newer version of that file.
479 First, \command{patch} tries an exact match, where the line numbers,
480 the context, and the text to be modified must apply exactly. If it
481 cannot make an exact match, it tries to find an exact match for the
482 context, without honouring the line numbering information. If this
483 succeeds, it prints a line of output saying that the hunk was applied,
484 but at some \emph{offset} from the original line number.
486 If a context-only match fails, \command{patch} removes the first and
487 last lines of the context, and tries a \emph{reduced} context-only
488 match. If the hunk with reduced context succeeds, it prints a message
489 saying that it applied the hunk with a \emph{fuzz factor} (the number
490 after the fuzz factor indicates how many lines of context
491 \command{patch} had to trim before the patch applied).
493 When neither of these techniques works, \command{patch} prints a
494 message saying that the hunk in question was rejected. It saves
495 rejected hunks (also simply called ``rejects'') to a file with the
496 same name, and an added \sfilename{.rej} extension. It also saves an
497 unmodified copy of the file with a \sfilename{.orig} extension; the
498 copy of the file without any extensions will contain any changes made
499 by hunks that \emph{did} apply cleanly. If you have a patch that
500 modifies \filename{foo} with six hunks, and one of them fails to
501 apply, you will have: an unmodified \filename{foo.orig}, a
502 \filename{foo.rej} containing one hunk, and \filename{foo}, containing
503 the changes made by the five successful five hunks.
505 \subsection{Some quirks of patch representation}
507 There are a few useful things to know about how \command{patch} works
508 with files.
509 \begin{itemize}
510 \item This should already be obvious, but \command{patch} cannot
511 handle binary files.
512 \item Neither does it care about the executable bit; it creates new
513 files as readable, but not executable.
514 \item \command{patch} treats the removal of a file as a diff between
515 the file to be removed and the empty file. So your idea of ``I
516 deleted this file'' looks like ``every line of this file was
517 deleted'' in a patch.
518 \item It treats the addition of a file as a diff between the empty
519 file and the file to be added. So in a patch, your idea of ``I
520 added this file'' looks like ``every line of this file was added''.
521 \item It treats a renamed file as the removal of the old name, and the
522 addition of the new name. This means that renamed files have a big
523 footprint in patches. (Note also that Mercurial does not currently
524 try to infer when files have been renamed or copied in a patch.)
525 \item \command{patch} cannot represent empty files, so you cannot use
526 a patch to represent the notion ``I added this empty file to the
527 tree''.
528 \end{itemize}
529 \subsection{Beware the fuzz}
531 While applying a hunk at an offset, or with a fuzz factor, will often
532 be completely successful, these inexact techniques naturally leave
533 open the possibility of corrupting the patched file. The most common
534 cases typically involve applying a patch twice, or at an incorrect
535 location in the file. If \command{patch} or \hgcmd{qpush} ever
536 mentions an offset or fuzz factor, you should make sure that the
537 modified files are correct afterwards.
539 It's often a good idea to refresh a patch that has applied with an
540 offset or fuzz factor; refreshing the patch generates new context
541 information that will make it apply cleanly. I say ``often,'' not
542 ``always,'' because sometimes refreshing a patch will make it fail to
543 apply against a different revision of the underlying files. In some
544 cases, such as when you're maintaining a patch that must sit on top of
545 multiple versions of a source tree, it's acceptable to have a patch
546 apply with some fuzz, provided you've verified the results of the
547 patching process in such cases.
549 \subsection{Handling rejection}
551 If \hgcmd{qpush} fails to apply a patch, it will print an error
552 message and exit. If it has left \sfilename{.rej} files behind, it is
553 usually best to fix up the rejected hunks before you push more patches
554 or do any further work.
556 If your patch \emph{used to} apply cleanly, and no longer does because
557 you've changed the underlying code that your patches are based on,
558 Mercurial Queues can help; see section~\ref{sec:mq:merge} for details.
560 Unfortunately, there aren't any great techniques for dealing with
561 rejected hunks. Most often, you'll need to view the \sfilename{.rej}
562 file and edit the target file, applying the rejected hunks by hand.
564 If you're feeling adventurous, Neil Brown, a Linux kernel hacker,
565 wrote a tool called \command{wiggle}~\cite{web:wiggle}, which is more
566 vigorous than \command{patch} in its attempts to make a patch apply.
568 Another Linux kernel hacker, Chris Mason (the author of Mercurial
569 Queues), wrote a similar tool called \command{rej}~\cite{web:rej},
570 which takes a simple approach to automating the application of hunks
571 rejected by \command{patch}. \command{rej} can help with four common
572 reasons that a hunk may be rejected:
574 \begin{itemize}
575 \item The context in the middle of a hunk has changed.
576 \item A hunk is missing some context at the beginning or end.
577 \item A large hunk might apply better---either entirely or in
578 part---if it was broken up into smaller hunks.
579 \item A hunk removes lines with slightly different content than those
580 currently present in the file.
581 \end{itemize}
583 If you use \command{wiggle} or \command{rej}, you should be doubly
584 careful to check your results when you're done.
586 \section{Getting the best performance out of MQ}
587 \label{sec:mq:perf}
589 MQ is very efficient at handling a large number of patches. I ran
590 some performance experiments in mid-2006 for a talk that I gave at the
591 2006 EuroPython conference~\cite{web:europython}. I used as my data
592 set the Linux 2.6.17-mm1 patch series, which consists of 1,738
593 patches. I applied thes on top of a Linux kernel repository
594 containing all 27,472 revisions between Linux 2.6.12-rc2 and Linux
595 2.6.17.
597 On my old, slow laptop, I was able to
598 \hgcmdargs{qpush}{\hgopt{qpush}{-a}} all 1,738 patches in 3.5 minutes,
599 and \hgcmdargs{qpop}{\hgopt{qpop}{-a}} them all in 30 seconds. I
600 could \hgcmd{qrefresh} one of the biggest patches (which made 22,779
601 lines of changes to 287 files) in 6.6 seconds.
603 Clearly, MQ is well suited to working in large trees, but there are a
604 few tricks you can use to get the best performance of it.
606 First of all, try to ``batch'' operations together. Every time you
607 run \hgcmd{qpush} or \hgcmd{qpop}, these commands scan the working
608 directory once to make sure you haven't made some changes and then
609 forgotten to run \hgcmd{qrefresh}. On a small tree, the time that
610 this scan takes is unnoticeable. However, on a medium-sized tree
611 (containing tens of thousands of files), it can take a second or more.
613 The \hgcmd{qpush} and \hgcmd{qpop} commands allow you to push and pop
614 multiple patches at a time. You can identify the ``destination
615 patch'' that you want to end up at. When you \hgcmd{qpush} with a
616 destination specified, it will push patches until that patch is at the
617 top of the applied stack. When you \hgcmd{qpop} to a destination, MQ
618 will pop patches until the destination patch \emph{is no longer}
619 applied.
621 You can identify a destination patch using either the name of the
622 patch, or by number. If you use numeric addressing, patches are
623 counted from zero; this means that the first patch is zero, the second
624 is one, and so on.
626 \section{Updating your patches when the underlying code changes}
627 \label{sec:mq:merge}
629 It's common to have a stack of patches on top of an underlying
630 repository that you don't modify directly. If you're working on
631 changes to third-party code, or on a feature that is taking longer to
632 develop than the rate of change of the code beneath, you will often
633 need to sync up with the underlying code, and fix up any hunks in your
634 patches that no longer apply. This is called \emph{rebasing} your
635 patch series.
637 The simplest way to do this is to \hgcmdargs{qpop}{\hgopt{qpop}{-a}}
638 your patches, then \hgcmd{pull} changes into the underlying
639 repository, and finally \hgcmdargs{qpush}{\hgopt{qpop}{-a}} your
640 patches again. MQ will stop pushing any time it runs across a patch
641 that fails to apply during conflicts, allowing you to fix your
642 conflicts, \hgcmd{qrefresh} the affected patch, and continue pushing
643 until you have fixed your entire stack.
645 This approach is easy to use and works well if you don't expect
646 changes to the underlying code to affect how well your patches apply.
647 If your patch stack touches code that is modified frequently or
648 invasively in the underlying repository, however, fixing up rejected
649 hunks by hand quickly becomes tiresome.
651 It's possible to partially automate the rebasing process. If your
652 patches apply cleanly against some revision of the underlying repo, MQ
653 can use this information to help you to resolve conflicts between your
654 patches and a different revision.
656 The process is a little involved.
657 \begin{enumerate}
658 \item To begin, \hgcmdargs{qpush}{-a} all of your patches on top of
659 the revision where you know that they apply cleanly.
660 \item Save a backup copy of your patch directory using
661 \hgcmdargs{qsave}{\hgopt{qsave}{-e} \hgopt{qsave}{-c}}. This prints
662 the name of the directory that it has saved the patches in. It will
663 save the patches to a directory called
664 \sdirname{.hg/patches.\emph{N}}, where \texttt{\emph{N}} is a small
665 integer. It also commits a ``save changeset'' on top of your
666 applied patches; this is for internal book-keeping, and records the
667 states of the \sfilename{series} and \sfilename{status} files.
668 \item Use \hgcmd{pull} to bring new changes into the underlying
669 repository. (Don't run \hgcmdargs{pull}{-u}; see below for why.)
670 \item Update to the new tip revision, using
671 \hgcmdargs{update}{\hgopt{update}{-C}} to override the patches you
672 have pushed.
673 \item Merge all patches using \hgcmdargs{qpush}{\hgopt{qpush}{-m}
674 \hgopt{qpush}{-a}}. The \hgopt{qpush}{-m} option to \hgcmd{qpush}
675 tells MQ to perform a three-way merge if the patch fails to apply.
676 \end{enumerate}
678 During the \hgcmdargs{qpush}{\hgopt{qpush}{-m}}, each patch in the
679 \sfilename{series} file is applied normally. If a patch applies with
680 fuzz or rejects, MQ looks at the queue you \hgcmd{qsave}d, and
681 performs a three-way merge with the corresponding changeset. This
682 merge uses Mercurial's normal merge machinery, so it may pop up a GUI
683 merge tool to help you to resolve problems.
685 When you finish resolving the effects of a patch, MQ refreshes your
686 patch based on the result of the merge.
688 At the end of this process, your repository will have one extra head
689 from the old patch queue, and a copy of the old patch queue will be in
690 \sdirname{.hg/patches.\emph{N}}. You can remove the extra head using
691 \hgcmdargs{qpop}{\hgopt{qpop}{-a} \hgopt{qpop}{-n} patches.\emph{N}}
692 or \hgcmd{strip}. You can delete \sdirname{.hg/patches.\emph{N}} once
693 you are sure that you no longer need it as a backup.
695 \section{Useful things to know about}
697 There are a number of aspects of MQ usage that don't fit tidily into
698 sections of their own, but that are good to know. Here they are, in
699 one place.
701 \begin{itemize}
702 \item Normally, when you \hgcmd{qpop} a patch and \hgcmd{qpush} it
703 again, the changeset that represents the patch after the pop/push
704 will have a \emph{different identity} than the changeset that
705 represented the hash beforehand. See section~\ref{sec:mq:cmd:qpush}
706 for information as to why this is.
707 \item It's not a good idea to \hgcmd{merge} changes from another
708 branch with a patch changeset, at least if you want to maintain the
709 ``patchiness'' of that changeset and changesets below it on the
710 patch stack. If you try to do this, it will appear to succeed, but
711 MQ will become confused.
712 \end{itemize}
713 \section{Managing patches in a repository}
715 Because MQ's \sdirname{.hg/patches} directory resides outside a
716 Mercurial repository's working directory, the ``underlying'' Mercurial
717 repository knows nothing about the management or presence of patches.
719 This presents the interesting possibility of managing the contents of
720 the patch directory as a Mercurial repository in its own right. This
721 can be a useful way to work. For example, you can work on a patch for
722 a while, \hgcmd{qrefresh} it, then \hgcmd{commit} the current state of
723 the patch. This lets you ``roll back'' to that version of the patch
724 later on.
726 You can then share different versions of the same patch stack among
727 multiple underlying repositories. I use this when I am developing a
728 Linux kernel feature. I have a pristine copy of my kernel sources for
729 each of several CPU architectures, and a cloned repository under each
730 that contains the patches I am working on. When I want to test a
731 change on a different architecture, I push my current patches to the
732 patch repository associated with that kernel tree, pop and push all of
733 my patches, and build and test that kernel.
735 Managing patches in a repository makes it possible for multiple
736 developers to work on the same patch series without colliding with
737 each other, all on top of an underlying source base that they may or
738 may not control.
740 \subsection{MQ support for patch repositories}
742 MQ helps you to work with the \sdirname{.hg/patches} directory as a
743 repository; when you prepare a repository for working with patches
744 using \hgcmd{qinit}, you can pass the \hgopt{qinit}{-c} option to
745 create the \sdirname{.hg/patches} directory as a Mercurial repository.
747 \begin{note}
748 If you forget to use the \hgopt{qinit}{-c} option, you can simply go
749 into the \sdirname{.hg/patches} directory at any time and run
750 \hgcmd{init}. Don't forget to add an entry for the
751 \sfilename{status} file to the \sfilename{.hgignore} file, though
752 (\hgcmdargs{qinit}{\hgopt{qinit}{-c}} does this for you
753 automatically); you \emph{really} don't want to manage the
754 \sfilename{status} file.
755 \end{note}
757 As a convenience, if MQ notices that the \dirname{.hg/patches}
758 directory is a repository, it will automatically \hgcmd{add} every
759 patch that you create and import.
761 Finally, MQ provides a shortcut command, \hgcmd{qcommit}, that runs
762 \hgcmd{commit} in the \sdirname{.hg/patches} directory. This saves
763 some cumbersome typing.
765 \subsection{A few things to watch out for}
767 MQ's support for working with a repository full of patches is limited
768 in a few small respects.
770 MQ cannot automatically detect changes that you make to the patch
771 directory. If you \hgcmd{pull}, manually edit, or \hgcmd{update}
772 changes to patches or the \sfilename{series} file, you will have to
773 \hgcmdargs{qpop}{\hgopt{qpop}{-a}} and then
774 \hgcmdargs{qpush}{\hgopt{qpush}{-a}} in the underlying repository to
775 see those changes show up there. If you forget to do this, you can
776 confuse MQ's idea of which patches are applied.
778 \section{Third party tools for working with patches}
779 \label{sec:mq:tools}
781 Once you've been working with patches for a while, you'll find
782 yourself hungry for tools that will help you to understand and
783 manipulate the patches you're dealing with.
785 The \command{diffstat} command~\cite{web:diffstat} generates a
786 histogram of the modifications made to each file in a patch. It
787 provides a good way to ``get a sense of'' a patch---which files it
788 affects, and how much change it introduces to each file and as a
789 whole. (I find that it's a good idea to use \command{diffstat}'s
790 \texttt{-p} option as a matter of course, as otherwise it will try to
791 do clever things with prefixes of file names that inevitably confuse
792 at least me.)
794 \begin{figure}[ht]
795 \interaction{mq.tools.tools}
796 \caption{The \command{diffstat}, \command{filterdiff}, and \command{lsdiff} commands}
797 \label{ex:mq:tools}
798 \end{figure}
800 The \package{patchutils} package~\cite{web:patchutils} is invaluable.
801 It provides a set of small utilities that follow the ``Unix
802 philosophy;'' each does one useful thing with a patch. The
803 \package{patchutils} command I use most is \command{filterdiff}, which
804 extracts subsets from a patch file. For example, given a patch that
805 modifies hundreds of files across dozens of directories, a single
806 invocation of \command{filterdiff} can generate a smaller patch that
807 only touches files whose names match a particular glob pattern.
809 \section{Good ways to work with patches}
811 Whether you are working on a patch series to submit to a free software
812 or open source project, or a series that you intend to treat as a
813 sequence of regular changesets when you're done, you can use some
814 simple techniques to keep your work well organised.
816 Give your patches descriptive names. A good name for a patch might be
817 \filename{rework-device-alloc.patch}, because it will immediately give
818 you a hint what the purpose of the patch is. Long names shouldn't be
819 a problem; you won't be typing the names often, but you \emph{will} be
820 running commands like \hgcmd{qapplied} and \hgcmd{qtop} over and over.
821 Good naming becomes especially important when you have a number of
822 patches to work with, or if you are juggling a number of different
823 tasks and your patches only get a fraction of your attention.
825 Be aware of what patch you're working on. Use the \hgcmd{qtop}
826 command and skim over the text of your patches frequently---for
827 example, using \hgcmdargs{tip}{\hgopt{tip}{-p}})---to be sure of where
828 you stand. I have several times worked on and \hgcmd{qrefresh}ed a
829 patch other than the one I intended, and it's often tricky to migrate
830 changes into the right patch after making them in the wrong one.
832 For this reason, it is very much worth investing a little time to
833 learn how to use some of the third-party tools I described in
834 section~\ref{sec:mq:tools}, particularly \command{diffstat} and
835 \command{filterdiff}. The former will give you a quick idea of what
836 changes your patch is making, while the latter makes it easy to splice
837 hunks selectively out of one patch and into another.
839 \section{MQ cookbook}
841 \subsection{Manage ``trivial'' patches}
843 Because the overhead of dropping files into a new Mercurial repository
844 is so low, it makes a lot of sense to manage patches this way even if
845 you simply want to make a few changes to a source tarball that you
846 downloaded.
848 Begin by downloading and unpacking the source tarball,
849 and turning it into a Mercurial repository.
850 \interaction{mq.tarball.download}
852 Continue by creating a patch stack and making your changes.
853 \interaction{mq.tarball.qinit}
855 Let's say a few weeks or months pass, and your package author releases
856 a new version. First, bring their changes into the repository.
857 \interaction{mq.tarball.newsource}
858 The pipeline starting with \hgcmd{locate} above deletes all files in
859 the working directory, so that \hgcmd{commit}'s
860 \hgopt{commit}{--addremove} option can actually tell which files have
861 really been removed in the newer version of the source.
863 Finally, you can apply your patches on top of the new tree.
864 \interaction{mq.tarball.repush}
866 \subsection{Combining entire patches}
867 \label{sec:mq:combine}
869 It's easy to combine entire patches.
871 \begin{enumerate}
872 \item \hgcmd{qpop} your applied patches until neither patch is
873 applied.
874 \item Concatenate the patches that you want to combine together:
875 \begin{codesample4}
876 cat patch-to-drop.patch >> patch-to-augment.patch
877 \end{codesample4}
878 The description from the first patch (if you have one) will be used
879 as the commit comment when you \hgcmd{qpush} the combined patch.
880 Edit the patch description if you need to.
881 \item Use the \hgcmd{qdel} command to delete the patch you're dropping
882 from the \sfilename{series} file.
883 \item \hgcmd{qpush} the combined patch. Fix up any rejects.
884 \item \hgcmd{qrefresh} the combined patch to tidy it up.
885 \end{enumerate}
887 \subsection{Merging part of one patch into another}
889 Merging \emph{part} of one patch into another is more difficult than
890 combining entire patches.
892 If you want to move changes to entire files, you can use
893 \command{filterdiff}'s \cmdopt{filterdiff}{-i} and
894 \cmdopt{filterdiff}{-x} options to choose the modifications to snip
895 out of one patch, concatenating its output onto the end of the patch
896 you want to merge into. You usually won't need to modify the patch
897 you've merged the changes from. Instead, MQ will report some rejected
898 hunks when you \hgcmd{qpush} it (from the hunks you moved into the
899 other patch), and you can simply \hgcmd{qrefresh} the patch to drop
900 the duplicate hunks.
902 If you have a patch that has multiple hunks modifying a file, and you
903 only want to move a few of those hunks, the job becomes more messy,
904 but you can still partly automate it. Use \cmdargs{lsdiff}{-nvv} to
905 print some metadata about the patch.
906 \interaction{mq.tools.lsdiff}
908 This command prints three different kinds of number:
909 \begin{itemize}
910 \item (in the first column) a \emph{file number} to identify each file
911 modified in the patch;
912 \item (on the next line, indented) the line number within a modified
913 file where a hunk starts; and
914 \item (on the same line) a \emph{hunk number} to identify that hunk.
915 \end{itemize}
917 You'll have to use some visual inspection, and reading of the patch,
918 to identify the file and hunk numbers you'll want, but you can then
919 pass them to to \command{filterdiff}'s \cmdopt{filterdiff}{--files}
920 and \cmdopt{filterdiff}{--hunks} options, to select exactly the file
921 and hunk you want to extract.
923 Once you have this hunk, you can concatenate it onto the end of your
924 destination patch and continue with the remainder of
925 section~\ref{sec:mq:combine}.
927 \section{Differences between quilt and MQ}
929 If you are already familiar with quilt, MQ provides a similar command
930 set. There are a few differences in the way that it works.
932 You will already have noticed that most quilt commands have MQ
933 counterparts that simply begin with a ``\texttt{q}''. The exceptions
934 are quilt's \texttt{add} and \texttt{remove} commands, the
935 counterparts for which are the normal Mercurial \hgcmd{add} and
936 \hgcmd{remove} commands. There is no MQ equivalent of the quilt
937 \texttt{edit} command.
938 \section{MQ command reference}
939 \label{sec:mq:cmdref}
941 For an overview of the commands provided by MQ, use the command
942 \hgcmdargs{help}{mq}.
944 \subsection{\hgcmd{qapplied}---print applied patches}
946 The \hgcmd{qapplied} command prints the current stack of applied
947 patches. Patches are printed in oldest-to-newest order, so the last
948 patch in the list is the ``top'' patch.
950 \subsection{\hgcmd{qcommit}---commit changes in the queue repository}
952 The \hgcmd{qcommit} command commits any outstanding changes in the
953 \sdirname{.hg/patches} repository. This command only works if the
954 \sdirname{.hg/patches} directory is a repository, i.e.~you created the
955 directory using \hgcmdargs{qinit}{\hgopt{qinit}{-c}} or ran
956 \hgcmd{init} in the directory after running \hgcmd{qinit}.
958 This command is shorthand for \hgcmdargs{commit}{--cwd .hg/patches}.
960 \subsection{\hgcmd{qdelete}---delete a patch from the
961 \sfilename{series} file}
963 The \hgcmd{qdelete} command removes the entry for a patch from the
964 \sfilename{series} file in the \sdirname{.hg/patches} directory. It
965 does not delete the patch file, nor does it pop the patch if the patch
966 is already applied.
968 \subsection{\hgcmd{qdiff}---print a diff of the topmost applied patch}
970 The \hgcmd{qdiff} command prints a diff of the topmost applied patch.
971 It is equivalent to \hgcmdargs{diff}{-r-2:-1}.
973 \subsection{\hgcmd{qimport}---import a third-party patch into the queue}
975 The \hgcmd{qimport} command adds an entry for an external patch to the
976 \sfilename{series} file, and copies the patch into the
977 \sdirname{.hg/patches} directory. It adds the entry immediately after
978 the topmost applied patch, but does not push the patch.
980 If the \sdirname{.hg/patches} directory is a repository,
981 \hgcmd{qimport} automatically does an \hgcmd{add} of the imported
982 patch.
984 \subsection{\hgcmd{qinit}---prepare a repository to work with MQ}
986 The \hgcmd{qinit} command prepares a repository to work with MQ. It
987 creates a directory called \sdirname{.hg/patches}.
989 Options:
990 \begin{itemize}
991 \item[\hgopt{qinit}{-c}] Create \sdirname{.hg/patches} as a repository
992 in its own right. Also creates a \sfilename{.hgignore} file that
993 will ignore the \sfilename{status} file.
994 \end{itemize}
996 When the \sdirname{.hg/patches} directory is a repository, the
997 \hgcmd{qimport} and \hgcmd{qnew} commands automatically \hgcmd{add}
998 new patches.
1000 \subsection{\hgcmd{qnew}---create a new patch}
1002 The \hgcmd{qnew} command creates a new patch. It takes one mandatory
1003 argument, the name to use for the patch file. The newly created patch
1004 is created empty by default. It is added to the \sfilename{series}
1005 file after the current topmost applied patch, and is immediately
1006 pushed on top of that patch.
1008 If \hgcmd{qnew} finds modified files in the working directory, it will
1009 refuse to create a new patch unless the \hgopt{qnew}{-f} option is
1010 used (see below). This behaviour allows you to \hgcmd{qrefresh} your
1011 topmost applied patch before you apply a new patch on top of it.
1013 Options:
1014 \begin{itemize}
1015 \item[\hgopt{qnew}{-f}] Create a new patch if the contents of the
1016 working directory are modified. Any outstanding modifications are
1017 added to the newly created patch, so after this command completes,
1018 the working directory will no longer be modified.
1019 \item[\hgopt{qnew}{-m}] Use the given text as the commit message.
1020 This text will be stored at the beginning of the patch file, before
1021 the patch data.
1022 \end{itemize}
1024 \subsection{\hgcmd{qnext}---print the name of the next patch}
1026 The \hgcmd{qnext} command prints the name name of the next patch in
1027 the \sfilename{series} file after the topmost applied patch. This
1028 patch will become the topmost applied patch if you run \hgcmd{qpush}.
1030 \subsection{\hgcmd{qpop}---pop patches off the stack}
1032 The \hgcmd{qpop} command removes applied patches from the top of the
1033 stack of applied patches. By default, it removes only one patch.
1035 This command removes the changesets that represent the popped patches
1036 from the repository, and updates the working directory to undo the
1037 effects of the patches.
1039 This command takes an optional argument, which it uses as the name or
1040 index of the patch to pop to. If given a name, it will pop patches
1041 until the named patch is no longer applied. If given a number,
1042 \hgcmd{qpop} treats the number as an index into the entries in the
1043 series file, counting from zero (empty lines and lines containing only
1044 comments do not count). It pops patches until the patch identified by
1045 the given index is no longer applied.
1047 The \hgcmd{qpop} command does not read or write patches or the
1048 \sfilename{series} file. It is thus safe to \hgcmd{qpop} a patch that
1049 you have removed from the \sfilename{series} file, or a patch that you
1050 have renamed or deleted entirely. In the latter two cases, use the
1051 name of the patch as it was when you applied it.
1053 By default, the \hgcmd{qpop} command will not pop any patches if the
1054 working directory has been modified. You can override this behaviour
1055 using the \hgopt{qpop}{-f} option, which reverts all modifications in
1056 the working directory.
1058 Options:
1059 \begin{itemize}
1060 \item[\hgopt{qpop}{-a}] Pop all applied patches. This returns the
1061 repository to its state before you applied any patches.
1062 \item[\hgopt{qpop}{-f}] Forcibly revert any modifications to the
1063 working directory when popping.
1064 \item[\hgopt{qpop}{-n}] Pop a patch from the named queue.
1065 \end{itemize}
1067 The \hgcmd{qpop} command removes one line from the end of the
1068 \sfilename{status} file for each patch that it pops.
1069 \subsection{\hgcmd{qprev}---print the name of the previous patch}
1071 The \hgcmd{qprev} command prints the name of the patch in the
1072 \sfilename{series} file that comes before the topmost applied patch.
1073 This will become the topmost applied patch if you run \hgcmd{qpop}.
1075 \subsection{\hgcmd{qpush}---push patches onto the stack}
1076 \label{sec:mq:cmd:qpush}
1078 The \hgcmd{qpush} command adds patches onto the applied stack. By
1079 default, it adds only one patch.
1081 This command creates a new changeset to represent each applied patch,
1082 and updates the working directory to apply the effects of the patches.
1084 The default data used when creating a changeset are as follows:
1085 \begin{itemize}
1086 \item The commit date and time zone are the current date and time
1087 zone. Because these data are used to compute the identity of a
1088 changeset, this means that if you \hgcmd{qpop} a patch and
1089 \hgcmd{qpush} it again, the changeset that you push will have a
1090 different identity than the changeset you popped.
1091 \item The author is the same as the default used by the \hgcmd{commit}
1092 command.
1093 \item The commit message is any text from the patch file that comes
1094 before the first diff header. If there is no such text, a default
1095 commit message is used that identifies the name of the patch.
1096 \end{itemize}
1097 If a patch contains a Mercurial patch header (XXX add link), the
1098 information in the patch header overrides these defaults.
1100 Options:
1101 \begin{itemize}
1102 \item[\hgopt{qpush}{-a}] Push all unapplied patches from the
1103 \sfilename{series} file until there are none left to push.
1104 \item[\hgopt{qpush}{-l}] Add the name of the patch to the end
1105 of the commit message.
1106 \item[\hgopt{qpush}{-m}] If a patch fails to apply cleanly, use the
1107 entry for the patch in another saved queue to compute the parameters
1108 for a three-way merge, and perform a three-way merge using the
1109 normal Mercurial merge machinery. Use the resolution of the merge
1110 as the new patch content.
1111 \item[\hgopt{qpush}{-n}] Use the named queue if merging while pushing.
1112 \end{itemize}
1114 The \hgcmd{qpush} command reads, but does not modify, the
1115 \sfilename{series} file. It appends one line to the \hgcmd{status}
1116 file for each patch that it pushes.
1118 \subsection{\hgcmd{qrefresh}---update the topmost applied patch}
1120 The \hgcmd{qrefresh} command updates the topmost applied patch. It
1121 modifies the patch, removes the old changeset that represented the
1122 patch, and creates a new changeset to represent the modified patch.
1124 The \hgcmd{qrefresh} command looks for the following modifications:
1125 \begin{itemize}
1126 \item Changes to the commit message, i.e.~the text before the first
1127 diff header in the patch file, are reflected in the new changeset
1128 that represents the patch.
1129 \item Modifications to tracked files in the working directory are
1130 added to the patch.
1131 \item Changes to the files tracked using \hgcmd{add}, \hgcmd{copy},
1132 \hgcmd{remove}, or \hgcmd{rename}. Added files and copy and rename
1133 destinations are added to the patch, while removed files and rename
1134 sources are removed.
1135 \end{itemize}
1137 Even if \hgcmd{qrefresh} detects no changes, it still recreates the
1138 changeset that represents the patch. This causes the identity of the
1139 changeset to differ from the previous changeset that identified the
1140 patch.
1142 \subsection{\hgcmd{qrestore}---restore saved queue state}
1144 XXX No idea what this does.
1146 \subsection{\hgcmd{qsave}---save current queue state}
1148 XXX Likewise.
1150 \subsection{\hgcmd{qseries}---print the entire patch series}
1152 The \hgcmd{qseries} command prints the entire patch series from the
1153 \sfilename{series} file. It prints only patch names, not empty lines
1154 or comments. It prints in order from first to be applied to last.
1156 \subsection{\hgcmd{qtop}---print the name of the current patch}
1158 The \hgcmd{qtop} prints the name of the topmost currently applied
1159 patch.
1161 \subsection{\hgcmd{qunapplied}---print patches not yet applied}
1163 The \hgcmd{qunapplied} command prints the names of patches from the
1164 \sfilename{series} file that are not yet applied. It prints them in
1165 order from the next patch that will be pushed to the last.
1167 \subsection{\hgcmd{qversion}}
1169 The \hgcmd{qversion} command prints the version of MQ that is in use.
1171 \subsection{\hgcmd{strip}---remove a revision and descendants}
1173 The \hgcmd{strip} command removes a revision, and all of its
1174 descendants, from the repository. It undoes the effects of the
1175 removed revisions from the repository, and updates the working
1176 directory to the first parent of the removed revision.
1178 The \hgcmd{strip} command saves a backup of the removed changesets in
1179 a bundle, so that they can be reapplied if removed in error.
1181 Options:
1182 \begin{itemize}
1183 \item[\hgopt{strip}{-b}] Save unrelated changesets that are intermixed
1184 with the stripped changesets in the backup bundle.
1185 \item[\hgopt{strip}{-f}] If a branch has multiple heads, remove all
1186 heads. XXX This should be renamed, and use \texttt{-f} to strip revs
1187 when there are pending changes.
1188 \item[\hgopt{strip}{-n}] Do not save a backup bundle.
1189 \end{itemize}
1190 \section{MQ file reference}
1193 \subsection{The \sfilename{series} file}
1195 The \sfilename{series} file contains a list of the names of all
1196 patches that MQ can apply. It is represented as a list of names, with
1197 one name saved per line. Leading and trailing white space in each
1198 line are ignored.
1200 Lines may contain comments. A comment begins with the ``\texttt{\#}''
1201 character, and extends to the end of the line. Empty lines, and lines
1202 that contain only comments, are ignored.
1204 You will often need to edit the \sfilename{series} file by hand, hence
1205 the support for comments and empty lines noted above. For example,
1206 you can comment out a patch temporarily, and \hgcmd{qpush} will skip
1207 over that patch when applying patches. You can also change the order
1208 in which patches are applied by reordering their entries in the
1209 \sfilename{series} file.
1211 Placing the \sfilename{series} file under revision control is also
1212 supported; it is a good idea to place all of the patches that it
1213 refers to under revision control, as well. If you create a patch
1214 directory using the \hgopt{qinit}{-c} option to \hgcmd{qinit}, this
1215 will be done for you automatically.
1216 \subsection{The \sfilename{status} file}
1218 The \sfilename{status} file contains the names and changeset hashes of
1219 all patches that MQ currently has applied. Unlike the
1220 \sfilename{series} file, this file is not intended for editing. You
1221 should not place this file under revision control, or modify it in any
1222 way. It is used by MQ strictly for internal book-keeping.
1224 %%% Local Variables:
1225 %%% mode: latex
1226 %%% TeX-master: "00book"
1227 %%% End: